projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'master' of https://github.com/hashcat/oclHashcat
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 0
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 " --powertune-enable | | Enable power tuning, restores settings when finished |",
415 #endif
416 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
417 " -s, --skip | Num | Skip X words from the start | -s 1000000",
418 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
419 " --keyspace | | Show keyspace base:mod values and quit |",
420 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
421 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
422 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
423 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
424 " --generate-rules-func-min | Num | Force min X funcs per rule |",
425 " --generate-rules-func-max | Num | Force max X funcs per rule |",
426 " --generate-rules-seed | Num | Force RNG seed set to X |",
427 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
428 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
429 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
430 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
431 " -i, --increment | | Enable mask increment mode |",
432 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
433 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
434 "",
435 "- [ Hash modes ] -",
436 "",
437 " # | Name | Category",
438 " ======+==================================================+======================================",
439 " 900 | MD4 | Raw Hash",
440 " 0 | MD5 | Raw Hash",
441 " 5100 | Half MD5 | Raw Hash",
442 " 100 | SHA1 | Raw Hash",
443 " 10800 | SHA-384 | Raw Hash",
444 " 1400 | SHA-256 | Raw Hash",
445 " 1700 | SHA-512 | Raw Hash",
446 " 5000 | SHA-3(Keccak) | Raw Hash",
447 " 10100 | SipHash | Raw Hash",
448 " 6000 | RipeMD160 | Raw Hash",
449 " 6100 | Whirlpool | Raw Hash",
450 " 6900 | GOST R 34.11-94 | Raw Hash",
451 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
452 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
453 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
454 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
455 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
456 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
457 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
458 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
459 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
460 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
461 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
462 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
463 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
464 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
465 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
466 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
467 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
475 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
476 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
477 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
478 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
479 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
480 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
481 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
482 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
483 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
484 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
485 " 400 | phpass | Generic KDF",
486 " 8900 | scrypt | Generic KDF",
487 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
488 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
489 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
490 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
491 " 23 | Skype | Network protocols",
492 " 2500 | WPA/WPA2 | Network protocols",
493 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
494 " 5300 | IKE-PSK MD5 | Network protocols",
495 " 5400 | IKE-PSK SHA1 | Network protocols",
496 " 5500 | NetNTLMv1 | Network protocols",
497 " 5500 | NetNTLMv1 + ESS | Network protocols",
498 " 5600 | NetNTLMv2 | Network protocols",
499 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
500 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
501 " 8300 | DNSSEC (NSEC3) | Network protocols",
502 " 10200 | Cram MD5 | Network protocols",
503 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
504 " 11200 | MySQL CRAM (SHA1) | Network protocols",
505 " 11400 | SIP digest authentication (MD5) | Network protocols",
506 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
507 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
508 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
509 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
510 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
511 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
512 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
513 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
514 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
516 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
517 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
518 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
519 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
520 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
521 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
522 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
523 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
524 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
525 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
526 " 12 | PostgreSQL | Database Server",
527 " 131 | MSSQL(2000) | Database Server",
528 " 132 | MSSQL(2005) | Database Server",
529 " 1731 | MSSQL(2012) | Database Server",
530 " 1731 | MSSQL(2014) | Database Server",
531 " 200 | MySQL323 | Database Server",
532 " 300 | MySQL4.1/MySQL5 | Database Server",
533 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
534 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
535 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
536 " 8000 | Sybase ASE | Database Server",
537 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
538 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
539 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
540 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
541 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
542 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
543 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
544 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
545 " 11500 | CRC32 | Checksums",
546 " 3000 | LM | Operating-Systems",
547 " 1000 | NTLM | Operating-Systems",
548 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
549 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
550 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
551 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
552 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
553 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
554 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
555 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
556 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
557 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
558 " 1722 | OSX v10.7 | Operating-Systems",
559 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
560 " 6300 | AIX {smd5} | Operating-Systems",
561 " 6700 | AIX {ssha1} | Operating-Systems",
562 " 6400 | AIX {ssha256} | Operating-Systems",
563 " 6500 | AIX {ssha512} | Operating-Systems",
564 " 2400 | Cisco-PIX | Operating-Systems",
565 " 2410 | Cisco-ASA | Operating-Systems",
566 " 500 | Cisco-IOS $1$ | Operating-Systems",
567 " 5700 | Cisco-IOS $4$ | Operating-Systems",
568 " 9200 | Cisco-IOS $8$ | Operating-Systems",
569 " 9300 | Cisco-IOS $9$ | Operating-Systems",
570 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
571 " 501 | Juniper IVE | Operating-Systems",
572 " 5800 | Android PIN | Operating-Systems",
573 " 8100 | Citrix Netscaler | Operating-Systems",
574 " 8500 | RACF | Operating-Systems",
575 " 7200 | GRUB 2 | Operating-Systems",
576 " 9900 | Radmin2 | Operating-Systems",
577 " 125 | ArubaOS | Operating-Systems",
578 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
579 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
580 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
581 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
582 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
583 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
584 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
585 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
586 " 11600 | 7-Zip | Archives",
587 " 12500 | RAR3-hp | Archives",
588 " 13000 | RAR5 | Archives",
589 " 13200 | AxCrypt | Archives",
590 " 13300 | AxCrypt in memory SHA1 | Archives",
591 " 13600 | WinZip | Archives",
592 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
593 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
594 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
595 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
596 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
597 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
598 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
600 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
601 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
606 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
607 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
608 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
609 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
610 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
611 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
612 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
613 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
614 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
615 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
616 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
617 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
626 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
627 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
628 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
629 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
630 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
631 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
632 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
633 " 9400 | MS Office 2007 | Documents",
634 " 9500 | MS Office 2010 | Documents",
635 " 9600 | MS Office 2013 | Documents",
636 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
637 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
638 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
639 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
640 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
641 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
642 " 9000 | Password Safe v2 | Password Managers",
643 " 5200 | Password Safe v3 | Password Managers",
644 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
645 " 6600 | 1Password, agilekeychain | Password Managers",
646 " 8200 | 1Password, cloudkeychain | Password Managers",
647 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
648 " 12700 | Blockchain, My Wallet | Password Managers",
649 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
650 "",
651 "- [ Outfile Formats ] -",
652 "",
653 " # | Format",
654 " ===+========",
655 " 1 | hash[:salt]",
656 " 2 | plain",
657 " 3 | hash[:salt]:plain",
658 " 4 | hex_plain",
659 " 5 | hash[:salt]:hex_plain",
660 " 6 | plain:hex_plain",
661 " 7 | hash[:salt]:plain:hex_plain",
662 " 8 | crackpos",
663 " 9 | hash[:salt]:crack_pos",
664 " 10 | plain:crack_pos",
665 " 11 | hash[:salt]:plain:crack_pos",
666 " 12 | hex_plain:crack_pos",
667 " 13 | hash[:salt]:hex_plain:crack_pos",
668 " 14 | plain:hex_plain:crack_pos",
669 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
670 "",
671 "- [ Rule Debugging Modes ] -",
672 "",
673 " # | Format",
674 " ===+========",
675 " 1 | Finding-Rule",
676 " 2 | Original-Word",
677 " 3 | Original-Word:Finding-Rule",
678 " 4 | Original-Word:Finding-Rule:Processed-Word",
679 "",
680 "- [ Attack Modes ] -",
681 "",
682 " # | Mode",
683 " ===+======",
684 " 0 | Straight",
685 " 1 | Combination",
686 " 3 | Brute-force",
687 " 6 | Hybrid Wordlist + Mask",
688 " 7 | Hybrid Mask + Wordlist",
689 "",
690 "- [ Built-in Charsets ] -",
691 "",
692 " ? | Charset",
693 " ===+=========",
694 " l | abcdefghijklmnopqrstuvwxyz",
695 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
696 " d | 0123456789",
697 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
698 " a | ?l?u?d?s",
699 " b | 0x00 - 0xff",
700 "",
701 "- [ OpenCL Device Types ] -",
702 "",
703 " # | Device Type",
704 " ===+=============",
705 " 1 | CPU",
706 " 2 | GPU",
707 " 3 | FPGA, DSP, Co-Processor",
708 "",
709 "- [ Workload Profiles ] -",
710 "",
711 " # | Performance | Runtime | Power Consumption | Desktop Impact",
712 " ===+=============+=========+===================+=================",
713 " 1 | Low | 2 ms | Low | Minimal",
714 " 2 | Default | 12 ms | Economic | Noticeable",
715 " 3 | High | 96 ms | High | Unresponsive",
716 " 4 | Nightmare | 480 ms | Insane | Headless",
717 "",
718 "If you have no idea what just happened then visit the following pages:",
719 "",
720 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
721 "* https://hashcat.net/wiki/#frequently_asked_questions",
722 "",
723 NULL
724 };
725
726 /**
727 * hashcat specific functions
728 */
729
730 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
731 {
732 int exec_pos = (int) device_param->exec_pos - last_num_entries;
733
734 if (exec_pos < 0) exec_pos += EXEC_CACHE;
735
736 double exec_ms_sum = 0;
737
738 int exec_ms_cnt = 0;
739
740 for (int i = 0; i < last_num_entries; i++)
741 {
742 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
743
744 if (exec_ms)
745 {
746 exec_ms_sum += exec_ms;
747
748 exec_ms_cnt++;
749 }
750 }
751
752 if (exec_ms_cnt == 0) return 0;
753
754 return exec_ms_sum / exec_ms_cnt;
755 }
756
757 void status_display_machine_readable ()
758 {
759 FILE *out = stdout;
760
761 fprintf (out, "STATUS\t%u\t", data.devices_status);
762
763 /**
764 * speed new
765 */
766
767 fprintf (out, "SPEED\t");
768
769 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
770 {
771 hc_device_param_t *device_param = &data.devices_param[device_id];
772
773 if (device_param->skipped) continue;
774
775 u64 speed_cnt = 0;
776 double speed_ms = 0;
777
778 for (int i = 0; i < SPEED_CACHE; i++)
779 {
780 speed_cnt += device_param->speed_cnt[i];
781 speed_ms += device_param->speed_ms[i];
782 }
783
784 speed_cnt /= SPEED_CACHE;
785 speed_ms /= SPEED_CACHE;
786
787 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
788 }
789
790 /**
791 * exec time
792 */
793
794 fprintf (out, "EXEC_RUNTIME\t");
795
796 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
797 {
798 hc_device_param_t *device_param = &data.devices_param[device_id];
799
800 if (device_param->skipped) continue;
801
802 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
803
804 fprintf (out, "%f\t", exec_ms_avg);
805 }
806
807 /**
808 * words_cur
809 */
810
811 u64 words_cur = get_lowest_words_done ();
812
813 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
814
815 /**
816 * counter
817 */
818
819 u64 progress_total = data.words_cnt * data.salts_cnt;
820
821 u64 all_done = 0;
822 u64 all_rejected = 0;
823 u64 all_restored = 0;
824
825 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
826 {
827 all_done += data.words_progress_done[salt_pos];
828 all_rejected += data.words_progress_rejected[salt_pos];
829 all_restored += data.words_progress_restored[salt_pos];
830 }
831
832 u64 progress_cur = all_restored + all_done + all_rejected;
833 u64 progress_end = progress_total;
834
835 u64 progress_skip = 0;
836
837 if (data.skip)
838 {
839 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
840
841 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
842 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
843 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
844 }
845
846 if (data.limit)
847 {
848 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
849
850 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
851 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
852 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
853 }
854
855 u64 progress_cur_relative_skip = progress_cur - progress_skip;
856 u64 progress_end_relative_skip = progress_end - progress_skip;
857
858 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
859
860 /**
861 * cracks
862 */
863
864 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
865 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
866
867 /**
868 * temperature
869 */
870
871 #ifdef HAVE_HWMON
872 if (data.gpu_temp_disable == 0)
873 {
874 fprintf (out, "TEMP\t");
875
876 hc_thread_mutex_lock (mux_adl);
877
878 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
879 {
880 hc_device_param_t *device_param = &data.devices_param[device_id];
881
882 if (device_param->skipped) continue;
883
884 int temp = hm_get_temperature_with_device_id (device_id);
885
886 fprintf (out, "%d\t", temp);
887 }
888
889 hc_thread_mutex_unlock (mux_adl);
890 }
891 #endif // HAVE_HWMON
892
893 /**
894 * flush
895 */
896
897 #ifdef _WIN
898 fputc ('\r', out);
899 fputc ('\n', out);
900 #endif
901
902 #ifdef _POSIX
903 fputc ('\n', out);
904 #endif
905
906 fflush (out);
907 }
908
909 void status_display ()
910 {
911 if (data.devices_status == STATUS_INIT) return;
912 if (data.devices_status == STATUS_STARTING) return;
913 if (data.devices_status == STATUS_BYPASS) return;
914
915 if (data.machine_readable == 1)
916 {
917 status_display_machine_readable ();
918
919 return;
920 }
921
922 char tmp_buf[1000] = { 0 };
923
924 uint tmp_len = 0;
925
926 log_info ("Session.Name...: %s", data.session);
927
928 char *status_type = strstatus (data.devices_status);
929
930 uint hash_mode = data.hash_mode;
931
932 char *hash_type = strhashtype (hash_mode); // not a bug
933
934 log_info ("Status.........: %s", status_type);
935
936 /**
937 * show rules
938 */
939
940 if (data.rp_files_cnt)
941 {
942 uint i;
943
944 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
945 {
946 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
947 }
948
949 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
950
951 log_info ("Rules.Type.....: %s", tmp_buf);
952
953 tmp_len = 0;
954 }
955
956 if (data.rp_gen)
957 {
958 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
959
960 if (data.rp_gen_seed)
961 {
962 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
963 }
964 }
965
966 /**
967 * show input
968 */
969
970 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
971 {
972 if (data.wordlist_mode == WL_MODE_FILE)
973 {
974 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
975 }
976 else if (data.wordlist_mode == WL_MODE_STDIN)
977 {
978 log_info ("Input.Mode.....: Pipe");
979 }
980 }
981 else if (data.attack_mode == ATTACK_MODE_COMBI)
982 {
983 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
984 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
985 }
986 else if (data.attack_mode == ATTACK_MODE_BF)
987 {
988 char *mask = data.mask;
989
990 if (mask != NULL)
991 {
992 uint mask_len = data.css_cnt;
993
994 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
995
996 if (mask_len > 0)
997 {
998 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
999 {
1000 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1001 {
1002 mask_len -= data.salts_buf[0].salt_len;
1003 }
1004 }
1005
1006 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1007
1008 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1009 }
1010
1011 if (data.maskcnt > 1)
1012 {
1013 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1014
1015 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1016 }
1017
1018 log_info ("Input.Mode.....: %s", tmp_buf);
1019 }
1020
1021 tmp_len = 0;
1022 }
1023 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1024 {
1025 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1026 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1027 }
1028 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1029 {
1030 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1031 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1032 }
1033
1034 if (data.digests_cnt == 1)
1035 {
1036 if (data.hash_mode == 2500)
1037 {
1038 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1039
1040 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1041 (char *) data.salts_buf[0].salt_buf,
1042 wpa->orig_mac1[0],
1043 wpa->orig_mac1[1],
1044 wpa->orig_mac1[2],
1045 wpa->orig_mac1[3],
1046 wpa->orig_mac1[4],
1047 wpa->orig_mac1[5],
1048 wpa->orig_mac2[0],
1049 wpa->orig_mac2[1],
1050 wpa->orig_mac2[2],
1051 wpa->orig_mac2[3],
1052 wpa->orig_mac2[4],
1053 wpa->orig_mac2[5]);
1054 }
1055 else if (data.hash_mode == 5200)
1056 {
1057 log_info ("Hash.Target....: File (%s)", data.hashfile);
1058 }
1059 else if (data.hash_mode == 9000)
1060 {
1061 log_info ("Hash.Target....: File (%s)", data.hashfile);
1062 }
1063 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1064 {
1065 log_info ("Hash.Target....: File (%s)", data.hashfile);
1066 }
1067 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1068 {
1069 log_info ("Hash.Target....: File (%s)", data.hashfile);
1070 }
1071 else
1072 {
1073 char out_buf[HCBUFSIZ] = { 0 };
1074
1075 ascii_digest (out_buf, 0, 0);
1076
1077 // limit length
1078 if (strlen (out_buf) > 40)
1079 {
1080 out_buf[41] = '.';
1081 out_buf[42] = '.';
1082 out_buf[43] = '.';
1083 out_buf[44] = 0;
1084 }
1085
1086 log_info ("Hash.Target....: %s", out_buf);
1087 }
1088 }
1089 else
1090 {
1091 if (data.hash_mode == 3000)
1092 {
1093 char out_buf1[32] = { 0 };
1094 char out_buf2[32] = { 0 };
1095
1096 ascii_digest (out_buf1, 0, 0);
1097 ascii_digest (out_buf2, 0, 1);
1098
1099 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1100 }
1101 else
1102 {
1103 log_info ("Hash.Target....: File (%s)", data.hashfile);
1104 }
1105 }
1106
1107 log_info ("Hash.Type......: %s", hash_type);
1108
1109 /**
1110 * speed new
1111 */
1112
1113 u64 speed_cnt[DEVICES_MAX] = { 0 };
1114 double speed_ms[DEVICES_MAX] = { 0 };
1115
1116 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1117 {
1118 hc_device_param_t *device_param = &data.devices_param[device_id];
1119
1120 if (device_param->skipped) continue;
1121
1122 speed_cnt[device_id] = 0;
1123 speed_ms[device_id] = 0;
1124
1125 for (int i = 0; i < SPEED_CACHE; i++)
1126 {
1127 speed_cnt[device_id] += device_param->speed_cnt[i];
1128 speed_ms[device_id] += device_param->speed_ms[i];
1129 }
1130
1131 speed_cnt[device_id] /= SPEED_CACHE;
1132 speed_ms[device_id] /= SPEED_CACHE;
1133 }
1134
1135 double hashes_all_ms = 0;
1136
1137 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1138
1139 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1140 {
1141 hc_device_param_t *device_param = &data.devices_param[device_id];
1142
1143 if (device_param->skipped) continue;
1144
1145 hashes_dev_ms[device_id] = 0;
1146
1147 if (speed_ms[device_id])
1148 {
1149 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1150
1151 hashes_all_ms += hashes_dev_ms[device_id];
1152 }
1153 }
1154
1155 /**
1156 * exec time
1157 */
1158
1159 double exec_all_ms[DEVICES_MAX] = { 0 };
1160
1161 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1162 {
1163 hc_device_param_t *device_param = &data.devices_param[device_id];
1164
1165 if (device_param->skipped) continue;
1166
1167 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1168
1169 exec_all_ms[device_id] = exec_ms_avg;
1170 }
1171
1172 /**
1173 * timers
1174 */
1175
1176 double ms_running = 0;
1177
1178 hc_timer_get (data.timer_running, ms_running);
1179
1180 double ms_paused = data.ms_paused;
1181
1182 if (data.devices_status == STATUS_PAUSED)
1183 {
1184 double ms_paused_tmp = 0;
1185
1186 hc_timer_get (data.timer_paused, ms_paused_tmp);
1187
1188 ms_paused += ms_paused_tmp;
1189 }
1190
1191 #ifdef WIN
1192
1193 __time64_t sec_run = ms_running / 1000;
1194
1195 #else
1196
1197 time_t sec_run = ms_running / 1000;
1198
1199 #endif
1200
1201 if (sec_run)
1202 {
1203 char display_run[32] = { 0 };
1204
1205 struct tm tm_run;
1206
1207 struct tm *tmp = NULL;
1208
1209 #ifdef WIN
1210
1211 tmp = _gmtime64 (&sec_run);
1212
1213 #else
1214
1215 tmp = gmtime (&sec_run);
1216
1217 #endif
1218
1219 if (tmp != NULL)
1220 {
1221 memset (&tm_run, 0, sizeof (tm_run));
1222
1223 memcpy (&tm_run, tmp, sizeof (tm_run));
1224
1225 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1226
1227 char *start = ctime (&data.proc_start);
1228
1229 size_t start_len = strlen (start);
1230
1231 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1232 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1233
1234 log_info ("Time.Started...: %s (%s)", start, display_run);
1235 }
1236 }
1237 else
1238 {
1239 log_info ("Time.Started...: 0 secs");
1240 }
1241
1242 /**
1243 * counters
1244 */
1245
1246 u64 progress_total = data.words_cnt * data.salts_cnt;
1247
1248 u64 all_done = 0;
1249 u64 all_rejected = 0;
1250 u64 all_restored = 0;
1251
1252 u64 progress_noneed = 0;
1253
1254 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1255 {
1256 all_done += data.words_progress_done[salt_pos];
1257 all_rejected += data.words_progress_rejected[salt_pos];
1258 all_restored += data.words_progress_restored[salt_pos];
1259
1260 // Important for ETA only
1261
1262 if (data.salts_shown[salt_pos] == 1)
1263 {
1264 const u64 all = data.words_progress_done[salt_pos]
1265 + data.words_progress_rejected[salt_pos]
1266 + data.words_progress_restored[salt_pos];
1267
1268 const u64 left = data.words_cnt - all;
1269
1270 progress_noneed += left;
1271 }
1272 }
1273
1274 u64 progress_cur = all_restored + all_done + all_rejected;
1275 u64 progress_end = progress_total;
1276
1277 u64 progress_skip = 0;
1278
1279 if (data.skip)
1280 {
1281 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1282
1283 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1284 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1285 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1286 }
1287
1288 if (data.limit)
1289 {
1290 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1291
1292 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1293 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1294 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1295 }
1296
1297 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1298 u64 progress_end_relative_skip = progress_end - progress_skip;
1299
1300 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1301 {
1302 if (data.devices_status != STATUS_CRACKED)
1303 {
1304 #ifdef WIN
1305 __time64_t sec_etc = 0;
1306 #else
1307 time_t sec_etc = 0;
1308 #endif
1309
1310 if (hashes_all_ms)
1311 {
1312 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1313
1314 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1315
1316 sec_etc = ms_left / 1000;
1317 }
1318
1319 if (sec_etc == 0)
1320 {
1321 //log_info ("Time.Estimated.: 0 secs");
1322 }
1323 else if ((u64) sec_etc > ETC_MAX)
1324 {
1325 log_info ("Time.Estimated.: > 10 Years");
1326 }
1327 else
1328 {
1329 char display_etc[32] = { 0 };
1330
1331 struct tm tm_etc;
1332
1333 struct tm *tmp = NULL;
1334
1335 #ifdef WIN
1336
1337 tmp = _gmtime64 (&sec_etc);
1338
1339 #else
1340
1341 tmp = gmtime (&sec_etc);
1342
1343 #endif
1344
1345 if (tmp != NULL)
1346 {
1347 memset (&tm_etc, 0, sizeof (tm_etc));
1348
1349 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1350
1351 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1352
1353 time_t now;
1354
1355 time (&now);
1356
1357 now += sec_etc;
1358
1359 char *etc = ctime (&now);
1360
1361 size_t etc_len = strlen (etc);
1362
1363 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1364 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1365
1366 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1367 }
1368 }
1369 }
1370 }
1371
1372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1373 {
1374 hc_device_param_t *device_param = &data.devices_param[device_id];
1375
1376 if (device_param->skipped) continue;
1377
1378 char display_dev_cur[16] = { 0 };
1379
1380 strncpy (display_dev_cur, "0.00", 4);
1381
1382 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1383
1384 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1385 }
1386
1387 char display_all_cur[16] = { 0 };
1388
1389 strncpy (display_all_cur, "0.00", 4);
1390
1391 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1392
1393 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1394
1395 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1396 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1397
1398 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1399
1400 // crack-per-time
1401
1402 if (data.digests_cnt > 100)
1403 {
1404 time_t now = time (NULL);
1405
1406 int cpt_cur_min = 0;
1407 int cpt_cur_hour = 0;
1408 int cpt_cur_day = 0;
1409
1410 for (int i = 0; i < CPT_BUF; i++)
1411 {
1412 const uint cracked = data.cpt_buf[i].cracked;
1413 const time_t timestamp = data.cpt_buf[i].timestamp;
1414
1415 if ((timestamp + 60) > now)
1416 {
1417 cpt_cur_min += cracked;
1418 }
1419
1420 if ((timestamp + 3600) > now)
1421 {
1422 cpt_cur_hour += cracked;
1423 }
1424
1425 if ((timestamp + 86400) > now)
1426 {
1427 cpt_cur_day += cracked;
1428 }
1429 }
1430
1431 double ms_real = ms_running - ms_paused;
1432
1433 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1434 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1435 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1436
1437 if ((data.cpt_start + 86400) < now)
1438 {
1439 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1440 cpt_cur_min,
1441 cpt_cur_hour,
1442 cpt_cur_day,
1443 cpt_avg_min,
1444 cpt_avg_hour,
1445 cpt_avg_day);
1446 }
1447 else if ((data.cpt_start + 3600) < now)
1448 {
1449 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1450 cpt_cur_min,
1451 cpt_cur_hour,
1452 cpt_avg_min,
1453 cpt_avg_hour,
1454 cpt_avg_day);
1455 }
1456 else if ((data.cpt_start + 60) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_avg_min,
1461 cpt_avg_hour,
1462 cpt_avg_day);
1463 }
1464 else
1465 {
1466 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1467 cpt_avg_min,
1468 cpt_avg_hour,
1469 cpt_avg_day);
1470 }
1471 }
1472
1473 // Restore point
1474
1475 u64 restore_point = get_lowest_words_done ();
1476
1477 u64 restore_total = data.words_base;
1478
1479 float percent_restore = 0;
1480
1481 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1482
1483 if (progress_end_relative_skip)
1484 {
1485 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1486 {
1487 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1488 float percent_rejected = 0.0;
1489
1490 if (progress_cur)
1491 {
1492 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1493 }
1494
1495 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1496 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1497
1498 if (data.restore_disable == 0)
1499 {
1500 if (percent_finished != 1)
1501 {
1502 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1503 }
1504 }
1505 }
1506 }
1507 else
1508 {
1509 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1510 {
1511 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1512 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1513
1514 if (data.restore_disable == 0)
1515 {
1516 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1517 }
1518 }
1519 else
1520 {
1521 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1522 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1523
1524 // --restore not allowed if stdin is used -- really? why?
1525
1526 //if (data.restore_disable == 0)
1527 //{
1528 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1529 //}
1530 }
1531 }
1532
1533 #ifdef HAVE_HWMON
1534 if (data.gpu_temp_disable == 0)
1535 {
1536 hc_thread_mutex_lock (mux_adl);
1537
1538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1539 {
1540 hc_device_param_t *device_param = &data.devices_param[device_id];
1541
1542 if (device_param->skipped) continue;
1543
1544 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1545 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1546 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1547 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1548 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1549 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1550 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1551
1552 char output_buf[256] = { 0 };
1553
1554 int output_len = 0;
1555
1556 if (num_temperature >= 0)
1557 {
1558 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1559
1560 output_len = strlen (output_buf);
1561 }
1562
1563 if (num_fanspeed >= 0)
1564 {
1565 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1566
1567 output_len = strlen (output_buf);
1568 }
1569
1570 if (num_utilization >= 0)
1571 {
1572 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1573
1574 output_len = strlen (output_buf);
1575 }
1576
1577 if (num_corespeed >= 0)
1578 {
1579 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1580
1581 output_len = strlen (output_buf);
1582 }
1583
1584 if (num_memoryspeed >= 0)
1585 {
1586 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1587
1588 output_len = strlen (output_buf);
1589 }
1590
1591 if (num_buslanes >= 0)
1592 {
1593 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1594
1595 output_len = strlen (output_buf);
1596 }
1597
1598 if (num_throttle == 1)
1599 {
1600 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1601
1602 output_len = strlen (output_buf);
1603 }
1604
1605 if (output_len == 0)
1606 {
1607 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1608
1609 output_len = strlen (output_buf);
1610 }
1611
1612 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1613 }
1614
1615 hc_thread_mutex_unlock (mux_adl);
1616 }
1617 #endif // HAVE_HWMON
1618 }
1619
1620 static void status_benchmark_automate ()
1621 {
1622 u64 speed_cnt[DEVICES_MAX] = { 0 };
1623 double speed_ms[DEVICES_MAX] = { 0 };
1624
1625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1626 {
1627 hc_device_param_t *device_param = &data.devices_param[device_id];
1628
1629 if (device_param->skipped) continue;
1630
1631 speed_cnt[device_id] = device_param->speed_cnt[0];
1632 speed_ms[device_id] = device_param->speed_ms[0];
1633 }
1634
1635 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1636
1637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1638 {
1639 hc_device_param_t *device_param = &data.devices_param[device_id];
1640
1641 if (device_param->skipped) continue;
1642
1643 hashes_dev_ms[device_id] = 0;
1644
1645 if (speed_ms[device_id])
1646 {
1647 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1648 }
1649 }
1650
1651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1652 {
1653 hc_device_param_t *device_param = &data.devices_param[device_id];
1654
1655 if (device_param->skipped) continue;
1656
1657 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1658 }
1659 }
1660
1661 static void status_benchmark ()
1662 {
1663 if (data.devices_status == STATUS_INIT) return;
1664 if (data.devices_status == STATUS_STARTING) return;
1665 if (data.devices_status == STATUS_BYPASS) return;
1666
1667 if (data.machine_readable == 1)
1668 {
1669 status_benchmark_automate ();
1670
1671 return;
1672 }
1673
1674 u64 speed_cnt[DEVICES_MAX] = { 0 };
1675 double speed_ms[DEVICES_MAX] = { 0 };
1676
1677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1678 {
1679 hc_device_param_t *device_param = &data.devices_param[device_id];
1680
1681 if (device_param->skipped) continue;
1682
1683 speed_cnt[device_id] = device_param->speed_cnt[0];
1684 speed_ms[device_id] = device_param->speed_ms[0];
1685 }
1686
1687 double hashes_all_ms = 0;
1688
1689 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1690
1691 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1692 {
1693 hc_device_param_t *device_param = &data.devices_param[device_id];
1694
1695 if (device_param->skipped) continue;
1696
1697 hashes_dev_ms[device_id] = 0;
1698
1699 if (speed_ms[device_id])
1700 {
1701 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1702
1703 hashes_all_ms += hashes_dev_ms[device_id];
1704 }
1705 }
1706
1707 /**
1708 * exec time
1709 */
1710
1711 double exec_all_ms[DEVICES_MAX] = { 0 };
1712
1713 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1714 {
1715 hc_device_param_t *device_param = &data.devices_param[device_id];
1716
1717 if (device_param->skipped) continue;
1718
1719 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1720
1721 exec_all_ms[device_id] = exec_ms_avg;
1722 }
1723
1724 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1725 {
1726 hc_device_param_t *device_param = &data.devices_param[device_id];
1727
1728 if (device_param->skipped) continue;
1729
1730 char display_dev_cur[16] = { 0 };
1731
1732 strncpy (display_dev_cur, "0.00", 4);
1733
1734 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1735
1736 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1737 }
1738
1739 char display_all_cur[16] = { 0 };
1740
1741 strncpy (display_all_cur, "0.00", 4);
1742
1743 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1744
1745 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1746 }
1747
1748 /**
1749 * hashcat -only- functions
1750 */
1751
1752 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1753 {
1754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1755 {
1756 if (attack_kern == ATTACK_KERN_STRAIGHT)
1757 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1758 else if (attack_kern == ATTACK_KERN_COMBI)
1759 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1760 else if (attack_kern == ATTACK_KERN_BF)
1761 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1762 }
1763 else
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1765 }
1766
1767 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)
1768 {
1769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1770 {
1771 if (attack_kern == ATTACK_KERN_STRAIGHT)
1772 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1773 else if (attack_kern == ATTACK_KERN_COMBI)
1774 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1775 else if (attack_kern == ATTACK_KERN_BF)
1776 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1777 }
1778 else
1779 {
1780 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1781 }
1782 }
1783
1784 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1785 {
1786 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1787 {
1788 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1789 }
1790 else
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1793 }
1794 }
1795
1796 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)
1797 {
1798 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1799 {
1800 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1801 }
1802 else
1803 {
1804 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1805 }
1806 }
1807
1808 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1811 }
1812
1813 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1814 {
1815 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1816 }
1817
1818 static uint convert_from_hex (char *line_buf, const uint line_len)
1819 {
1820 if (line_len & 1) return (line_len); // not in hex
1821
1822 if (data.hex_wordlist == 1)
1823 {
1824 uint i;
1825 uint j;
1826
1827 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1828 {
1829 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1830 }
1831
1832 memset (line_buf + i, 0, line_len - i);
1833
1834 return (i);
1835 }
1836 else if (line_len >= 6) // $HEX[] = 6
1837 {
1838 if (line_buf[0] != '$') return (line_len);
1839 if (line_buf[1] != 'H') return (line_len);
1840 if (line_buf[2] != 'E') return (line_len);
1841 if (line_buf[3] != 'X') return (line_len);
1842 if (line_buf[4] != '[') return (line_len);
1843 if (line_buf[line_len - 1] != ']') return (line_len);
1844
1845 uint i;
1846 uint j;
1847
1848 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1849 {
1850 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1851 }
1852
1853 memset (line_buf + i, 0, line_len - i);
1854
1855 return (i);
1856 }
1857
1858 return (line_len);
1859 }
1860
1861 static void clear_prompt ()
1862 {
1863 fputc ('\r', stdout);
1864
1865 for (size_t i = 0; i < strlen (PROMPT); i++)
1866 {
1867 fputc (' ', stdout);
1868 }
1869
1870 fputc ('\r', stdout);
1871
1872 fflush (stdout);
1873 }
1874
1875 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1876 {
1877 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);
1878 }
1879
1880 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1881 {
1882 char *outfile = data.outfile;
1883 uint quiet = data.quiet;
1884 FILE *pot_fp = data.pot_fp;
1885 uint loopback = data.loopback;
1886 uint debug_mode = data.debug_mode;
1887 char *debug_file = data.debug_file;
1888
1889 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1890 int debug_rule_len = 0; // -1 error
1891 uint debug_plain_len = 0;
1892
1893 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1894
1895 // hash
1896
1897 char out_buf[HCBUFSIZ] = { 0 };
1898
1899 const u32 salt_pos = plain->salt_pos;
1900 const u32 digest_pos = plain->digest_pos; // relative
1901 const u32 gidvid = plain->gidvid;
1902 const u32 il_pos = plain->il_pos;
1903
1904 ascii_digest (out_buf, salt_pos, digest_pos);
1905
1906 // plain
1907
1908 u64 crackpos = device_param->words_off;
1909
1910 uint plain_buf[16] = { 0 };
1911
1912 u8 *plain_ptr = (u8 *) plain_buf;
1913
1914 unsigned int plain_len = 0;
1915
1916 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1917 {
1918 pw_t pw;
1919
1920 gidd_to_pw_t (device_param, gidvid, &pw);
1921
1922 for (int i = 0; i < 16; i++)
1923 {
1924 plain_buf[i] = pw.i[i];
1925 }
1926
1927 plain_len = pw.pw_len;
1928
1929 const uint off = device_param->innerloop_pos + il_pos;
1930
1931 if (debug_mode > 0)
1932 {
1933 debug_rule_len = 0;
1934
1935 // save rule
1936 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1937 {
1938 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1939
1940 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1941 }
1942
1943 // save plain
1944 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1945 {
1946 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1947
1948 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1949
1950 debug_plain_len = plain_len;
1951 }
1952 }
1953
1954 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1955
1956 crackpos += gidvid;
1957 crackpos *= data.kernel_rules_cnt;
1958 crackpos += device_param->innerloop_pos + il_pos;
1959
1960 if (plain_len > data.pw_max) plain_len = data.pw_max;
1961 }
1962 else if (data.attack_mode == ATTACK_MODE_COMBI)
1963 {
1964 pw_t pw;
1965
1966 gidd_to_pw_t (device_param, gidvid, &pw);
1967
1968 for (int i = 0; i < 16; i++)
1969 {
1970 plain_buf[i] = pw.i[i];
1971 }
1972
1973 plain_len = pw.pw_len;
1974
1975 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1976 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1977
1978 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1979 {
1980 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1981 }
1982 else
1983 {
1984 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1985
1986 memcpy (plain_ptr, comb_buf, comb_len);
1987 }
1988
1989 plain_len += comb_len;
1990
1991 crackpos += gidvid;
1992 crackpos *= data.combs_cnt;
1993 crackpos += device_param->innerloop_pos + il_pos;
1994
1995 if (data.pw_max != PW_DICTMAX1)
1996 {
1997 if (plain_len > data.pw_max) plain_len = data.pw_max;
1998 }
1999 }
2000 else if (data.attack_mode == ATTACK_MODE_BF)
2001 {
2002 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2003 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2004
2005 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2006 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2007
2008 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2009 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2010
2011 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2012 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2013
2014 plain_len = data.css_cnt;
2015
2016 crackpos += gidvid;
2017 crackpos *= data.bfs_cnt;
2018 crackpos += device_param->innerloop_pos + il_pos;
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2021 {
2022 pw_t pw;
2023
2024 gidd_to_pw_t (device_param, gidvid, &pw);
2025
2026 for (int i = 0; i < 16; i++)
2027 {
2028 plain_buf[i] = pw.i[i];
2029 }
2030
2031 plain_len = pw.pw_len;
2032
2033 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2034
2035 uint start = 0;
2036 uint stop = device_param->kernel_params_mp_buf32[4];
2037
2038 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2039
2040 plain_len += start + stop;
2041
2042 crackpos += gidvid;
2043 crackpos *= data.combs_cnt;
2044 crackpos += device_param->innerloop_pos + il_pos;
2045
2046 if (data.pw_max != PW_DICTMAX1)
2047 {
2048 if (plain_len > data.pw_max) plain_len = data.pw_max;
2049 }
2050 }
2051 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2052 {
2053 pw_t pw;
2054
2055 gidd_to_pw_t (device_param, gidvid, &pw);
2056
2057 for (int i = 0; i < 16; i++)
2058 {
2059 plain_buf[i] = pw.i[i];
2060 }
2061
2062 plain_len = pw.pw_len;
2063
2064 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2065
2066 uint start = 0;
2067 uint stop = device_param->kernel_params_mp_buf32[4];
2068
2069 memmove (plain_ptr + stop, plain_ptr, plain_len);
2070
2071 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2072
2073 plain_len += start + stop;
2074
2075 crackpos += gidvid;
2076 crackpos *= data.combs_cnt;
2077 crackpos += device_param->innerloop_pos + il_pos;
2078
2079 if (data.pw_max != PW_DICTMAX1)
2080 {
2081 if (plain_len > data.pw_max) plain_len = data.pw_max;
2082 }
2083 }
2084
2085 if (data.attack_mode == ATTACK_MODE_BF)
2086 {
2087 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2088 {
2089 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2090 {
2091 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2092 {
2093 plain_len = plain_len - data.salts_buf[0].salt_len;
2094 }
2095 }
2096
2097 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2098 {
2099 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2100 {
2101 plain_ptr[j] = plain_ptr[i];
2102 }
2103
2104 plain_len = plain_len / 2;
2105 }
2106 }
2107 }
2108
2109 // if enabled, update also the potfile
2110
2111 if (pot_fp)
2112 {
2113 lock_file (pot_fp);
2114
2115 fprintf (pot_fp, "%s:", out_buf);
2116
2117 format_plain (pot_fp, plain_ptr, plain_len, 1);
2118
2119 fputc ('\n', pot_fp);
2120
2121 fflush (pot_fp);
2122
2123 unlock_file (pot_fp);
2124 }
2125
2126 // outfile
2127
2128 FILE *out_fp = NULL;
2129
2130 if (outfile != NULL)
2131 {
2132 if ((out_fp = fopen (outfile, "ab")) == NULL)
2133 {
2134 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2135
2136 out_fp = stdout;
2137 }
2138
2139 lock_file (out_fp);
2140 }
2141 else
2142 {
2143 out_fp = stdout;
2144
2145 if (quiet == 0) clear_prompt ();
2146 }
2147
2148 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2149
2150 if (outfile != NULL)
2151 {
2152 if (out_fp != stdout)
2153 {
2154 fclose (out_fp);
2155 }
2156 }
2157 else
2158 {
2159 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2160 {
2161 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2162 {
2163 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2164 if (quiet == 0) fflush (stdout);
2165 }
2166 }
2167 }
2168
2169 // loopback
2170
2171 if (loopback)
2172 {
2173 char *loopback_file = data.loopback_file;
2174
2175 FILE *fb_fp = NULL;
2176
2177 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2178 {
2179 lock_file (fb_fp);
2180
2181 format_plain (fb_fp, plain_ptr, plain_len, 1);
2182
2183 fputc ('\n', fb_fp);
2184
2185 fclose (fb_fp);
2186 }
2187 }
2188
2189 // (rule) debug mode
2190
2191 // the next check implies that:
2192 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2193 // - debug_mode > 0
2194
2195 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2196 {
2197 if (debug_rule_len < 0) debug_rule_len = 0;
2198
2199 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2200
2201 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2202
2203 if ((quiet == 0) && (debug_file == NULL))
2204 {
2205 fprintf (stdout, "%s", PROMPT);
2206
2207 fflush (stdout);
2208 }
2209 }
2210 }
2211
2212 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2213 {
2214 salt_t *salt_buf = &data.salts_buf[salt_pos];
2215
2216 u32 num_cracked;
2217
2218 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2219
2220 if (num_cracked)
2221 {
2222 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2223
2224 log_info_nn ("");
2225
2226 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2227
2228 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);
2229
2230 uint cpt_cracked = 0;
2231
2232 for (uint i = 0; i < num_cracked; i++)
2233 {
2234 const uint hash_pos = cracked[i].hash_pos;
2235
2236 if (data.digests_shown[hash_pos] == 1) continue;
2237
2238 hc_thread_mutex_lock (mux_display);
2239
2240 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2241 {
2242 data.digests_shown[hash_pos] = 1;
2243
2244 data.digests_done++;
2245
2246 cpt_cracked++;
2247
2248 salt_buf->digests_done++;
2249
2250 if (salt_buf->digests_done == salt_buf->digests_cnt)
2251 {
2252 data.salts_shown[salt_pos] = 1;
2253
2254 data.salts_done++;
2255 }
2256 }
2257
2258 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261
2262 check_hash (device_param, &cracked[i]);
2263 }
2264
2265 myfree (cracked);
2266
2267 if (cpt_cracked > 0)
2268 {
2269 hc_thread_mutex_lock (mux_display);
2270
2271 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2272 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2273
2274 data.cpt_pos++;
2275
2276 data.cpt_total += cpt_cracked;
2277
2278 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2279
2280 hc_thread_mutex_unlock (mux_display);
2281 }
2282
2283 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2284 {
2285 // we need to reset cracked state on the device
2286 // otherwise host thinks again and again the hash was cracked
2287 // and returns invalid password each time
2288
2289 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2290
2291 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);
2292 }
2293
2294 num_cracked = 0;
2295
2296 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2297 }
2298 }
2299
2300 static void save_hash ()
2301 {
2302 char *hashfile = data.hashfile;
2303
2304 char new_hashfile[256] = { 0 };
2305 char old_hashfile[256] = { 0 };
2306
2307 snprintf (new_hashfile, 255, "%s.new", hashfile);
2308 snprintf (old_hashfile, 255, "%s.old", hashfile);
2309
2310 unlink (new_hashfile);
2311
2312 char separator = data.separator;
2313
2314 FILE *fp = fopen (new_hashfile, "wb");
2315
2316 if (fp == NULL)
2317 {
2318 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2319
2320 exit (-1);
2321 }
2322
2323 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2324 {
2325 if (data.salts_shown[salt_pos] == 1) continue;
2326
2327 salt_t *salt_buf = &data.salts_buf[salt_pos];
2328
2329 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2330 {
2331 uint idx = salt_buf->digests_offset + digest_pos;
2332
2333 if (data.digests_shown[idx] == 1) continue;
2334
2335 if (data.hash_mode != 2500)
2336 {
2337 char out_buf[HCBUFSIZ] = { 0 };
2338
2339 if (data.username == 1)
2340 {
2341 user_t *user = data.hash_info[idx]->user;
2342
2343 uint i;
2344
2345 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2346
2347 fputc (separator, fp);
2348 }
2349
2350 ascii_digest (out_buf, salt_pos, digest_pos);
2351
2352 fputs (out_buf, fp);
2353
2354 log_out (fp, "");
2355 }
2356 else
2357 {
2358 hccap_t hccap;
2359
2360 to_hccap_t (&hccap, salt_pos, digest_pos);
2361
2362 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2363 }
2364 }
2365 }
2366
2367 fflush (fp);
2368
2369 fclose (fp);
2370
2371 unlink (old_hashfile);
2372
2373 if (rename (hashfile, old_hashfile) != 0)
2374 {
2375 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2376
2377 exit (-1);
2378 }
2379
2380 unlink (hashfile);
2381
2382 if (rename (new_hashfile, hashfile) != 0)
2383 {
2384 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2385
2386 exit (-1);
2387 }
2388
2389 unlink (old_hashfile);
2390 }
2391
2392 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2393 {
2394 // function called only in case kernel_power_all > words_left
2395
2396 float kernel_power_div = (float) (total_left) / kernel_power_all;
2397
2398 kernel_power_div += kernel_power_div / 100;
2399
2400 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2401
2402 while (kernel_power_new < total_left)
2403 {
2404 kernel_power_div += kernel_power_div / 100;
2405
2406 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2407 }
2408
2409 if (data.quiet == 0)
2410 {
2411 clear_prompt ();
2412
2413 //log_info ("");
2414
2415 log_info ("INFO: approaching final keyspace, workload adjusted");
2416 log_info ("");
2417
2418 fprintf (stdout, "%s", PROMPT);
2419
2420 fflush (stdout);
2421 }
2422
2423 //if ((kernel_power_all * kernel_power_div) < 8) return 1;
2424
2425 return kernel_power_div;
2426 }
2427
2428 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2429 {
2430 uint num_elements = num;
2431
2432 device_param->kernel_params_buf32[30] = data.combs_mode;
2433 device_param->kernel_params_buf32[31] = num;
2434
2435 uint kernel_threads = device_param->kernel_threads;
2436
2437 while (num_elements % kernel_threads) num_elements++;
2438
2439 cl_kernel kernel = NULL;
2440
2441 switch (kern_run)
2442 {
2443 case KERN_RUN_1: kernel = device_param->kernel1; break;
2444 case KERN_RUN_12: kernel = device_param->kernel12; break;
2445 case KERN_RUN_2: kernel = device_param->kernel2; break;
2446 case KERN_RUN_23: kernel = device_param->kernel23; break;
2447 case KERN_RUN_3: kernel = device_param->kernel3; break;
2448 }
2449
2450 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2451 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2452 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2453 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2454 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2455 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2456 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2457 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2458 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2459 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2460 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2461
2462 cl_event event;
2463
2464 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2465 {
2466 const size_t global_work_size[3] = { num_elements, 32, 1 };
2467 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2468
2469 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2470 }
2471 else
2472 {
2473 if (kern_run == KERN_RUN_2)
2474 {
2475 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2476 {
2477 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2478 }
2479 }
2480
2481 while (num_elements % kernel_threads) num_elements++;
2482
2483 const size_t global_work_size[3] = { num_elements, 1, 1 };
2484 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2485
2486 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2487 }
2488
2489 hc_clFlush (data.ocl, device_param->command_queue);
2490
2491 hc_clWaitForEvents (data.ocl, 1, &event);
2492
2493 if (event_update)
2494 {
2495 cl_ulong time_start;
2496 cl_ulong time_end;
2497
2498 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2499 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2500
2501 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2502
2503 uint exec_pos = device_param->exec_pos;
2504
2505 device_param->exec_ms[exec_pos] = exec_time;
2506
2507 exec_pos++;
2508
2509 if (exec_pos == EXEC_CACHE)
2510 {
2511 exec_pos = 0;
2512 }
2513
2514 device_param->exec_pos = exec_pos;
2515 }
2516
2517 hc_clReleaseEvent (data.ocl, event);
2518
2519 hc_clFinish (data.ocl, device_param->command_queue);
2520 }
2521
2522 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2523 {
2524 uint num_elements = num;
2525
2526 switch (kern_run)
2527 {
2528 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2529 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2530 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2531 }
2532
2533 // causes problems with special threads like in bcrypt
2534 // const uint kernel_threads = device_param->kernel_threads;
2535
2536 uint kernel_threads = device_param->kernel_threads;
2537
2538 while (num_elements % kernel_threads) num_elements++;
2539
2540 cl_kernel kernel = NULL;
2541
2542 switch (kern_run)
2543 {
2544 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2545 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2546 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2547 }
2548
2549 switch (kern_run)
2550 {
2551 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2552 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2553 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2554 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2555 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2556 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2557 break;
2558 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2559 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2560 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2561 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2562 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2563 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2564 break;
2565 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2566 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2567 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2568 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2569 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2570 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2571 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2572 break;
2573 }
2574
2575 const size_t global_work_size[3] = { num_elements, 1, 1 };
2576 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2577
2578 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2579
2580 hc_clFlush (data.ocl, device_param->command_queue);
2581
2582 hc_clFinish (data.ocl, device_param->command_queue);
2583 }
2584
2585 static void run_kernel_tm (hc_device_param_t *device_param)
2586 {
2587 const uint num_elements = 1024; // fixed
2588
2589 uint kernel_threads = 32;
2590
2591 cl_kernel kernel = device_param->kernel_tm;
2592
2593 const size_t global_work_size[3] = { num_elements, 1, 1 };
2594 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2595
2596 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2597
2598 hc_clFlush (data.ocl, device_param->command_queue);
2599
2600 hc_clFinish (data.ocl, device_param->command_queue);
2601 }
2602
2603 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2604 {
2605 uint num_elements = num;
2606
2607 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2608 device_param->kernel_params_amp_buf32[6] = num_elements;
2609
2610 // causes problems with special threads like in bcrypt
2611 // const uint kernel_threads = device_param->kernel_threads;
2612
2613 uint kernel_threads = device_param->kernel_threads;
2614
2615 while (num_elements % kernel_threads) num_elements++;
2616
2617 cl_kernel kernel = device_param->kernel_amp;
2618
2619 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2620 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2621
2622 const size_t global_work_size[3] = { num_elements, 1, 1 };
2623 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2624
2625 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2626
2627 hc_clFlush (data.ocl, device_param->command_queue);
2628
2629 hc_clFinish (data.ocl, device_param->command_queue);
2630 }
2631
2632 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2633 {
2634 const u32 num16d = num / 16;
2635 const u32 num16m = num % 16;
2636
2637 if (num16d)
2638 {
2639 device_param->kernel_params_memset_buf32[1] = value;
2640 device_param->kernel_params_memset_buf32[2] = num16d;
2641
2642 uint kernel_threads = device_param->kernel_threads;
2643
2644 uint num_elements = num16d;
2645
2646 while (num_elements % kernel_threads) num_elements++;
2647
2648 cl_kernel kernel = device_param->kernel_memset;
2649
2650 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2651 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2652 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2653
2654 const size_t global_work_size[3] = { num_elements, 1, 1 };
2655 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2656
2657 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2658
2659 hc_clFlush (data.ocl, device_param->command_queue);
2660
2661 hc_clFinish (data.ocl, device_param->command_queue);
2662 }
2663
2664 if (num16m)
2665 {
2666 u32 tmp[4];
2667
2668 tmp[0] = value;
2669 tmp[1] = value;
2670 tmp[2] = value;
2671 tmp[3] = value;
2672
2673 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2674 }
2675 }
2676
2677 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2678 {
2679 run_kernel_memset (device_param, buf, 0, size);
2680
2681 /*
2682 int rc = -1;
2683
2684 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2685 {
2686 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2687
2688 const cl_uchar zero = 0;
2689
2690 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2691 }
2692
2693 if (rc != 0)
2694 {
2695 // NOTE: clEnqueueFillBuffer () always fails with -59
2696 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2697 // How's that possible, OpenCL 1.2 support is advertised??
2698 // We need to workaround...
2699
2700 #define FILLSZ 0x100000
2701
2702 char *tmp = (char *) mymalloc (FILLSZ);
2703
2704 for (size_t i = 0; i < size; i += FILLSZ)
2705 {
2706 const size_t left = size - i;
2707
2708 const size_t fillsz = MIN (FILLSZ, left);
2709
2710 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2711 }
2712
2713 myfree (tmp);
2714 }
2715 */
2716 }
2717
2718 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)
2719 {
2720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2721 {
2722 if (attack_mode == ATTACK_MODE_BF)
2723 {
2724 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2725 {
2726 const uint size_tm = 32 * sizeof (bs_word_t);
2727
2728 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2729
2730 run_kernel_tm (device_param);
2731
2732 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);
2733 }
2734 }
2735
2736 if (highest_pw_len < 16)
2737 {
2738 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2739 }
2740 else if (highest_pw_len < 32)
2741 {
2742 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2743 }
2744 else
2745 {
2746 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2747 }
2748 }
2749 else
2750 {
2751 run_kernel_amp (device_param, pws_cnt);
2752
2753 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2754
2755 if (opts_type & OPTS_TYPE_HOOK12)
2756 {
2757 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2758 }
2759
2760 uint iter = salt_buf->salt_iter;
2761
2762 uint loop_step = device_param->kernel_loops;
2763
2764 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2765 {
2766 uint loop_left = iter - loop_pos;
2767
2768 loop_left = MIN (loop_left, loop_step);
2769
2770 device_param->kernel_params_buf32[25] = loop_pos;
2771 device_param->kernel_params_buf32[26] = loop_left;
2772
2773 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2774
2775 if (data.devices_status == STATUS_CRACKED) break;
2776 if (data.devices_status == STATUS_ABORTED) break;
2777 if (data.devices_status == STATUS_QUIT) break;
2778
2779 /**
2780 * speed
2781 */
2782
2783 const float iter_part = (float) (loop_pos + loop_left) / iter;
2784
2785 const u64 perf_sum_all = pws_cnt * iter_part;
2786
2787 double speed_ms;
2788
2789 hc_timer_get (device_param->timer_speed, speed_ms);
2790
2791 const u32 speed_pos = device_param->speed_pos;
2792
2793 device_param->speed_cnt[speed_pos] = perf_sum_all;
2794
2795 device_param->speed_ms[speed_pos] = speed_ms;
2796
2797 if (data.benchmark == 1)
2798 {
2799 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2800 }
2801 }
2802
2803 if (opts_type & OPTS_TYPE_HOOK23)
2804 {
2805 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2806
2807 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);
2808
2809 // do something with data
2810
2811 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);
2812 }
2813
2814 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2815 }
2816 }
2817
2818 static int run_rule_engine (const int rule_len, const char *rule_buf)
2819 {
2820 if (rule_len == 0)
2821 {
2822 return 0;
2823 }
2824 else if (rule_len == 1)
2825 {
2826 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2827 }
2828
2829 return 1;
2830 }
2831
2832 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2833 {
2834 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2835 {
2836 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);
2837 }
2838 else if (data.attack_kern == ATTACK_KERN_COMBI)
2839 {
2840 if (data.attack_mode == ATTACK_MODE_COMBI)
2841 {
2842 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2843 {
2844 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2845 {
2846 for (u32 i = 0; i < pws_cnt; i++)
2847 {
2848 const u32 pw_len = device_param->pws_buf[i].pw_len;
2849
2850 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2851
2852 ptr[pw_len] = 0x01;
2853 }
2854 }
2855 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2856 {
2857 for (u32 i = 0; i < pws_cnt; i++)
2858 {
2859 const u32 pw_len = device_param->pws_buf[i].pw_len;
2860
2861 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2862
2863 ptr[pw_len] = 0x80;
2864 }
2865 }
2866 }
2867 }
2868 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2869 {
2870 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2871 {
2872 for (u32 i = 0; i < pws_cnt; i++)
2873 {
2874 const u32 pw_len = device_param->pws_buf[i].pw_len;
2875
2876 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2877
2878 ptr[pw_len] = 0x01;
2879 }
2880 }
2881 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2882 {
2883 for (u32 i = 0; i < pws_cnt; i++)
2884 {
2885 const u32 pw_len = device_param->pws_buf[i].pw_len;
2886
2887 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2888
2889 ptr[pw_len] = 0x80;
2890 }
2891 }
2892 }
2893
2894 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);
2895 }
2896 else if (data.attack_kern == ATTACK_KERN_BF)
2897 {
2898 const u64 off = device_param->words_off;
2899
2900 device_param->kernel_params_mp_l_buf64[3] = off;
2901
2902 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2903 }
2904 }
2905
2906 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2907 {
2908 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2909
2910 device_param->kernel_params_buf32[25] = 0;
2911 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2912 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2913
2914 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2915 {
2916 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true);
2917 }
2918 else
2919 {
2920 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true);
2921 }
2922
2923 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2924
2925 return exec_ms_prev;
2926 }
2927
2928 static void autotune (hc_device_param_t *device_param)
2929 {
2930 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2931
2932 const u32 kernel_accel_min = device_param->kernel_accel_min;
2933 const u32 kernel_accel_max = device_param->kernel_accel_max;
2934
2935 const u32 kernel_loops_min = device_param->kernel_loops_min;
2936 const u32 kernel_loops_max = device_param->kernel_loops_max;
2937
2938 u32 kernel_accel = kernel_accel_min;
2939 u32 kernel_loops = kernel_loops_min;
2940
2941 // in this case the user specified a fixed -u and -n on the commandline
2942 // no way to tune anything
2943 // but we need to run a few caching rounds
2944
2945 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2946 {
2947 try_run (device_param, kernel_accel, kernel_loops);
2948 try_run (device_param, kernel_accel, kernel_loops);
2949 try_run (device_param, kernel_accel, kernel_loops);
2950 try_run (device_param, kernel_accel, kernel_loops);
2951
2952 device_param->kernel_accel = kernel_accel;
2953 device_param->kernel_loops = kernel_loops;
2954
2955 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2956
2957 device_param->kernel_power = kernel_power;
2958
2959 return;
2960 }
2961
2962 // from here it's clear we are allowed to autotune
2963 // so let's init some fake words
2964
2965 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2966
2967 if (data.attack_kern == ATTACK_KERN_BF)
2968 {
2969 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2970 }
2971 else
2972 {
2973 for (u32 i = 0; i < kernel_power_max; i++)
2974 {
2975 device_param->pws_buf[i].i[0] = i;
2976 device_param->pws_buf[i].i[1] = 0x01234567;
2977 device_param->pws_buf[i].pw_len = 7 + (i & 7);
2978 }
2979
2980 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);
2981 }
2982
2983 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2984 {
2985 if (data.kernel_rules_cnt > 1)
2986 {
2987 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
2988 }
2989 }
2990 else
2991 {
2992 run_kernel_amp (device_param, kernel_power_max);
2993 }
2994
2995 #define VERIFIER_CNT 1
2996
2997 // first find out highest kernel-loops that stays below target_ms
2998
2999 if (kernel_loops_min < kernel_loops_max)
3000 {
3001 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3002 {
3003 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3004
3005 for (int i = 0; i < VERIFIER_CNT; i++)
3006 {
3007 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3008
3009 exec_ms = MIN (exec_ms, exec_ms_v);
3010 }
3011
3012 if (exec_ms < target_ms) break;
3013 }
3014 }
3015
3016 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3017
3018 #define STEPS_CNT 10
3019
3020 if (kernel_accel_min < kernel_accel_max)
3021 {
3022 for (int i = 0; i < STEPS_CNT; i++)
3023 {
3024 const u32 kernel_accel_try = 1 << i;
3025
3026 if (kernel_accel_try < kernel_accel_min) continue;
3027 if (kernel_accel_try > kernel_accel_max) break;
3028
3029 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3030
3031 for (int i = 0; i < VERIFIER_CNT; i++)
3032 {
3033 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3034
3035 exec_ms = MIN (exec_ms, exec_ms_v);
3036 }
3037
3038 if (exec_ms > target_ms) break;
3039
3040 kernel_accel = kernel_accel_try;
3041 }
3042 }
3043
3044 // at this point we want to know the actual runtime for the following reason:
3045 // we need a reference for the balancing loop following up, and this
3046 // the balancing loop can have an effect that the creates a new opportunity, for example:
3047 // if the target is 95 ms and the current runtime is 48ms the above loop
3048 // stopped the execution because the previous exec_ms was > 95ms
3049 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3050 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3051
3052 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3053
3054 for (int i = 0; i < VERIFIER_CNT; i++)
3055 {
3056 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3057
3058 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3059 }
3060
3061 u32 diff = kernel_loops - kernel_accel;
3062
3063 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3064 {
3065 u32 kernel_accel_orig = kernel_accel;
3066 u32 kernel_loops_orig = kernel_loops;
3067
3068 for (u32 f = 1; f < 1024; f++)
3069 {
3070 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3071 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3072
3073 if (kernel_accel_try > kernel_accel_max) break;
3074 if (kernel_loops_try < kernel_loops_min) break;
3075
3076 u32 diff_new = kernel_loops_try - kernel_accel_try;
3077
3078 if (diff_new > diff) break;
3079
3080 diff_new = diff;
3081
3082 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3083
3084 for (int i = 0; i < VERIFIER_CNT; i++)
3085 {
3086 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3087
3088 exec_ms = MIN (exec_ms, exec_ms_v);
3089 }
3090
3091 if (exec_ms < exec_ms_pre_final)
3092 {
3093 exec_ms_pre_final = exec_ms;
3094
3095 kernel_accel = kernel_accel_try;
3096 kernel_loops = kernel_loops_try;
3097 }
3098 }
3099 }
3100
3101 const double exec_left = target_ms / exec_ms_pre_final;
3102
3103 const double accel_left = kernel_accel_max / kernel_accel;
3104
3105 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3106
3107 if (exec_accel_min >= 1.0)
3108 {
3109 // this is safe to not overflow kernel_accel_max because of accel_left
3110
3111 kernel_accel = (double) kernel_accel * exec_accel_min;
3112 }
3113
3114 // reset them fake words
3115
3116 /*
3117 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3118
3119 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);
3120 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);
3121 */
3122
3123 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3124
3125 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3126 {
3127 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3128 }
3129
3130 // reset timer
3131
3132 device_param->exec_pos = 0;
3133
3134 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3135
3136 // store
3137
3138 device_param->kernel_accel = kernel_accel;
3139 device_param->kernel_loops = kernel_loops;
3140
3141 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3142
3143 device_param->kernel_power = kernel_power;
3144
3145 #ifdef DEBUG
3146
3147 if (data.quiet == 0)
3148 {
3149 clear_prompt ();
3150
3151 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3152 "Device #%u: autotuned kernel-loops to %u\n",
3153 device_param->device_id + 1, kernel_accel,
3154 device_param->device_id + 1, kernel_loops);
3155
3156 fprintf (stdout, "%s", PROMPT);
3157
3158 fflush (stdout);
3159 }
3160
3161 #endif
3162 }
3163
3164 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3165 {
3166 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3167
3168 // init speed timer
3169
3170 uint speed_pos = device_param->speed_pos;
3171
3172 #ifdef _POSIX
3173 if (device_param->timer_speed.tv_sec == 0)
3174 {
3175 hc_timer_set (&device_param->timer_speed);
3176 }
3177 #endif
3178
3179 #ifdef _WIN
3180 if (device_param->timer_speed.QuadPart == 0)
3181 {
3182 hc_timer_set (&device_param->timer_speed);
3183 }
3184 #endif
3185
3186 // find higest password length, this is for optimization stuff
3187
3188 uint highest_pw_len = 0;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3191 {
3192 }
3193 else if (data.attack_kern == ATTACK_KERN_COMBI)
3194 {
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3199 + device_param->kernel_params_mp_l_buf32[5];
3200 }
3201
3202 // iteration type
3203
3204 uint innerloop_step = 0;
3205 uint innerloop_cnt = 0;
3206
3207 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3208 else innerloop_step = 1;
3209
3210 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3211 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3212 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3213
3214 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3215
3216 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3217 {
3218 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3219
3220 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3221
3222 if (data.devices_status == STATUS_CRACKED) break;
3223 if (data.devices_status == STATUS_ABORTED) break;
3224 if (data.devices_status == STATUS_QUIT) break;
3225 if (data.devices_status == STATUS_BYPASS) break;
3226
3227 salt_t *salt_buf = &data.salts_buf[salt_pos];
3228
3229 device_param->kernel_params_buf32[24] = salt_pos;
3230 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3231 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3232
3233 FILE *combs_fp = device_param->combs_fp;
3234
3235 if (data.attack_mode == ATTACK_MODE_COMBI)
3236 {
3237 rewind (combs_fp);
3238 }
3239
3240 // innerloops
3241
3242 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3243 {
3244 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3245
3246 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3247
3248 if (data.devices_status == STATUS_CRACKED) break;
3249 if (data.devices_status == STATUS_ABORTED) break;
3250 if (data.devices_status == STATUS_QUIT) break;
3251 if (data.devices_status == STATUS_BYPASS) break;
3252
3253 uint innerloop_left = innerloop_cnt - innerloop_pos;
3254
3255 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3256
3257 device_param->innerloop_pos = innerloop_pos;
3258 device_param->innerloop_left = innerloop_left;
3259
3260 device_param->kernel_params_buf32[27] = innerloop_left;
3261
3262 // i think we can get rid of this
3263 if (innerloop_left == 0)
3264 {
3265 puts ("bug, how should this happen????\n");
3266
3267 continue;
3268 }
3269
3270 if (data.salts_shown[salt_pos] == 1)
3271 {
3272 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3273
3274 continue;
3275 }
3276
3277 // initialize amplifiers
3278
3279 if (data.attack_mode == ATTACK_MODE_COMBI)
3280 {
3281 uint i = 0;
3282
3283 while (i < innerloop_left)
3284 {
3285 if (feof (combs_fp)) break;
3286
3287 int line_len = fgetl (combs_fp, line_buf);
3288
3289 if (line_len >= PW_MAX1) continue;
3290
3291 line_len = convert_from_hex (line_buf, line_len);
3292
3293 char *line_buf_new = line_buf;
3294
3295 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3296 {
3297 char rule_buf_out[BLOCK_SIZE] = { 0 };
3298
3299 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3300
3301 if (rule_len_out < 0)
3302 {
3303 data.words_progress_rejected[salt_pos] += pws_cnt;
3304
3305 continue;
3306 }
3307
3308 line_len = rule_len_out;
3309
3310 line_buf_new = rule_buf_out;
3311 }
3312
3313 line_len = MIN (line_len, PW_DICTMAX);
3314
3315 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3316
3317 memcpy (ptr, line_buf_new, line_len);
3318
3319 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3320
3321 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3322 {
3323 uppercase (ptr, line_len);
3324 }
3325
3326 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3327 {
3328 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3329 {
3330 ptr[line_len] = 0x80;
3331 }
3332
3333 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3334 {
3335 ptr[line_len] = 0x01;
3336 }
3337 }
3338
3339 device_param->combs_buf[i].pw_len = line_len;
3340
3341 i++;
3342 }
3343
3344 for (uint j = i; j < innerloop_left; j++)
3345 {
3346 device_param->combs_buf[j].i[0] = 0;
3347 device_param->combs_buf[j].i[1] = 0;
3348 device_param->combs_buf[j].i[2] = 0;
3349 device_param->combs_buf[j].i[3] = 0;
3350 device_param->combs_buf[j].i[4] = 0;
3351 device_param->combs_buf[j].i[5] = 0;
3352 device_param->combs_buf[j].i[6] = 0;
3353 device_param->combs_buf[j].i[7] = 0;
3354
3355 device_param->combs_buf[j].pw_len = 0;
3356 }
3357
3358 innerloop_left = i;
3359 }
3360 else if (data.attack_mode == ATTACK_MODE_BF)
3361 {
3362 u64 off = innerloop_pos;
3363
3364 device_param->kernel_params_mp_r_buf64[3] = off;
3365
3366 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3367 }
3368 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3369 {
3370 u64 off = innerloop_pos;
3371
3372 device_param->kernel_params_mp_buf64[3] = off;
3373
3374 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3375 }
3376 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3377 {
3378 u64 off = innerloop_pos;
3379
3380 device_param->kernel_params_mp_buf64[3] = off;
3381
3382 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3383 }
3384
3385 // copy amplifiers
3386
3387 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3388 {
3389 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);
3390 }
3391 else if (data.attack_mode == ATTACK_MODE_COMBI)
3392 {
3393 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);
3394 }
3395 else if (data.attack_mode == ATTACK_MODE_BF)
3396 {
3397 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);
3398 }
3399 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3400 {
3401 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);
3402 }
3403 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3404 {
3405 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);
3406 }
3407
3408 if (data.benchmark == 1)
3409 {
3410 hc_timer_set (&device_param->timer_speed);
3411 }
3412
3413 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3414
3415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3416
3417 if (data.devices_status == STATUS_CRACKED) break;
3418 if (data.devices_status == STATUS_ABORTED) break;
3419 if (data.devices_status == STATUS_QUIT) break;
3420
3421 /**
3422 * result
3423 */
3424
3425 check_cracked (device_param, salt_pos);
3426
3427 /**
3428 * progress
3429 */
3430
3431 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3432
3433 hc_thread_mutex_lock (mux_counter);
3434
3435 data.words_progress_done[salt_pos] += perf_sum_all;
3436
3437 hc_thread_mutex_unlock (mux_counter);
3438
3439 /**
3440 * speed
3441 */
3442
3443 double speed_ms;
3444
3445 hc_timer_get (device_param->timer_speed, speed_ms);
3446
3447 hc_timer_set (&device_param->timer_speed);
3448
3449 // current speed
3450
3451 //hc_thread_mutex_lock (mux_display);
3452
3453 device_param->speed_cnt[speed_pos] = perf_sum_all;
3454
3455 device_param->speed_ms[speed_pos] = speed_ms;
3456
3457 //hc_thread_mutex_unlock (mux_display);
3458
3459 speed_pos++;
3460
3461 if (speed_pos == SPEED_CACHE)
3462 {
3463 speed_pos = 0;
3464 }
3465
3466 /**
3467 * benchmark
3468 */
3469
3470 if (data.benchmark == 1) break;
3471 }
3472 }
3473
3474 device_param->speed_pos = speed_pos;
3475
3476 myfree (line_buf);
3477 }
3478
3479 static void load_segment (wl_data_t *wl_data, FILE *fd)
3480 {
3481 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3482
3483 wl_data->pos = 0;
3484
3485 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3486
3487 wl_data->buf[wl_data->cnt] = 0;
3488
3489 if (wl_data->cnt == 0) return;
3490
3491 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3492
3493 while (!feof (fd))
3494 {
3495 if (wl_data->cnt == wl_data->avail)
3496 {
3497 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3498
3499 wl_data->avail += wl_data->incr;
3500 }
3501
3502 const int c = fgetc (fd);
3503
3504 if (c == EOF) break;
3505
3506 wl_data->buf[wl_data->cnt] = (char) c;
3507
3508 wl_data->cnt++;
3509
3510 if (c == '\n') break;
3511 }
3512
3513 // ensure stream ends with a newline
3514
3515 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3516 {
3517 wl_data->cnt++;
3518
3519 wl_data->buf[wl_data->cnt - 1] = '\n';
3520 }
3521
3522 return;
3523 }
3524
3525 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3526 {
3527 char *ptr = buf;
3528
3529 for (u32 i = 0; i < sz; i++, ptr++)
3530 {
3531 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3532
3533 if (i == 7)
3534 {
3535 *off = i;
3536 *len = i;
3537
3538 return;
3539 }
3540
3541 if (*ptr != '\n') continue;
3542
3543 *off = i + 1;
3544
3545 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3546
3547 *len = i;
3548
3549 return;
3550 }
3551
3552 *off = sz;
3553 *len = sz;
3554 }
3555
3556 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3557 {
3558 char *ptr = buf;
3559
3560 for (u32 i = 0; i < sz; i++, ptr++)
3561 {
3562 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3563
3564 if (*ptr != '\n') continue;
3565
3566 *off = i + 1;
3567
3568 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3569
3570 *len = i;
3571
3572 return;
3573 }
3574
3575 *off = sz;
3576 *len = sz;
3577 }
3578
3579 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3580 {
3581 char *ptr = buf;
3582
3583 for (u32 i = 0; i < sz; i++, ptr++)
3584 {
3585 if (*ptr != '\n') continue;
3586
3587 *off = i + 1;
3588
3589 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3590
3591 *len = i;
3592
3593 return;
3594 }
3595
3596 *off = sz;
3597 *len = sz;
3598 }
3599
3600 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3601 {
3602 while (wl_data->pos < wl_data->cnt)
3603 {
3604 uint off;
3605 uint len;
3606
3607 char *ptr = wl_data->buf + wl_data->pos;
3608
3609 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3610
3611 wl_data->pos += off;
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3614 {
3615 char rule_buf_out[BLOCK_SIZE] = { 0 };
3616
3617 int rule_len_out = -1;
3618
3619 if (len < BLOCK_SIZE)
3620 {
3621 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3622 }
3623
3624 if (rule_len_out < 0)
3625 {
3626 continue;
3627 }
3628
3629 if (rule_len_out > PW_MAX)
3630 {
3631 continue;
3632 }
3633 }
3634 else
3635 {
3636 if (len > PW_MAX)
3637 {
3638 continue;
3639 }
3640 }
3641
3642 *out_buf = ptr;
3643 *out_len = len;
3644
3645 return;
3646 }
3647
3648 if (feof (fd))
3649 {
3650 fprintf (stderr, "BUG feof()!!\n");
3651
3652 return;
3653 }
3654
3655 load_segment (wl_data, fd);
3656
3657 get_next_word (wl_data, fd, out_buf, out_len);
3658 }
3659
3660 #ifdef _POSIX
3661 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3662 #endif
3663
3664 #ifdef _WIN
3665 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3666 #endif
3667 {
3668 hc_signal (NULL);
3669
3670 dictstat_t d;
3671
3672 d.cnt = 0;
3673
3674 #ifdef _POSIX
3675 fstat (fileno (fd), &d.stat);
3676 #endif
3677
3678 #ifdef _WIN
3679 _fstat64 (fileno (fd), &d.stat);
3680 #endif
3681
3682 d.stat.st_mode = 0;
3683 d.stat.st_nlink = 0;
3684 d.stat.st_uid = 0;
3685 d.stat.st_gid = 0;
3686 d.stat.st_rdev = 0;
3687 d.stat.st_atime = 0;
3688
3689 #ifdef _POSIX
3690 d.stat.st_blksize = 0;
3691 d.stat.st_blocks = 0;
3692 #endif
3693
3694 if (d.stat.st_size == 0) return 0;
3695
3696 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3697
3698 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3699 {
3700 if (d_cache)
3701 {
3702 u64 cnt = d_cache->cnt;
3703
3704 u64 keyspace = cnt;
3705
3706 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3707 {
3708 keyspace *= data.kernel_rules_cnt;
3709 }
3710 else if (data.attack_kern == ATTACK_KERN_COMBI)
3711 {
3712 keyspace *= data.combs_cnt;
3713 }
3714
3715 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);
3716 if (data.quiet == 0) log_info ("");
3717
3718 hc_signal (sigHandler_default);
3719
3720 return (keyspace);
3721 }
3722 }
3723
3724 time_t now = 0;
3725 time_t prev = 0;
3726
3727 u64 comp = 0;
3728 u64 cnt = 0;
3729 u64 cnt2 = 0;
3730
3731 while (!feof (fd))
3732 {
3733 load_segment (wl_data, fd);
3734
3735 comp += wl_data->cnt;
3736
3737 u32 i = 0;
3738
3739 while (i < wl_data->cnt)
3740 {
3741 u32 len;
3742 u32 off;
3743
3744 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3745
3746 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3747 {
3748 char rule_buf_out[BLOCK_SIZE] = { 0 };
3749
3750 int rule_len_out = -1;
3751
3752 if (len < BLOCK_SIZE)
3753 {
3754 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3755 }
3756
3757 if (rule_len_out < 0)
3758 {
3759 len = PW_MAX1;
3760 }
3761 else
3762 {
3763 len = rule_len_out;
3764 }
3765 }
3766
3767 if (len < PW_MAX1)
3768 {
3769 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3770 {
3771 cnt += data.kernel_rules_cnt;
3772 }
3773 else if (data.attack_kern == ATTACK_KERN_COMBI)
3774 {
3775 cnt += data.combs_cnt;
3776 }
3777
3778 d.cnt++;
3779 }
3780
3781 i += off;
3782
3783 cnt2++;
3784 }
3785
3786 time (&now);
3787
3788 if ((now - prev) == 0) continue;
3789
3790 float percent = (float) comp / (float) d.stat.st_size;
3791
3792 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);
3793
3794 time (&prev);
3795 }
3796
3797 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);
3798 if (data.quiet == 0) log_info ("");
3799
3800 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3801
3802 hc_signal (sigHandler_default);
3803
3804 return (cnt);
3805 }
3806
3807 static void *thread_monitor (void *p)
3808 {
3809 uint runtime_check = 0;
3810 uint remove_check = 0;
3811 uint status_check = 0;
3812 uint restore_check = 0;
3813
3814 uint restore_left = data.restore_timer;
3815 uint remove_left = data.remove_timer;
3816 uint status_left = data.status_timer;
3817
3818 #ifdef HAVE_HWMON
3819 uint hwmon_check = 0;
3820
3821 // these variables are mainly used for fan control
3822
3823 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3824
3825 // temperature controller "loopback" values
3826
3827 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3828 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3829
3830 int temp_threshold = 1; // degrees celcius
3831
3832 int fan_speed_min = 15; // in percentage
3833 int fan_speed_max = 100;
3834
3835 time_t last_temp_check_time;
3836 #endif // HAVE_HWMON
3837
3838 uint sleep_time = 1;
3839
3840 if (data.runtime)
3841 {
3842 runtime_check = 1;
3843 }
3844
3845 if (data.restore_timer)
3846 {
3847 restore_check = 1;
3848 }
3849
3850 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3851 {
3852 remove_check = 1;
3853 }
3854
3855 if (data.status == 1)
3856 {
3857 status_check = 1;
3858 }
3859
3860 #ifdef HAVE_HWMON
3861 if (data.gpu_temp_disable == 0)
3862 {
3863 time (&last_temp_check_time);
3864
3865 hwmon_check = 1;
3866 }
3867 #endif
3868
3869 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3870 {
3871 #ifdef HAVE_HWMON
3872 if (hwmon_check == 0)
3873 #endif
3874 return (p);
3875 }
3876
3877 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3878 {
3879 hc_sleep (sleep_time);
3880
3881 if (data.devices_status != STATUS_RUNNING) continue;
3882
3883 #ifdef HAVE_HWMON
3884
3885 if (hwmon_check == 1)
3886 {
3887 hc_thread_mutex_lock (mux_adl);
3888
3889 time_t temp_check_time;
3890
3891 time (&temp_check_time);
3892
3893 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3894
3895 if (Ta == 0) Ta = 1;
3896
3897 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3898 {
3899 hc_device_param_t *device_param = &data.devices_param[device_id];
3900
3901 if (device_param->skipped) continue;
3902
3903 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3904
3905 const int temperature = hm_get_temperature_with_device_id (device_id);
3906
3907 if (temperature > (int) data.gpu_temp_abort)
3908 {
3909 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3910
3911 if (data.devices_status != STATUS_QUIT) myabort ();
3912
3913 break;
3914 }
3915
3916 const int gpu_temp_retain = data.gpu_temp_retain;
3917
3918 if (gpu_temp_retain)
3919 {
3920 if (data.hm_device[device_id].fan_set_supported == 1)
3921 {
3922 int temp_cur = temperature;
3923
3924 int temp_diff_new = gpu_temp_retain - temp_cur;
3925
3926 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3927
3928 // calculate Ta value (time difference in seconds between the last check and this check)
3929
3930 last_temp_check_time = temp_check_time;
3931
3932 float Kp = 1.8;
3933 float Ki = 0.005;
3934 float Kd = 6;
3935
3936 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3937
3938 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);
3939
3940 if (abs (fan_diff_required) >= temp_threshold)
3941 {
3942 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3943
3944 int fan_speed_level = fan_speed_cur;
3945
3946 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3947
3948 int fan_speed_new = fan_speed_level - fan_diff_required;
3949
3950 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3951 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3952
3953 if (fan_speed_new != fan_speed_cur)
3954 {
3955 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3956 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3957
3958 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3959 {
3960 if (device_param->device_vendor_id == VENDOR_ID_AMD)
3961 {
3962 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
3963 }
3964 else if (device_param->device_vendor_id == VENDOR_ID_NV)
3965 {
3966
3967 }
3968
3969 fan_speed_chgd[device_id] = 1;
3970 }
3971
3972 temp_diff_old[device_id] = temp_diff_new;
3973 }
3974 }
3975 }
3976 }
3977 }
3978
3979 hc_thread_mutex_unlock (mux_adl);
3980 }
3981 #endif // HAVE_HWMON
3982
3983 if (restore_check == 1)
3984 {
3985 restore_left--;
3986
3987 if (restore_left == 0)
3988 {
3989 if (data.restore_disable == 0) cycle_restore ();
3990
3991 restore_left = data.restore_timer;
3992 }
3993 }
3994
3995 if ((runtime_check == 1) && (data.runtime_start > 0))
3996 {
3997 time_t runtime_cur;
3998
3999 time (&runtime_cur);
4000
4001 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4002
4003 if (runtime_left <= 0)
4004 {
4005 if (data.benchmark == 0)
4006 {
4007 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4008 }
4009
4010 if (data.devices_status != STATUS_QUIT) myabort ();
4011 }
4012 }
4013
4014 if (remove_check == 1)
4015 {
4016 remove_left--;
4017
4018 if (remove_left == 0)
4019 {
4020 if (data.digests_saved != data.digests_done)
4021 {
4022 data.digests_saved = data.digests_done;
4023
4024 save_hash ();
4025 }
4026
4027 remove_left = data.remove_timer;
4028 }
4029 }
4030
4031 if (status_check == 1)
4032 {
4033 status_left--;
4034
4035 if (status_left == 0)
4036 {
4037 //hc_thread_mutex_lock (mux_display);
4038
4039 if (data.quiet == 0) clear_prompt ();
4040
4041 if (data.quiet == 0) log_info ("");
4042
4043 status_display ();
4044
4045 if (data.quiet == 0) log_info ("");
4046
4047 //hc_thread_mutex_unlock (mux_display);
4048
4049 status_left = data.status_timer;
4050 }
4051 }
4052 }
4053
4054 #ifdef HAVE_HWMON
4055 myfree (fan_speed_chgd);
4056
4057 myfree (temp_diff_old);
4058 myfree (temp_diff_sum);
4059 #endif
4060
4061 p = NULL;
4062
4063 return (p);
4064 }
4065
4066 static void *thread_outfile_remove (void *p)
4067 {
4068 // some hash-dependent constants
4069 char *outfile_dir = data.outfile_check_directory;
4070 uint dgst_size = data.dgst_size;
4071 uint isSalted = data.isSalted;
4072 uint esalt_size = data.esalt_size;
4073 uint hash_mode = data.hash_mode;
4074
4075 uint outfile_check_timer = data.outfile_check_timer;
4076
4077 char separator = data.separator;
4078
4079 // some hash-dependent functions
4080 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4081 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4082
4083 // buffers
4084 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4085
4086 hash_buf.digest = mymalloc (dgst_size);
4087
4088 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4089
4090 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4091
4092 uint digest_buf[64] = { 0 };
4093
4094 outfile_data_t *out_info = NULL;
4095
4096 char **out_files = NULL;
4097
4098 time_t folder_mtime = 0;
4099
4100 int out_cnt = 0;
4101
4102 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4103
4104 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4105 {
4106 hc_sleep (1);
4107
4108 if (data.devices_status != STATUS_RUNNING) continue;
4109
4110 check_left--;
4111
4112 if (check_left == 0)
4113 {
4114 struct stat outfile_check_stat;
4115
4116 if (stat (outfile_dir, &outfile_check_stat) == 0)
4117 {
4118 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4119
4120 if (is_dir == 1)
4121 {
4122 if (outfile_check_stat.st_mtime > folder_mtime)
4123 {
4124 char **out_files_new = scan_directory (outfile_dir);
4125
4126 int out_cnt_new = count_dictionaries (out_files_new);
4127
4128 outfile_data_t *out_info_new = NULL;
4129
4130 if (out_cnt_new > 0)
4131 {
4132 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4133
4134 for (int i = 0; i < out_cnt_new; i++)
4135 {
4136 out_info_new[i].file_name = out_files_new[i];
4137
4138 // check if there are files that we have seen/checked before (and not changed)
4139
4140 for (int j = 0; j < out_cnt; j++)
4141 {
4142 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4143 {
4144 struct stat outfile_stat;
4145
4146 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4147 {
4148 if (outfile_stat.st_ctime == out_info[j].ctime)
4149 {
4150 out_info_new[i].ctime = out_info[j].ctime;
4151 out_info_new[i].seek = out_info[j].seek;
4152 }
4153 }
4154 }
4155 }
4156 }
4157 }
4158
4159 local_free (out_info);
4160 local_free (out_files);
4161
4162 out_files = out_files_new;
4163 out_cnt = out_cnt_new;
4164 out_info = out_info_new;
4165
4166 folder_mtime = outfile_check_stat.st_mtime;
4167 }
4168
4169 for (int j = 0; j < out_cnt; j++)
4170 {
4171 FILE *fp = fopen (out_info[j].file_name, "rb");
4172
4173 if (fp != NULL)
4174 {
4175 //hc_thread_mutex_lock (mux_display);
4176
4177 #ifdef _POSIX
4178 struct stat outfile_stat;
4179
4180 fstat (fileno (fp), &outfile_stat);
4181 #endif
4182
4183 #ifdef _WIN
4184 struct stat64 outfile_stat;
4185
4186 _fstat64 (fileno (fp), &outfile_stat);
4187 #endif
4188
4189 if (outfile_stat.st_ctime > out_info[j].ctime)
4190 {
4191 out_info[j].ctime = outfile_stat.st_ctime;
4192 out_info[j].seek = 0;
4193 }
4194
4195 fseek (fp, out_info[j].seek, SEEK_SET);
4196
4197 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4198
4199 while (!feof (fp))
4200 {
4201 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4202
4203 if (ptr == NULL) break;
4204
4205 int line_len = strlen (line_buf);
4206
4207 if (line_len <= 0) continue;
4208
4209 int iter = MAX_CUT_TRIES;
4210
4211 for (uint i = line_len - 1; i && iter; i--, line_len--)
4212 {
4213 if (line_buf[i] != separator) continue;
4214
4215 int parser_status = PARSER_OK;
4216
4217 if ((hash_mode != 2500) && (hash_mode != 6800))
4218 {
4219 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4220 }
4221
4222 uint found = 0;
4223
4224 if (parser_status == PARSER_OK)
4225 {
4226 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4227 {
4228 if (data.salts_shown[salt_pos] == 1) continue;
4229
4230 salt_t *salt_buf = &data.salts_buf[salt_pos];
4231
4232 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4233 {
4234 uint idx = salt_buf->digests_offset + digest_pos;
4235
4236 if (data.digests_shown[idx] == 1) continue;
4237
4238 uint cracked = 0;
4239
4240 if (hash_mode == 6800)
4241 {
4242 if (i == salt_buf->salt_len)
4243 {
4244 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4245 }
4246 }
4247 else if (hash_mode == 2500)
4248 {
4249 // BSSID : MAC1 : MAC2 (:plain)
4250 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4251 {
4252 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4253
4254 if (!cracked) continue;
4255
4256 // now compare MAC1 and MAC2 too, since we have this additional info
4257 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4258 char *mac2_pos = mac1_pos + 12 + 1;
4259
4260 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4261 wpa_t *wpa = &wpas[salt_pos];
4262
4263 // compare hex string(s) vs binary MAC address(es)
4264
4265 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4266 {
4267 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4268 {
4269 cracked = 0;
4270
4271 break;
4272 }
4273 }
4274
4275 // early skip ;)
4276 if (!cracked) continue;
4277
4278 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4279 {
4280 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4281 {
4282 cracked = 0;
4283
4284 break;
4285 }
4286 }
4287 }
4288 }
4289 else
4290 {
4291 char *digests_buf_ptr = (char *) data.digests_buf;
4292
4293 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4294
4295 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4296 }
4297
4298 if (cracked == 1)
4299 {
4300 found = 1;
4301
4302 data.digests_shown[idx] = 1;
4303
4304 data.digests_done++;
4305
4306 salt_buf->digests_done++;
4307
4308 if (salt_buf->digests_done == salt_buf->digests_cnt)
4309 {
4310 data.salts_shown[salt_pos] = 1;
4311
4312 data.salts_done++;
4313
4314 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4315 }
4316 }
4317 }
4318
4319 if (data.devices_status == STATUS_CRACKED) break;
4320 }
4321 }
4322
4323 if (found) break;
4324
4325 if (data.devices_status == STATUS_CRACKED) break;
4326
4327 iter--;
4328 }
4329
4330 if (data.devices_status == STATUS_CRACKED) break;
4331 }
4332
4333 myfree (line_buf);
4334
4335 out_info[j].seek = ftell (fp);
4336
4337 //hc_thread_mutex_unlock (mux_display);
4338
4339 fclose (fp);
4340 }
4341 }
4342 }
4343 }
4344
4345 check_left = outfile_check_timer;
4346 }
4347 }
4348
4349 if (esalt_size) local_free (hash_buf.esalt);
4350
4351 if (isSalted) local_free (hash_buf.salt);
4352
4353 local_free (hash_buf.digest);
4354
4355 local_free (out_info);
4356
4357 local_free (out_files);
4358
4359 p = NULL;
4360
4361 return (p);
4362 }
4363
4364 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4365 {
4366 //if (device_param->pws_cnt < device_param->kernel_power)
4367 //{
4368 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4369
4370 u8 *ptr = (u8 *) pw->i;
4371
4372 memcpy (ptr, pw_buf, pw_len);
4373
4374 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4375
4376 pw->pw_len = pw_len;
4377
4378 device_param->pws_cnt++;
4379 //}
4380 //else
4381 //{
4382 // fprintf (stderr, "BUG pw_add()!!\n");
4383 //
4384 // return;
4385 //}
4386 }
4387
4388 static u32 get_power (const u32 kernel_power)
4389 {
4390 if (data.kernel_power_div)
4391 {
4392 return (float) kernel_power * data.kernel_power_div;
4393 }
4394
4395 return kernel_power;
4396 }
4397
4398 static uint get_work (hc_device_param_t *device_param, const u64 max)
4399 {
4400 hc_thread_mutex_lock (mux_dispatcher);
4401
4402 const u64 words_cur = data.words_cur;
4403 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4404
4405 device_param->words_off = words_cur;
4406
4407 const u64 words_left = words_base - words_cur;
4408
4409 if (data.kernel_power_all > words_left)
4410 {
4411 if (data.kernel_power_div == 0)
4412 {
4413 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4414 }
4415 }
4416
4417 const u32 kernel_power = get_power (device_param->kernel_power);
4418
4419 uint work = MIN (words_left, kernel_power);
4420
4421 work = MIN (work, max);
4422
4423 data.words_cur += work;
4424
4425 hc_thread_mutex_unlock (mux_dispatcher);
4426
4427 return work;
4428 }
4429
4430 static void *thread_autotune (void *p)
4431 {
4432 hc_device_param_t *device_param = (hc_device_param_t *) p;
4433
4434 if (device_param->skipped) return NULL;
4435
4436 autotune (device_param);
4437
4438 return NULL;
4439 }
4440
4441 static void *thread_calc_stdin (void *p)
4442 {
4443 hc_device_param_t *device_param = (hc_device_param_t *) p;
4444
4445 if (device_param->skipped) return NULL;
4446
4447 char *buf = (char *) mymalloc (HCBUFSIZ);
4448
4449 const uint attack_kern = data.attack_kern;
4450
4451 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4452 {
4453 hc_thread_mutex_lock (mux_dispatcher);
4454
4455 if (feof (stdin) != 0)
4456 {
4457 hc_thread_mutex_unlock (mux_dispatcher);
4458
4459 break;
4460 }
4461
4462 uint words_cur = 0;
4463
4464 while (words_cur < get_power (device_param->kernel_power))
4465 {
4466 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4467
4468 if (line_buf == NULL) break;
4469
4470 uint line_len = in_superchop (line_buf);
4471
4472 line_len = convert_from_hex (line_buf, line_len);
4473
4474 // post-process rule engine
4475
4476 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4477 {
4478 char rule_buf_out[BLOCK_SIZE] = { 0 };
4479
4480 int rule_len_out = -1;
4481
4482 if (line_len < BLOCK_SIZE)
4483 {
4484 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4485 }
4486
4487 if (rule_len_out < 0) continue;
4488
4489 line_buf = rule_buf_out;
4490 line_len = rule_len_out;
4491 }
4492
4493 if (line_len > PW_MAX)
4494 {
4495 continue;
4496 }
4497
4498 if (attack_kern == ATTACK_KERN_STRAIGHT)
4499 {
4500 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4501 {
4502 hc_thread_mutex_lock (mux_counter);
4503
4504 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4505 {
4506 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4507 }
4508
4509 hc_thread_mutex_unlock (mux_counter);
4510
4511 continue;
4512 }
4513 }
4514 else if (attack_kern == ATTACK_KERN_COMBI)
4515 {
4516 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4517 // since we still need to combine the plains
4518
4519 if (line_len > data.pw_max)
4520 {
4521 hc_thread_mutex_lock (mux_counter);
4522
4523 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4524 {
4525 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4526 }
4527
4528 hc_thread_mutex_unlock (mux_counter);
4529
4530 continue;
4531 }
4532 }
4533
4534 pw_add (device_param, (u8 *) line_buf, line_len);
4535
4536 words_cur++;
4537
4538 if (data.devices_status == STATUS_CRACKED) break;
4539 if (data.devices_status == STATUS_ABORTED) break;
4540 if (data.devices_status == STATUS_QUIT) break;
4541 if (data.devices_status == STATUS_BYPASS) break;
4542 }
4543
4544 hc_thread_mutex_unlock (mux_dispatcher);
4545
4546 if (data.devices_status == STATUS_CRACKED) break;
4547 if (data.devices_status == STATUS_ABORTED) break;
4548 if (data.devices_status == STATUS_QUIT) break;
4549 if (data.devices_status == STATUS_BYPASS) break;
4550
4551 // flush
4552
4553 const uint pws_cnt = device_param->pws_cnt;
4554
4555 if (pws_cnt)
4556 {
4557 run_copy (device_param, pws_cnt);
4558
4559 run_cracker (device_param, pws_cnt);
4560
4561 device_param->pws_cnt = 0;
4562
4563 /*
4564 still required?
4565 if (attack_kern == ATTACK_KERN_STRAIGHT)
4566 {
4567 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4568 }
4569 else if (attack_kern == ATTACK_KERN_COMBI)
4570 {
4571 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4572 }
4573 */
4574 }
4575 }
4576
4577 device_param->kernel_accel = 0;
4578 device_param->kernel_loops = 0;
4579
4580 myfree (buf);
4581
4582 return NULL;
4583 }
4584
4585 static void *thread_calc (void *p)
4586 {
4587 hc_device_param_t *device_param = (hc_device_param_t *) p;
4588
4589 if (device_param->skipped) return NULL;
4590
4591 const uint attack_mode = data.attack_mode;
4592 const uint attack_kern = data.attack_kern;
4593
4594 if (attack_mode == ATTACK_MODE_BF)
4595 {
4596 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4597 {
4598 const uint work = get_work (device_param, -1);
4599
4600 if (work == 0) break;
4601
4602 const u64 words_off = device_param->words_off;
4603 const u64 words_fin = words_off + work;
4604
4605 const uint pws_cnt = work;
4606
4607 device_param->pws_cnt = pws_cnt;
4608
4609 if (pws_cnt)
4610 {
4611 run_copy (device_param, pws_cnt);
4612
4613 run_cracker (device_param, pws_cnt);
4614
4615 device_param->pws_cnt = 0;
4616
4617 /*
4618 still required?
4619 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4620 */
4621 }
4622
4623 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4624
4625 if (data.devices_status == STATUS_CRACKED) break;
4626 if (data.devices_status == STATUS_ABORTED) break;
4627 if (data.devices_status == STATUS_QUIT) break;
4628 if (data.devices_status == STATUS_BYPASS) break;
4629
4630 if (data.benchmark == 1) break;
4631
4632 device_param->words_done = words_fin;
4633 }
4634 }
4635 else
4636 {
4637 const uint segment_size = data.segment_size;
4638
4639 char *dictfile = data.dictfile;
4640
4641 if (attack_mode == ATTACK_MODE_COMBI)
4642 {
4643 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4644 {
4645 dictfile = data.dictfile2;
4646 }
4647 }
4648
4649 FILE *fd = fopen (dictfile, "rb");
4650
4651 if (fd == NULL)
4652 {
4653 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4654
4655 return NULL;
4656 }
4657
4658 if (attack_mode == ATTACK_MODE_COMBI)
4659 {
4660 const uint combs_mode = data.combs_mode;
4661
4662 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4663 {
4664 const char *dictfilec = data.dictfile2;
4665
4666 FILE *combs_fp = fopen (dictfilec, "rb");
4667
4668 if (combs_fp == NULL)
4669 {
4670 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4671
4672 fclose (fd);
4673
4674 return NULL;
4675 }
4676
4677 device_param->combs_fp = combs_fp;
4678 }
4679 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4680 {
4681 const char *dictfilec = data.dictfile;
4682
4683 FILE *combs_fp = fopen (dictfilec, "rb");
4684
4685 if (combs_fp == NULL)
4686 {
4687 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4688
4689 fclose (fd);
4690
4691 return NULL;
4692 }
4693
4694 device_param->combs_fp = combs_fp;
4695 }
4696 }
4697
4698 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4699
4700 wl_data->buf = (char *) mymalloc (segment_size);
4701 wl_data->avail = segment_size;
4702 wl_data->incr = segment_size;
4703 wl_data->cnt = 0;
4704 wl_data->pos = 0;
4705
4706 u64 words_cur = 0;
4707
4708 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4709 {
4710 u64 words_off = 0;
4711 u64 words_fin = 0;
4712
4713 u64 max = -1;
4714
4715 while (max)
4716 {
4717 const uint work = get_work (device_param, max);
4718
4719 if (work == 0) break;
4720
4721 max = 0;
4722
4723 words_off = device_param->words_off;
4724 words_fin = words_off + work;
4725
4726 char *line_buf;
4727 uint line_len;
4728
4729 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4730
4731 for ( ; words_cur < words_fin; words_cur++)
4732 {
4733 get_next_word (wl_data, fd, &line_buf, &line_len);
4734
4735 line_len = convert_from_hex (line_buf, line_len);
4736
4737 // post-process rule engine
4738
4739 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4740 {
4741 char rule_buf_out[BLOCK_SIZE] = { 0 };
4742
4743 int rule_len_out = -1;
4744
4745 if (line_len < BLOCK_SIZE)
4746 {
4747 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4748 }
4749
4750 if (rule_len_out < 0) continue;
4751
4752 line_buf = rule_buf_out;
4753 line_len = rule_len_out;
4754 }
4755
4756 if (attack_kern == ATTACK_KERN_STRAIGHT)
4757 {
4758 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4759 {
4760 max++;
4761
4762 hc_thread_mutex_lock (mux_counter);
4763
4764 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4765 {
4766 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4767 }
4768
4769 hc_thread_mutex_unlock (mux_counter);
4770
4771 continue;
4772 }
4773 }
4774 else if (attack_kern == ATTACK_KERN_COMBI)
4775 {
4776 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4777 // since we still need to combine the plains
4778
4779 if (line_len > data.pw_max)
4780 {
4781 max++;
4782
4783 hc_thread_mutex_lock (mux_counter);
4784
4785 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4786 {
4787 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4788 }
4789
4790 hc_thread_mutex_unlock (mux_counter);
4791
4792 continue;
4793 }
4794 }
4795
4796 pw_add (device_param, (u8 *) line_buf, line_len);
4797
4798 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4799
4800 if (data.devices_status == STATUS_CRACKED) break;
4801 if (data.devices_status == STATUS_ABORTED) break;
4802 if (data.devices_status == STATUS_QUIT) break;
4803 if (data.devices_status == STATUS_BYPASS) break;
4804 }
4805
4806 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4807
4808 if (data.devices_status == STATUS_CRACKED) break;
4809 if (data.devices_status == STATUS_ABORTED) break;
4810 if (data.devices_status == STATUS_QUIT) break;
4811 if (data.devices_status == STATUS_BYPASS) break;
4812 }
4813
4814 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4815
4816 if (data.devices_status == STATUS_CRACKED) break;
4817 if (data.devices_status == STATUS_ABORTED) break;
4818 if (data.devices_status == STATUS_QUIT) break;
4819 if (data.devices_status == STATUS_BYPASS) break;
4820
4821 //
4822 // flush
4823 //
4824
4825 const uint pws_cnt = device_param->pws_cnt;
4826
4827 if (pws_cnt)
4828 {
4829 run_copy (device_param, pws_cnt);
4830
4831 run_cracker (device_param, pws_cnt);
4832
4833 device_param->pws_cnt = 0;
4834
4835 /*
4836 still required?
4837 if (attack_kern == ATTACK_KERN_STRAIGHT)
4838 {
4839 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4840 }
4841 else if (attack_kern == ATTACK_KERN_COMBI)
4842 {
4843 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4844 }
4845 */
4846 }
4847
4848 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4849
4850 if (data.devices_status == STATUS_CRACKED) break;
4851 if (data.devices_status == STATUS_ABORTED) break;
4852 if (data.devices_status == STATUS_QUIT) break;
4853 if (data.devices_status == STATUS_BYPASS) break;
4854
4855 if (words_fin == 0) break;
4856
4857 device_param->words_done = words_fin;
4858 }
4859
4860 if (attack_mode == ATTACK_MODE_COMBI)
4861 {
4862 fclose (device_param->combs_fp);
4863 }
4864
4865 free (wl_data->buf);
4866 free (wl_data);
4867
4868 fclose (fd);
4869 }
4870
4871 device_param->kernel_accel = 0;
4872 device_param->kernel_loops = 0;
4873
4874 return NULL;
4875 }
4876
4877 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4878 {
4879 if (!device_param)
4880 {
4881 log_error ("ERROR: %s : Invalid argument", __func__);
4882
4883 exit (-1);
4884 }
4885
4886 salt_t *salt_buf = &data.salts_buf[salt_pos];
4887
4888 device_param->kernel_params_buf32[24] = salt_pos;
4889 device_param->kernel_params_buf32[27] = 1;
4890 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4891 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4892 device_param->kernel_params_buf32[30] = 0;
4893 device_param->kernel_params_buf32[31] = 1;
4894
4895 char *dictfile_old = data.dictfile;
4896
4897 const char *weak_hash_check = "weak-hash-check";
4898
4899 data.dictfile = (char *) weak_hash_check;
4900
4901 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4902
4903 data.kernel_rules_buf[0].cmds[0] = 0;
4904
4905 /**
4906 * run the kernel
4907 */
4908
4909 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4910 {
4911 run_kernel (KERN_RUN_1, device_param, 1, false);
4912 }
4913 else
4914 {
4915 run_kernel (KERN_RUN_1, device_param, 1, false);
4916
4917 uint loop_step = 16;
4918
4919 const uint iter = salt_buf->salt_iter;
4920
4921 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4922 {
4923 uint loop_left = iter - loop_pos;
4924
4925 loop_left = MIN (loop_left, loop_step);
4926
4927 device_param->kernel_params_buf32[25] = loop_pos;
4928 device_param->kernel_params_buf32[26] = loop_left;
4929
4930 run_kernel (KERN_RUN_2, device_param, 1, false);
4931 }
4932
4933 run_kernel (KERN_RUN_3, device_param, 1, false);
4934 }
4935
4936 /**
4937 * result
4938 */
4939
4940 check_cracked (device_param, salt_pos);
4941
4942 /**
4943 * cleanup
4944 */
4945
4946 device_param->kernel_params_buf32[24] = 0;
4947 device_param->kernel_params_buf32[25] = 0;
4948 device_param->kernel_params_buf32[26] = 0;
4949 device_param->kernel_params_buf32[27] = 0;
4950 device_param->kernel_params_buf32[28] = 0;
4951 device_param->kernel_params_buf32[29] = 0;
4952 device_param->kernel_params_buf32[30] = 0;
4953 device_param->kernel_params_buf32[31] = 0;
4954
4955 data.dictfile = dictfile_old;
4956
4957 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4958 }
4959
4960 // hlfmt hashcat
4961
4962 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4963 {
4964 if (data.username == 0)
4965 {
4966 *hashbuf_pos = line_buf;
4967 *hashbuf_len = line_len;
4968 }
4969 else
4970 {
4971 char *pos = line_buf;
4972 int len = line_len;
4973
4974 for (int i = 0; i < line_len; i++, pos++, len--)
4975 {
4976 if (line_buf[i] == data.separator)
4977 {
4978 pos++;
4979
4980 len--;
4981
4982 break;
4983 }
4984 }
4985
4986 *hashbuf_pos = pos;
4987 *hashbuf_len = len;
4988 }
4989 }
4990
4991 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4992 {
4993 char *pos = NULL;
4994 int len = 0;
4995
4996 int sep_cnt = 0;
4997
4998 for (int i = 0; i < line_len; i++)
4999 {
5000 if (line_buf[i] == data.separator)
5001 {
5002 sep_cnt++;
5003
5004 continue;
5005 }
5006
5007 if (sep_cnt == 0)
5008 {
5009 if (pos == NULL) pos = line_buf + i;
5010
5011 len++;
5012 }
5013 }
5014
5015 *userbuf_pos = pos;
5016 *userbuf_len = len;
5017 }
5018
5019 // hlfmt pwdump
5020
5021 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5022 {
5023 int sep_cnt = 0;
5024
5025 int sep2_len = 0;
5026 int sep3_len = 0;
5027
5028 for (int i = 0; i < line_len; i++)
5029 {
5030 if (line_buf[i] == ':')
5031 {
5032 sep_cnt++;
5033
5034 continue;
5035 }
5036
5037 if (sep_cnt == 2) sep2_len++;
5038 if (sep_cnt == 3) sep3_len++;
5039 }
5040
5041 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5042
5043 return 0;
5044 }
5045
5046 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5047 {
5048 char *pos = NULL;
5049 int len = 0;
5050
5051 int sep_cnt = 0;
5052
5053 for (int i = 0; i < line_len; i++)
5054 {
5055 if (line_buf[i] == ':')
5056 {
5057 sep_cnt++;
5058
5059 continue;
5060 }
5061
5062 if (data.hash_mode == 1000)
5063 {
5064 if (sep_cnt == 3)
5065 {
5066 if (pos == NULL) pos = line_buf + i;
5067
5068 len++;
5069 }
5070 }
5071 else if (data.hash_mode == 3000)
5072 {
5073 if (sep_cnt == 2)
5074 {
5075 if (pos == NULL) pos = line_buf + i;
5076
5077 len++;
5078 }
5079 }
5080 }
5081
5082 *hashbuf_pos = pos;
5083 *hashbuf_len = len;
5084 }
5085
5086 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5087 {
5088 char *pos = NULL;
5089 int len = 0;
5090
5091 int sep_cnt = 0;
5092
5093 for (int i = 0; i < line_len; i++)
5094 {
5095 if (line_buf[i] == ':')
5096 {
5097 sep_cnt++;
5098
5099 continue;
5100 }
5101
5102 if (sep_cnt == 0)
5103 {
5104 if (pos == NULL) pos = line_buf + i;
5105
5106 len++;
5107 }
5108 }
5109
5110 *userbuf_pos = pos;
5111 *userbuf_len = len;
5112 }
5113
5114 // hlfmt passwd
5115
5116 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5117 {
5118 int sep_cnt = 0;
5119
5120 char sep5_first = 0;
5121 char sep6_first = 0;
5122
5123 for (int i = 0; i < line_len; i++)
5124 {
5125 if (line_buf[i] == ':')
5126 {
5127 sep_cnt++;
5128
5129 continue;
5130 }
5131
5132 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5133 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5134 }
5135
5136 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5137
5138 return 0;
5139 }
5140
5141 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5142 {
5143 char *pos = NULL;
5144 int len = 0;
5145
5146 int sep_cnt = 0;
5147
5148 for (int i = 0; i < line_len; i++)
5149 {
5150 if (line_buf[i] == ':')
5151 {
5152 sep_cnt++;
5153
5154 continue;
5155 }
5156
5157 if (sep_cnt == 1)
5158 {
5159 if (pos == NULL) pos = line_buf + i;
5160
5161 len++;
5162 }
5163 }
5164
5165 *hashbuf_pos = pos;
5166 *hashbuf_len = len;
5167 }
5168
5169 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5170 {
5171 char *pos = NULL;
5172 int len = 0;
5173
5174 int sep_cnt = 0;
5175
5176 for (int i = 0; i < line_len; i++)
5177 {
5178 if (line_buf[i] == ':')
5179 {
5180 sep_cnt++;
5181
5182 continue;
5183 }
5184
5185 if (sep_cnt == 0)
5186 {
5187 if (pos == NULL) pos = line_buf + i;
5188
5189 len++;
5190 }
5191 }
5192
5193 *userbuf_pos = pos;
5194 *userbuf_len = len;
5195 }
5196
5197 // hlfmt shadow
5198
5199 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5200 {
5201 int sep_cnt = 0;
5202
5203 for (int i = 0; i < line_len; i++)
5204 {
5205 if (line_buf[i] == ':') sep_cnt++;
5206 }
5207
5208 if (sep_cnt == 8) return 1;
5209
5210 return 0;
5211 }
5212
5213 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5214 {
5215 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5216 }
5217
5218 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5219 {
5220 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5221 }
5222
5223 // hlfmt main
5224
5225 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5226 {
5227 switch (hashfile_format)
5228 {
5229 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5230 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5231 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5232 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5233 }
5234 }
5235
5236 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5237 {
5238 switch (hashfile_format)
5239 {
5240 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5241 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5242 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5243 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5244 }
5245 }
5246
5247 char *strhlfmt (const uint hashfile_format)
5248 {
5249 switch (hashfile_format)
5250 {
5251 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5252 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5253 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5254 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5255 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5256 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5257 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5258 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5259 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5260 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5261 }
5262
5263 return ((char *) "Unknown");
5264 }
5265
5266 static uint hlfmt_detect (FILE *fp, uint max_check)
5267 {
5268 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5269
5270 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5271 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5272
5273 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5274
5275 uint num_check = 0;
5276
5277 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5278
5279 while (!feof (fp))
5280 {
5281 int line_len = fgetl (fp, line_buf);
5282
5283 if (line_len == 0) continue;
5284
5285 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5286 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5287 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5288
5289 if (num_check == max_check) break;
5290
5291 num_check++;
5292 }
5293
5294 myfree (line_buf);
5295
5296 uint hashlist_format = HLFMT_HASHCAT;
5297
5298 for (int i = 1; i < HLFMTS_CNT; i++)
5299 {
5300 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5301
5302 hashlist_format = i;
5303 }
5304
5305 free (formats_cnt);
5306
5307 return hashlist_format;
5308 }
5309
5310 /**
5311 * some further helper function
5312 */
5313
5314 // wrapper around mymalloc for ADL
5315
5316 #if defined(HAVE_HWMON)
5317 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5318 {
5319 return mymalloc (iSize);
5320 }
5321 #endif
5322
5323 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)
5324 {
5325 u64 collisions = 0;
5326
5327 const uint dgst_pos0 = data.dgst_pos0;
5328 const uint dgst_pos1 = data.dgst_pos1;
5329 const uint dgst_pos2 = data.dgst_pos2;
5330 const uint dgst_pos3 = data.dgst_pos3;
5331
5332 memset (bitmap_a, 0, bitmap_size);
5333 memset (bitmap_b, 0, bitmap_size);
5334 memset (bitmap_c, 0, bitmap_size);
5335 memset (bitmap_d, 0, bitmap_size);
5336
5337 for (uint i = 0; i < digests_cnt; i++)
5338 {
5339 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5340
5341 uint *digest_ptr = (uint *) digests_buf_ptr;
5342
5343 digests_buf_ptr += dgst_size;
5344
5345 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5346 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5347 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5348 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5349
5350 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5351 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5352 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5353 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5354
5355 if (bitmap_a[idx0] & val0) collisions++;
5356 if (bitmap_b[idx1] & val1) collisions++;
5357 if (bitmap_c[idx2] & val2) collisions++;
5358 if (bitmap_d[idx3] & val3) collisions++;
5359
5360 bitmap_a[idx0] |= val0;
5361 bitmap_b[idx1] |= val1;
5362 bitmap_c[idx2] |= val2;
5363 bitmap_d[idx3] |= val3;
5364
5365 if (collisions >= collisions_max) return 0x7fffffff;
5366 }
5367
5368 return collisions;
5369 }
5370
5371 /**
5372 * main
5373 */
5374
5375 #ifdef _WIN
5376 void SetConsoleWindowSize (const int x)
5377 {
5378 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5379
5380 if (h == INVALID_HANDLE_VALUE) return;
5381
5382 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5383
5384 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5385
5386 SMALL_RECT *sr = &bufferInfo.srWindow;
5387
5388 sr->Right = MAX (sr->Right, x - 1);
5389
5390 COORD co;
5391
5392 co.X = sr->Right + 1;
5393 co.Y = 9999;
5394
5395 if (!SetConsoleScreenBufferSize (h, co)) return;
5396
5397 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5398 }
5399 #endif
5400
5401 int main (int argc, char **argv)
5402 {
5403 #ifdef _WIN
5404 SetConsoleWindowSize (132);
5405 #endif
5406
5407 /**
5408 * To help users a bit
5409 */
5410
5411 char *compute = getenv ("COMPUTE");
5412
5413 if (compute)
5414 {
5415 static char display[100];
5416
5417 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5418
5419 putenv (display);
5420 }
5421 else
5422 {
5423 if (getenv ("DISPLAY") == NULL)
5424 putenv ((char *) "DISPLAY=:0");
5425 }
5426
5427 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5428 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5429
5430 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5431 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5432
5433 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5434 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5435
5436 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5437 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5438
5439 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5440 putenv ((char *) "POCL_KERNEL_CACHE=0");
5441
5442 umask (077);
5443
5444 /**
5445 * Real init
5446 */
5447
5448 memset (&data, 0, sizeof (hc_global_data_t));
5449
5450 time_t proc_start;
5451
5452 time (&proc_start);
5453
5454 data.proc_start = proc_start;
5455
5456 int myargc = argc;
5457 char **myargv = argv;
5458
5459 hc_thread_mutex_init (mux_dispatcher);
5460 hc_thread_mutex_init (mux_counter);
5461 hc_thread_mutex_init (mux_display);
5462 hc_thread_mutex_init (mux_adl);
5463
5464 /**
5465 * commandline parameters
5466 */
5467
5468 uint usage = USAGE;
5469 uint version = VERSION;
5470 uint quiet = QUIET;
5471 uint benchmark = BENCHMARK;
5472 uint show = SHOW;
5473 uint left = LEFT;
5474 uint username = USERNAME;
5475 uint remove = REMOVE;
5476 uint remove_timer = REMOVE_TIMER;
5477 u64 skip = SKIP;
5478 u64 limit = LIMIT;
5479 uint keyspace = KEYSPACE;
5480 uint potfile_disable = POTFILE_DISABLE;
5481 char *potfile_path = NULL;
5482 uint debug_mode = DEBUG_MODE;
5483 char *debug_file = NULL;
5484 char *induction_dir = NULL;
5485 char *outfile_check_dir = NULL;
5486 uint force = FORCE;
5487 uint runtime = RUNTIME;
5488 uint hash_mode = HASH_MODE;
5489 uint attack_mode = ATTACK_MODE;
5490 uint markov_disable = MARKOV_DISABLE;
5491 uint markov_classic = MARKOV_CLASSIC;
5492 uint markov_threshold = MARKOV_THRESHOLD;
5493 char *markov_hcstat = NULL;
5494 char *outfile = NULL;
5495 uint outfile_format = OUTFILE_FORMAT;
5496 uint outfile_autohex = OUTFILE_AUTOHEX;
5497 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5498 uint restore = RESTORE;
5499 uint restore_timer = RESTORE_TIMER;
5500 uint restore_disable = RESTORE_DISABLE;
5501 uint status = STATUS;
5502 uint status_timer = STATUS_TIMER;
5503 uint machine_readable = MACHINE_READABLE;
5504 uint loopback = LOOPBACK;
5505 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5506 char *session = NULL;
5507 uint hex_charset = HEX_CHARSET;
5508 uint hex_salt = HEX_SALT;
5509 uint hex_wordlist = HEX_WORDLIST;
5510 uint rp_gen = RP_GEN;
5511 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5512 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5513 uint rp_gen_seed = RP_GEN_SEED;
5514 char *rule_buf_l = (char *) RULE_BUF_L;
5515 char *rule_buf_r = (char *) RULE_BUF_R;
5516 uint increment = INCREMENT;
5517 uint increment_min = INCREMENT_MIN;
5518 uint increment_max = INCREMENT_MAX;
5519 char *cpu_affinity = NULL;
5520 OCL_PTR *ocl = NULL;
5521 char *opencl_devices = NULL;
5522 char *opencl_platforms = NULL;
5523 char *opencl_device_types = NULL;
5524 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5525 char *truecrypt_keyfiles = NULL;
5526 char *veracrypt_keyfiles = NULL;
5527 uint veracrypt_pim = 0;
5528 uint workload_profile = WORKLOAD_PROFILE;
5529 uint kernel_accel = KERNEL_ACCEL;
5530 uint kernel_loops = KERNEL_LOOPS;
5531 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5532 #ifdef HAVE_HWMON
5533 uint gpu_temp_abort = GPU_TEMP_ABORT;
5534 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5535 uint powertune_enable = POWERTUNE_ENABLE;
5536 #endif
5537 uint logfile_disable = LOGFILE_DISABLE;
5538 uint segment_size = SEGMENT_SIZE;
5539 uint scrypt_tmto = SCRYPT_TMTO;
5540 char separator = SEPARATOR;
5541 uint bitmap_min = BITMAP_MIN;
5542 uint bitmap_max = BITMAP_MAX;
5543 char *custom_charset_1 = NULL;
5544 char *custom_charset_2 = NULL;
5545 char *custom_charset_3 = NULL;
5546 char *custom_charset_4 = NULL;
5547
5548 #define IDX_HELP 'h'
5549 #define IDX_VERSION 'V'
5550 #define IDX_VERSION_LOWER 'v'
5551 #define IDX_QUIET 0xff02
5552 #define IDX_SHOW 0xff03
5553 #define IDX_LEFT 0xff04
5554 #define IDX_REMOVE 0xff05
5555 #define IDX_REMOVE_TIMER 0xff37
5556 #define IDX_SKIP 's'
5557 #define IDX_LIMIT 'l'
5558 #define IDX_KEYSPACE 0xff35
5559 #define IDX_POTFILE_DISABLE 0xff06
5560 #define IDX_POTFILE_PATH 0xffe0
5561 #define IDX_DEBUG_MODE 0xff43
5562 #define IDX_DEBUG_FILE 0xff44
5563 #define IDX_INDUCTION_DIR 0xff46
5564 #define IDX_OUTFILE_CHECK_DIR 0xff47
5565 #define IDX_USERNAME 0xff07
5566 #define IDX_FORCE 0xff08
5567 #define IDX_RUNTIME 0xff09
5568 #define IDX_BENCHMARK 'b'
5569 #define IDX_HASH_MODE 'm'
5570 #define IDX_ATTACK_MODE 'a'
5571 #define IDX_RP_FILE 'r'
5572 #define IDX_RP_GEN 'g'
5573 #define IDX_RP_GEN_FUNC_MIN 0xff10
5574 #define IDX_RP_GEN_FUNC_MAX 0xff11
5575 #define IDX_RP_GEN_SEED 0xff34
5576 #define IDX_RULE_BUF_L 'j'
5577 #define IDX_RULE_BUF_R 'k'
5578 #define IDX_INCREMENT 'i'
5579 #define IDX_INCREMENT_MIN 0xff12
5580 #define IDX_INCREMENT_MAX 0xff13
5581 #define IDX_OUTFILE 'o'
5582 #define IDX_OUTFILE_FORMAT 0xff14
5583 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5584 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5585 #define IDX_RESTORE 0xff15
5586 #define IDX_RESTORE_DISABLE 0xff27
5587 #define IDX_STATUS 0xff17
5588 #define IDX_STATUS_TIMER 0xff18
5589 #define IDX_MACHINE_READABLE 0xff50
5590 #define IDX_LOOPBACK 0xff38
5591 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5592 #define IDX_SESSION 0xff19
5593 #define IDX_HEX_CHARSET 0xff20
5594 #define IDX_HEX_SALT 0xff21
5595 #define IDX_HEX_WORDLIST 0xff40
5596 #define IDX_MARKOV_DISABLE 0xff22
5597 #define IDX_MARKOV_CLASSIC 0xff23
5598 #define IDX_MARKOV_THRESHOLD 't'
5599 #define IDX_MARKOV_HCSTAT 0xff24
5600 #define IDX_CPU_AFFINITY 0xff25
5601 #define IDX_OPENCL_DEVICES 'd'
5602 #define IDX_OPENCL_PLATFORMS 0xff72
5603 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5604 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5605 #define IDX_WORKLOAD_PROFILE 'w'
5606 #define IDX_KERNEL_ACCEL 'n'
5607 #define IDX_KERNEL_LOOPS 'u'
5608 #define IDX_GPU_TEMP_DISABLE 0xff29
5609 #define IDX_GPU_TEMP_ABORT 0xff30
5610 #define IDX_GPU_TEMP_RETAIN 0xff31
5611 #define IDX_POWERTUNE_ENABLE 0xff41
5612 #define IDX_LOGFILE_DISABLE 0xff51
5613 #define IDX_TRUECRYPT_KEYFILES 0xff52
5614 #define IDX_VERACRYPT_KEYFILES 0xff53
5615 #define IDX_VERACRYPT_PIM 0xff54
5616 #define IDX_SCRYPT_TMTO 0xff61
5617 #define IDX_SEGMENT_SIZE 'c'
5618 #define IDX_SEPARATOR 'p'
5619 #define IDX_BITMAP_MIN 0xff70
5620 #define IDX_BITMAP_MAX 0xff71
5621 #define IDX_CUSTOM_CHARSET_1 '1'
5622 #define IDX_CUSTOM_CHARSET_2 '2'
5623 #define IDX_CUSTOM_CHARSET_3 '3'
5624 #define IDX_CUSTOM_CHARSET_4 '4'
5625
5626 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5627
5628 struct option long_options[] =
5629 {
5630 {"help", no_argument, 0, IDX_HELP},
5631 {"version", no_argument, 0, IDX_VERSION},
5632 {"quiet", no_argument, 0, IDX_QUIET},
5633 {"show", no_argument, 0, IDX_SHOW},
5634 {"left", no_argument, 0, IDX_LEFT},
5635 {"username", no_argument, 0, IDX_USERNAME},
5636 {"remove", no_argument, 0, IDX_REMOVE},
5637 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5638 {"skip", required_argument, 0, IDX_SKIP},
5639 {"limit", required_argument, 0, IDX_LIMIT},
5640 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5641 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5642 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5643 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5644 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5645 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5646 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5647 {"force", no_argument, 0, IDX_FORCE},
5648 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5649 {"restore", no_argument, 0, IDX_RESTORE},
5650 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5651 {"status", no_argument, 0, IDX_STATUS},
5652 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5653 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5654 {"loopback", no_argument, 0, IDX_LOOPBACK},
5655 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5656 {"session", required_argument, 0, IDX_SESSION},
5657 {"runtime", required_argument, 0, IDX_RUNTIME},
5658 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5659 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5660 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5661 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5662 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5663 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5664 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5665 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5666 {"rules-file", required_argument, 0, IDX_RP_FILE},
5667 {"outfile", required_argument, 0, IDX_OUTFILE},
5668 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5669 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5670 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5671 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5672 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5673 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5674 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5675 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5676 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5677 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5678 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5679 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5680 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5681 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5682 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5683 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5684 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5685 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5686 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5687 #ifdef HAVE_HWMON
5688 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5689 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5690 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5691 #endif // HAVE_HWMON
5692 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5693 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5694 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5695 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5696 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5697 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5698 {"seperator", required_argument, 0, IDX_SEPARATOR},
5699 {"separator", required_argument, 0, IDX_SEPARATOR},
5700 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5701 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5702 {"increment", no_argument, 0, IDX_INCREMENT},
5703 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5704 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5705 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5706 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5707 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5708 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5709 {0, 0, 0, 0}
5710 };
5711
5712 uint rp_files_cnt = 0;
5713
5714 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5715
5716 int option_index = 0;
5717 int c = -1;
5718
5719 optind = 1;
5720 optopt = 0;
5721
5722 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5723 {
5724 switch (c)
5725 {
5726 case IDX_HELP: usage = 1; break;
5727 case IDX_VERSION:
5728 case IDX_VERSION_LOWER: version = 1; break;
5729 case IDX_RESTORE: restore = 1; break;
5730 case IDX_SESSION: session = optarg; break;
5731 case IDX_SHOW: show = 1; break;
5732 case IDX_LEFT: left = 1; break;
5733 case '?': return (-1);
5734 }
5735 }
5736
5737 if (optopt != 0)
5738 {
5739 log_error ("ERROR: Invalid argument specified");
5740
5741 return (-1);
5742 }
5743
5744 /**
5745 * exit functions
5746 */
5747
5748 if (version)
5749 {
5750 log_info ("%s", VERSION_TAG);
5751
5752 return (0);
5753 }
5754
5755 if (usage)
5756 {
5757 usage_big_print (PROGNAME);
5758
5759 return (0);
5760 }
5761
5762 /**
5763 * session needs to be set, always!
5764 */
5765
5766 if (session == NULL) session = (char *) PROGNAME;
5767
5768 /**
5769 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5770 */
5771
5772 char *exec_path = get_exec_path ();
5773
5774 #ifdef LINUX
5775
5776 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5777 char *resolved_exec_path = realpath (exec_path, NULL);
5778
5779 char *install_dir = get_install_dir (resolved_exec_path);
5780 char *profile_dir = NULL;
5781 char *session_dir = NULL;
5782 char *shared_dir = NULL;
5783
5784 if (strcmp (install_dir, resolved_install_folder) == 0)
5785 {
5786 struct passwd *pw = getpwuid (getuid ());
5787
5788 const char *homedir = pw->pw_dir;
5789
5790 profile_dir = get_profile_dir (homedir);
5791 session_dir = get_session_dir (profile_dir);
5792 shared_dir = strdup (SHARED_FOLDER);
5793
5794 mkdir (profile_dir, 0700);
5795 mkdir (session_dir, 0700);
5796 }
5797 else
5798 {
5799 profile_dir = install_dir;
5800 session_dir = install_dir;
5801 shared_dir = install_dir;
5802 }
5803
5804 myfree (resolved_install_folder);
5805 myfree (resolved_exec_path);
5806
5807 #else
5808
5809 char *install_dir = get_install_dir (exec_path);
5810 char *profile_dir = install_dir;
5811 char *session_dir = install_dir;
5812 char *shared_dir = install_dir;
5813
5814 #endif
5815
5816 data.install_dir = install_dir;
5817 data.profile_dir = profile_dir;
5818 data.session_dir = session_dir;
5819 data.shared_dir = shared_dir;
5820
5821 myfree (exec_path);
5822
5823 /**
5824 * kernel cache, we need to make sure folder exist
5825 */
5826
5827 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5828
5829 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5830
5831 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5832
5833 mkdir (kernels_folder, 0700);
5834
5835 myfree (kernels_folder);
5836
5837 /**
5838 * session
5839 */
5840
5841 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5842
5843 data.session = session;
5844
5845 char *eff_restore_file = (char *) mymalloc (session_size);
5846 char *new_restore_file = (char *) mymalloc (session_size);
5847
5848 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5849 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5850
5851 data.eff_restore_file = eff_restore_file;
5852 data.new_restore_file = new_restore_file;
5853
5854 if (((show == 1) || (left == 1)) && (restore == 1))
5855 {
5856 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5857 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5858
5859 return (-1);
5860 }
5861
5862 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5863 if ((show == 1) || (left == 1))
5864 {
5865 restore_disable = 1;
5866
5867 restore = 0;
5868 }
5869
5870 data.restore_disable = restore_disable;
5871
5872 restore_data_t *rd = init_restore (argc, argv);
5873
5874 data.rd = rd;
5875
5876 /**
5877 * restore file
5878 */
5879
5880 if (restore == 1)
5881 {
5882 read_restore (eff_restore_file, rd);
5883
5884 if (rd->version_bin < RESTORE_MIN)
5885 {
5886 log_error ("ERROR: Incompatible restore-file version");
5887
5888 return (-1);
5889 }
5890
5891 myargc = rd->argc;
5892 myargv = rd->argv;
5893
5894 #ifdef _POSIX
5895 rd->pid = getpid ();
5896 #elif _WIN
5897 rd->pid = GetCurrentProcessId ();
5898 #endif
5899 }
5900
5901 uint hash_mode_chgd = 0;
5902 uint runtime_chgd = 0;
5903 uint kernel_loops_chgd = 0;
5904 uint kernel_accel_chgd = 0;
5905 uint attack_mode_chgd = 0;
5906 uint outfile_format_chgd = 0;
5907 uint rp_gen_seed_chgd = 0;
5908 uint remove_timer_chgd = 0;
5909 uint increment_min_chgd = 0;
5910 uint increment_max_chgd = 0;
5911 uint workload_profile_chgd = 0;
5912 uint opencl_vector_width_chgd = 0;
5913
5914 optind = 1;
5915 optopt = 0;
5916 option_index = 0;
5917
5918 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5919 {
5920 switch (c)
5921 {
5922 //case IDX_HELP: usage = 1; break;
5923 //case IDX_VERSION: version = 1; break;
5924 //case IDX_RESTORE: restore = 1; break;
5925 case IDX_QUIET: quiet = 1; break;
5926 //case IDX_SHOW: show = 1; break;
5927 case IDX_SHOW: break;
5928 //case IDX_LEFT: left = 1; break;
5929 case IDX_LEFT: break;
5930 case IDX_USERNAME: username = 1; break;
5931 case IDX_REMOVE: remove = 1; break;
5932 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5933 remove_timer_chgd = 1; break;
5934 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5935 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5936 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5937 case IDX_DEBUG_FILE: debug_file = optarg; break;
5938 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5939 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5940 case IDX_FORCE: force = 1; break;
5941 case IDX_SKIP: skip = atoll (optarg); break;
5942 case IDX_LIMIT: limit = atoll (optarg); break;
5943 case IDX_KEYSPACE: keyspace = 1; break;
5944 case IDX_BENCHMARK: benchmark = 1; break;
5945 case IDX_RESTORE: break;
5946 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5947 case IDX_STATUS: status = 1; break;
5948 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5949 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5950 case IDX_LOOPBACK: loopback = 1; break;
5951 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5952 //case IDX_SESSION: session = optarg; break;
5953 case IDX_SESSION: break;
5954 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5955 hash_mode_chgd = 1; break;
5956 case IDX_RUNTIME: runtime = atoi (optarg);
5957 runtime_chgd = 1; break;
5958 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5959 attack_mode_chgd = 1; break;
5960 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5961 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5962 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5963 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5964 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5965 rp_gen_seed_chgd = 1; break;
5966 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5967 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5968 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5969 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5970 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5971 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5972 case IDX_OUTFILE: outfile = optarg; break;
5973 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5974 outfile_format_chgd = 1; break;
5975 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5976 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5977 case IDX_HEX_CHARSET: hex_charset = 1; break;
5978 case IDX_HEX_SALT: hex_salt = 1; break;
5979 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5980 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5981 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5982 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5983 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5984 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5985 opencl_vector_width_chgd = 1; break;
5986 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5987 workload_profile_chgd = 1; break;
5988 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5989 kernel_accel_chgd = 1; break;
5990 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5991 kernel_loops_chgd = 1; break;
5992 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5993 #ifdef HAVE_HWMON
5994 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
5995 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
5996 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5997 #endif // HAVE_HWMON
5998 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5999 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6000 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6001 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6002 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6003 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6004 case IDX_SEPARATOR: separator = optarg[0]; break;
6005 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6006 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6007 case IDX_INCREMENT: increment = 1; break;
6008 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6009 increment_min_chgd = 1; break;
6010 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6011 increment_max_chgd = 1; break;
6012 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6013 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6014 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6015 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6016
6017 default:
6018 log_error ("ERROR: Invalid argument specified");
6019 return (-1);
6020 }
6021 }
6022
6023 if (optopt != 0)
6024 {
6025 log_error ("ERROR: Invalid argument specified");
6026
6027 return (-1);
6028 }
6029
6030 /**
6031 * Inform user things getting started,
6032 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6033 * - we do not need to check algorithm_pos
6034 */
6035
6036 if (quiet == 0)
6037 {
6038 if (benchmark == 1)
6039 {
6040 if (machine_readable == 0)
6041 {
6042 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6043 log_info ("");
6044 }
6045 else
6046 {
6047 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6048 }
6049 }
6050 else if (restore == 1)
6051 {
6052 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6053 log_info ("");
6054 }
6055 else
6056 {
6057 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6058 log_info ("");
6059 }
6060 }
6061
6062 /**
6063 * sanity check
6064 */
6065
6066 if (attack_mode > 7)
6067 {
6068 log_error ("ERROR: Invalid attack-mode specified");
6069
6070 return (-1);
6071 }
6072
6073 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6074 {
6075 log_error ("ERROR: Invalid runtime specified");
6076
6077 return (-1);
6078 }
6079
6080 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6081 {
6082 log_error ("ERROR: Invalid hash-type specified");
6083
6084 return (-1);
6085 }
6086
6087 // renamed hash modes
6088
6089 if (hash_mode_chgd)
6090 {
6091 int n = -1;
6092
6093 switch (hash_mode)
6094 {
6095 case 123: n = 124;
6096 break;
6097 }
6098
6099 if (n >= 0)
6100 {
6101 log_error ("Old -m specified, use -m %d instead", n);
6102
6103 return (-1);
6104 }
6105 }
6106
6107 if (username == 1)
6108 {
6109 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6110 {
6111 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6112
6113 return (-1);
6114 }
6115 }
6116
6117 if (outfile_format > 16)
6118 {
6119 log_error ("ERROR: Invalid outfile-format specified");
6120
6121 return (-1);
6122 }
6123
6124 if (left == 1)
6125 {
6126 if (outfile_format_chgd == 1)
6127 {
6128 if (outfile_format > 1)
6129 {
6130 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6131
6132 return (-1);
6133 }
6134 }
6135 else
6136 {
6137 outfile_format = OUTFILE_FMT_HASH;
6138 }
6139 }
6140
6141 if (show == 1)
6142 {
6143 if (outfile_format_chgd == 1)
6144 {
6145 if ((outfile_format > 7) && (outfile_format < 16))
6146 {
6147 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6148
6149 return (-1);
6150 }
6151 }
6152 }
6153
6154 if (increment_min < INCREMENT_MIN)
6155 {
6156 log_error ("ERROR: Invalid increment-min specified");
6157
6158 return (-1);
6159 }
6160
6161 if (increment_max > INCREMENT_MAX)
6162 {
6163 log_error ("ERROR: Invalid increment-max specified");
6164
6165 return (-1);
6166 }
6167
6168 if (increment_min > increment_max)
6169 {
6170 log_error ("ERROR: Invalid increment-min specified");
6171
6172 return (-1);
6173 }
6174
6175 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6176 {
6177 log_error ("ERROR: increment is not allowed in attack-mode 0");
6178
6179 return (-1);
6180 }
6181
6182 if ((increment == 0) && (increment_min_chgd == 1))
6183 {
6184 log_error ("ERROR: increment-min is only supported together with increment switch");
6185
6186 return (-1);
6187 }
6188
6189 if ((increment == 0) && (increment_max_chgd == 1))
6190 {
6191 log_error ("ERROR: increment-max is only supported together with increment switch");
6192
6193 return (-1);
6194 }
6195
6196 if (rp_files_cnt && rp_gen)
6197 {
6198 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6199
6200 return (-1);
6201 }
6202
6203 if (rp_files_cnt || rp_gen)
6204 {
6205 if (attack_mode != ATTACK_MODE_STRAIGHT)
6206 {
6207 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6208
6209 return (-1);
6210 }
6211 }
6212
6213 if (rp_gen_func_min > rp_gen_func_max)
6214 {
6215 log_error ("ERROR: Invalid rp-gen-func-min specified");
6216
6217 return (-1);
6218 }
6219
6220 if (kernel_accel_chgd == 1)
6221 {
6222 if (force == 0)
6223 {
6224 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6225 log_info ("Please consider using the option -w instead");
6226 log_info ("You can use --force to override this but do not post error reports if you do so");
6227 log_info ("");
6228
6229 return (-1);
6230 }
6231
6232 if (kernel_accel < 1)
6233 {
6234 log_error ("ERROR: Invalid kernel-accel specified");
6235
6236 return (-1);
6237 }
6238
6239 if (kernel_accel > 1024)
6240 {
6241 log_error ("ERROR: Invalid kernel-accel specified");
6242
6243 return (-1);
6244 }
6245 }
6246
6247 if (kernel_loops_chgd == 1)
6248 {
6249 if (force == 0)
6250 {
6251 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6252 log_info ("Please consider using the option -w instead");
6253 log_info ("You can use --force to override this but do not post error reports if you do so");
6254 log_info ("");
6255
6256 return (-1);
6257 }
6258
6259 if (kernel_loops < 1)
6260 {
6261 log_error ("ERROR: Invalid kernel-loops specified");
6262
6263 return (-1);
6264 }
6265
6266 if (kernel_loops > 1024)
6267 {
6268 log_error ("ERROR: Invalid kernel-loops specified");
6269
6270 return (-1);
6271 }
6272 }
6273
6274 if ((workload_profile < 1) || (workload_profile > 4))
6275 {
6276 log_error ("ERROR: workload-profile %i not available", workload_profile);
6277
6278 return (-1);
6279 }
6280
6281 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6282 {
6283 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6284
6285 return (-1);
6286 }
6287
6288 if (show == 1 || left == 1)
6289 {
6290 attack_mode = ATTACK_MODE_NONE;
6291
6292 if (remove == 1)
6293 {
6294 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6295
6296 return (-1);
6297 }
6298
6299 if (potfile_disable == 1)
6300 {
6301 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6302
6303 return (-1);
6304 }
6305 }
6306
6307 uint attack_kern = ATTACK_KERN_NONE;
6308
6309 switch (attack_mode)
6310 {
6311 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6312 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6313 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6314 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6315 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6316 }
6317
6318 if (benchmark == 0)
6319 {
6320 if (keyspace == 1)
6321 {
6322 int num_additional_params = 1;
6323
6324 if (attack_kern == ATTACK_KERN_COMBI)
6325 {
6326 num_additional_params = 2;
6327 }
6328
6329 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6330
6331 if (keyspace_wordlist_specified == 0) optind--;
6332 }
6333
6334 if (attack_kern == ATTACK_KERN_NONE)
6335 {
6336 if ((optind + 1) != myargc)
6337 {
6338 usage_mini_print (myargv[0]);
6339
6340 return (-1);
6341 }
6342 }
6343 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6344 {
6345 if ((optind + 1) > myargc)
6346 {
6347 usage_mini_print (myargv[0]);
6348
6349 return (-1);
6350 }
6351 }
6352 else if (attack_kern == ATTACK_KERN_COMBI)
6353 {
6354 if ((optind + 3) != myargc)
6355 {
6356 usage_mini_print (myargv[0]);
6357
6358 return (-1);
6359 }
6360 }
6361 else if (attack_kern == ATTACK_KERN_BF)
6362 {
6363 if ((optind + 1) > myargc)
6364 {
6365 usage_mini_print (myargv[0]);
6366
6367 return (-1);
6368 }
6369 }
6370 else
6371 {
6372 usage_mini_print (myargv[0]);
6373
6374 return (-1);
6375 }
6376 }
6377 else
6378 {
6379 if (myargv[optind] != 0)
6380 {
6381 log_error ("ERROR: Invalid argument for benchmark mode specified");
6382
6383 return (-1);
6384 }
6385
6386 if (attack_mode_chgd == 1)
6387 {
6388 if (attack_mode != ATTACK_MODE_BF)
6389 {
6390 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6391
6392 return (-1);
6393 }
6394 }
6395 }
6396
6397 if (skip != 0 && limit != 0)
6398 {
6399 limit += skip;
6400 }
6401
6402 if (keyspace == 1)
6403 {
6404 if (show == 1)
6405 {
6406 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6407
6408 return (-1);
6409 }
6410 else if (left == 1)
6411 {
6412 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6413
6414 return (-1);
6415 }
6416
6417 potfile_disable = 1;
6418
6419 restore_disable = 1;
6420
6421 restore = 0;
6422
6423 weak_hash_threshold = 0;
6424
6425 quiet = 1;
6426 }
6427
6428 if (remove_timer_chgd == 1)
6429 {
6430 if (remove == 0)
6431 {
6432 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6433
6434 return (-1);
6435 }
6436
6437 if (remove_timer < 1)
6438 {
6439 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6440
6441 return (-1);
6442 }
6443 }
6444
6445 if (loopback == 1)
6446 {
6447 if (attack_mode == ATTACK_MODE_STRAIGHT)
6448 {
6449 if ((rp_files_cnt == 0) && (rp_gen == 0))
6450 {
6451 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6452
6453 return (-1);
6454 }
6455 }
6456 else
6457 {
6458 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6459
6460 return (-1);
6461 }
6462 }
6463
6464 if (debug_mode > 0)
6465 {
6466 if (attack_mode != ATTACK_MODE_STRAIGHT)
6467 {
6468 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6469
6470 return (-1);
6471 }
6472
6473 if ((rp_files_cnt == 0) && (rp_gen == 0))
6474 {
6475 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6476
6477 return (-1);
6478 }
6479 }
6480
6481 if (debug_mode > 4)
6482 {
6483 log_error ("ERROR: Invalid debug-mode specified");
6484
6485 return (-1);
6486 }
6487
6488 if (debug_file != NULL)
6489 {
6490 if (debug_mode < 1)
6491 {
6492 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6493
6494 return (-1);
6495 }
6496 }
6497
6498 if (induction_dir != NULL)
6499 {
6500 if (attack_mode == ATTACK_MODE_BF)
6501 {
6502 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6503
6504 return (-1);
6505 }
6506 }
6507
6508 if (attack_mode != ATTACK_MODE_STRAIGHT)
6509 {
6510 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6511 {
6512 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6513
6514 return (-1);
6515 }
6516
6517 weak_hash_threshold = 0;
6518 }
6519
6520 /**
6521 * induction directory
6522 */
6523
6524 char *induction_directory = NULL;
6525
6526 if (attack_mode != ATTACK_MODE_BF)
6527 {
6528 if (induction_dir == NULL)
6529 {
6530 induction_directory = (char *) mymalloc (session_size);
6531
6532 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6533
6534 // create induction folder if it does not already exist
6535
6536 if (keyspace == 0)
6537 {
6538 if (rmdir (induction_directory) == -1)
6539 {
6540 if (errno == ENOENT)
6541 {
6542 // good, we can ignore
6543 }
6544 else if (errno == ENOTEMPTY)
6545 {
6546 char *induction_directory_mv = (char *) mymalloc (session_size);
6547
6548 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6549
6550 if (rename (induction_directory, induction_directory_mv) != 0)
6551 {
6552 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6553
6554 return (-1);
6555 }
6556 }
6557 else
6558 {
6559 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6560
6561 return (-1);
6562 }
6563 }
6564
6565 if (mkdir (induction_directory, 0700) == -1)
6566 {
6567 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6568
6569 return (-1);
6570 }
6571 }
6572 }
6573 else
6574 {
6575 induction_directory = induction_dir;
6576 }
6577 }
6578
6579 data.induction_directory = induction_directory;
6580
6581 /**
6582 * loopback
6583 */
6584
6585 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6586
6587 char *loopback_file = (char *) mymalloc (loopback_size);
6588
6589 /**
6590 * tuning db
6591 */
6592
6593 char tuning_db_file[256] = { 0 };
6594
6595 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6596
6597 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6598
6599 /**
6600 * outfile-check directory
6601 */
6602
6603 char *outfile_check_directory = NULL;
6604
6605 if (outfile_check_dir == NULL)
6606 {
6607 outfile_check_directory = (char *) mymalloc (session_size);
6608
6609 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6610 }
6611 else
6612 {
6613 outfile_check_directory = outfile_check_dir;
6614 }
6615
6616 data.outfile_check_directory = outfile_check_directory;
6617
6618 if (keyspace == 0)
6619 {
6620 struct stat outfile_check_stat;
6621
6622 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6623 {
6624 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6625
6626 if (is_dir == 0)
6627 {
6628 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6629
6630 return (-1);
6631 }
6632 }
6633 else if (outfile_check_dir == NULL)
6634 {
6635 if (mkdir (outfile_check_directory, 0700) == -1)
6636 {
6637 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6638
6639 return (-1);
6640 }
6641 }
6642 }
6643
6644 /**
6645 * special other stuff
6646 */
6647
6648 if (hash_mode == 9710)
6649 {
6650 outfile_format = 5;
6651 outfile_format_chgd = 1;
6652 }
6653
6654 if (hash_mode == 9810)
6655 {
6656 outfile_format = 5;
6657 outfile_format_chgd = 1;
6658 }
6659
6660 if (hash_mode == 10410)
6661 {
6662 outfile_format = 5;
6663 outfile_format_chgd = 1;
6664 }
6665
6666 /**
6667 * store stuff
6668 */
6669
6670 data.hash_mode = hash_mode;
6671 data.restore = restore;
6672 data.restore_timer = restore_timer;
6673 data.restore_disable = restore_disable;
6674 data.status = status;
6675 data.status_timer = status_timer;
6676 data.machine_readable = machine_readable;
6677 data.loopback = loopback;
6678 data.runtime = runtime;
6679 data.remove = remove;
6680 data.remove_timer = remove_timer;
6681 data.debug_mode = debug_mode;
6682 data.debug_file = debug_file;
6683 data.username = username;
6684 data.quiet = quiet;
6685 data.outfile = outfile;
6686 data.outfile_format = outfile_format;
6687 data.outfile_autohex = outfile_autohex;
6688 data.hex_charset = hex_charset;
6689 data.hex_salt = hex_salt;
6690 data.hex_wordlist = hex_wordlist;
6691 data.separator = separator;
6692 data.rp_files = rp_files;
6693 data.rp_files_cnt = rp_files_cnt;
6694 data.rp_gen = rp_gen;
6695 data.rp_gen_seed = rp_gen_seed;
6696 data.force = force;
6697 data.benchmark = benchmark;
6698 data.skip = skip;
6699 data.limit = limit;
6700 #ifdef HAVE_HWMON
6701 data.powertune_enable = powertune_enable;
6702 #endif
6703 data.logfile_disable = logfile_disable;
6704 data.truecrypt_keyfiles = truecrypt_keyfiles;
6705 data.veracrypt_keyfiles = veracrypt_keyfiles;
6706 data.veracrypt_pim = veracrypt_pim;
6707 data.scrypt_tmto = scrypt_tmto;
6708 data.workload_profile = workload_profile;
6709
6710 /**
6711 * cpu affinity
6712 */
6713
6714 if (cpu_affinity)
6715 {
6716 set_cpu_affinity (cpu_affinity);
6717 }
6718
6719 if (rp_gen_seed_chgd == 0)
6720 {
6721 srand (proc_start);
6722 }
6723 else
6724 {
6725 srand (rp_gen_seed);
6726 }
6727
6728 /**
6729 * logfile init
6730 */
6731
6732 if (logfile_disable == 0)
6733 {
6734 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6735
6736 char *logfile = (char *) mymalloc (logfile_size);
6737
6738 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6739
6740 data.logfile = logfile;
6741
6742 char *topid = logfile_generate_topid ();
6743
6744 data.topid = topid;
6745 }
6746
6747 // logfile_append() checks for logfile_disable internally to make it easier from here
6748
6749 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6750 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6751 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6752 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6753 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6754 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6755 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6756 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6757 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6758 #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));
6759
6760 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6761 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6762 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6763 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6764 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6765 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6766 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6767 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6768
6769 logfile_top_msg ("START");
6770
6771 logfile_top_uint (attack_mode);
6772 logfile_top_uint (attack_kern);
6773 logfile_top_uint (benchmark);
6774 logfile_top_uint (bitmap_min);
6775 logfile_top_uint (bitmap_max);
6776 logfile_top_uint (debug_mode);
6777 logfile_top_uint (force);
6778 logfile_top_uint (kernel_accel);
6779 logfile_top_uint (kernel_loops);
6780 logfile_top_uint (gpu_temp_disable);
6781 #ifdef HAVE_HWMON
6782 logfile_top_uint (gpu_temp_abort);
6783 logfile_top_uint (gpu_temp_retain);
6784 #endif
6785 logfile_top_uint (hash_mode);
6786 logfile_top_uint (hex_charset);
6787 logfile_top_uint (hex_salt);
6788 logfile_top_uint (hex_wordlist);
6789 logfile_top_uint (increment);
6790 logfile_top_uint (increment_max);
6791 logfile_top_uint (increment_min);
6792 logfile_top_uint (keyspace);
6793 logfile_top_uint (left);
6794 logfile_top_uint (logfile_disable);
6795 logfile_top_uint (loopback);
6796 logfile_top_uint (markov_classic);
6797 logfile_top_uint (markov_disable);
6798 logfile_top_uint (markov_threshold);
6799 logfile_top_uint (outfile_autohex);
6800 logfile_top_uint (outfile_check_timer);
6801 logfile_top_uint (outfile_format);
6802 logfile_top_uint (potfile_disable);
6803 logfile_top_string (potfile_path);
6804 #if defined(HAVE_HWMON)
6805 logfile_top_uint (powertune_enable);
6806 #endif
6807 logfile_top_uint (scrypt_tmto);
6808 logfile_top_uint (quiet);
6809 logfile_top_uint (remove);
6810 logfile_top_uint (remove_timer);
6811 logfile_top_uint (restore);
6812 logfile_top_uint (restore_disable);
6813 logfile_top_uint (restore_timer);
6814 logfile_top_uint (rp_gen);
6815 logfile_top_uint (rp_gen_func_max);
6816 logfile_top_uint (rp_gen_func_min);
6817 logfile_top_uint (rp_gen_seed);
6818 logfile_top_uint (runtime);
6819 logfile_top_uint (segment_size);
6820 logfile_top_uint (show);
6821 logfile_top_uint (status);
6822 logfile_top_uint (machine_readable);
6823 logfile_top_uint (status_timer);
6824 logfile_top_uint (usage);
6825 logfile_top_uint (username);
6826 logfile_top_uint (version);
6827 logfile_top_uint (weak_hash_threshold);
6828 logfile_top_uint (workload_profile);
6829 logfile_top_uint64 (limit);
6830 logfile_top_uint64 (skip);
6831 logfile_top_char (separator);
6832 logfile_top_string (cpu_affinity);
6833 logfile_top_string (custom_charset_1);
6834 logfile_top_string (custom_charset_2);
6835 logfile_top_string (custom_charset_3);
6836 logfile_top_string (custom_charset_4);
6837 logfile_top_string (debug_file);
6838 logfile_top_string (opencl_devices);
6839 logfile_top_string (opencl_platforms);
6840 logfile_top_string (opencl_device_types);
6841 logfile_top_uint (opencl_vector_width);
6842 logfile_top_string (induction_dir);
6843 logfile_top_string (markov_hcstat);
6844 logfile_top_string (outfile);
6845 logfile_top_string (outfile_check_dir);
6846 logfile_top_string (rule_buf_l);
6847 logfile_top_string (rule_buf_r);
6848 logfile_top_string (session);
6849 logfile_top_string (truecrypt_keyfiles);
6850 logfile_top_string (veracrypt_keyfiles);
6851 logfile_top_uint (veracrypt_pim);
6852
6853 /**
6854 * Init OpenCL library loader
6855 */
6856
6857 if (keyspace == 0)
6858 {
6859 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6860
6861 ocl_init (ocl);
6862
6863 data.ocl = ocl;
6864 }
6865
6866 /**
6867 * OpenCL platform selection
6868 */
6869
6870 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6871
6872 /**
6873 * OpenCL device selection
6874 */
6875
6876 u32 devices_filter = setup_devices_filter (opencl_devices);
6877
6878 /**
6879 * OpenCL device type selection
6880 */
6881
6882 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6883
6884 /**
6885 * benchmark
6886 */
6887
6888 if (benchmark == 1)
6889 {
6890 /**
6891 * disable useless stuff for benchmark
6892 */
6893
6894 status_timer = 0;
6895 restore_timer = 0;
6896 restore_disable = 1;
6897 potfile_disable = 1;
6898 weak_hash_threshold = 0;
6899 gpu_temp_disable = 1;
6900
6901 #ifdef HAVE_HWMON
6902 powertune_enable = 1;
6903 #endif
6904
6905 data.status_timer = status_timer;
6906 data.restore_timer = restore_timer;
6907 data.restore_disable = restore_disable;
6908
6909 /**
6910 * force attack mode to be bruteforce
6911 */
6912
6913 attack_mode = ATTACK_MODE_BF;
6914 attack_kern = ATTACK_KERN_BF;
6915
6916 if (workload_profile_chgd == 0)
6917 {
6918 workload_profile = 3;
6919
6920 data.workload_profile = workload_profile;
6921 }
6922 }
6923
6924 /**
6925 * config
6926 */
6927
6928 uint hash_type = 0;
6929 uint salt_type = 0;
6930 uint attack_exec = 0;
6931 uint opts_type = 0;
6932 uint kern_type = 0;
6933 uint dgst_size = 0;
6934 uint esalt_size = 0;
6935 uint opti_type = 0;
6936 uint dgst_pos0 = -1;
6937 uint dgst_pos1 = -1;
6938 uint dgst_pos2 = -1;
6939 uint dgst_pos3 = -1;
6940
6941 int (*parse_func) (char *, uint, hash_t *);
6942 int (*sort_by_digest) (const void *, const void *);
6943
6944 uint algorithm_pos = 0;
6945 uint algorithm_max = 1;
6946
6947 uint *algorithms = default_benchmark_algorithms;
6948
6949 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6950
6951 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6952 {
6953 /*
6954 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6955 * the following algos are skipped entirely
6956 */
6957
6958 if (algorithm_pos > 0)
6959 {
6960 local_free (rd);
6961
6962 rd = init_restore (argc, argv);
6963
6964 data.rd = rd;
6965 }
6966
6967 /**
6968 * update hash_mode in case of multihash benchmark
6969 */
6970
6971 if (benchmark == 1)
6972 {
6973 if (hash_mode_chgd == 0)
6974 {
6975 hash_mode = algorithms[algorithm_pos];
6976
6977 data.hash_mode = hash_mode;
6978 }
6979
6980 quiet = 1;
6981
6982 data.quiet = quiet;
6983 }
6984
6985 switch (hash_mode)
6986 {
6987 case 0: hash_type = HASH_TYPE_MD5;
6988 salt_type = SALT_TYPE_NONE;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_LE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS14;
6993 kern_type = KERN_TYPE_MD5;
6994 dgst_size = DGST_SIZE_4_4;
6995 parse_func = md5_parse_hash;
6996 sort_by_digest = sort_by_digest_4_4;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_MEET_IN_MIDDLE
7001 | OPTI_TYPE_EARLY_SKIP
7002 | OPTI_TYPE_NOT_ITERATED
7003 | OPTI_TYPE_NOT_SALTED
7004 | OPTI_TYPE_RAW_HASH;
7005 dgst_pos0 = 0;
7006 dgst_pos1 = 3;
7007 dgst_pos2 = 2;
7008 dgst_pos3 = 1;
7009 break;
7010
7011 case 10: hash_type = HASH_TYPE_MD5;
7012 salt_type = SALT_TYPE_INTERN;
7013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7014 opts_type = OPTS_TYPE_PT_GENERATE_LE
7015 | OPTS_TYPE_ST_ADD80
7016 | OPTS_TYPE_ST_ADDBITS14;
7017 kern_type = KERN_TYPE_MD5_PWSLT;
7018 dgst_size = DGST_SIZE_4_4;
7019 parse_func = md5s_parse_hash;
7020 sort_by_digest = sort_by_digest_4_4;
7021 opti_type = OPTI_TYPE_ZERO_BYTE
7022 | OPTI_TYPE_PRECOMPUTE_INIT
7023 | OPTI_TYPE_PRECOMPUTE_MERKLE
7024 | OPTI_TYPE_MEET_IN_MIDDLE
7025 | OPTI_TYPE_EARLY_SKIP
7026 | OPTI_TYPE_NOT_ITERATED
7027 | OPTI_TYPE_APPENDED_SALT
7028 | OPTI_TYPE_RAW_HASH;
7029 dgst_pos0 = 0;
7030 dgst_pos1 = 3;
7031 dgst_pos2 = 2;
7032 dgst_pos3 = 1;
7033 break;
7034
7035 case 11: hash_type = HASH_TYPE_MD5;
7036 salt_type = SALT_TYPE_INTERN;
7037 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7038 opts_type = OPTS_TYPE_PT_GENERATE_LE
7039 | OPTS_TYPE_ST_ADD80
7040 | OPTS_TYPE_ST_ADDBITS14;
7041 kern_type = KERN_TYPE_MD5_PWSLT;
7042 dgst_size = DGST_SIZE_4_4;
7043 parse_func = joomla_parse_hash;
7044 sort_by_digest = sort_by_digest_4_4;
7045 opti_type = OPTI_TYPE_ZERO_BYTE
7046 | OPTI_TYPE_PRECOMPUTE_INIT
7047 | OPTI_TYPE_PRECOMPUTE_MERKLE
7048 | OPTI_TYPE_MEET_IN_MIDDLE
7049 | OPTI_TYPE_EARLY_SKIP
7050 | OPTI_TYPE_NOT_ITERATED
7051 | OPTI_TYPE_APPENDED_SALT
7052 | OPTI_TYPE_RAW_HASH;
7053 dgst_pos0 = 0;
7054 dgst_pos1 = 3;
7055 dgst_pos2 = 2;
7056 dgst_pos3 = 1;
7057 break;
7058
7059 case 12: hash_type = HASH_TYPE_MD5;
7060 salt_type = SALT_TYPE_INTERN;
7061 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7062 opts_type = OPTS_TYPE_PT_GENERATE_LE
7063 | OPTS_TYPE_ST_ADD80
7064 | OPTS_TYPE_ST_ADDBITS14;
7065 kern_type = KERN_TYPE_MD5_PWSLT;
7066 dgst_size = DGST_SIZE_4_4;
7067 parse_func = postgresql_parse_hash;
7068 sort_by_digest = sort_by_digest_4_4;
7069 opti_type = OPTI_TYPE_ZERO_BYTE
7070 | OPTI_TYPE_PRECOMPUTE_INIT
7071 | OPTI_TYPE_PRECOMPUTE_MERKLE
7072 | OPTI_TYPE_MEET_IN_MIDDLE
7073 | OPTI_TYPE_EARLY_SKIP
7074 | OPTI_TYPE_NOT_ITERATED
7075 | OPTI_TYPE_APPENDED_SALT
7076 | OPTI_TYPE_RAW_HASH;
7077 dgst_pos0 = 0;
7078 dgst_pos1 = 3;
7079 dgst_pos2 = 2;
7080 dgst_pos3 = 1;
7081 break;
7082
7083 case 20: hash_type = HASH_TYPE_MD5;
7084 salt_type = SALT_TYPE_INTERN;
7085 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7086 opts_type = OPTS_TYPE_PT_GENERATE_LE
7087 | OPTS_TYPE_PT_ADD80
7088 | OPTS_TYPE_PT_ADDBITS14;
7089 kern_type = KERN_TYPE_MD5_SLTPW;
7090 dgst_size = DGST_SIZE_4_4;
7091 parse_func = md5s_parse_hash;
7092 sort_by_digest = sort_by_digest_4_4;
7093 opti_type = OPTI_TYPE_ZERO_BYTE
7094 | OPTI_TYPE_PRECOMPUTE_INIT
7095 | OPTI_TYPE_PRECOMPUTE_MERKLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_PREPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 21: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_PT_ADD80
7111 | OPTS_TYPE_PT_ADDBITS14;
7112 kern_type = KERN_TYPE_MD5_SLTPW;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = osc_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_EARLY_SKIP
7120 | OPTI_TYPE_NOT_ITERATED
7121 | OPTI_TYPE_PREPENDED_SALT
7122 | OPTI_TYPE_RAW_HASH;
7123 dgst_pos0 = 0;
7124 dgst_pos1 = 3;
7125 dgst_pos2 = 2;
7126 dgst_pos3 = 1;
7127 break;
7128
7129 case 22: hash_type = HASH_TYPE_MD5;
7130 salt_type = SALT_TYPE_EMBEDDED;
7131 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7132 opts_type = OPTS_TYPE_PT_GENERATE_LE
7133 | OPTS_TYPE_PT_ADD80
7134 | OPTS_TYPE_PT_ADDBITS14;
7135 kern_type = KERN_TYPE_MD5_SLTPW;
7136 dgst_size = DGST_SIZE_4_4;
7137 parse_func = netscreen_parse_hash;
7138 sort_by_digest = sort_by_digest_4_4;
7139 opti_type = OPTI_TYPE_ZERO_BYTE
7140 | OPTI_TYPE_PRECOMPUTE_INIT
7141 | OPTI_TYPE_PRECOMPUTE_MERKLE
7142 | OPTI_TYPE_EARLY_SKIP
7143 | OPTI_TYPE_NOT_ITERATED
7144 | OPTI_TYPE_PREPENDED_SALT
7145 | OPTI_TYPE_RAW_HASH;
7146 dgst_pos0 = 0;
7147 dgst_pos1 = 3;
7148 dgst_pos2 = 2;
7149 dgst_pos3 = 1;
7150 break;
7151
7152 case 23: hash_type = HASH_TYPE_MD5;
7153 salt_type = SALT_TYPE_EMBEDDED;
7154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7155 opts_type = OPTS_TYPE_PT_GENERATE_LE
7156 | OPTS_TYPE_PT_ADD80
7157 | OPTS_TYPE_PT_ADDBITS14;
7158 kern_type = KERN_TYPE_MD5_SLTPW;
7159 dgst_size = DGST_SIZE_4_4;
7160 parse_func = skype_parse_hash;
7161 sort_by_digest = sort_by_digest_4_4;
7162 opti_type = OPTI_TYPE_ZERO_BYTE
7163 | OPTI_TYPE_PRECOMPUTE_INIT
7164 | OPTI_TYPE_PRECOMPUTE_MERKLE
7165 | OPTI_TYPE_EARLY_SKIP
7166 | OPTI_TYPE_NOT_ITERATED
7167 | OPTI_TYPE_PREPENDED_SALT
7168 | OPTI_TYPE_RAW_HASH;
7169 dgst_pos0 = 0;
7170 dgst_pos1 = 3;
7171 dgst_pos2 = 2;
7172 dgst_pos3 = 1;
7173 break;
7174
7175 case 30: hash_type = HASH_TYPE_MD5;
7176 salt_type = SALT_TYPE_INTERN;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_LE
7179 | OPTS_TYPE_PT_UNICODE
7180 | OPTS_TYPE_ST_ADD80
7181 | OPTS_TYPE_ST_ADDBITS14;
7182 kern_type = KERN_TYPE_MD5_PWUSLT;
7183 dgst_size = DGST_SIZE_4_4;
7184 parse_func = md5s_parse_hash;
7185 sort_by_digest = sort_by_digest_4_4;
7186 opti_type = OPTI_TYPE_ZERO_BYTE
7187 | OPTI_TYPE_PRECOMPUTE_INIT
7188 | OPTI_TYPE_PRECOMPUTE_MERKLE
7189 | OPTI_TYPE_MEET_IN_MIDDLE
7190 | OPTI_TYPE_EARLY_SKIP
7191 | OPTI_TYPE_NOT_ITERATED
7192 | OPTI_TYPE_APPENDED_SALT
7193 | OPTI_TYPE_RAW_HASH;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 3;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 40: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_INTERN;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS14
7206 | OPTS_TYPE_PT_UNICODE;
7207 kern_type = KERN_TYPE_MD5_SLTPWU;
7208 dgst_size = DGST_SIZE_4_4;
7209 parse_func = md5s_parse_hash;
7210 sort_by_digest = sort_by_digest_4_4;
7211 opti_type = OPTI_TYPE_ZERO_BYTE
7212 | OPTI_TYPE_PRECOMPUTE_INIT
7213 | OPTI_TYPE_PRECOMPUTE_MERKLE
7214 | OPTI_TYPE_EARLY_SKIP
7215 | OPTI_TYPE_NOT_ITERATED
7216 | OPTI_TYPE_PREPENDED_SALT
7217 | OPTI_TYPE_RAW_HASH;
7218 dgst_pos0 = 0;
7219 dgst_pos1 = 3;
7220 dgst_pos2 = 2;
7221 dgst_pos3 = 1;
7222 break;
7223
7224 case 50: hash_type = HASH_TYPE_MD5;
7225 salt_type = SALT_TYPE_INTERN;
7226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7227 opts_type = OPTS_TYPE_PT_GENERATE_LE
7228 | OPTS_TYPE_ST_ADD80
7229 | OPTS_TYPE_ST_ADDBITS14;
7230 kern_type = KERN_TYPE_HMACMD5_PW;
7231 dgst_size = DGST_SIZE_4_4;
7232 parse_func = hmacmd5_parse_hash;
7233 sort_by_digest = sort_by_digest_4_4;
7234 opti_type = OPTI_TYPE_ZERO_BYTE
7235 | OPTI_TYPE_NOT_ITERATED;
7236 dgst_pos0 = 0;
7237 dgst_pos1 = 3;
7238 dgst_pos2 = 2;
7239 dgst_pos3 = 1;
7240 break;
7241
7242 case 60: hash_type = HASH_TYPE_MD5;
7243 salt_type = SALT_TYPE_INTERN;
7244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7245 opts_type = OPTS_TYPE_PT_GENERATE_LE
7246 | OPTS_TYPE_PT_ADD80
7247 | OPTS_TYPE_PT_ADDBITS14;
7248 kern_type = KERN_TYPE_HMACMD5_SLT;
7249 dgst_size = DGST_SIZE_4_4;
7250 parse_func = hmacmd5_parse_hash;
7251 sort_by_digest = sort_by_digest_4_4;
7252 opti_type = OPTI_TYPE_ZERO_BYTE
7253 | OPTI_TYPE_NOT_ITERATED;
7254 dgst_pos0 = 0;
7255 dgst_pos1 = 3;
7256 dgst_pos2 = 2;
7257 dgst_pos3 = 1;
7258 break;
7259
7260 case 100: hash_type = HASH_TYPE_SHA1;
7261 salt_type = SALT_TYPE_NONE;
7262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7263 opts_type = OPTS_TYPE_PT_GENERATE_BE
7264 | OPTS_TYPE_PT_ADD80
7265 | OPTS_TYPE_PT_ADDBITS15;
7266 kern_type = KERN_TYPE_SHA1;
7267 dgst_size = DGST_SIZE_4_5;
7268 parse_func = sha1_parse_hash;
7269 sort_by_digest = sort_by_digest_4_5;
7270 opti_type = OPTI_TYPE_ZERO_BYTE
7271 | OPTI_TYPE_PRECOMPUTE_INIT
7272 | OPTI_TYPE_PRECOMPUTE_MERKLE
7273 | OPTI_TYPE_EARLY_SKIP
7274 | OPTI_TYPE_NOT_ITERATED
7275 | OPTI_TYPE_NOT_SALTED
7276 | OPTI_TYPE_RAW_HASH;
7277 dgst_pos0 = 3;
7278 dgst_pos1 = 4;
7279 dgst_pos2 = 2;
7280 dgst_pos3 = 1;
7281 break;
7282
7283 case 101: hash_type = HASH_TYPE_SHA1;
7284 salt_type = SALT_TYPE_NONE;
7285 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7286 opts_type = OPTS_TYPE_PT_GENERATE_BE
7287 | OPTS_TYPE_PT_ADD80
7288 | OPTS_TYPE_PT_ADDBITS15;
7289 kern_type = KERN_TYPE_SHA1;
7290 dgst_size = DGST_SIZE_4_5;
7291 parse_func = sha1b64_parse_hash;
7292 sort_by_digest = sort_by_digest_4_5;
7293 opti_type = OPTI_TYPE_ZERO_BYTE
7294 | OPTI_TYPE_PRECOMPUTE_INIT
7295 | OPTI_TYPE_PRECOMPUTE_MERKLE
7296 | OPTI_TYPE_EARLY_SKIP
7297 | OPTI_TYPE_NOT_ITERATED
7298 | OPTI_TYPE_NOT_SALTED
7299 | OPTI_TYPE_RAW_HASH;
7300 dgst_pos0 = 3;
7301 dgst_pos1 = 4;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 110: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_INTERN;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_ST_ADD80
7311 | OPTS_TYPE_ST_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1_PWSLT;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = sha1s_parse_hash;
7315 sort_by_digest = sort_by_digest_4_5;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_EARLY_SKIP
7320 | OPTI_TYPE_NOT_ITERATED
7321 | OPTI_TYPE_APPENDED_SALT
7322 | OPTI_TYPE_RAW_HASH;
7323 dgst_pos0 = 3;
7324 dgst_pos1 = 4;
7325 dgst_pos2 = 2;
7326 dgst_pos3 = 1;
7327 break;
7328
7329 case 111: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_EMBEDDED;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_ST_ADD80
7334 | OPTS_TYPE_ST_ADDBITS15;
7335 kern_type = KERN_TYPE_SHA1_PWSLT;
7336 dgst_size = DGST_SIZE_4_5;
7337 parse_func = sha1b64s_parse_hash;
7338 sort_by_digest = sort_by_digest_4_5;
7339 opti_type = OPTI_TYPE_ZERO_BYTE
7340 | OPTI_TYPE_PRECOMPUTE_INIT
7341 | OPTI_TYPE_PRECOMPUTE_MERKLE
7342 | OPTI_TYPE_EARLY_SKIP
7343 | OPTI_TYPE_NOT_ITERATED
7344 | OPTI_TYPE_APPENDED_SALT
7345 | OPTI_TYPE_RAW_HASH;
7346 dgst_pos0 = 3;
7347 dgst_pos1 = 4;
7348 dgst_pos2 = 2;
7349 dgst_pos3 = 1;
7350 break;
7351
7352 case 112: hash_type = HASH_TYPE_SHA1;
7353 salt_type = SALT_TYPE_INTERN;
7354 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7355 opts_type = OPTS_TYPE_PT_GENERATE_BE
7356 | OPTS_TYPE_ST_ADD80
7357 | OPTS_TYPE_ST_ADDBITS15
7358 | OPTS_TYPE_ST_HEX;
7359 kern_type = KERN_TYPE_SHA1_PWSLT;
7360 dgst_size = DGST_SIZE_4_5;
7361 parse_func = oracles_parse_hash;
7362 sort_by_digest = sort_by_digest_4_5;
7363 opti_type = OPTI_TYPE_ZERO_BYTE
7364 | OPTI_TYPE_PRECOMPUTE_INIT
7365 | OPTI_TYPE_PRECOMPUTE_MERKLE
7366 | OPTI_TYPE_EARLY_SKIP
7367 | OPTI_TYPE_NOT_ITERATED
7368 | OPTI_TYPE_APPENDED_SALT
7369 | OPTI_TYPE_RAW_HASH;
7370 dgst_pos0 = 3;
7371 dgst_pos1 = 4;
7372 dgst_pos2 = 2;
7373 dgst_pos3 = 1;
7374 break;
7375
7376 case 120: hash_type = HASH_TYPE_SHA1;
7377 salt_type = SALT_TYPE_INTERN;
7378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7379 opts_type = OPTS_TYPE_PT_GENERATE_BE
7380 | OPTS_TYPE_PT_ADD80
7381 | OPTS_TYPE_PT_ADDBITS15;
7382 kern_type = KERN_TYPE_SHA1_SLTPW;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = sha1s_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_PREPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 121: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_INTERN;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_ADD80
7404 | OPTS_TYPE_PT_ADDBITS15
7405 | OPTS_TYPE_ST_LOWER;
7406 kern_type = KERN_TYPE_SHA1_SLTPW;
7407 dgst_size = DGST_SIZE_4_5;
7408 parse_func = smf_parse_hash;
7409 sort_by_digest = sort_by_digest_4_5;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_PREPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 122: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_EMBEDDED;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_PT_ADD80
7428 | OPTS_TYPE_PT_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_SLTPW;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = osx1_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_PREPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 124: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_EMBEDDED;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_ADD80
7452 | OPTS_TYPE_PT_ADDBITS15;
7453 kern_type = KERN_TYPE_SHA1_SLTPW;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = djangosha1_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 125: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_EMBEDDED;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_ST_HEX;
7477 kern_type = KERN_TYPE_SHA1_SLTPW;
7478 dgst_size = DGST_SIZE_4_5;
7479 parse_func = arubaos_parse_hash;
7480 sort_by_digest = sort_by_digest_4_5;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 3;
7489 dgst_pos1 = 4;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 130: hash_type = HASH_TYPE_SHA1;
7495 salt_type = SALT_TYPE_INTERN;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_BE
7498 | OPTS_TYPE_PT_UNICODE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_ADDBITS15;
7501 kern_type = KERN_TYPE_SHA1_PWUSLT;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = sha1s_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_APPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 131: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_UNICODE
7523 | OPTS_TYPE_PT_UPPER
7524 | OPTS_TYPE_ST_ADD80
7525 | OPTS_TYPE_ST_ADDBITS15
7526 | OPTS_TYPE_ST_HEX;
7527 kern_type = KERN_TYPE_SHA1_PWUSLT;
7528 dgst_size = DGST_SIZE_4_5;
7529 parse_func = mssql2000_parse_hash;
7530 sort_by_digest = sort_by_digest_4_5;
7531 opti_type = OPTI_TYPE_ZERO_BYTE
7532 | OPTI_TYPE_PRECOMPUTE_INIT
7533 | OPTI_TYPE_PRECOMPUTE_MERKLE
7534 | OPTI_TYPE_EARLY_SKIP
7535 | OPTI_TYPE_NOT_ITERATED
7536 | OPTI_TYPE_APPENDED_SALT
7537 | OPTI_TYPE_RAW_HASH;
7538 dgst_pos0 = 3;
7539 dgst_pos1 = 4;
7540 dgst_pos2 = 2;
7541 dgst_pos3 = 1;
7542 break;
7543
7544 case 132: hash_type = HASH_TYPE_SHA1;
7545 salt_type = SALT_TYPE_EMBEDDED;
7546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7547 opts_type = OPTS_TYPE_PT_GENERATE_BE
7548 | OPTS_TYPE_PT_UNICODE
7549 | OPTS_TYPE_ST_ADD80
7550 | OPTS_TYPE_ST_ADDBITS15
7551 | OPTS_TYPE_ST_HEX;
7552 kern_type = KERN_TYPE_SHA1_PWUSLT;
7553 dgst_size = DGST_SIZE_4_5;
7554 parse_func = mssql2005_parse_hash;
7555 sort_by_digest = sort_by_digest_4_5;
7556 opti_type = OPTI_TYPE_ZERO_BYTE
7557 | OPTI_TYPE_PRECOMPUTE_INIT
7558 | OPTI_TYPE_PRECOMPUTE_MERKLE
7559 | OPTI_TYPE_EARLY_SKIP
7560 | OPTI_TYPE_NOT_ITERATED
7561 | OPTI_TYPE_APPENDED_SALT
7562 | OPTI_TYPE_RAW_HASH;
7563 dgst_pos0 = 3;
7564 dgst_pos1 = 4;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 133: hash_type = HASH_TYPE_SHA1;
7570 salt_type = SALT_TYPE_EMBEDDED;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_BE
7573 | OPTS_TYPE_PT_UNICODE
7574 | OPTS_TYPE_ST_ADD80
7575 | OPTS_TYPE_ST_ADDBITS15;
7576 kern_type = KERN_TYPE_SHA1_PWUSLT;
7577 dgst_size = DGST_SIZE_4_5;
7578 parse_func = peoplesoft_parse_hash;
7579 sort_by_digest = sort_by_digest_4_5;
7580 opti_type = OPTI_TYPE_ZERO_BYTE
7581 | OPTI_TYPE_PRECOMPUTE_INIT
7582 | OPTI_TYPE_PRECOMPUTE_MERKLE
7583 | OPTI_TYPE_EARLY_SKIP
7584 | OPTI_TYPE_NOT_ITERATED
7585 | OPTI_TYPE_APPENDED_SALT
7586 | OPTI_TYPE_RAW_HASH;
7587 dgst_pos0 = 3;
7588 dgst_pos1 = 4;
7589 dgst_pos2 = 2;
7590 dgst_pos3 = 1;
7591 break;
7592
7593 case 140: hash_type = HASH_TYPE_SHA1;
7594 salt_type = SALT_TYPE_INTERN;
7595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7596 opts_type = OPTS_TYPE_PT_GENERATE_BE
7597 | OPTS_TYPE_PT_ADD80
7598 | OPTS_TYPE_PT_ADDBITS15
7599 | OPTS_TYPE_PT_UNICODE;
7600 kern_type = KERN_TYPE_SHA1_SLTPWU;
7601 dgst_size = DGST_SIZE_4_5;
7602 parse_func = sha1s_parse_hash;
7603 sort_by_digest = sort_by_digest_4_5;
7604 opti_type = OPTI_TYPE_ZERO_BYTE
7605 | OPTI_TYPE_PRECOMPUTE_INIT
7606 | OPTI_TYPE_PRECOMPUTE_MERKLE
7607 | OPTI_TYPE_EARLY_SKIP
7608 | OPTI_TYPE_NOT_ITERATED
7609 | OPTI_TYPE_PREPENDED_SALT
7610 | OPTI_TYPE_RAW_HASH;
7611 dgst_pos0 = 3;
7612 dgst_pos1 = 4;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 1;
7615 break;
7616
7617 case 141: hash_type = HASH_TYPE_SHA1;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_BE
7621 | OPTS_TYPE_PT_ADD80
7622 | OPTS_TYPE_PT_ADDBITS15
7623 | OPTS_TYPE_PT_UNICODE
7624 | OPTS_TYPE_ST_BASE64;
7625 kern_type = KERN_TYPE_SHA1_SLTPWU;
7626 dgst_size = DGST_SIZE_4_5;
7627 parse_func = episerver_parse_hash;
7628 sort_by_digest = sort_by_digest_4_5;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_PRECOMPUTE_INIT
7631 | OPTI_TYPE_PRECOMPUTE_MERKLE
7632 | OPTI_TYPE_EARLY_SKIP
7633 | OPTI_TYPE_NOT_ITERATED
7634 | OPTI_TYPE_PREPENDED_SALT
7635 | OPTI_TYPE_RAW_HASH;
7636 dgst_pos0 = 3;
7637 dgst_pos1 = 4;
7638 dgst_pos2 = 2;
7639 dgst_pos3 = 1;
7640 break;
7641
7642 case 150: hash_type = HASH_TYPE_SHA1;
7643 salt_type = SALT_TYPE_INTERN;
7644 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7645 opts_type = OPTS_TYPE_PT_GENERATE_BE
7646 | OPTS_TYPE_ST_ADD80
7647 | OPTS_TYPE_ST_ADDBITS15;
7648 kern_type = KERN_TYPE_HMACSHA1_PW;
7649 dgst_size = DGST_SIZE_4_5;
7650 parse_func = hmacsha1_parse_hash;
7651 sort_by_digest = sort_by_digest_4_5;
7652 opti_type = OPTI_TYPE_ZERO_BYTE
7653 | OPTI_TYPE_NOT_ITERATED;
7654 dgst_pos0 = 3;
7655 dgst_pos1 = 4;
7656 dgst_pos2 = 2;
7657 dgst_pos3 = 1;
7658 break;
7659
7660 case 160: hash_type = HASH_TYPE_SHA1;
7661 salt_type = SALT_TYPE_INTERN;
7662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7663 opts_type = OPTS_TYPE_PT_GENERATE_BE
7664 | OPTS_TYPE_PT_ADD80
7665 | OPTS_TYPE_PT_ADDBITS15;
7666 kern_type = KERN_TYPE_HMACSHA1_SLT;
7667 dgst_size = DGST_SIZE_4_5;
7668 parse_func = hmacsha1_parse_hash;
7669 sort_by_digest = sort_by_digest_4_5;
7670 opti_type = OPTI_TYPE_ZERO_BYTE
7671 | OPTI_TYPE_NOT_ITERATED;
7672 dgst_pos0 = 3;
7673 dgst_pos1 = 4;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 1;
7676 break;
7677
7678 case 190: hash_type = HASH_TYPE_SHA1;
7679 salt_type = SALT_TYPE_NONE;
7680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7681 opts_type = OPTS_TYPE_PT_GENERATE_BE
7682 | OPTS_TYPE_PT_ADD80
7683 | OPTS_TYPE_PT_ADDBITS15;
7684 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7685 dgst_size = DGST_SIZE_4_5;
7686 parse_func = sha1linkedin_parse_hash;
7687 sort_by_digest = sort_by_digest_4_5;
7688 opti_type = OPTI_TYPE_ZERO_BYTE
7689 | OPTI_TYPE_PRECOMPUTE_INIT
7690 | OPTI_TYPE_EARLY_SKIP
7691 | OPTI_TYPE_NOT_ITERATED
7692 | OPTI_TYPE_NOT_SALTED;
7693 dgst_pos0 = 0;
7694 dgst_pos1 = 4;
7695 dgst_pos2 = 3;
7696 dgst_pos3 = 2;
7697 break;
7698
7699 case 200: hash_type = HASH_TYPE_MYSQL;
7700 salt_type = SALT_TYPE_NONE;
7701 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7702 opts_type = 0;
7703 kern_type = KERN_TYPE_MYSQL;
7704 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7705 parse_func = mysql323_parse_hash;
7706 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7707 opti_type = OPTI_TYPE_ZERO_BYTE;
7708 dgst_pos0 = 0;
7709 dgst_pos1 = 1;
7710 dgst_pos2 = 2;
7711 dgst_pos3 = 3;
7712 break;
7713
7714 case 300: hash_type = HASH_TYPE_SHA1;
7715 salt_type = SALT_TYPE_NONE;
7716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7717 opts_type = OPTS_TYPE_PT_GENERATE_BE
7718 | OPTS_TYPE_PT_ADD80
7719 | OPTS_TYPE_PT_ADDBITS15;
7720 kern_type = KERN_TYPE_MYSQL41;
7721 dgst_size = DGST_SIZE_4_5;
7722 parse_func = sha1_parse_hash;
7723 sort_by_digest = sort_by_digest_4_5;
7724 opti_type = OPTI_TYPE_ZERO_BYTE
7725 | OPTI_TYPE_PRECOMPUTE_INIT
7726 | OPTI_TYPE_PRECOMPUTE_MERKLE
7727 | OPTI_TYPE_EARLY_SKIP
7728 | OPTI_TYPE_NOT_ITERATED
7729 | OPTI_TYPE_NOT_SALTED;
7730 dgst_pos0 = 3;
7731 dgst_pos1 = 4;
7732 dgst_pos2 = 2;
7733 dgst_pos3 = 1;
7734 break;
7735
7736 case 400: hash_type = HASH_TYPE_MD5;
7737 salt_type = SALT_TYPE_EMBEDDED;
7738 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7739 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7740 kern_type = KERN_TYPE_PHPASS;
7741 dgst_size = DGST_SIZE_4_4;
7742 parse_func = phpass_parse_hash;
7743 sort_by_digest = sort_by_digest_4_4;
7744 opti_type = OPTI_TYPE_ZERO_BYTE
7745 | OPTI_TYPE_SLOW_HASH_SIMD;
7746 dgst_pos0 = 0;
7747 dgst_pos1 = 1;
7748 dgst_pos2 = 2;
7749 dgst_pos3 = 3;
7750 break;
7751
7752 case 500: 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_MD5CRYPT;
7757 dgst_size = DGST_SIZE_4_4;
7758 parse_func = md5crypt_parse_hash;
7759 sort_by_digest = sort_by_digest_4_4;
7760 opti_type = OPTI_TYPE_ZERO_BYTE;
7761 dgst_pos0 = 0;
7762 dgst_pos1 = 1;
7763 dgst_pos2 = 2;
7764 dgst_pos3 = 3;
7765 break;
7766
7767 case 501: hash_type = HASH_TYPE_MD5;
7768 salt_type = SALT_TYPE_EMBEDDED;
7769 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7770 opts_type = OPTS_TYPE_PT_GENERATE_LE
7771 | OPTS_TYPE_HASH_COPY;
7772 kern_type = KERN_TYPE_MD5CRYPT;
7773 dgst_size = DGST_SIZE_4_4;
7774 parse_func = juniper_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 900: hash_type = HASH_TYPE_MD4;
7784 salt_type = SALT_TYPE_NONE;
7785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7786 opts_type = OPTS_TYPE_PT_GENERATE_LE
7787 | OPTS_TYPE_PT_ADD80
7788 | OPTS_TYPE_PT_ADDBITS14;
7789 kern_type = KERN_TYPE_MD4;
7790 dgst_size = DGST_SIZE_4_4;
7791 parse_func = md4_parse_hash;
7792 sort_by_digest = sort_by_digest_4_4;
7793 opti_type = OPTI_TYPE_ZERO_BYTE
7794 | OPTI_TYPE_PRECOMPUTE_INIT
7795 | OPTI_TYPE_PRECOMPUTE_MERKLE
7796 | OPTI_TYPE_MEET_IN_MIDDLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_NOT_SALTED
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 0;
7802 dgst_pos1 = 3;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 1000: hash_type = HASH_TYPE_MD4;
7808 salt_type = SALT_TYPE_NONE;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_LE
7811 | OPTS_TYPE_PT_ADD80
7812 | OPTS_TYPE_PT_ADDBITS14
7813 | OPTS_TYPE_PT_UNICODE;
7814 kern_type = KERN_TYPE_MD4_PWU;
7815 dgst_size = DGST_SIZE_4_4;
7816 parse_func = md4_parse_hash;
7817 sort_by_digest = sort_by_digest_4_4;
7818 opti_type = OPTI_TYPE_ZERO_BYTE
7819 | OPTI_TYPE_PRECOMPUTE_INIT
7820 | OPTI_TYPE_PRECOMPUTE_MERKLE
7821 | OPTI_TYPE_MEET_IN_MIDDLE
7822 | OPTI_TYPE_EARLY_SKIP
7823 | OPTI_TYPE_NOT_ITERATED
7824 | OPTI_TYPE_NOT_SALTED
7825 | OPTI_TYPE_RAW_HASH;
7826 dgst_pos0 = 0;
7827 dgst_pos1 = 3;
7828 dgst_pos2 = 2;
7829 dgst_pos3 = 1;
7830 break;
7831
7832 case 1100: hash_type = HASH_TYPE_MD4;
7833 salt_type = SALT_TYPE_INTERN;
7834 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7835 opts_type = OPTS_TYPE_PT_GENERATE_LE
7836 | OPTS_TYPE_PT_ADD80
7837 | OPTS_TYPE_PT_ADDBITS14
7838 | OPTS_TYPE_PT_UNICODE
7839 | OPTS_TYPE_ST_ADD80
7840 | OPTS_TYPE_ST_UNICODE
7841 | OPTS_TYPE_ST_LOWER;
7842 kern_type = KERN_TYPE_MD44_PWUSLT;
7843 dgst_size = DGST_SIZE_4_4;
7844 parse_func = dcc_parse_hash;
7845 sort_by_digest = sort_by_digest_4_4;
7846 opti_type = OPTI_TYPE_ZERO_BYTE
7847 | OPTI_TYPE_PRECOMPUTE_INIT
7848 | OPTI_TYPE_PRECOMPUTE_MERKLE
7849 | OPTI_TYPE_EARLY_SKIP
7850 | OPTI_TYPE_NOT_ITERATED;
7851 dgst_pos0 = 0;
7852 dgst_pos1 = 3;
7853 dgst_pos2 = 2;
7854 dgst_pos3 = 1;
7855 break;
7856
7857 case 1400: hash_type = HASH_TYPE_SHA256;
7858 salt_type = SALT_TYPE_NONE;
7859 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7860 opts_type = OPTS_TYPE_PT_GENERATE_BE
7861 | OPTS_TYPE_PT_ADD80
7862 | OPTS_TYPE_PT_ADDBITS15;
7863 kern_type = KERN_TYPE_SHA256;
7864 dgst_size = DGST_SIZE_4_8;
7865 parse_func = sha256_parse_hash;
7866 sort_by_digest = sort_by_digest_4_8;
7867 opti_type = OPTI_TYPE_ZERO_BYTE
7868 | OPTI_TYPE_PRECOMPUTE_INIT
7869 | OPTI_TYPE_PRECOMPUTE_MERKLE
7870 | OPTI_TYPE_EARLY_SKIP
7871 | OPTI_TYPE_NOT_ITERATED
7872 | OPTI_TYPE_NOT_SALTED
7873 | OPTI_TYPE_RAW_HASH;
7874 dgst_pos0 = 3;
7875 dgst_pos1 = 7;
7876 dgst_pos2 = 2;
7877 dgst_pos3 = 6;
7878 break;
7879
7880 case 1410: hash_type = HASH_TYPE_SHA256;
7881 salt_type = SALT_TYPE_INTERN;
7882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7883 opts_type = OPTS_TYPE_PT_GENERATE_BE
7884 | OPTS_TYPE_ST_ADD80
7885 | OPTS_TYPE_ST_ADDBITS15;
7886 kern_type = KERN_TYPE_SHA256_PWSLT;
7887 dgst_size = DGST_SIZE_4_8;
7888 parse_func = sha256s_parse_hash;
7889 sort_by_digest = sort_by_digest_4_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_PRECOMPUTE_INIT
7892 | OPTI_TYPE_PRECOMPUTE_MERKLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_APPENDED_SALT
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 3;
7898 dgst_pos1 = 7;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 6;
7901 break;
7902
7903 case 1420: hash_type = HASH_TYPE_SHA256;
7904 salt_type = SALT_TYPE_INTERN;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_BE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS15;
7909 kern_type = KERN_TYPE_SHA256_SLTPW;
7910 dgst_size = DGST_SIZE_4_8;
7911 parse_func = sha256s_parse_hash;
7912 sort_by_digest = sort_by_digest_4_8;
7913 opti_type = OPTI_TYPE_ZERO_BYTE
7914 | OPTI_TYPE_PRECOMPUTE_INIT
7915 | OPTI_TYPE_PRECOMPUTE_MERKLE
7916 | OPTI_TYPE_EARLY_SKIP
7917 | OPTI_TYPE_NOT_ITERATED
7918 | OPTI_TYPE_PREPENDED_SALT
7919 | OPTI_TYPE_RAW_HASH;
7920 dgst_pos0 = 3;
7921 dgst_pos1 = 7;
7922 dgst_pos2 = 2;
7923 dgst_pos3 = 6;
7924 break;
7925
7926 case 1421: hash_type = HASH_TYPE_SHA256;
7927 salt_type = SALT_TYPE_EMBEDDED;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_BE
7930 | OPTS_TYPE_PT_ADD80
7931 | OPTS_TYPE_PT_ADDBITS15;
7932 kern_type = KERN_TYPE_SHA256_SLTPW;
7933 dgst_size = DGST_SIZE_4_8;
7934 parse_func = hmailserver_parse_hash;
7935 sort_by_digest = sort_by_digest_4_8;
7936 opti_type = OPTI_TYPE_ZERO_BYTE
7937 | OPTI_TYPE_PRECOMPUTE_INIT
7938 | OPTI_TYPE_PRECOMPUTE_MERKLE
7939 | OPTI_TYPE_EARLY_SKIP
7940 | OPTI_TYPE_NOT_ITERATED
7941 | OPTI_TYPE_PREPENDED_SALT
7942 | OPTI_TYPE_RAW_HASH;
7943 dgst_pos0 = 3;
7944 dgst_pos1 = 7;
7945 dgst_pos2 = 2;
7946 dgst_pos3 = 6;
7947 break;
7948
7949 case 1430: hash_type = HASH_TYPE_SHA256;
7950 salt_type = SALT_TYPE_INTERN;
7951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7952 opts_type = OPTS_TYPE_PT_GENERATE_BE
7953 | OPTS_TYPE_PT_UNICODE
7954 | OPTS_TYPE_ST_ADD80
7955 | OPTS_TYPE_ST_ADDBITS15;
7956 kern_type = KERN_TYPE_SHA256_PWUSLT;
7957 dgst_size = DGST_SIZE_4_8;
7958 parse_func = sha256s_parse_hash;
7959 sort_by_digest = sort_by_digest_4_8;
7960 opti_type = OPTI_TYPE_ZERO_BYTE
7961 | OPTI_TYPE_PRECOMPUTE_INIT
7962 | OPTI_TYPE_PRECOMPUTE_MERKLE
7963 | OPTI_TYPE_EARLY_SKIP
7964 | OPTI_TYPE_NOT_ITERATED
7965 | OPTI_TYPE_APPENDED_SALT
7966 | OPTI_TYPE_RAW_HASH;
7967 dgst_pos0 = 3;
7968 dgst_pos1 = 7;
7969 dgst_pos2 = 2;
7970 dgst_pos3 = 6;
7971 break;
7972
7973 case 1440: hash_type = HASH_TYPE_SHA256;
7974 salt_type = SALT_TYPE_INTERN;
7975 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7976 opts_type = OPTS_TYPE_PT_GENERATE_BE
7977 | OPTS_TYPE_PT_ADD80
7978 | OPTS_TYPE_PT_ADDBITS15
7979 | OPTS_TYPE_PT_UNICODE;
7980 kern_type = KERN_TYPE_SHA256_SLTPWU;
7981 dgst_size = DGST_SIZE_4_8;
7982 parse_func = sha256s_parse_hash;
7983 sort_by_digest = sort_by_digest_4_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_PREPENDED_SALT
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 7;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 6;
7995 break;
7996
7997 case 1441: hash_type = HASH_TYPE_SHA256;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15
8003 | OPTS_TYPE_PT_UNICODE
8004 | OPTS_TYPE_ST_BASE64;
8005 kern_type = KERN_TYPE_SHA256_SLTPWU;
8006 dgst_size = DGST_SIZE_4_8;
8007 parse_func = episerver4_parse_hash;
8008 sort_by_digest = sort_by_digest_4_8;
8009 opti_type = OPTI_TYPE_ZERO_BYTE
8010 | OPTI_TYPE_PRECOMPUTE_INIT
8011 | OPTI_TYPE_PRECOMPUTE_MERKLE
8012 | OPTI_TYPE_EARLY_SKIP
8013 | OPTI_TYPE_NOT_ITERATED
8014 | OPTI_TYPE_PREPENDED_SALT
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 3;
8017 dgst_pos1 = 7;
8018 dgst_pos2 = 2;
8019 dgst_pos3 = 6;
8020 break;
8021
8022 case 1450: hash_type = HASH_TYPE_SHA256;
8023 salt_type = SALT_TYPE_INTERN;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_ST_ADD80;
8027 kern_type = KERN_TYPE_HMACSHA256_PW;
8028 dgst_size = DGST_SIZE_4_8;
8029 parse_func = hmacsha256_parse_hash;
8030 sort_by_digest = sort_by_digest_4_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_NOT_ITERATED;
8033 dgst_pos0 = 3;
8034 dgst_pos1 = 7;
8035 dgst_pos2 = 2;
8036 dgst_pos3 = 6;
8037 break;
8038
8039 case 1460: hash_type = HASH_TYPE_SHA256;
8040 salt_type = SALT_TYPE_INTERN;
8041 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8042 opts_type = OPTS_TYPE_PT_GENERATE_BE
8043 | OPTS_TYPE_PT_ADD80
8044 | OPTS_TYPE_PT_ADDBITS15;
8045 kern_type = KERN_TYPE_HMACSHA256_SLT;
8046 dgst_size = DGST_SIZE_4_8;
8047 parse_func = hmacsha256_parse_hash;
8048 sort_by_digest = sort_by_digest_4_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_NOT_ITERATED;
8051 dgst_pos0 = 3;
8052 dgst_pos1 = 7;
8053 dgst_pos2 = 2;
8054 dgst_pos3 = 6;
8055 break;
8056
8057 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8058 salt_type = SALT_TYPE_EMBEDDED;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_LE
8061 | OPTS_TYPE_PT_BITSLICE;
8062 kern_type = KERN_TYPE_DESCRYPT;
8063 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8064 parse_func = descrypt_parse_hash;
8065 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8066 opti_type = OPTI_TYPE_ZERO_BYTE
8067 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8068 dgst_pos0 = 0;
8069 dgst_pos1 = 1;
8070 dgst_pos2 = 2;
8071 dgst_pos3 = 3;
8072 break;
8073
8074 case 1600: hash_type = HASH_TYPE_MD5;
8075 salt_type = SALT_TYPE_EMBEDDED;
8076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8078 kern_type = KERN_TYPE_APR1CRYPT;
8079 dgst_size = DGST_SIZE_4_4;
8080 parse_func = md5apr1_parse_hash;
8081 sort_by_digest = sort_by_digest_4_4;
8082 opti_type = OPTI_TYPE_ZERO_BYTE;
8083 dgst_pos0 = 0;
8084 dgst_pos1 = 1;
8085 dgst_pos2 = 2;
8086 dgst_pos3 = 3;
8087 break;
8088
8089 case 1700: hash_type = HASH_TYPE_SHA512;
8090 salt_type = SALT_TYPE_NONE;
8091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8092 opts_type = OPTS_TYPE_PT_GENERATE_BE
8093 | OPTS_TYPE_PT_ADD80
8094 | OPTS_TYPE_PT_ADDBITS15;
8095 kern_type = KERN_TYPE_SHA512;
8096 dgst_size = DGST_SIZE_8_8;
8097 parse_func = sha512_parse_hash;
8098 sort_by_digest = sort_by_digest_8_8;
8099 opti_type = OPTI_TYPE_ZERO_BYTE
8100 | OPTI_TYPE_PRECOMPUTE_INIT
8101 | OPTI_TYPE_PRECOMPUTE_MERKLE
8102 | OPTI_TYPE_EARLY_SKIP
8103 | OPTI_TYPE_NOT_ITERATED
8104 | OPTI_TYPE_NOT_SALTED
8105 | OPTI_TYPE_USES_BITS_64
8106 | OPTI_TYPE_RAW_HASH;
8107 dgst_pos0 = 14;
8108 dgst_pos1 = 15;
8109 dgst_pos2 = 6;
8110 dgst_pos3 = 7;
8111 break;
8112
8113 case 1710: hash_type = HASH_TYPE_SHA512;
8114 salt_type = SALT_TYPE_INTERN;
8115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8116 opts_type = OPTS_TYPE_PT_GENERATE_BE
8117 | OPTS_TYPE_ST_ADD80
8118 | OPTS_TYPE_ST_ADDBITS15;
8119 kern_type = KERN_TYPE_SHA512_PWSLT;
8120 dgst_size = DGST_SIZE_8_8;
8121 parse_func = sha512s_parse_hash;
8122 sort_by_digest = sort_by_digest_8_8;
8123 opti_type = OPTI_TYPE_ZERO_BYTE
8124 | OPTI_TYPE_PRECOMPUTE_INIT
8125 | OPTI_TYPE_PRECOMPUTE_MERKLE
8126 | OPTI_TYPE_EARLY_SKIP
8127 | OPTI_TYPE_NOT_ITERATED
8128 | OPTI_TYPE_APPENDED_SALT
8129 | OPTI_TYPE_USES_BITS_64
8130 | OPTI_TYPE_RAW_HASH;
8131 dgst_pos0 = 14;
8132 dgst_pos1 = 15;
8133 dgst_pos2 = 6;
8134 dgst_pos3 = 7;
8135 break;
8136
8137 case 1711: hash_type = HASH_TYPE_SHA512;
8138 salt_type = SALT_TYPE_EMBEDDED;
8139 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8140 opts_type = OPTS_TYPE_PT_GENERATE_BE
8141 | OPTS_TYPE_ST_ADD80
8142 | OPTS_TYPE_ST_ADDBITS15;
8143 kern_type = KERN_TYPE_SHA512_PWSLT;
8144 dgst_size = DGST_SIZE_8_8;
8145 parse_func = sha512b64s_parse_hash;
8146 sort_by_digest = sort_by_digest_8_8;
8147 opti_type = OPTI_TYPE_ZERO_BYTE
8148 | OPTI_TYPE_PRECOMPUTE_INIT
8149 | OPTI_TYPE_PRECOMPUTE_MERKLE
8150 | OPTI_TYPE_EARLY_SKIP
8151 | OPTI_TYPE_NOT_ITERATED
8152 | OPTI_TYPE_APPENDED_SALT
8153 | OPTI_TYPE_USES_BITS_64
8154 | OPTI_TYPE_RAW_HASH;
8155 dgst_pos0 = 14;
8156 dgst_pos1 = 15;
8157 dgst_pos2 = 6;
8158 dgst_pos3 = 7;
8159 break;
8160
8161 case 1720: hash_type = HASH_TYPE_SHA512;
8162 salt_type = SALT_TYPE_INTERN;
8163 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8164 opts_type = OPTS_TYPE_PT_GENERATE_BE
8165 | OPTS_TYPE_PT_ADD80
8166 | OPTS_TYPE_PT_ADDBITS15;
8167 kern_type = KERN_TYPE_SHA512_SLTPW;
8168 dgst_size = DGST_SIZE_8_8;
8169 parse_func = sha512s_parse_hash;
8170 sort_by_digest = sort_by_digest_8_8;
8171 opti_type = OPTI_TYPE_ZERO_BYTE
8172 | OPTI_TYPE_PRECOMPUTE_INIT
8173 | OPTI_TYPE_PRECOMPUTE_MERKLE
8174 | OPTI_TYPE_EARLY_SKIP
8175 | OPTI_TYPE_NOT_ITERATED
8176 | OPTI_TYPE_PREPENDED_SALT
8177 | OPTI_TYPE_USES_BITS_64
8178 | OPTI_TYPE_RAW_HASH;
8179 dgst_pos0 = 14;
8180 dgst_pos1 = 15;
8181 dgst_pos2 = 6;
8182 dgst_pos3 = 7;
8183 break;
8184
8185 case 1722: hash_type = HASH_TYPE_SHA512;
8186 salt_type = SALT_TYPE_EMBEDDED;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_BE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS15
8191 | OPTS_TYPE_ST_HEX;
8192 kern_type = KERN_TYPE_SHA512_SLTPW;
8193 dgst_size = DGST_SIZE_8_8;
8194 parse_func = osx512_parse_hash;
8195 sort_by_digest = sort_by_digest_8_8;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_PRECOMPUTE_INIT
8198 | OPTI_TYPE_PRECOMPUTE_MERKLE
8199 | OPTI_TYPE_EARLY_SKIP
8200 | OPTI_TYPE_NOT_ITERATED
8201 | OPTI_TYPE_PREPENDED_SALT
8202 | OPTI_TYPE_USES_BITS_64
8203 | OPTI_TYPE_RAW_HASH;
8204 dgst_pos0 = 14;
8205 dgst_pos1 = 15;
8206 dgst_pos2 = 6;
8207 dgst_pos3 = 7;
8208 break;
8209
8210 case 1730: hash_type = HASH_TYPE_SHA512;
8211 salt_type = SALT_TYPE_INTERN;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_BE
8214 | OPTS_TYPE_PT_UNICODE
8215 | OPTS_TYPE_ST_ADD80
8216 | OPTS_TYPE_ST_ADDBITS15;
8217 kern_type = KERN_TYPE_SHA512_PWSLTU;
8218 dgst_size = DGST_SIZE_8_8;
8219 parse_func = sha512s_parse_hash;
8220 sort_by_digest = sort_by_digest_8_8;
8221 opti_type = OPTI_TYPE_ZERO_BYTE
8222 | OPTI_TYPE_PRECOMPUTE_INIT
8223 | OPTI_TYPE_PRECOMPUTE_MERKLE
8224 | OPTI_TYPE_EARLY_SKIP
8225 | OPTI_TYPE_NOT_ITERATED
8226 | OPTI_TYPE_APPENDED_SALT
8227 | OPTI_TYPE_USES_BITS_64
8228 | OPTI_TYPE_RAW_HASH;
8229 dgst_pos0 = 14;
8230 dgst_pos1 = 15;
8231 dgst_pos2 = 6;
8232 dgst_pos3 = 7;
8233 break;
8234
8235 case 1731: hash_type = HASH_TYPE_SHA512;
8236 salt_type = SALT_TYPE_EMBEDDED;
8237 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_BE
8239 | OPTS_TYPE_PT_UNICODE
8240 | OPTS_TYPE_ST_ADD80
8241 | OPTS_TYPE_ST_ADDBITS15
8242 | OPTS_TYPE_ST_HEX;
8243 kern_type = KERN_TYPE_SHA512_PWSLTU;
8244 dgst_size = DGST_SIZE_8_8;
8245 parse_func = mssql2012_parse_hash;
8246 sort_by_digest = sort_by_digest_8_8;
8247 opti_type = OPTI_TYPE_ZERO_BYTE
8248 | OPTI_TYPE_PRECOMPUTE_INIT
8249 | OPTI_TYPE_PRECOMPUTE_MERKLE
8250 | OPTI_TYPE_EARLY_SKIP
8251 | OPTI_TYPE_NOT_ITERATED
8252 | OPTI_TYPE_APPENDED_SALT
8253 | OPTI_TYPE_USES_BITS_64
8254 | OPTI_TYPE_RAW_HASH;
8255 dgst_pos0 = 14;
8256 dgst_pos1 = 15;
8257 dgst_pos2 = 6;
8258 dgst_pos3 = 7;
8259 break;
8260
8261 case 1740: hash_type = HASH_TYPE_SHA512;
8262 salt_type = SALT_TYPE_INTERN;
8263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8264 opts_type = OPTS_TYPE_PT_GENERATE_BE
8265 | OPTS_TYPE_PT_ADD80
8266 | OPTS_TYPE_PT_ADDBITS15
8267 | OPTS_TYPE_PT_UNICODE;
8268 kern_type = KERN_TYPE_SHA512_SLTPWU;
8269 dgst_size = DGST_SIZE_8_8;
8270 parse_func = sha512s_parse_hash;
8271 sort_by_digest = sort_by_digest_8_8;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_PREPENDED_SALT
8278 | OPTI_TYPE_USES_BITS_64
8279 | OPTI_TYPE_RAW_HASH;
8280 dgst_pos0 = 14;
8281 dgst_pos1 = 15;
8282 dgst_pos2 = 6;
8283 dgst_pos3 = 7;
8284 break;
8285
8286 case 1750: hash_type = HASH_TYPE_SHA512;
8287 salt_type = SALT_TYPE_INTERN;
8288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_BE
8290 | OPTS_TYPE_ST_ADD80;
8291 kern_type = KERN_TYPE_HMACSHA512_PW;
8292 dgst_size = DGST_SIZE_8_8;
8293 parse_func = hmacsha512_parse_hash;
8294 sort_by_digest = sort_by_digest_8_8;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_USES_BITS_64
8297 | OPTI_TYPE_NOT_ITERATED;
8298 dgst_pos0 = 14;
8299 dgst_pos1 = 15;
8300 dgst_pos2 = 6;
8301 dgst_pos3 = 7;
8302 break;
8303
8304 case 1760: hash_type = HASH_TYPE_SHA512;
8305 salt_type = SALT_TYPE_INTERN;
8306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8307 opts_type = OPTS_TYPE_PT_GENERATE_BE
8308 | OPTS_TYPE_PT_ADD80
8309 | OPTS_TYPE_PT_ADDBITS15;
8310 kern_type = KERN_TYPE_HMACSHA512_SLT;
8311 dgst_size = DGST_SIZE_8_8;
8312 parse_func = hmacsha512_parse_hash;
8313 sort_by_digest = sort_by_digest_8_8;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_USES_BITS_64
8316 | OPTI_TYPE_NOT_ITERATED;
8317 dgst_pos0 = 14;
8318 dgst_pos1 = 15;
8319 dgst_pos2 = 6;
8320 dgst_pos3 = 7;
8321 break;
8322
8323 case 1800: hash_type = HASH_TYPE_SHA512;
8324 salt_type = SALT_TYPE_EMBEDDED;
8325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8327 kern_type = KERN_TYPE_SHA512CRYPT;
8328 dgst_size = DGST_SIZE_8_8;
8329 parse_func = sha512crypt_parse_hash;
8330 sort_by_digest = sort_by_digest_8_8;
8331 opti_type = OPTI_TYPE_ZERO_BYTE
8332 | OPTI_TYPE_USES_BITS_64;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 1;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 3;
8337 break;
8338
8339 case 2100: hash_type = HASH_TYPE_DCC2;
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 | OPTS_TYPE_ST_LOWER
8344 | OPTS_TYPE_ST_UNICODE;
8345 kern_type = KERN_TYPE_DCC2;
8346 dgst_size = DGST_SIZE_4_4;
8347 parse_func = dcc2_parse_hash;
8348 sort_by_digest = sort_by_digest_4_4;
8349 opti_type = OPTI_TYPE_ZERO_BYTE
8350 | OPTI_TYPE_SLOW_HASH_SIMD;
8351 dgst_pos0 = 0;
8352 dgst_pos1 = 1;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 3;
8355 break;
8356
8357 case 2400: hash_type = HASH_TYPE_MD5;
8358 salt_type = SALT_TYPE_NONE;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8361 kern_type = KERN_TYPE_MD5PIX;
8362 dgst_size = DGST_SIZE_4_4;
8363 parse_func = md5pix_parse_hash;
8364 sort_by_digest = sort_by_digest_4_4;
8365 opti_type = OPTI_TYPE_ZERO_BYTE
8366 | OPTI_TYPE_PRECOMPUTE_INIT
8367 | OPTI_TYPE_PRECOMPUTE_MERKLE
8368 | OPTI_TYPE_EARLY_SKIP
8369 | OPTI_TYPE_NOT_ITERATED
8370 | OPTI_TYPE_NOT_SALTED;
8371 dgst_pos0 = 0;
8372 dgst_pos1 = 3;
8373 dgst_pos2 = 2;
8374 dgst_pos3 = 1;
8375 break;
8376
8377 case 2410: hash_type = HASH_TYPE_MD5;
8378 salt_type = SALT_TYPE_INTERN;
8379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8381 kern_type = KERN_TYPE_MD5ASA;
8382 dgst_size = DGST_SIZE_4_4;
8383 parse_func = md5asa_parse_hash;
8384 sort_by_digest = sort_by_digest_4_4;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_PRECOMPUTE_INIT
8387 | OPTI_TYPE_PRECOMPUTE_MERKLE
8388 | OPTI_TYPE_EARLY_SKIP
8389 | OPTI_TYPE_NOT_ITERATED;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 2500: hash_type = HASH_TYPE_WPA;
8397 salt_type = SALT_TYPE_EMBEDDED;
8398 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8400 kern_type = KERN_TYPE_WPA;
8401 dgst_size = DGST_SIZE_4_4;
8402 parse_func = wpa_parse_hash;
8403 sort_by_digest = sort_by_digest_4_4;
8404 opti_type = OPTI_TYPE_ZERO_BYTE
8405 | OPTI_TYPE_SLOW_HASH_SIMD;
8406 dgst_pos0 = 0;
8407 dgst_pos1 = 1;
8408 dgst_pos2 = 2;
8409 dgst_pos3 = 3;
8410 break;
8411
8412 case 2600: hash_type = HASH_TYPE_MD5;
8413 salt_type = SALT_TYPE_VIRTUAL;
8414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8415 opts_type = OPTS_TYPE_PT_GENERATE_LE
8416 | OPTS_TYPE_PT_ADD80
8417 | OPTS_TYPE_PT_ADDBITS14
8418 | OPTS_TYPE_ST_ADD80;
8419 kern_type = KERN_TYPE_MD55_PWSLT1;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5md5_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 2611: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_INTERN;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_PT_ADD80
8438 | OPTS_TYPE_PT_ADDBITS14
8439 | OPTS_TYPE_ST_ADD80;
8440 kern_type = KERN_TYPE_MD55_PWSLT1;
8441 dgst_size = DGST_SIZE_4_4;
8442 parse_func = vb3_parse_hash;
8443 sort_by_digest = sort_by_digest_4_4;
8444 opti_type = OPTI_TYPE_ZERO_BYTE
8445 | OPTI_TYPE_PRECOMPUTE_INIT
8446 | OPTI_TYPE_PRECOMPUTE_MERKLE
8447 | OPTI_TYPE_EARLY_SKIP;
8448 dgst_pos0 = 0;
8449 dgst_pos1 = 3;
8450 dgst_pos2 = 2;
8451 dgst_pos3 = 1;
8452 break;
8453
8454 case 2612: hash_type = HASH_TYPE_MD5;
8455 salt_type = SALT_TYPE_EMBEDDED;
8456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8457 opts_type = OPTS_TYPE_PT_GENERATE_LE
8458 | OPTS_TYPE_PT_ADD80
8459 | OPTS_TYPE_PT_ADDBITS14
8460 | OPTS_TYPE_ST_ADD80
8461 | OPTS_TYPE_ST_HEX;
8462 kern_type = KERN_TYPE_MD55_PWSLT1;
8463 dgst_size = DGST_SIZE_4_4;
8464 parse_func = phps_parse_hash;
8465 sort_by_digest = sort_by_digest_4_4;
8466 opti_type = OPTI_TYPE_ZERO_BYTE
8467 | OPTI_TYPE_PRECOMPUTE_INIT
8468 | OPTI_TYPE_PRECOMPUTE_MERKLE
8469 | OPTI_TYPE_EARLY_SKIP;
8470 dgst_pos0 = 0;
8471 dgst_pos1 = 3;
8472 dgst_pos2 = 2;
8473 dgst_pos3 = 1;
8474 break;
8475
8476 case 2711: hash_type = HASH_TYPE_MD5;
8477 salt_type = SALT_TYPE_INTERN;
8478 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8479 opts_type = OPTS_TYPE_PT_GENERATE_LE
8480 | OPTS_TYPE_PT_ADD80
8481 | OPTS_TYPE_PT_ADDBITS14
8482 | OPTS_TYPE_ST_ADD80;
8483 kern_type = KERN_TYPE_MD55_PWSLT2;
8484 dgst_size = DGST_SIZE_4_4;
8485 parse_func = vb30_parse_hash;
8486 sort_by_digest = sort_by_digest_4_4;
8487 opti_type = OPTI_TYPE_ZERO_BYTE
8488 | OPTI_TYPE_PRECOMPUTE_INIT
8489 | OPTI_TYPE_EARLY_SKIP;
8490 dgst_pos0 = 0;
8491 dgst_pos1 = 3;
8492 dgst_pos2 = 2;
8493 dgst_pos3 = 1;
8494 break;
8495
8496 case 2811: hash_type = HASH_TYPE_MD5;
8497 salt_type = SALT_TYPE_INTERN;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_LE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS14;
8502 kern_type = KERN_TYPE_MD55_SLTPW;
8503 dgst_size = DGST_SIZE_4_4;
8504 parse_func = ipb2_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_EARLY_SKIP;
8509 dgst_pos0 = 0;
8510 dgst_pos1 = 3;
8511 dgst_pos2 = 2;
8512 dgst_pos3 = 1;
8513 break;
8514
8515 case 3000: hash_type = HASH_TYPE_LM;
8516 salt_type = SALT_TYPE_NONE;
8517 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8518 opts_type = OPTS_TYPE_PT_GENERATE_LE
8519 | OPTS_TYPE_PT_UPPER
8520 | OPTS_TYPE_PT_BITSLICE;
8521 kern_type = KERN_TYPE_LM;
8522 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8523 parse_func = lm_parse_hash;
8524 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8525 opti_type = OPTI_TYPE_ZERO_BYTE
8526 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 1;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 3;
8531 break;
8532
8533 case 3100: hash_type = HASH_TYPE_ORACLEH;
8534 salt_type = SALT_TYPE_INTERN;
8535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8536 opts_type = OPTS_TYPE_PT_GENERATE_LE
8537 | OPTS_TYPE_PT_UPPER
8538 | OPTS_TYPE_ST_UPPER;
8539 kern_type = KERN_TYPE_ORACLEH;
8540 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8541 parse_func = oracleh_parse_hash;
8542 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8543 opti_type = OPTI_TYPE_ZERO_BYTE;
8544 dgst_pos0 = 0;
8545 dgst_pos1 = 1;
8546 dgst_pos2 = 2;
8547 dgst_pos3 = 3;
8548 break;
8549
8550 case 3200: hash_type = HASH_TYPE_BCRYPT;
8551 salt_type = SALT_TYPE_EMBEDDED;
8552 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8553 opts_type = OPTS_TYPE_PT_GENERATE_LE
8554 | OPTS_TYPE_ST_GENERATE_LE;
8555 kern_type = KERN_TYPE_BCRYPT;
8556 dgst_size = DGST_SIZE_4_6;
8557 parse_func = bcrypt_parse_hash;
8558 sort_by_digest = sort_by_digest_4_6;
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 3710: hash_type = HASH_TYPE_MD5;
8567 salt_type = SALT_TYPE_INTERN;
8568 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8569 opts_type = OPTS_TYPE_PT_GENERATE_LE
8570 | OPTS_TYPE_PT_ADD80
8571 | OPTS_TYPE_PT_ADDBITS14;
8572 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8573 dgst_size = DGST_SIZE_4_4;
8574 parse_func = md5s_parse_hash;
8575 sort_by_digest = sort_by_digest_4_4;
8576 opti_type = OPTI_TYPE_ZERO_BYTE
8577 | OPTI_TYPE_PRECOMPUTE_INIT
8578 | OPTI_TYPE_PRECOMPUTE_MERKLE
8579 | OPTI_TYPE_EARLY_SKIP;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 3;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 1;
8584 break;
8585
8586 case 3711: hash_type = HASH_TYPE_MD5;
8587 salt_type = SALT_TYPE_EMBEDDED;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE
8590 | OPTS_TYPE_PT_ADD80
8591 | OPTS_TYPE_PT_ADDBITS14;
8592 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8593 dgst_size = DGST_SIZE_4_4;
8594 parse_func = mediawiki_b_parse_hash;
8595 sort_by_digest = sort_by_digest_4_4;
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_INIT
8598 | OPTI_TYPE_PRECOMPUTE_MERKLE
8599 | OPTI_TYPE_EARLY_SKIP;
8600 dgst_pos0 = 0;
8601 dgst_pos1 = 3;
8602 dgst_pos2 = 2;
8603 dgst_pos3 = 1;
8604 break;
8605
8606 case 3800: hash_type = HASH_TYPE_MD5;
8607 salt_type = SALT_TYPE_INTERN;
8608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8609 opts_type = OPTS_TYPE_PT_GENERATE_LE
8610 | OPTS_TYPE_ST_ADDBITS14;
8611 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8612 dgst_size = DGST_SIZE_4_4;
8613 parse_func = md5s_parse_hash;
8614 sort_by_digest = sort_by_digest_4_4;
8615 opti_type = OPTI_TYPE_ZERO_BYTE
8616 | OPTI_TYPE_PRECOMPUTE_INIT
8617 | OPTI_TYPE_PRECOMPUTE_MERKLE
8618 | OPTI_TYPE_EARLY_SKIP
8619 | OPTI_TYPE_NOT_ITERATED
8620 | OPTI_TYPE_RAW_HASH;
8621 dgst_pos0 = 0;
8622 dgst_pos1 = 3;
8623 dgst_pos2 = 2;
8624 dgst_pos3 = 1;
8625 break;
8626
8627 case 4300: hash_type = HASH_TYPE_MD5;
8628 salt_type = SALT_TYPE_VIRTUAL;
8629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8630 opts_type = OPTS_TYPE_PT_GENERATE_LE
8631 | OPTS_TYPE_PT_ADD80
8632 | OPTS_TYPE_PT_ADDBITS14
8633 | OPTS_TYPE_ST_ADD80;
8634 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8635 dgst_size = DGST_SIZE_4_4;
8636 parse_func = md5md5_parse_hash;
8637 sort_by_digest = sort_by_digest_4_4;
8638 opti_type = OPTI_TYPE_ZERO_BYTE
8639 | OPTI_TYPE_PRECOMPUTE_INIT
8640 | OPTI_TYPE_PRECOMPUTE_MERKLE
8641 | OPTI_TYPE_EARLY_SKIP;
8642 dgst_pos0 = 0;
8643 dgst_pos1 = 3;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 1;
8646 break;
8647
8648
8649 case 4400: hash_type = HASH_TYPE_MD5;
8650 salt_type = SALT_TYPE_NONE;
8651 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8652 opts_type = OPTS_TYPE_PT_GENERATE_BE
8653 | OPTS_TYPE_PT_ADD80
8654 | OPTS_TYPE_PT_ADDBITS15;
8655 kern_type = KERN_TYPE_MD5_SHA1;
8656 dgst_size = DGST_SIZE_4_4;
8657 parse_func = md5_parse_hash;
8658 sort_by_digest = sort_by_digest_4_4;
8659 opti_type = OPTI_TYPE_ZERO_BYTE
8660 | OPTI_TYPE_PRECOMPUTE_INIT
8661 | OPTI_TYPE_PRECOMPUTE_MERKLE
8662 | OPTI_TYPE_EARLY_SKIP
8663 | OPTI_TYPE_NOT_ITERATED
8664 | OPTI_TYPE_NOT_SALTED
8665 | OPTI_TYPE_RAW_HASH;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 3;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 1;
8670 break;
8671
8672 case 4500: hash_type = HASH_TYPE_SHA1;
8673 salt_type = SALT_TYPE_NONE;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_BE
8676 | OPTS_TYPE_PT_ADD80
8677 | OPTS_TYPE_PT_ADDBITS15;
8678 kern_type = KERN_TYPE_SHA11;
8679 dgst_size = DGST_SIZE_4_5;
8680 parse_func = sha1_parse_hash;
8681 sort_by_digest = sort_by_digest_4_5;
8682 opti_type = OPTI_TYPE_ZERO_BYTE
8683 | OPTI_TYPE_PRECOMPUTE_INIT
8684 | OPTI_TYPE_PRECOMPUTE_MERKLE
8685 | OPTI_TYPE_EARLY_SKIP
8686 | OPTI_TYPE_NOT_SALTED;
8687 dgst_pos0 = 3;
8688 dgst_pos1 = 4;
8689 dgst_pos2 = 2;
8690 dgst_pos3 = 1;
8691 break;
8692
8693 case 4700: hash_type = HASH_TYPE_SHA1;
8694 salt_type = SALT_TYPE_NONE;
8695 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8696 opts_type = OPTS_TYPE_PT_GENERATE_LE
8697 | OPTS_TYPE_PT_ADD80
8698 | OPTS_TYPE_PT_ADDBITS14;
8699 kern_type = KERN_TYPE_SHA1_MD5;
8700 dgst_size = DGST_SIZE_4_5;
8701 parse_func = sha1_parse_hash;
8702 sort_by_digest = sort_by_digest_4_5;
8703 opti_type = OPTI_TYPE_ZERO_BYTE
8704 | OPTI_TYPE_PRECOMPUTE_INIT
8705 | OPTI_TYPE_PRECOMPUTE_MERKLE
8706 | OPTI_TYPE_EARLY_SKIP
8707 | OPTI_TYPE_NOT_ITERATED
8708 | OPTI_TYPE_NOT_SALTED
8709 | OPTI_TYPE_RAW_HASH;
8710 dgst_pos0 = 3;
8711 dgst_pos1 = 4;
8712 dgst_pos2 = 2;
8713 dgst_pos3 = 1;
8714 break;
8715
8716 case 4800: hash_type = HASH_TYPE_MD5;
8717 salt_type = SALT_TYPE_EMBEDDED;
8718 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8719 opts_type = OPTS_TYPE_PT_GENERATE_LE
8720 | OPTS_TYPE_PT_ADDBITS14;
8721 kern_type = KERN_TYPE_MD5_CHAP;
8722 dgst_size = DGST_SIZE_4_4;
8723 parse_func = chap_parse_hash;
8724 sort_by_digest = sort_by_digest_4_4;
8725 opti_type = OPTI_TYPE_ZERO_BYTE
8726 | OPTI_TYPE_PRECOMPUTE_INIT
8727 | OPTI_TYPE_PRECOMPUTE_MERKLE
8728 | OPTI_TYPE_MEET_IN_MIDDLE
8729 | OPTI_TYPE_EARLY_SKIP
8730 | OPTI_TYPE_NOT_ITERATED
8731 | OPTI_TYPE_RAW_HASH;
8732 dgst_pos0 = 0;
8733 dgst_pos1 = 3;
8734 dgst_pos2 = 2;
8735 dgst_pos3 = 1;
8736 break;
8737
8738 case 4900: hash_type = HASH_TYPE_SHA1;
8739 salt_type = SALT_TYPE_INTERN;
8740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8741 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8742 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8743 dgst_size = DGST_SIZE_4_5;
8744 parse_func = sha1s_parse_hash;
8745 sort_by_digest = sort_by_digest_4_5;
8746 opti_type = OPTI_TYPE_ZERO_BYTE
8747 | OPTI_TYPE_PRECOMPUTE_INIT
8748 | OPTI_TYPE_PRECOMPUTE_MERKLE
8749 | OPTI_TYPE_EARLY_SKIP;
8750 dgst_pos0 = 3;
8751 dgst_pos1 = 4;
8752 dgst_pos2 = 2;
8753 dgst_pos3 = 1;
8754 break;
8755
8756 case 5000: hash_type = HASH_TYPE_KECCAK;
8757 salt_type = SALT_TYPE_EMBEDDED;
8758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8759 opts_type = OPTS_TYPE_PT_GENERATE_LE
8760 | OPTS_TYPE_PT_ADD01;
8761 kern_type = KERN_TYPE_KECCAK;
8762 dgst_size = DGST_SIZE_8_25;
8763 parse_func = keccak_parse_hash;
8764 sort_by_digest = sort_by_digest_8_25;
8765 opti_type = OPTI_TYPE_ZERO_BYTE
8766 | OPTI_TYPE_USES_BITS_64
8767 | OPTI_TYPE_RAW_HASH;
8768 dgst_pos0 = 2;
8769 dgst_pos1 = 3;
8770 dgst_pos2 = 4;
8771 dgst_pos3 = 5;
8772 break;
8773
8774 case 5100: hash_type = HASH_TYPE_MD5H;
8775 salt_type = SALT_TYPE_NONE;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD80
8779 | OPTS_TYPE_PT_ADDBITS14;
8780 kern_type = KERN_TYPE_MD5H;
8781 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8782 parse_func = md5half_parse_hash;
8783 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8784 opti_type = OPTI_TYPE_ZERO_BYTE
8785 | OPTI_TYPE_RAW_HASH;
8786 dgst_pos0 = 0;
8787 dgst_pos1 = 1;
8788 dgst_pos2 = 2;
8789 dgst_pos3 = 3;
8790 break;
8791
8792 case 5200: hash_type = HASH_TYPE_SHA256;
8793 salt_type = SALT_TYPE_EMBEDDED;
8794 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8795 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8796 kern_type = KERN_TYPE_PSAFE3;
8797 dgst_size = DGST_SIZE_4_8;
8798 parse_func = psafe3_parse_hash;
8799 sort_by_digest = sort_by_digest_4_8;
8800 opti_type = OPTI_TYPE_ZERO_BYTE;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 5300: hash_type = HASH_TYPE_MD5;
8808 salt_type = SALT_TYPE_EMBEDDED;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_ST_ADD80;
8812 kern_type = KERN_TYPE_IKEPSK_MD5;
8813 dgst_size = DGST_SIZE_4_4;
8814 parse_func = ikepsk_md5_parse_hash;
8815 sort_by_digest = sort_by_digest_4_4;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 3;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 1;
8821 break;
8822
8823 case 5400: hash_type = HASH_TYPE_SHA1;
8824 salt_type = SALT_TYPE_EMBEDDED;
8825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_BE
8827 | OPTS_TYPE_ST_ADD80;
8828 kern_type = KERN_TYPE_IKEPSK_SHA1;
8829 dgst_size = DGST_SIZE_4_5;
8830 parse_func = ikepsk_sha1_parse_hash;
8831 sort_by_digest = sort_by_digest_4_5;
8832 opti_type = OPTI_TYPE_ZERO_BYTE;
8833 dgst_pos0 = 3;
8834 dgst_pos1 = 4;
8835 dgst_pos2 = 2;
8836 dgst_pos3 = 1;
8837 break;
8838
8839 case 5500: hash_type = HASH_TYPE_NETNTLM;
8840 salt_type = SALT_TYPE_EMBEDDED;
8841 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8842 opts_type = OPTS_TYPE_PT_GENERATE_LE
8843 | OPTS_TYPE_PT_ADD80
8844 | OPTS_TYPE_PT_ADDBITS14
8845 | OPTS_TYPE_PT_UNICODE
8846 | OPTS_TYPE_ST_HEX;
8847 kern_type = KERN_TYPE_NETNTLMv1;
8848 dgst_size = DGST_SIZE_4_4;
8849 parse_func = netntlmv1_parse_hash;
8850 sort_by_digest = sort_by_digest_4_4;
8851 opti_type = OPTI_TYPE_ZERO_BYTE
8852 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 5600: hash_type = HASH_TYPE_MD5;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE
8863 | OPTS_TYPE_PT_ADD80
8864 | OPTS_TYPE_PT_ADDBITS14
8865 | OPTS_TYPE_PT_UNICODE;
8866 kern_type = KERN_TYPE_NETNTLMv2;
8867 dgst_size = DGST_SIZE_4_4;
8868 parse_func = netntlmv2_parse_hash;
8869 sort_by_digest = sort_by_digest_4_4;
8870 opti_type = OPTI_TYPE_ZERO_BYTE;
8871 dgst_pos0 = 0;
8872 dgst_pos1 = 3;
8873 dgst_pos2 = 2;
8874 dgst_pos3 = 1;
8875 break;
8876
8877 case 5700: hash_type = HASH_TYPE_SHA256;
8878 salt_type = SALT_TYPE_NONE;
8879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8880 opts_type = OPTS_TYPE_PT_GENERATE_BE
8881 | OPTS_TYPE_PT_ADD80
8882 | OPTS_TYPE_PT_ADDBITS15;
8883 kern_type = KERN_TYPE_SHA256;
8884 dgst_size = DGST_SIZE_4_8;
8885 parse_func = cisco4_parse_hash;
8886 sort_by_digest = sort_by_digest_4_8;
8887 opti_type = OPTI_TYPE_ZERO_BYTE
8888 | OPTI_TYPE_PRECOMPUTE_INIT
8889 | OPTI_TYPE_PRECOMPUTE_MERKLE
8890 | OPTI_TYPE_EARLY_SKIP
8891 | OPTI_TYPE_NOT_ITERATED
8892 | OPTI_TYPE_NOT_SALTED
8893 | OPTI_TYPE_RAW_HASH;
8894 dgst_pos0 = 3;
8895 dgst_pos1 = 7;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 6;
8898 break;
8899
8900 case 5800: hash_type = HASH_TYPE_SHA1;
8901 salt_type = SALT_TYPE_INTERN;
8902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8904 | OPTS_TYPE_ST_ADD80;
8905 kern_type = KERN_TYPE_ANDROIDPIN;
8906 dgst_size = DGST_SIZE_4_5;
8907 parse_func = androidpin_parse_hash;
8908 sort_by_digest = sort_by_digest_4_5;
8909 opti_type = OPTI_TYPE_ZERO_BYTE;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8917 salt_type = SALT_TYPE_NONE;
8918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE
8920 | OPTS_TYPE_PT_ADD80;
8921 kern_type = KERN_TYPE_RIPEMD160;
8922 dgst_size = DGST_SIZE_4_5;
8923 parse_func = ripemd160_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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8933 salt_type = SALT_TYPE_NONE;
8934 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8935 opts_type = OPTS_TYPE_PT_GENERATE_BE
8936 | OPTS_TYPE_PT_ADD80;
8937 kern_type = KERN_TYPE_WHIRLPOOL;
8938 dgst_size = DGST_SIZE_4_16;
8939 parse_func = whirlpool_parse_hash;
8940 sort_by_digest = sort_by_digest_4_16;
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 6211: hash_type = HASH_TYPE_RIPEMD160;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = truecrypt_parse_hash_2k;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8964 salt_type = SALT_TYPE_EMBEDDED;
8965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8967 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = truecrypt_parse_hash_2k;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8979 salt_type = SALT_TYPE_EMBEDDED;
8980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8982 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8983 dgst_size = DGST_SIZE_4_5;
8984 parse_func = truecrypt_parse_hash_2k;
8985 sort_by_digest = sort_by_digest_4_5;
8986 opti_type = OPTI_TYPE_ZERO_BYTE;
8987 dgst_pos0 = 0;
8988 dgst_pos1 = 1;
8989 dgst_pos2 = 2;
8990 dgst_pos3 = 3;
8991 break;
8992
8993 case 6221: hash_type = HASH_TYPE_SHA512;
8994 salt_type = SALT_TYPE_EMBEDDED;
8995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8996 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8997 kern_type = KERN_TYPE_TCSHA512_XTS512;
8998 dgst_size = DGST_SIZE_8_8;
8999 parse_func = truecrypt_parse_hash_1k;
9000 sort_by_digest = sort_by_digest_8_8;
9001 opti_type = OPTI_TYPE_ZERO_BYTE
9002 | OPTI_TYPE_USES_BITS_64;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6222: 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_XTS1024;
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 6223: 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_XTS1536;
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 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9045 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9046 dgst_size = DGST_SIZE_4_8;
9047 parse_func = truecrypt_parse_hash_1k;
9048 sort_by_digest = sort_by_digest_4_8;
9049 opti_type = OPTI_TYPE_ZERO_BYTE;
9050 dgst_pos0 = 0;
9051 dgst_pos1 = 1;
9052 dgst_pos2 = 2;
9053 dgst_pos3 = 3;
9054 break;
9055
9056 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9057 salt_type = SALT_TYPE_EMBEDDED;
9058 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9059 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9060 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9061 dgst_size = DGST_SIZE_4_8;
9062 parse_func = truecrypt_parse_hash_1k;
9063 sort_by_digest = sort_by_digest_4_8;
9064 opti_type = OPTI_TYPE_ZERO_BYTE;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9075 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9076 dgst_size = DGST_SIZE_4_8;
9077 parse_func = truecrypt_parse_hash_1k;
9078 sort_by_digest = sort_by_digest_4_8;
9079 opti_type = OPTI_TYPE_ZERO_BYTE;
9080 dgst_pos0 = 0;
9081 dgst_pos1 = 1;
9082 dgst_pos2 = 2;
9083 dgst_pos3 = 3;
9084 break;
9085
9086 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9087 salt_type = SALT_TYPE_EMBEDDED;
9088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9090 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9091 dgst_size = DGST_SIZE_4_5;
9092 parse_func = truecrypt_parse_hash_1k;
9093 sort_by_digest = sort_by_digest_4_5;
9094 opti_type = OPTI_TYPE_ZERO_BYTE;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9105 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9106 dgst_size = DGST_SIZE_4_5;
9107 parse_func = truecrypt_parse_hash_1k;
9108 sort_by_digest = sort_by_digest_4_5;
9109 opti_type = OPTI_TYPE_ZERO_BYTE;
9110 dgst_pos0 = 0;
9111 dgst_pos1 = 1;
9112 dgst_pos2 = 2;
9113 dgst_pos3 = 3;
9114 break;
9115
9116 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9117 salt_type = SALT_TYPE_EMBEDDED;
9118 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9119 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9120 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9121 dgst_size = DGST_SIZE_4_5;
9122 parse_func = truecrypt_parse_hash_1k;
9123 sort_by_digest = sort_by_digest_4_5;
9124 opti_type = OPTI_TYPE_ZERO_BYTE;
9125 dgst_pos0 = 0;
9126 dgst_pos1 = 1;
9127 dgst_pos2 = 2;
9128 dgst_pos3 = 3;
9129 break;
9130
9131 case 6300: hash_type = HASH_TYPE_MD5;
9132 salt_type = SALT_TYPE_EMBEDDED;
9133 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9134 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9135 kern_type = KERN_TYPE_MD5AIX;
9136 dgst_size = DGST_SIZE_4_4;
9137 parse_func = md5aix_parse_hash;
9138 sort_by_digest = sort_by_digest_4_4;
9139 opti_type = OPTI_TYPE_ZERO_BYTE;
9140 dgst_pos0 = 0;
9141 dgst_pos1 = 1;
9142 dgst_pos2 = 2;
9143 dgst_pos3 = 3;
9144 break;
9145
9146 case 6400: hash_type = HASH_TYPE_SHA256;
9147 salt_type = SALT_TYPE_EMBEDDED;
9148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9149 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9150 kern_type = KERN_TYPE_SHA256AIX;
9151 dgst_size = DGST_SIZE_4_8;
9152 parse_func = sha256aix_parse_hash;
9153 sort_by_digest = sort_by_digest_4_8;
9154 opti_type = OPTI_TYPE_ZERO_BYTE;
9155 dgst_pos0 = 0;
9156 dgst_pos1 = 1;
9157 dgst_pos2 = 2;
9158 dgst_pos3 = 3;
9159 break;
9160
9161 case 6500: hash_type = HASH_TYPE_SHA512;
9162 salt_type = SALT_TYPE_EMBEDDED;
9163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9164 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9165 kern_type = KERN_TYPE_SHA512AIX;
9166 dgst_size = DGST_SIZE_8_8;
9167 parse_func = sha512aix_parse_hash;
9168 sort_by_digest = sort_by_digest_8_8;
9169 opti_type = OPTI_TYPE_ZERO_BYTE
9170 | OPTI_TYPE_USES_BITS_64;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6600: hash_type = HASH_TYPE_AES;
9178 salt_type = SALT_TYPE_EMBEDDED;
9179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9181 kern_type = KERN_TYPE_AGILEKEY;
9182 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9183 parse_func = agilekey_parse_hash;
9184 sort_by_digest = sort_by_digest_4_5;
9185 opti_type = OPTI_TYPE_ZERO_BYTE;
9186 dgst_pos0 = 0;
9187 dgst_pos1 = 1;
9188 dgst_pos2 = 2;
9189 dgst_pos3 = 3;
9190 break;
9191
9192 case 6700: hash_type = HASH_TYPE_SHA1;
9193 salt_type = SALT_TYPE_EMBEDDED;
9194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9195 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9196 kern_type = KERN_TYPE_SHA1AIX;
9197 dgst_size = DGST_SIZE_4_5;
9198 parse_func = sha1aix_parse_hash;
9199 sort_by_digest = sort_by_digest_4_5;
9200 opti_type = OPTI_TYPE_ZERO_BYTE;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 6800: hash_type = HASH_TYPE_AES;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9211 kern_type = KERN_TYPE_LASTPASS;
9212 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9213 parse_func = lastpass_parse_hash;
9214 sort_by_digest = sort_by_digest_4_8;
9215 opti_type = OPTI_TYPE_ZERO_BYTE;
9216 dgst_pos0 = 0;
9217 dgst_pos1 = 1;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 3;
9220 break;
9221
9222 case 6900: hash_type = HASH_TYPE_GOST;
9223 salt_type = SALT_TYPE_NONE;
9224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9226 kern_type = KERN_TYPE_GOST;
9227 dgst_size = DGST_SIZE_4_8;
9228 parse_func = gost_parse_hash;
9229 sort_by_digest = sort_by_digest_4_8;
9230 opti_type = OPTI_TYPE_ZERO_BYTE;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 7100: hash_type = HASH_TYPE_SHA512;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9241 kern_type = KERN_TYPE_PBKDF2_SHA512;
9242 dgst_size = DGST_SIZE_8_16;
9243 parse_func = sha512osx_parse_hash;
9244 sort_by_digest = sort_by_digest_8_16;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_USES_BITS_64
9247 | OPTI_TYPE_SLOW_HASH_SIMD;
9248 dgst_pos0 = 0;
9249 dgst_pos1 = 1;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 3;
9252 break;
9253
9254 case 7200: hash_type = HASH_TYPE_SHA512;
9255 salt_type = SALT_TYPE_EMBEDDED;
9256 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9258 kern_type = KERN_TYPE_PBKDF2_SHA512;
9259 dgst_size = DGST_SIZE_8_16;
9260 parse_func = sha512grub_parse_hash;
9261 sort_by_digest = sort_by_digest_8_16;
9262 opti_type = OPTI_TYPE_ZERO_BYTE
9263 | OPTI_TYPE_USES_BITS_64
9264 | OPTI_TYPE_SLOW_HASH_SIMD;
9265 dgst_pos0 = 0;
9266 dgst_pos1 = 1;
9267 dgst_pos2 = 2;
9268 dgst_pos3 = 3;
9269 break;
9270
9271 case 7300: hash_type = HASH_TYPE_SHA1;
9272 salt_type = SALT_TYPE_EMBEDDED;
9273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9274 opts_type = OPTS_TYPE_PT_GENERATE_BE
9275 | OPTS_TYPE_ST_ADD80
9276 | OPTS_TYPE_ST_ADDBITS15;
9277 kern_type = KERN_TYPE_RAKP;
9278 dgst_size = DGST_SIZE_4_5;
9279 parse_func = rakp_parse_hash;
9280 sort_by_digest = sort_by_digest_4_5;
9281 opti_type = OPTI_TYPE_ZERO_BYTE
9282 | OPTI_TYPE_NOT_ITERATED;
9283 dgst_pos0 = 3;
9284 dgst_pos1 = 4;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 1;
9287 break;
9288
9289 case 7400: hash_type = HASH_TYPE_SHA256;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9293 kern_type = KERN_TYPE_SHA256CRYPT;
9294 dgst_size = DGST_SIZE_4_8;
9295 parse_func = sha256crypt_parse_hash;
9296 sort_by_digest = sort_by_digest_4_8;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 7500: hash_type = HASH_TYPE_KRB5PA;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9308 kern_type = KERN_TYPE_KRB5PA;
9309 dgst_size = DGST_SIZE_4_4;
9310 parse_func = krb5pa_parse_hash;
9311 sort_by_digest = sort_by_digest_4_4;
9312 opti_type = OPTI_TYPE_ZERO_BYTE
9313 | OPTI_TYPE_NOT_ITERATED;
9314 dgst_pos0 = 0;
9315 dgst_pos1 = 1;
9316 dgst_pos2 = 2;
9317 dgst_pos3 = 3;
9318 break;
9319
9320 case 7600: hash_type = HASH_TYPE_SHA1;
9321 salt_type = SALT_TYPE_INTERN;
9322 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9323 opts_type = OPTS_TYPE_PT_GENERATE_BE
9324 | OPTS_TYPE_PT_ADD80
9325 | OPTS_TYPE_PT_ADDBITS15;
9326 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9327 dgst_size = DGST_SIZE_4_5;
9328 parse_func = redmine_parse_hash;
9329 sort_by_digest = sort_by_digest_4_5;
9330 opti_type = OPTI_TYPE_ZERO_BYTE
9331 | OPTI_TYPE_PRECOMPUTE_INIT
9332 | OPTI_TYPE_EARLY_SKIP
9333 | OPTI_TYPE_NOT_ITERATED
9334 | OPTI_TYPE_PREPENDED_SALT;
9335 dgst_pos0 = 3;
9336 dgst_pos1 = 4;
9337 dgst_pos2 = 2;
9338 dgst_pos3 = 1;
9339 break;
9340
9341 case 7700: hash_type = HASH_TYPE_SAPB;
9342 salt_type = SALT_TYPE_EMBEDDED;
9343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9344 opts_type = OPTS_TYPE_PT_GENERATE_LE
9345 | OPTS_TYPE_PT_UPPER
9346 | OPTS_TYPE_ST_UPPER;
9347 kern_type = KERN_TYPE_SAPB;
9348 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9349 parse_func = sapb_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9351 opti_type = OPTI_TYPE_ZERO_BYTE
9352 | OPTI_TYPE_PRECOMPUTE_INIT
9353 | OPTI_TYPE_NOT_ITERATED;
9354 dgst_pos0 = 0;
9355 dgst_pos1 = 1;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 3;
9358 break;
9359
9360 case 7800: hash_type = HASH_TYPE_SAPG;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_BE
9364 | OPTS_TYPE_ST_ADD80
9365 | OPTS_TYPE_ST_UPPER;
9366 kern_type = KERN_TYPE_SAPG;
9367 dgst_size = DGST_SIZE_4_5;
9368 parse_func = sapg_parse_hash;
9369 sort_by_digest = sort_by_digest_4_5;
9370 opti_type = OPTI_TYPE_ZERO_BYTE
9371 | OPTI_TYPE_PRECOMPUTE_INIT
9372 | OPTI_TYPE_NOT_ITERATED;
9373 dgst_pos0 = 3;
9374 dgst_pos1 = 4;
9375 dgst_pos2 = 2;
9376 dgst_pos3 = 1;
9377 break;
9378
9379 case 7900: hash_type = HASH_TYPE_SHA512;
9380 salt_type = SALT_TYPE_EMBEDDED;
9381 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9382 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9383 kern_type = KERN_TYPE_DRUPAL7;
9384 dgst_size = DGST_SIZE_8_8;
9385 parse_func = drupal7_parse_hash;
9386 sort_by_digest = sort_by_digest_8_8;
9387 opti_type = OPTI_TYPE_ZERO_BYTE
9388 | OPTI_TYPE_USES_BITS_64;
9389 dgst_pos0 = 0;
9390 dgst_pos1 = 1;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 3;
9393 break;
9394
9395 case 8000: hash_type = HASH_TYPE_SHA256;
9396 salt_type = SALT_TYPE_EMBEDDED;
9397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_BE
9399 | OPTS_TYPE_PT_UNICODE
9400 | OPTS_TYPE_ST_ADD80
9401 | OPTS_TYPE_ST_HEX;
9402 kern_type = KERN_TYPE_SYBASEASE;
9403 dgst_size = DGST_SIZE_4_8;
9404 parse_func = sybasease_parse_hash;
9405 sort_by_digest = sort_by_digest_4_8;
9406 opti_type = OPTI_TYPE_ZERO_BYTE
9407 | OPTI_TYPE_PRECOMPUTE_INIT
9408 | OPTI_TYPE_EARLY_SKIP
9409 | OPTI_TYPE_NOT_ITERATED
9410 | OPTI_TYPE_RAW_HASH;
9411 dgst_pos0 = 3;
9412 dgst_pos1 = 7;
9413 dgst_pos2 = 2;
9414 dgst_pos3 = 6;
9415 break;
9416
9417 case 8100: hash_type = HASH_TYPE_SHA1;
9418 salt_type = SALT_TYPE_EMBEDDED;
9419 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9420 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9421 kern_type = KERN_TYPE_NETSCALER;
9422 dgst_size = DGST_SIZE_4_5;
9423 parse_func = netscaler_parse_hash;
9424 sort_by_digest = sort_by_digest_4_5;
9425 opti_type = OPTI_TYPE_ZERO_BYTE
9426 | OPTI_TYPE_PRECOMPUTE_INIT
9427 | OPTI_TYPE_PRECOMPUTE_MERKLE
9428 | OPTI_TYPE_EARLY_SKIP
9429 | OPTI_TYPE_NOT_ITERATED
9430 | OPTI_TYPE_PREPENDED_SALT
9431 | OPTI_TYPE_RAW_HASH;
9432 dgst_pos0 = 3;
9433 dgst_pos1 = 4;
9434 dgst_pos2 = 2;
9435 dgst_pos3 = 1;
9436 break;
9437
9438 case 8200: hash_type = HASH_TYPE_SHA256;
9439 salt_type = SALT_TYPE_EMBEDDED;
9440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9441 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9442 kern_type = KERN_TYPE_CLOUDKEY;
9443 dgst_size = DGST_SIZE_4_8;
9444 parse_func = cloudkey_parse_hash;
9445 sort_by_digest = sort_by_digest_4_8;
9446 opti_type = OPTI_TYPE_ZERO_BYTE;
9447 dgst_pos0 = 0;
9448 dgst_pos1 = 1;
9449 dgst_pos2 = 2;
9450 dgst_pos3 = 3;
9451 break;
9452
9453 case 8300: hash_type = HASH_TYPE_SHA1;
9454 salt_type = SALT_TYPE_EMBEDDED;
9455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9456 opts_type = OPTS_TYPE_PT_GENERATE_BE
9457 | OPTS_TYPE_ST_HEX
9458 | OPTS_TYPE_ST_ADD80;
9459 kern_type = KERN_TYPE_NSEC3;
9460 dgst_size = DGST_SIZE_4_5;
9461 parse_func = nsec3_parse_hash;
9462 sort_by_digest = sort_by_digest_4_5;
9463 opti_type = OPTI_TYPE_ZERO_BYTE;
9464 dgst_pos0 = 3;
9465 dgst_pos1 = 4;
9466 dgst_pos2 = 2;
9467 dgst_pos3 = 1;
9468 break;
9469
9470 case 8400: hash_type = HASH_TYPE_SHA1;
9471 salt_type = SALT_TYPE_INTERN;
9472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_BE
9474 | OPTS_TYPE_PT_ADD80
9475 | OPTS_TYPE_PT_ADDBITS15;
9476 kern_type = KERN_TYPE_WBB3;
9477 dgst_size = DGST_SIZE_4_5;
9478 parse_func = wbb3_parse_hash;
9479 sort_by_digest = sort_by_digest_4_5;
9480 opti_type = OPTI_TYPE_ZERO_BYTE
9481 | OPTI_TYPE_PRECOMPUTE_INIT
9482 | OPTI_TYPE_NOT_ITERATED;
9483 dgst_pos0 = 3;
9484 dgst_pos1 = 4;
9485 dgst_pos2 = 2;
9486 dgst_pos3 = 1;
9487 break;
9488
9489 case 8500: hash_type = HASH_TYPE_DESRACF;
9490 salt_type = SALT_TYPE_EMBEDDED;
9491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9492 opts_type = OPTS_TYPE_PT_GENERATE_LE
9493 | OPTS_TYPE_ST_UPPER;
9494 kern_type = KERN_TYPE_RACF;
9495 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9496 parse_func = racf_parse_hash;
9497 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9498 opti_type = OPTI_TYPE_ZERO_BYTE
9499 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9500 dgst_pos0 = 0;
9501 dgst_pos1 = 1;
9502 dgst_pos2 = 2;
9503 dgst_pos3 = 3;
9504 break;
9505
9506 case 8600: hash_type = HASH_TYPE_LOTUS5;
9507 salt_type = SALT_TYPE_NONE;
9508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9509 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9510 kern_type = KERN_TYPE_LOTUS5;
9511 dgst_size = DGST_SIZE_4_4;
9512 parse_func = lotus5_parse_hash;
9513 sort_by_digest = sort_by_digest_4_4;
9514 opti_type = OPTI_TYPE_EARLY_SKIP
9515 | OPTI_TYPE_NOT_ITERATED
9516 | OPTI_TYPE_NOT_SALTED
9517 | OPTI_TYPE_RAW_HASH;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8700: hash_type = HASH_TYPE_LOTUS6;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9528 kern_type = KERN_TYPE_LOTUS6;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = lotus6_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_EARLY_SKIP
9533 | OPTI_TYPE_NOT_ITERATED
9534 | OPTI_TYPE_RAW_HASH;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_ANDROIDFDE;
9546 dgst_size = DGST_SIZE_4_4;
9547 parse_func = androidfde_parse_hash;
9548 sort_by_digest = sort_by_digest_4_4;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 8900: hash_type = HASH_TYPE_SCRYPT;
9557 salt_type = SALT_TYPE_EMBEDDED;
9558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9560 kern_type = KERN_TYPE_SCRYPT;
9561 dgst_size = DGST_SIZE_4_8;
9562 parse_func = scrypt_parse_hash;
9563 sort_by_digest = sort_by_digest_4_8;
9564 opti_type = OPTI_TYPE_ZERO_BYTE;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 9000: hash_type = HASH_TYPE_SHA1;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_LE
9575 | OPTS_TYPE_ST_GENERATE_LE;
9576 kern_type = KERN_TYPE_PSAFE2;
9577 dgst_size = DGST_SIZE_4_5;
9578 parse_func = psafe2_parse_hash;
9579 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
9588 salt_type = SALT_TYPE_EMBEDDED;
9589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9590 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9591 kern_type = KERN_TYPE_LOTUS8;
9592 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9593 parse_func = lotus8_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9595 opti_type = OPTI_TYPE_ZERO_BYTE;
9596 dgst_pos0 = 0;
9597 dgst_pos1 = 1;
9598 dgst_pos2 = 2;
9599 dgst_pos3 = 3;
9600 break;
9601
9602 case 9200: hash_type = HASH_TYPE_SHA256;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9606 kern_type = KERN_TYPE_PBKDF2_SHA256;
9607 dgst_size = DGST_SIZE_4_32;
9608 parse_func = cisco8_parse_hash;
9609 sort_by_digest = sort_by_digest_4_32;
9610 opti_type = OPTI_TYPE_ZERO_BYTE
9611 | OPTI_TYPE_SLOW_HASH_SIMD;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 9300: hash_type = HASH_TYPE_SCRYPT;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_SCRYPT;
9623 dgst_size = DGST_SIZE_4_8;
9624 parse_func = cisco9_parse_hash;
9625 sort_by_digest = sort_by_digest_4_8;
9626 opti_type = OPTI_TYPE_ZERO_BYTE;
9627 dgst_pos0 = 0;
9628 dgst_pos1 = 1;
9629 dgst_pos2 = 2;
9630 dgst_pos3 = 3;
9631 break;
9632
9633 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9634 salt_type = SALT_TYPE_EMBEDDED;
9635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9637 kern_type = KERN_TYPE_OFFICE2007;
9638 dgst_size = DGST_SIZE_4_4;
9639 parse_func = office2007_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4;
9641 opti_type = OPTI_TYPE_ZERO_BYTE;
9642 dgst_pos0 = 0;
9643 dgst_pos1 = 1;
9644 dgst_pos2 = 2;
9645 dgst_pos3 = 3;
9646 break;
9647
9648 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9652 kern_type = KERN_TYPE_OFFICE2010;
9653 dgst_size = DGST_SIZE_4_4;
9654 parse_func = office2010_parse_hash;
9655 sort_by_digest = sort_by_digest_4_4;
9656 opti_type = OPTI_TYPE_ZERO_BYTE;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 1;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 3;
9661 break;
9662
9663 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9667 kern_type = KERN_TYPE_OFFICE2013;
9668 dgst_size = DGST_SIZE_4_4;
9669 parse_func = office2013_parse_hash;
9670 sort_by_digest = sort_by_digest_4_4;
9671 opti_type = OPTI_TYPE_ZERO_BYTE;
9672 dgst_pos0 = 0;
9673 dgst_pos1 = 1;
9674 dgst_pos2 = 2;
9675 dgst_pos3 = 3;
9676 break;
9677
9678 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9679 salt_type = SALT_TYPE_EMBEDDED;
9680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9681 opts_type = OPTS_TYPE_PT_GENERATE_LE
9682 | OPTS_TYPE_PT_ADD80
9683 | OPTS_TYPE_PT_UNICODE;
9684 kern_type = KERN_TYPE_OLDOFFICE01;
9685 dgst_size = DGST_SIZE_4_4;
9686 parse_func = oldoffice01_parse_hash;
9687 sort_by_digest = sort_by_digest_4_4;
9688 opti_type = OPTI_TYPE_ZERO_BYTE
9689 | OPTI_TYPE_PRECOMPUTE_INIT
9690 | OPTI_TYPE_NOT_ITERATED;
9691 dgst_pos0 = 0;
9692 dgst_pos1 = 1;
9693 dgst_pos2 = 2;
9694 dgst_pos3 = 3;
9695 break;
9696
9697 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9698 salt_type = SALT_TYPE_EMBEDDED;
9699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9700 opts_type = OPTS_TYPE_PT_GENERATE_LE
9701 | OPTS_TYPE_PT_ADD80;
9702 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9703 dgst_size = DGST_SIZE_4_4;
9704 parse_func = oldoffice01cm1_parse_hash;
9705 sort_by_digest = sort_by_digest_4_4;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_PRECOMPUTE_INIT
9708 | OPTI_TYPE_NOT_ITERATED;
9709 dgst_pos0 = 0;
9710 dgst_pos1 = 1;
9711 dgst_pos2 = 2;
9712 dgst_pos3 = 3;
9713 break;
9714
9715 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9716 salt_type = SALT_TYPE_EMBEDDED;
9717 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9718 opts_type = OPTS_TYPE_PT_GENERATE_LE
9719 | OPTS_TYPE_PT_ADD80
9720 | OPTS_TYPE_PT_UNICODE
9721 | OPTS_TYPE_PT_NEVERCRACK;
9722 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9723 dgst_size = DGST_SIZE_4_4;
9724 parse_func = oldoffice01cm2_parse_hash;
9725 sort_by_digest = sort_by_digest_4_4;
9726 opti_type = OPTI_TYPE_ZERO_BYTE
9727 | OPTI_TYPE_PRECOMPUTE_INIT
9728 | OPTI_TYPE_NOT_ITERATED;
9729 dgst_pos0 = 0;
9730 dgst_pos1 = 1;
9731 dgst_pos2 = 2;
9732 dgst_pos3 = 3;
9733 break;
9734
9735 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9736 salt_type = SALT_TYPE_EMBEDDED;
9737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9738 opts_type = OPTS_TYPE_PT_GENERATE_BE
9739 | OPTS_TYPE_PT_ADD80
9740 | OPTS_TYPE_PT_UNICODE;
9741 kern_type = KERN_TYPE_OLDOFFICE34;
9742 dgst_size = DGST_SIZE_4_4;
9743 parse_func = oldoffice34_parse_hash;
9744 sort_by_digest = sort_by_digest_4_4;
9745 opti_type = OPTI_TYPE_ZERO_BYTE
9746 | OPTI_TYPE_PRECOMPUTE_INIT
9747 | OPTI_TYPE_NOT_ITERATED;
9748 dgst_pos0 = 0;
9749 dgst_pos1 = 1;
9750 dgst_pos2 = 2;
9751 dgst_pos3 = 3;
9752 break;
9753
9754 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9755 salt_type = SALT_TYPE_EMBEDDED;
9756 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9757 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9758 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9759 dgst_size = DGST_SIZE_4_4;
9760 parse_func = oldoffice34cm1_parse_hash;
9761 sort_by_digest = sort_by_digest_4_4;
9762 opti_type = OPTI_TYPE_ZERO_BYTE
9763 | OPTI_TYPE_PRECOMPUTE_INIT
9764 | OPTI_TYPE_NOT_ITERATED;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_BE
9775 | OPTS_TYPE_PT_ADD80
9776 | OPTS_TYPE_PT_UNICODE
9777 | OPTS_TYPE_PT_NEVERCRACK;
9778 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9779 dgst_size = DGST_SIZE_4_4;
9780 parse_func = oldoffice34cm2_parse_hash;
9781 sort_by_digest = sort_by_digest_4_4;
9782 opti_type = OPTI_TYPE_ZERO_BYTE
9783 | OPTI_TYPE_PRECOMPUTE_INIT
9784 | OPTI_TYPE_NOT_ITERATED;
9785 dgst_pos0 = 0;
9786 dgst_pos1 = 1;
9787 dgst_pos2 = 2;
9788 dgst_pos3 = 3;
9789 break;
9790
9791 case 9900: hash_type = HASH_TYPE_MD5;
9792 salt_type = SALT_TYPE_NONE;
9793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9794 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9795 kern_type = KERN_TYPE_RADMIN2;
9796 dgst_size = DGST_SIZE_4_4;
9797 parse_func = radmin2_parse_hash;
9798 sort_by_digest = sort_by_digest_4_4;
9799 opti_type = OPTI_TYPE_ZERO_BYTE
9800 | OPTI_TYPE_PRECOMPUTE_INIT
9801 | OPTI_TYPE_EARLY_SKIP
9802 | OPTI_TYPE_NOT_ITERATED
9803 | OPTI_TYPE_NOT_SALTED;
9804 dgst_pos0 = 0;
9805 dgst_pos1 = 3;
9806 dgst_pos2 = 2;
9807 dgst_pos3 = 1;
9808 break;
9809
9810 case 10000: hash_type = HASH_TYPE_SHA256;
9811 salt_type = SALT_TYPE_EMBEDDED;
9812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9813 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9814 kern_type = KERN_TYPE_PBKDF2_SHA256;
9815 dgst_size = DGST_SIZE_4_32;
9816 parse_func = djangopbkdf2_parse_hash;
9817 sort_by_digest = sort_by_digest_4_32;
9818 opti_type = OPTI_TYPE_ZERO_BYTE
9819 | OPTI_TYPE_SLOW_HASH_SIMD;
9820 dgst_pos0 = 0;
9821 dgst_pos1 = 1;
9822 dgst_pos2 = 2;
9823 dgst_pos3 = 3;
9824 break;
9825
9826 case 10100: hash_type = HASH_TYPE_SIPHASH;
9827 salt_type = SALT_TYPE_EMBEDDED;
9828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9829 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9830 kern_type = KERN_TYPE_SIPHASH;
9831 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9832 parse_func = siphash_parse_hash;
9833 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9834 opti_type = OPTI_TYPE_ZERO_BYTE
9835 | OPTI_TYPE_NOT_ITERATED
9836 | OPTI_TYPE_RAW_HASH;
9837 dgst_pos0 = 0;
9838 dgst_pos1 = 1;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 3;
9841 break;
9842
9843 case 10200: hash_type = HASH_TYPE_MD5;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE
9847 | OPTS_TYPE_ST_ADD80
9848 | OPTS_TYPE_ST_ADDBITS14;
9849 kern_type = KERN_TYPE_HMACMD5_PW;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = crammd5_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_NOT_ITERATED;
9855 dgst_pos0 = 0;
9856 dgst_pos1 = 3;
9857 dgst_pos2 = 2;
9858 dgst_pos3 = 1;
9859 break;
9860
9861 case 10300: hash_type = HASH_TYPE_SHA1;
9862 salt_type = SALT_TYPE_EMBEDDED;
9863 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9864 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9865 kern_type = KERN_TYPE_SAPH_SHA1;
9866 dgst_size = DGST_SIZE_4_5;
9867 parse_func = saph_sha1_parse_hash;
9868 sort_by_digest = sort_by_digest_4_5;
9869 opti_type = OPTI_TYPE_ZERO_BYTE;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 1;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 3;
9874 break;
9875
9876 case 10400: hash_type = HASH_TYPE_PDFU16;
9877 salt_type = SALT_TYPE_EMBEDDED;
9878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9880 kern_type = KERN_TYPE_PDF11;
9881 dgst_size = DGST_SIZE_4_4;
9882 parse_func = pdf11_parse_hash;
9883 sort_by_digest = sort_by_digest_4_4;
9884 opti_type = OPTI_TYPE_ZERO_BYTE
9885 | OPTI_TYPE_NOT_ITERATED;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 10410: 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_PDF11CM1;
9897 dgst_size = DGST_SIZE_4_4;
9898 parse_func = pdf11cm1_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 10420: 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_PDF11CM2;
9913 dgst_size = DGST_SIZE_4_4;
9914 parse_func = pdf11cm2_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 10500: hash_type = HASH_TYPE_PDFU16;
9925 salt_type = SALT_TYPE_EMBEDDED;
9926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9928 kern_type = KERN_TYPE_PDF14;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = pdf14_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 10600: hash_type = HASH_TYPE_SHA256;
9941 salt_type = SALT_TYPE_EMBEDDED;
9942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9943 opts_type = OPTS_TYPE_PT_GENERATE_BE
9944 | OPTS_TYPE_ST_ADD80
9945 | OPTS_TYPE_ST_ADDBITS15
9946 | OPTS_TYPE_HASH_COPY;
9947 kern_type = KERN_TYPE_SHA256_PWSLT;
9948 dgst_size = DGST_SIZE_4_8;
9949 parse_func = pdf17l3_parse_hash;
9950 sort_by_digest = sort_by_digest_4_8;
9951 opti_type = OPTI_TYPE_ZERO_BYTE
9952 | OPTI_TYPE_PRECOMPUTE_INIT
9953 | OPTI_TYPE_PRECOMPUTE_MERKLE
9954 | OPTI_TYPE_EARLY_SKIP
9955 | OPTI_TYPE_NOT_ITERATED
9956 | OPTI_TYPE_APPENDED_SALT
9957 | OPTI_TYPE_RAW_HASH;
9958 dgst_pos0 = 3;
9959 dgst_pos1 = 7;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 6;
9962 break;
9963
9964 case 10700: hash_type = HASH_TYPE_PDFU32;
9965 salt_type = SALT_TYPE_EMBEDDED;
9966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_HASH_COPY;
9969 kern_type = KERN_TYPE_PDF17L8;
9970 dgst_size = DGST_SIZE_4_8;
9971 parse_func = pdf17l8_parse_hash;
9972 sort_by_digest = sort_by_digest_4_8;
9973 opti_type = OPTI_TYPE_ZERO_BYTE
9974 | OPTI_TYPE_NOT_ITERATED;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 10800: hash_type = HASH_TYPE_SHA384;
9982 salt_type = SALT_TYPE_NONE;
9983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_BE
9985 | OPTS_TYPE_PT_ADD80
9986 | OPTS_TYPE_PT_ADDBITS15;
9987 kern_type = KERN_TYPE_SHA384;
9988 dgst_size = DGST_SIZE_8_8;
9989 parse_func = sha384_parse_hash;
9990 sort_by_digest = sort_by_digest_8_8;
9991 opti_type = OPTI_TYPE_ZERO_BYTE
9992 | OPTI_TYPE_PRECOMPUTE_INIT
9993 | OPTI_TYPE_PRECOMPUTE_MERKLE
9994 | OPTI_TYPE_EARLY_SKIP
9995 | OPTI_TYPE_NOT_ITERATED
9996 | OPTI_TYPE_NOT_SALTED
9997 | OPTI_TYPE_USES_BITS_64
9998 | OPTI_TYPE_RAW_HASH;
9999 dgst_pos0 = 6;
10000 dgst_pos1 = 7;
10001 dgst_pos2 = 4;
10002 dgst_pos3 = 5;
10003 break;
10004
10005 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10006 salt_type = SALT_TYPE_EMBEDDED;
10007 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10008 opts_type = OPTS_TYPE_PT_GENERATE_LE
10009 | OPTS_TYPE_ST_BASE64
10010 | OPTS_TYPE_HASH_COPY;
10011 kern_type = KERN_TYPE_PBKDF2_SHA256;
10012 dgst_size = DGST_SIZE_4_32;
10013 parse_func = pbkdf2_sha256_parse_hash;
10014 sort_by_digest = sort_by_digest_4_32;
10015 opti_type = OPTI_TYPE_ZERO_BYTE
10016 | OPTI_TYPE_SLOW_HASH_SIMD;
10017 dgst_pos0 = 0;
10018 dgst_pos1 = 1;
10019 dgst_pos2 = 2;
10020 dgst_pos3 = 3;
10021 break;
10022
10023 case 11000: hash_type = HASH_TYPE_MD5;
10024 salt_type = SALT_TYPE_INTERN;
10025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10026 opts_type = OPTS_TYPE_PT_GENERATE_LE
10027 | OPTS_TYPE_PT_ADD80;
10028 kern_type = KERN_TYPE_PRESTASHOP;
10029 dgst_size = DGST_SIZE_4_4;
10030 parse_func = prestashop_parse_hash;
10031 sort_by_digest = sort_by_digest_4_4;
10032 opti_type = OPTI_TYPE_ZERO_BYTE
10033 | OPTI_TYPE_PRECOMPUTE_INIT
10034 | OPTI_TYPE_NOT_ITERATED
10035 | OPTI_TYPE_PREPENDED_SALT;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 3;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 1;
10040 break;
10041
10042 case 11100: hash_type = HASH_TYPE_MD5;
10043 salt_type = SALT_TYPE_EMBEDDED;
10044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_ST_ADD80;
10047 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10048 dgst_size = DGST_SIZE_4_4;
10049 parse_func = postgresql_auth_parse_hash;
10050 sort_by_digest = sort_by_digest_4_4;
10051 opti_type = OPTI_TYPE_ZERO_BYTE
10052 | OPTI_TYPE_PRECOMPUTE_INIT
10053 | OPTI_TYPE_PRECOMPUTE_MERKLE
10054 | OPTI_TYPE_EARLY_SKIP;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 3;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 1;
10059 break;
10060
10061 case 11200: hash_type = HASH_TYPE_SHA1;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_BE
10065 | OPTS_TYPE_PT_ADD80
10066 | OPTS_TYPE_ST_HEX;
10067 kern_type = KERN_TYPE_MYSQL_AUTH;
10068 dgst_size = DGST_SIZE_4_5;
10069 parse_func = mysql_auth_parse_hash;
10070 sort_by_digest = sort_by_digest_4_5;
10071 opti_type = OPTI_TYPE_ZERO_BYTE
10072 | OPTI_TYPE_EARLY_SKIP;
10073 dgst_pos0 = 3;
10074 dgst_pos1 = 4;
10075 dgst_pos2 = 2;
10076 dgst_pos3 = 1;
10077 break;
10078
10079 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10080 salt_type = SALT_TYPE_EMBEDDED;
10081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10082 opts_type = OPTS_TYPE_PT_GENERATE_LE
10083 | OPTS_TYPE_ST_HEX
10084 | OPTS_TYPE_ST_ADD80;
10085 kern_type = KERN_TYPE_BITCOIN_WALLET;
10086 dgst_size = DGST_SIZE_4_4;
10087 parse_func = bitcoin_wallet_parse_hash;
10088 sort_by_digest = sort_by_digest_4_4;
10089 opti_type = OPTI_TYPE_ZERO_BYTE;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 11400: hash_type = HASH_TYPE_MD5;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE
10100 | OPTS_TYPE_PT_ADD80
10101 | OPTS_TYPE_HASH_COPY;
10102 kern_type = KERN_TYPE_SIP_AUTH;
10103 dgst_size = DGST_SIZE_4_4;
10104 parse_func = sip_auth_parse_hash;
10105 sort_by_digest = sort_by_digest_4_4;
10106 opti_type = OPTI_TYPE_ZERO_BYTE;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 3;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 1;
10111 break;
10112
10113 case 11500: hash_type = HASH_TYPE_CRC32;
10114 salt_type = SALT_TYPE_INTERN;
10115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE
10117 | OPTS_TYPE_ST_GENERATE_LE
10118 | OPTS_TYPE_ST_HEX;
10119 kern_type = KERN_TYPE_CRC32;
10120 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10121 parse_func = crc32_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10123 opti_type = OPTI_TYPE_ZERO_BYTE;
10124 dgst_pos0 = 0;
10125 dgst_pos1 = 1;
10126 dgst_pos2 = 2;
10127 dgst_pos3 = 3;
10128 break;
10129
10130 case 11600: hash_type = HASH_TYPE_AES;
10131 salt_type = SALT_TYPE_EMBEDDED;
10132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10133 opts_type = OPTS_TYPE_PT_GENERATE_LE
10134 | OPTS_TYPE_PT_NEVERCRACK;
10135 kern_type = KERN_TYPE_SEVEN_ZIP;
10136 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10137 parse_func = seven_zip_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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10147 salt_type = SALT_TYPE_NONE;
10148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE
10150 | OPTS_TYPE_PT_ADD01;
10151 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10152 dgst_size = DGST_SIZE_4_8;
10153 parse_func = gost2012sbog_256_parse_hash;
10154 sort_by_digest = sort_by_digest_4_8;
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 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
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_512;
10168 dgst_size = DGST_SIZE_4_16;
10169 parse_func = gost2012sbog_512_parse_hash;
10170 sort_by_digest = sort_by_digest_4_16;
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 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE
10182 | OPTS_TYPE_ST_BASE64
10183 | OPTS_TYPE_HASH_COPY;
10184 kern_type = KERN_TYPE_PBKDF2_MD5;
10185 dgst_size = DGST_SIZE_4_32;
10186 parse_func = pbkdf2_md5_parse_hash;
10187 sort_by_digest = sort_by_digest_4_32;
10188 opti_type = OPTI_TYPE_ZERO_BYTE
10189 | OPTI_TYPE_SLOW_HASH_SIMD;
10190 dgst_pos0 = 0;
10191 dgst_pos1 = 1;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 3;
10194 break;
10195
10196 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE
10200 | OPTS_TYPE_ST_BASE64
10201 | OPTS_TYPE_HASH_COPY;
10202 kern_type = KERN_TYPE_PBKDF2_SHA1;
10203 dgst_size = DGST_SIZE_4_32;
10204 parse_func = pbkdf2_sha1_parse_hash;
10205 sort_by_digest = sort_by_digest_4_32;
10206 opti_type = OPTI_TYPE_ZERO_BYTE
10207 | OPTI_TYPE_SLOW_HASH_SIMD;
10208 dgst_pos0 = 0;
10209 dgst_pos1 = 1;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 3;
10212 break;
10213
10214 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10215 salt_type = SALT_TYPE_EMBEDDED;
10216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE
10218 | OPTS_TYPE_ST_BASE64
10219 | OPTS_TYPE_HASH_COPY;
10220 kern_type = KERN_TYPE_PBKDF2_SHA512;
10221 dgst_size = DGST_SIZE_8_16;
10222 parse_func = pbkdf2_sha512_parse_hash;
10223 sort_by_digest = sort_by_digest_8_16;
10224 opti_type = OPTI_TYPE_ZERO_BYTE
10225 | OPTI_TYPE_USES_BITS_64
10226 | OPTI_TYPE_SLOW_HASH_SIMD;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_ECRYPTFS;
10238 dgst_size = DGST_SIZE_8_8;
10239 parse_func = ecryptfs_parse_hash;
10240 sort_by_digest = sort_by_digest_8_8;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_USES_BITS_64;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 12300: hash_type = HASH_TYPE_ORACLET;
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_ORACLET;
10254 dgst_size = DGST_SIZE_8_16;
10255 parse_func = oraclet_parse_hash;
10256 sort_by_digest = sort_by_digest_8_16;
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 12400: hash_type = HASH_TYPE_BSDICRYPT;
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_BSDICRYPT;
10270 dgst_size = DGST_SIZE_4_4;
10271 parse_func = bsdicrypt_parse_hash;
10272 sort_by_digest = sort_by_digest_4_4;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 12500: hash_type = HASH_TYPE_RAR3HP;
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_RAR3;
10286 dgst_size = DGST_SIZE_4_4;
10287 parse_func = rar3hp_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4;
10289 opti_type = OPTI_TYPE_ZERO_BYTE;
10290 dgst_pos0 = 0;
10291 dgst_pos1 = 1;
10292 dgst_pos2 = 2;
10293 dgst_pos3 = 3;
10294 break;
10295
10296 case 12600: hash_type = HASH_TYPE_SHA256;
10297 salt_type = SALT_TYPE_INTERN;
10298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10299 opts_type = OPTS_TYPE_PT_GENERATE_BE
10300 | OPTS_TYPE_PT_ADD80;
10301 kern_type = KERN_TYPE_CF10;
10302 dgst_size = DGST_SIZE_4_8;
10303 parse_func = cf10_parse_hash;
10304 sort_by_digest = sort_by_digest_4_8;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_PRECOMPUTE_INIT
10307 | OPTI_TYPE_EARLY_SKIP
10308 | OPTI_TYPE_NOT_ITERATED;
10309 dgst_pos0 = 3;
10310 dgst_pos1 = 7;
10311 dgst_pos2 = 2;
10312 dgst_pos3 = 6;
10313 break;
10314
10315 case 12700: hash_type = HASH_TYPE_AES;
10316 salt_type = SALT_TYPE_EMBEDDED;
10317 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10318 opts_type = OPTS_TYPE_PT_GENERATE_LE
10319 | OPTS_TYPE_HASH_COPY;
10320 kern_type = KERN_TYPE_MYWALLET;
10321 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10322 parse_func = mywallet_parse_hash;
10323 sort_by_digest = sort_by_digest_4_5;
10324 opti_type = OPTI_TYPE_ZERO_BYTE;
10325 dgst_pos0 = 0;
10326 dgst_pos1 = 1;
10327 dgst_pos2 = 2;
10328 dgst_pos3 = 3;
10329 break;
10330
10331 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10332 salt_type = SALT_TYPE_EMBEDDED;
10333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10335 kern_type = KERN_TYPE_MS_DRSR;
10336 dgst_size = DGST_SIZE_4_8;
10337 parse_func = ms_drsr_parse_hash;
10338 sort_by_digest = sort_by_digest_4_8;
10339 opti_type = OPTI_TYPE_ZERO_BYTE;
10340 dgst_pos0 = 0;
10341 dgst_pos1 = 1;
10342 dgst_pos2 = 2;
10343 dgst_pos3 = 3;
10344 break;
10345
10346 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10347 salt_type = SALT_TYPE_EMBEDDED;
10348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10350 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10351 dgst_size = DGST_SIZE_4_8;
10352 parse_func = androidfde_samsung_parse_hash;
10353 sort_by_digest = sort_by_digest_4_8;
10354 opti_type = OPTI_TYPE_ZERO_BYTE;
10355 dgst_pos0 = 0;
10356 dgst_pos1 = 1;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 3;
10359 break;
10360
10361 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_RAR5;
10366 dgst_size = DGST_SIZE_4_4;
10367 parse_func = rar5_parse_hash;
10368 sort_by_digest = sort_by_digest_4_4;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10380 kern_type = KERN_TYPE_KRB5TGS;
10381 dgst_size = DGST_SIZE_4_4;
10382 parse_func = krb5tgs_parse_hash;
10383 sort_by_digest = sort_by_digest_4_4;
10384 opti_type = OPTI_TYPE_ZERO_BYTE
10385 | OPTI_TYPE_NOT_ITERATED;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 13200: hash_type = HASH_TYPE_AES;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10396 kern_type = KERN_TYPE_AXCRYPT;
10397 dgst_size = DGST_SIZE_4_4;
10398 parse_func = axcrypt_parse_hash;
10399 sort_by_digest = sort_by_digest_4_4;
10400 opti_type = OPTI_TYPE_ZERO_BYTE;
10401 dgst_pos0 = 0;
10402 dgst_pos1 = 1;
10403 dgst_pos2 = 2;
10404 dgst_pos3 = 3;
10405 break;
10406
10407 case 13300: hash_type = HASH_TYPE_SHA1;
10408 salt_type = SALT_TYPE_NONE;
10409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10410 opts_type = OPTS_TYPE_PT_GENERATE_BE
10411 | OPTS_TYPE_PT_ADD80
10412 | OPTS_TYPE_PT_ADDBITS15;
10413 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10414 dgst_size = DGST_SIZE_4_5;
10415 parse_func = sha1axcrypt_parse_hash;
10416 sort_by_digest = sort_by_digest_4_5;
10417 opti_type = OPTI_TYPE_ZERO_BYTE
10418 | OPTI_TYPE_PRECOMPUTE_INIT
10419 | OPTI_TYPE_EARLY_SKIP
10420 | OPTI_TYPE_NOT_ITERATED
10421 | OPTI_TYPE_NOT_SALTED;
10422 dgst_pos0 = 0;
10423 dgst_pos1 = 4;
10424 dgst_pos2 = 3;
10425 dgst_pos3 = 2;
10426 break;
10427
10428 case 13400: hash_type = HASH_TYPE_AES;
10429 salt_type = SALT_TYPE_EMBEDDED;
10430 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10432 kern_type = KERN_TYPE_KEEPASS;
10433 dgst_size = DGST_SIZE_4_4;
10434 parse_func = keepass_parse_hash;
10435 sort_by_digest = sort_by_digest_4_4;
10436 opti_type = OPTI_TYPE_ZERO_BYTE;
10437 dgst_pos0 = 0;
10438 dgst_pos1 = 1;
10439 dgst_pos2 = 2;
10440 dgst_pos3 = 3;
10441 break;
10442
10443 case 13500: hash_type = HASH_TYPE_SHA1;
10444 salt_type = SALT_TYPE_EMBEDDED;
10445 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10446 opts_type = OPTS_TYPE_PT_GENERATE_BE
10447 | OPTS_TYPE_PT_UNICODE
10448 | OPTS_TYPE_PT_ADD80;
10449 kern_type = KERN_TYPE_PSTOKEN;
10450 dgst_size = DGST_SIZE_4_5;
10451 parse_func = pstoken_parse_hash;
10452 sort_by_digest = sort_by_digest_4_5;
10453 opti_type = OPTI_TYPE_ZERO_BYTE
10454 | OPTI_TYPE_PRECOMPUTE_INIT
10455 | OPTI_TYPE_EARLY_SKIP
10456 | OPTI_TYPE_NOT_ITERATED
10457 | OPTI_TYPE_PREPENDED_SALT
10458 | OPTI_TYPE_RAW_HASH;
10459 dgst_pos0 = 3;
10460 dgst_pos1 = 4;
10461 dgst_pos2 = 2;
10462 dgst_pos3 = 1;
10463 break;
10464
10465 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10466 salt_type = SALT_TYPE_EMBEDDED;
10467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10469 kern_type = KERN_TYPE_ZIP2;
10470 dgst_size = DGST_SIZE_4_4;
10471 parse_func = zip2_parse_hash;
10472 sort_by_digest = sort_by_digest_4_4;
10473 opti_type = OPTI_TYPE_ZERO_BYTE;
10474 dgst_pos0 = 0;
10475 dgst_pos1 = 1;
10476 dgst_pos2 = 2;
10477 dgst_pos3 = 3;
10478 break;
10479
10480 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10481 salt_type = SALT_TYPE_EMBEDDED;
10482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10484 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10485 dgst_size = DGST_SIZE_4_5;
10486 parse_func = veracrypt_parse_hash_655331;
10487 sort_by_digest = sort_by_digest_4_5;
10488 opti_type = OPTI_TYPE_ZERO_BYTE;
10489 dgst_pos0 = 0;
10490 dgst_pos1 = 1;
10491 dgst_pos2 = 2;
10492 dgst_pos3 = 3;
10493 break;
10494
10495 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10496 salt_type = SALT_TYPE_EMBEDDED;
10497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10499 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10500 dgst_size = DGST_SIZE_4_5;
10501 parse_func = veracrypt_parse_hash_655331;
10502 sort_by_digest = sort_by_digest_4_5;
10503 opti_type = OPTI_TYPE_ZERO_BYTE;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 1;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 3;
10508 break;
10509
10510 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10511 salt_type = SALT_TYPE_EMBEDDED;
10512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10514 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10515 dgst_size = DGST_SIZE_4_5;
10516 parse_func = veracrypt_parse_hash_655331;
10517 sort_by_digest = sort_by_digest_4_5;
10518 opti_type = OPTI_TYPE_ZERO_BYTE;
10519 dgst_pos0 = 0;
10520 dgst_pos1 = 1;
10521 dgst_pos2 = 2;
10522 dgst_pos3 = 3;
10523 break;
10524
10525 case 13721: hash_type = HASH_TYPE_SHA512;
10526 salt_type = SALT_TYPE_EMBEDDED;
10527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10528 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10529 kern_type = KERN_TYPE_TCSHA512_XTS512;
10530 dgst_size = DGST_SIZE_8_8;
10531 parse_func = veracrypt_parse_hash_500000;
10532 sort_by_digest = sort_by_digest_8_8;
10533 opti_type = OPTI_TYPE_ZERO_BYTE
10534 | OPTI_TYPE_USES_BITS_64;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 13722: 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_XTS1024;
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 13723: 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_XTS1536;
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 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10574 salt_type = SALT_TYPE_EMBEDDED;
10575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10576 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10577 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10578 dgst_size = DGST_SIZE_4_8;
10579 parse_func = veracrypt_parse_hash_500000;
10580 sort_by_digest = sort_by_digest_4_8;
10581 opti_type = OPTI_TYPE_ZERO_BYTE;
10582 dgst_pos0 = 0;
10583 dgst_pos1 = 1;
10584 dgst_pos2 = 2;
10585 dgst_pos3 = 3;
10586 break;
10587
10588 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10589 salt_type = SALT_TYPE_EMBEDDED;
10590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10591 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10592 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10593 dgst_size = DGST_SIZE_4_8;
10594 parse_func = veracrypt_parse_hash_500000;
10595 sort_by_digest = sort_by_digest_4_8;
10596 opti_type = OPTI_TYPE_ZERO_BYTE;
10597 dgst_pos0 = 0;
10598 dgst_pos1 = 1;
10599 dgst_pos2 = 2;
10600 dgst_pos3 = 3;
10601 break;
10602
10603 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10604 salt_type = SALT_TYPE_EMBEDDED;
10605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10606 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10607 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10608 dgst_size = DGST_SIZE_4_8;
10609 parse_func = veracrypt_parse_hash_500000;
10610 sort_by_digest = sort_by_digest_4_8;
10611 opti_type = OPTI_TYPE_ZERO_BYTE;
10612 dgst_pos0 = 0;
10613 dgst_pos1 = 1;
10614 dgst_pos2 = 2;
10615 dgst_pos3 = 3;
10616 break;
10617
10618 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10619 salt_type = SALT_TYPE_EMBEDDED;
10620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10622 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10623 dgst_size = DGST_SIZE_4_5;
10624 parse_func = veracrypt_parse_hash_327661;
10625 sort_by_digest = sort_by_digest_4_5;
10626 opti_type = OPTI_TYPE_ZERO_BYTE;
10627 dgst_pos0 = 0;
10628 dgst_pos1 = 1;
10629 dgst_pos2 = 2;
10630 dgst_pos3 = 3;
10631 break;
10632
10633 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10634 salt_type = SALT_TYPE_EMBEDDED;
10635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10637 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10638 dgst_size = DGST_SIZE_4_5;
10639 parse_func = veracrypt_parse_hash_327661;
10640 sort_by_digest = sort_by_digest_4_5;
10641 opti_type = OPTI_TYPE_ZERO_BYTE;
10642 dgst_pos0 = 0;
10643 dgst_pos1 = 1;
10644 dgst_pos2 = 2;
10645 dgst_pos3 = 3;
10646 break;
10647
10648 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10649 salt_type = SALT_TYPE_EMBEDDED;
10650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10652 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10653 dgst_size = DGST_SIZE_4_5;
10654 parse_func = veracrypt_parse_hash_327661;
10655 sort_by_digest = sort_by_digest_4_5;
10656 opti_type = OPTI_TYPE_ZERO_BYTE;
10657 dgst_pos0 = 0;
10658 dgst_pos1 = 1;
10659 dgst_pos2 = 2;
10660 dgst_pos3 = 3;
10661 break;
10662
10663 case 13751: hash_type = HASH_TYPE_SHA256;
10664 salt_type = SALT_TYPE_EMBEDDED;
10665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10667 kern_type = KERN_TYPE_VCSHA256_XTS512;
10668 dgst_size = DGST_SIZE_4_8;
10669 parse_func = veracrypt_parse_hash_500000;
10670 sort_by_digest = sort_by_digest_4_8;
10671 opti_type = OPTI_TYPE_ZERO_BYTE;
10672 dgst_pos0 = 0;
10673 dgst_pos1 = 1;
10674 dgst_pos2 = 2;
10675 dgst_pos3 = 3;
10676 break;
10677
10678 case 13752: hash_type = HASH_TYPE_SHA256;
10679 salt_type = SALT_TYPE_EMBEDDED;
10680 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10681 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10682 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10683 dgst_size = DGST_SIZE_4_8;
10684 parse_func = veracrypt_parse_hash_500000;
10685 sort_by_digest = sort_by_digest_4_8;
10686 opti_type = OPTI_TYPE_ZERO_BYTE;
10687 dgst_pos0 = 0;
10688 dgst_pos1 = 1;
10689 dgst_pos2 = 2;
10690 dgst_pos3 = 3;
10691 break;
10692
10693 case 13753: hash_type = HASH_TYPE_SHA256;
10694 salt_type = SALT_TYPE_EMBEDDED;
10695 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10696 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10697 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10698 dgst_size = DGST_SIZE_4_8;
10699 parse_func = veracrypt_parse_hash_500000;
10700 sort_by_digest = sort_by_digest_4_8;
10701 opti_type = OPTI_TYPE_ZERO_BYTE;
10702 dgst_pos0 = 0;
10703 dgst_pos1 = 1;
10704 dgst_pos2 = 2;
10705 dgst_pos3 = 3;
10706 break;
10707
10708 case 13761: hash_type = HASH_TYPE_SHA256;
10709 salt_type = SALT_TYPE_EMBEDDED;
10710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10711 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10712 kern_type = KERN_TYPE_VCSHA256_XTS512;
10713 dgst_size = DGST_SIZE_4_8;
10714 parse_func = veracrypt_parse_hash_200000;
10715 sort_by_digest = sort_by_digest_4_8;
10716 opti_type = OPTI_TYPE_ZERO_BYTE;
10717 dgst_pos0 = 0;
10718 dgst_pos1 = 1;
10719 dgst_pos2 = 2;
10720 dgst_pos3 = 3;
10721 break;
10722
10723 case 13762: hash_type = HASH_TYPE_SHA256;
10724 salt_type = SALT_TYPE_EMBEDDED;
10725 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10726 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10727 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10728 dgst_size = DGST_SIZE_4_8;
10729 parse_func = veracrypt_parse_hash_200000;
10730 sort_by_digest = sort_by_digest_4_8;
10731 opti_type = OPTI_TYPE_ZERO_BYTE;
10732 dgst_pos0 = 0;
10733 dgst_pos1 = 1;
10734 dgst_pos2 = 2;
10735 dgst_pos3 = 3;
10736 break;
10737
10738 case 13763: hash_type = HASH_TYPE_SHA256;
10739 salt_type = SALT_TYPE_EMBEDDED;
10740 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10741 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10742 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10743 dgst_size = DGST_SIZE_4_8;
10744 parse_func = veracrypt_parse_hash_200000;
10745 sort_by_digest = sort_by_digest_4_8;
10746 opti_type = OPTI_TYPE_ZERO_BYTE;
10747 dgst_pos0 = 0;
10748 dgst_pos1 = 1;
10749 dgst_pos2 = 2;
10750 dgst_pos3 = 3;
10751 break;
10752
10753
10754 default: usage_mini_print (PROGNAME); return (-1);
10755 }
10756
10757 /**
10758 * parser
10759 */
10760
10761 data.parse_func = parse_func;
10762
10763 /**
10764 * misc stuff
10765 */
10766
10767 if (hex_salt)
10768 {
10769 if (salt_type == SALT_TYPE_INTERN)
10770 {
10771 opts_type |= OPTS_TYPE_ST_HEX;
10772 }
10773 else
10774 {
10775 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10776
10777 return (-1);
10778 }
10779 }
10780
10781 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10782 | (salt_type == SALT_TYPE_EXTERN)
10783 | (salt_type == SALT_TYPE_EMBEDDED)
10784 | (salt_type == SALT_TYPE_VIRTUAL));
10785
10786 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10787
10788 data.hash_type = hash_type;
10789 data.attack_mode = attack_mode;
10790 data.attack_kern = attack_kern;
10791 data.attack_exec = attack_exec;
10792 data.kern_type = kern_type;
10793 data.opts_type = opts_type;
10794 data.dgst_size = dgst_size;
10795 data.salt_type = salt_type;
10796 data.isSalted = isSalted;
10797 data.sort_by_digest = sort_by_digest;
10798 data.dgst_pos0 = dgst_pos0;
10799 data.dgst_pos1 = dgst_pos1;
10800 data.dgst_pos2 = dgst_pos2;
10801 data.dgst_pos3 = dgst_pos3;
10802
10803 esalt_size = 0;
10804
10805 switch (hash_mode)
10806 {
10807 case 2500: esalt_size = sizeof (wpa_t); break;
10808 case 5300: esalt_size = sizeof (ikepsk_t); break;
10809 case 5400: esalt_size = sizeof (ikepsk_t); break;
10810 case 5500: esalt_size = sizeof (netntlm_t); break;
10811 case 5600: esalt_size = sizeof (netntlm_t); break;
10812 case 6211: esalt_size = sizeof (tc_t); break;
10813 case 6212: esalt_size = sizeof (tc_t); break;
10814 case 6213: esalt_size = sizeof (tc_t); break;
10815 case 6221: esalt_size = sizeof (tc_t); break;
10816 case 6222: esalt_size = sizeof (tc_t); break;
10817 case 6223: esalt_size = sizeof (tc_t); break;
10818 case 6231: esalt_size = sizeof (tc_t); break;
10819 case 6232: esalt_size = sizeof (tc_t); break;
10820 case 6233: esalt_size = sizeof (tc_t); break;
10821 case 6241: esalt_size = sizeof (tc_t); break;
10822 case 6242: esalt_size = sizeof (tc_t); break;
10823 case 6243: esalt_size = sizeof (tc_t); break;
10824 case 6600: esalt_size = sizeof (agilekey_t); break;
10825 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10826 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10827 case 7300: esalt_size = sizeof (rakp_t); break;
10828 case 7500: esalt_size = sizeof (krb5pa_t); break;
10829 case 8200: esalt_size = sizeof (cloudkey_t); break;
10830 case 8800: esalt_size = sizeof (androidfde_t); break;
10831 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10832 case 9400: esalt_size = sizeof (office2007_t); break;
10833 case 9500: esalt_size = sizeof (office2010_t); break;
10834 case 9600: esalt_size = sizeof (office2013_t); break;
10835 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10836 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10837 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10838 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10839 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10840 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10841 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10842 case 10200: esalt_size = sizeof (cram_md5_t); break;
10843 case 10400: esalt_size = sizeof (pdf_t); break;
10844 case 10410: esalt_size = sizeof (pdf_t); break;
10845 case 10420: esalt_size = sizeof (pdf_t); break;
10846 case 10500: esalt_size = sizeof (pdf_t); break;
10847 case 10600: esalt_size = sizeof (pdf_t); break;
10848 case 10700: esalt_size = sizeof (pdf_t); break;
10849 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10850 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10851 case 11400: esalt_size = sizeof (sip_t); break;
10852 case 11600: esalt_size = sizeof (seven_zip_t); break;
10853 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10854 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10855 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10856 case 13000: esalt_size = sizeof (rar5_t); break;
10857 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10858 case 13400: esalt_size = sizeof (keepass_t); break;
10859 case 13500: esalt_size = sizeof (pstoken_t); break;
10860 case 13600: esalt_size = sizeof (zip2_t); break;
10861 case 13711: esalt_size = sizeof (tc_t); break;
10862 case 13712: esalt_size = sizeof (tc_t); break;
10863 case 13713: esalt_size = sizeof (tc_t); break;
10864 case 13721: esalt_size = sizeof (tc_t); break;
10865 case 13722: esalt_size = sizeof (tc_t); break;
10866 case 13723: esalt_size = sizeof (tc_t); break;
10867 case 13731: esalt_size = sizeof (tc_t); break;
10868 case 13732: esalt_size = sizeof (tc_t); break;
10869 case 13733: esalt_size = sizeof (tc_t); break;
10870 case 13741: esalt_size = sizeof (tc_t); break;
10871 case 13742: esalt_size = sizeof (tc_t); break;
10872 case 13743: esalt_size = sizeof (tc_t); break;
10873 case 13751: esalt_size = sizeof (tc_t); break;
10874 case 13752: esalt_size = sizeof (tc_t); break;
10875 case 13753: esalt_size = sizeof (tc_t); break;
10876 case 13761: esalt_size = sizeof (tc_t); break;
10877 case 13762: esalt_size = sizeof (tc_t); break;
10878 case 13763: esalt_size = sizeof (tc_t); break;
10879 }
10880
10881 data.esalt_size = esalt_size;
10882
10883 /**
10884 * choose dictionary parser
10885 */
10886
10887 if (hash_type == HASH_TYPE_LM)
10888 {
10889 get_next_word_func = get_next_word_lm;
10890 }
10891 else if (opts_type & OPTS_TYPE_PT_UPPER)
10892 {
10893 get_next_word_func = get_next_word_uc;
10894 }
10895 else
10896 {
10897 get_next_word_func = get_next_word_std;
10898 }
10899
10900 /**
10901 * dictstat
10902 */
10903
10904 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10905
10906 #ifdef _POSIX
10907 size_t dictstat_nmemb = 0;
10908 #endif
10909
10910 #ifdef _WIN
10911 uint dictstat_nmemb = 0;
10912 #endif
10913
10914 char dictstat[256] = { 0 };
10915
10916 FILE *dictstat_fp = NULL;
10917
10918 if (keyspace == 0)
10919 {
10920 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10921
10922 dictstat_fp = fopen (dictstat, "rb");
10923
10924 if (dictstat_fp)
10925 {
10926 #ifdef _POSIX
10927 struct stat tmpstat;
10928
10929 fstat (fileno (dictstat_fp), &tmpstat);
10930 #endif
10931
10932 #ifdef _WIN
10933 struct stat64 tmpstat;
10934
10935 _fstat64 (fileno (dictstat_fp), &tmpstat);
10936 #endif
10937
10938 if (tmpstat.st_mtime < COMPTIME)
10939 {
10940 /* with v0.15 the format changed so we have to ensure user is using a good version
10941 since there is no version-header in the dictstat file */
10942
10943 fclose (dictstat_fp);
10944
10945 unlink (dictstat);
10946 }
10947 else
10948 {
10949 while (!feof (dictstat_fp))
10950 {
10951 dictstat_t d;
10952
10953 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10954
10955 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10956
10957 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10958 {
10959 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10960
10961 return -1;
10962 }
10963 }
10964
10965 fclose (dictstat_fp);
10966 }
10967 }
10968 }
10969
10970 /**
10971 * potfile
10972 */
10973
10974 char potfile[256] = { 0 };
10975
10976 if (potfile_path == NULL)
10977 {
10978 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10979 }
10980 else
10981 {
10982 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10983 }
10984
10985 data.pot_fp = NULL;
10986
10987 FILE *out_fp = NULL;
10988 FILE *pot_fp = NULL;
10989
10990 if (show == 1 || left == 1)
10991 {
10992 pot_fp = fopen (potfile, "rb");
10993
10994 if (pot_fp == NULL)
10995 {
10996 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10997
10998 return (-1);
10999 }
11000
11001 if (outfile != NULL)
11002 {
11003 if ((out_fp = fopen (outfile, "ab")) == NULL)
11004 {
11005 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11006
11007 fclose (pot_fp);
11008
11009 return (-1);
11010 }
11011 }
11012 else
11013 {
11014 out_fp = stdout;
11015 }
11016 }
11017 else
11018 {
11019 if (potfile_disable == 0)
11020 {
11021 pot_fp = fopen (potfile, "ab");
11022
11023 if (pot_fp == NULL)
11024 {
11025 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11026
11027 return (-1);
11028 }
11029
11030 data.pot_fp = pot_fp;
11031 }
11032 }
11033
11034 pot_t *pot = NULL;
11035
11036 uint pot_cnt = 0;
11037 uint pot_avail = 0;
11038
11039 if (show == 1 || left == 1)
11040 {
11041 SUPPRESS_OUTPUT = 1;
11042
11043 pot_avail = count_lines (pot_fp);
11044
11045 rewind (pot_fp);
11046
11047 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11048
11049 uint pot_hashes_avail = 0;
11050
11051 uint line_num = 0;
11052
11053 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11054
11055 while (!feof (pot_fp))
11056 {
11057 line_num++;
11058
11059 int line_len = fgetl (pot_fp, line_buf);
11060
11061 if (line_len == 0) continue;
11062
11063 char *plain_buf = line_buf + line_len;
11064
11065 pot_t *pot_ptr = &pot[pot_cnt];
11066
11067 hash_t *hashes_buf = &pot_ptr->hash;
11068
11069 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11070 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11071
11072 if (pot_cnt == pot_hashes_avail)
11073 {
11074 uint pos = 0;
11075
11076 for (pos = 0; pos < INCR_POT; pos++)
11077 {
11078 if ((pot_cnt + pos) >= pot_avail) break;
11079
11080 pot_t *tmp_pot = &pot[pot_cnt + pos];
11081
11082 hash_t *tmp_hash = &tmp_pot->hash;
11083
11084 tmp_hash->digest = mymalloc (dgst_size);
11085
11086 if (isSalted)
11087 {
11088 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11089 }
11090
11091 if (esalt_size)
11092 {
11093 tmp_hash->esalt = mymalloc (esalt_size);
11094 }
11095
11096 pot_hashes_avail++;
11097 }
11098 }
11099
11100 int plain_len = 0;
11101
11102 int parser_status;
11103
11104 int iter = MAX_CUT_TRIES;
11105
11106 do
11107 {
11108 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11109 {
11110 if (line_buf[i] == ':')
11111 {
11112 line_len--;
11113
11114 break;
11115 }
11116 }
11117
11118 if (data.hash_mode != 2500)
11119 {
11120 parser_status = parse_func (line_buf, line_len, hashes_buf);
11121 }
11122 else
11123 {
11124 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11125
11126 if (line_len > max_salt_size)
11127 {
11128 parser_status = PARSER_GLOBAL_LENGTH;
11129 }
11130 else
11131 {
11132 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11133
11134 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11135
11136 hashes_buf->salt->salt_len = line_len;
11137
11138 parser_status = PARSER_OK;
11139 }
11140 }
11141
11142 // if NOT parsed without error, we add the ":" to the plain
11143
11144 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11145 {
11146 plain_len++;
11147 plain_buf--;
11148 }
11149
11150 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11151
11152 if (parser_status < PARSER_GLOBAL_ZERO)
11153 {
11154 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11155
11156 continue;
11157 }
11158
11159 if (plain_len >= 255) continue;
11160
11161 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11162
11163 pot_ptr->plain_len = plain_len;
11164
11165 pot_cnt++;
11166 }
11167
11168 myfree (line_buf);
11169
11170 fclose (pot_fp);
11171
11172 SUPPRESS_OUTPUT = 0;
11173
11174 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11175 }
11176
11177 /**
11178 * word len
11179 */
11180
11181 uint pw_min = PW_MIN;
11182 uint pw_max = PW_MAX;
11183
11184 switch (hash_mode)
11185 {
11186 case 125: if (pw_max > 32) pw_max = 32;
11187 break;
11188 case 400: if (pw_max > 40) pw_max = 40;
11189 break;
11190 case 500: if (pw_max > 16) pw_max = 16;
11191 break;
11192 case 1500: if (pw_max > 8) pw_max = 8;
11193 break;
11194 case 1600: if (pw_max > 16) pw_max = 16;
11195 break;
11196 case 1800: if (pw_max > 16) pw_max = 16;
11197 break;
11198 case 2100: if (pw_max > 16) pw_max = 16;
11199 break;
11200 case 2500: if (pw_min < 8) pw_min = 8;
11201 break;
11202 case 3000: if (pw_max > 7) pw_max = 7;
11203 break;
11204 case 5200: if (pw_max > 24) pw_max = 24;
11205 break;
11206 case 5800: if (pw_max > 16) pw_max = 16;
11207 break;
11208 case 6300: if (pw_max > 16) pw_max = 16;
11209 break;
11210 case 7400: if (pw_max > 16) pw_max = 16;
11211 break;
11212 case 7500: if (pw_max > 8) pw_max = 8;
11213 break;
11214 case 7900: if (pw_max > 48) pw_max = 48;
11215 break;
11216 case 8500: if (pw_max > 8) pw_max = 8;
11217 break;
11218 case 8600: if (pw_max > 16) pw_max = 16;
11219 break;
11220 case 9710: pw_min = 5;
11221 pw_max = 5;
11222 break;
11223 case 9810: pw_min = 5;
11224 pw_max = 5;
11225 break;
11226 case 10410: pw_min = 5;
11227 pw_max = 5;
11228 break;
11229 case 10300: if (pw_max < 3) pw_min = 3;
11230 if (pw_max > 40) pw_max = 40;
11231 break;
11232 case 10500: if (pw_max < 3) pw_min = 3;
11233 if (pw_max > 40) pw_max = 40;
11234 break;
11235 case 10700: if (pw_max > 16) pw_max = 16;
11236 break;
11237 case 11300: if (pw_max > 40) pw_max = 40;
11238 break;
11239 case 11600: if (pw_max > 32) pw_max = 32;
11240 break;
11241 case 12500: if (pw_max > 20) pw_max = 20;
11242 break;
11243 case 12800: if (pw_max > 24) pw_max = 24;
11244 break;
11245 }
11246
11247 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11248 {
11249 switch (attack_kern)
11250 {
11251 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11252 break;
11253 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11254 break;
11255 }
11256 }
11257
11258 /**
11259 * charsets : keep them together for more easy maintainnce
11260 */
11261
11262 cs_t mp_sys[6] = { { { 0 }, 0 } };
11263 cs_t mp_usr[4] = { { { 0 }, 0 } };
11264
11265 mp_setup_sys (mp_sys);
11266
11267 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11268 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11269 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11270 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11271
11272 /**
11273 * load hashes, part I: find input mode, count hashes
11274 */
11275
11276 uint hashlist_mode = 0;
11277 uint hashlist_format = HLFMT_HASHCAT;
11278
11279 uint hashes_avail = 0;
11280
11281 if (benchmark == 0)
11282 {
11283 struct stat f;
11284
11285 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11286
11287 if ((hash_mode == 2500) ||
11288 (hash_mode == 5200) ||
11289 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11290 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11291 (hash_mode == 9000))
11292 {
11293 hashlist_mode = HL_MODE_ARG;
11294
11295 char *hashfile = myargv[optind];
11296
11297 data.hashfile = hashfile;
11298
11299 logfile_top_var_string ("target", hashfile);
11300 }
11301
11302 if (hashlist_mode == HL_MODE_ARG)
11303 {
11304 if (hash_mode == 2500)
11305 {
11306 struct stat st;
11307
11308 if (stat (data.hashfile, &st) == -1)
11309 {
11310 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11311
11312 return (-1);
11313 }
11314
11315 hashes_avail = st.st_size / sizeof (hccap_t);
11316 }
11317 else
11318 {
11319 hashes_avail = 1;
11320 }
11321 }
11322 else if (hashlist_mode == HL_MODE_FILE)
11323 {
11324 char *hashfile = myargv[optind];
11325
11326 data.hashfile = hashfile;
11327
11328 logfile_top_var_string ("target", hashfile);
11329
11330 FILE *fp = NULL;
11331
11332 if ((fp = fopen (hashfile, "rb")) == NULL)
11333 {
11334 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11335
11336 return (-1);
11337 }
11338
11339 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11340
11341 hashes_avail = count_lines (fp);
11342
11343 rewind (fp);
11344
11345 if (hashes_avail == 0)
11346 {
11347 log_error ("ERROR: hashfile is empty or corrupt");
11348
11349 fclose (fp);
11350
11351 return (-1);
11352 }
11353
11354 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11355
11356 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11357 {
11358 log_error ("ERROR: remove not supported in native hashfile-format mode");
11359
11360 fclose (fp);
11361
11362 return (-1);
11363 }
11364
11365 fclose (fp);
11366 }
11367 }
11368 else
11369 {
11370 hashlist_mode = HL_MODE_ARG;
11371
11372 hashes_avail = 1;
11373 }
11374
11375 if (hash_mode == 3000) hashes_avail *= 2;
11376
11377 data.hashlist_mode = hashlist_mode;
11378 data.hashlist_format = hashlist_format;
11379
11380 logfile_top_uint (hashlist_mode);
11381 logfile_top_uint (hashlist_format);
11382
11383 /**
11384 * load hashes, part II: allocate required memory, set pointers
11385 */
11386
11387 hash_t *hashes_buf = NULL;
11388 void *digests_buf = NULL;
11389 salt_t *salts_buf = NULL;
11390 void *esalts_buf = NULL;
11391
11392 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11393
11394 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11395
11396 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11397 {
11398 u32 hash_pos;
11399
11400 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11401 {
11402 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11403
11404 hashes_buf[hash_pos].hash_info = hash_info;
11405
11406 if (username && (remove || show || left))
11407 {
11408 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11409 }
11410
11411 if (benchmark)
11412 {
11413 hash_info->orighash = (char *) mymalloc (256);
11414 }
11415 }
11416 }
11417
11418 if (isSalted)
11419 {
11420 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11421
11422 if (esalt_size)
11423 {
11424 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11425 }
11426 }
11427 else
11428 {
11429 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11430 }
11431
11432 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11433 {
11434 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11435
11436 if (isSalted)
11437 {
11438 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11439
11440 if (esalt_size)
11441 {
11442 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11443 }
11444 }
11445 else
11446 {
11447 hashes_buf[hash_pos].salt = &salts_buf[0];
11448 }
11449 }
11450
11451 /**
11452 * load hashes, part III: parse hashes or generate them if benchmark
11453 */
11454
11455 uint hashes_cnt = 0;
11456
11457 if (benchmark == 0)
11458 {
11459 if (keyspace == 1)
11460 {
11461 // useless to read hash file for keyspace, cheat a little bit w/ optind
11462 }
11463 else if (hashes_avail == 0)
11464 {
11465 }
11466 else if (hashlist_mode == HL_MODE_ARG)
11467 {
11468 char *input_buf = myargv[optind];
11469
11470 uint input_len = strlen (input_buf);
11471
11472 logfile_top_var_string ("target", input_buf);
11473
11474 char *hash_buf = NULL;
11475 int hash_len = 0;
11476
11477 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11478
11479 bool hash_fmt_error = 0;
11480
11481 if (hash_len < 1) hash_fmt_error = 1;
11482 if (hash_buf == NULL) hash_fmt_error = 1;
11483
11484 if (hash_fmt_error)
11485 {
11486 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11487 }
11488 else
11489 {
11490 if (opts_type & OPTS_TYPE_HASH_COPY)
11491 {
11492 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11493
11494 hash_info_tmp->orighash = mystrdup (hash_buf);
11495 }
11496
11497 if (isSalted)
11498 {
11499 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11500 }
11501
11502 int parser_status = PARSER_OK;
11503
11504 if (hash_mode == 2500)
11505 {
11506 if (hash_len == 0)
11507 {
11508 log_error ("ERROR: hccap file not specified");
11509
11510 return (-1);
11511 }
11512
11513 hashlist_mode = HL_MODE_FILE;
11514
11515 data.hashlist_mode = hashlist_mode;
11516
11517 FILE *fp = fopen (hash_buf, "rb");
11518
11519 if (fp == NULL)
11520 {
11521 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11522
11523 return (-1);
11524 }
11525
11526 if (hashes_avail < 1)
11527 {
11528 log_error ("ERROR: hccap file is empty or corrupt");
11529
11530 fclose (fp);
11531
11532 return (-1);
11533 }
11534
11535 uint hccap_size = sizeof (hccap_t);
11536
11537 char *in = (char *) mymalloc (hccap_size);
11538
11539 while (!feof (fp))
11540 {
11541 int n = fread (in, hccap_size, 1, fp);
11542
11543 if (n != 1)
11544 {
11545 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11546
11547 break;
11548 }
11549
11550 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11551
11552 if (parser_status != PARSER_OK)
11553 {
11554 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11555
11556 continue;
11557 }
11558
11559 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11560
11561 if ((show == 1) || (left == 1))
11562 {
11563 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11564
11565 char *salt_ptr = (char *) tmp_salt->salt_buf;
11566
11567 int cur_pos = tmp_salt->salt_len;
11568 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11569
11570 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11571
11572 // do the appending task
11573
11574 snprintf (salt_ptr + cur_pos,
11575 rem_len,
11576 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11577 wpa->orig_mac1[0],
11578 wpa->orig_mac1[1],
11579 wpa->orig_mac1[2],
11580 wpa->orig_mac1[3],
11581 wpa->orig_mac1[4],
11582 wpa->orig_mac1[5],
11583 wpa->orig_mac2[0],
11584 wpa->orig_mac2[1],
11585 wpa->orig_mac2[2],
11586 wpa->orig_mac2[3],
11587 wpa->orig_mac2[4],
11588 wpa->orig_mac2[5]);
11589
11590 // memset () the remaining part of the salt
11591
11592 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11593 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11594
11595 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11596
11597 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11598 }
11599
11600 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);
11601 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);
11602
11603 hashes_cnt++;
11604 }
11605
11606 fclose (fp);
11607
11608 myfree (in);
11609 }
11610 else if (hash_mode == 3000)
11611 {
11612 if (hash_len == 32)
11613 {
11614 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11615
11616 hash_t *lm_hash_left = NULL;
11617
11618 if (parser_status == PARSER_OK)
11619 {
11620 lm_hash_left = &hashes_buf[hashes_cnt];
11621
11622 hashes_cnt++;
11623 }
11624 else
11625 {
11626 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11627 }
11628
11629 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11630
11631 hash_t *lm_hash_right = NULL;
11632
11633 if (parser_status == PARSER_OK)
11634 {
11635 lm_hash_right = &hashes_buf[hashes_cnt];
11636
11637 hashes_cnt++;
11638 }
11639 else
11640 {
11641 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11642 }
11643
11644 // show / left
11645
11646 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11647 {
11648 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);
11649 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);
11650 }
11651 }
11652 else
11653 {
11654 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11655
11656 if (parser_status == PARSER_OK)
11657 {
11658 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11659 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11660 }
11661
11662 if (parser_status == PARSER_OK)
11663 {
11664 hashes_cnt++;
11665 }
11666 else
11667 {
11668 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11669 }
11670 }
11671 }
11672 else
11673 {
11674 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11675
11676 if (parser_status == PARSER_OK)
11677 {
11678 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11679 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11680 }
11681
11682 if (parser_status == PARSER_OK)
11683 {
11684 hashes_cnt++;
11685 }
11686 else
11687 {
11688 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11689 }
11690 }
11691 }
11692 }
11693 else if (hashlist_mode == HL_MODE_FILE)
11694 {
11695 char *hashfile = data.hashfile;
11696
11697 FILE *fp;
11698
11699 if ((fp = fopen (hashfile, "rb")) == NULL)
11700 {
11701 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11702
11703 return (-1);
11704 }
11705
11706 uint line_num = 0;
11707
11708 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11709
11710 while (!feof (fp))
11711 {
11712 line_num++;
11713
11714 int line_len = fgetl (fp, line_buf);
11715
11716 if (line_len == 0) continue;
11717
11718 char *hash_buf = NULL;
11719 int hash_len = 0;
11720
11721 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11722
11723 bool hash_fmt_error = 0;
11724
11725 if (hash_len < 1) hash_fmt_error = 1;
11726 if (hash_buf == NULL) hash_fmt_error = 1;
11727
11728 if (hash_fmt_error)
11729 {
11730 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11731
11732 continue;
11733 }
11734
11735 if (username)
11736 {
11737 char *user_buf = NULL;
11738 int user_len = 0;
11739
11740 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11741
11742 if (remove || show)
11743 {
11744 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11745
11746 *user = (user_t *) mymalloc (sizeof (user_t));
11747
11748 user_t *user_ptr = *user;
11749
11750 if (user_buf != NULL)
11751 {
11752 user_ptr->user_name = mystrdup (user_buf);
11753 }
11754 else
11755 {
11756 user_ptr->user_name = mystrdup ("");
11757 }
11758
11759 user_ptr->user_len = user_len;
11760 }
11761 }
11762
11763 if (opts_type & OPTS_TYPE_HASH_COPY)
11764 {
11765 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11766
11767 hash_info_tmp->orighash = mystrdup (hash_buf);
11768 }
11769
11770 if (isSalted)
11771 {
11772 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11773 }
11774
11775 if (hash_mode == 3000)
11776 {
11777 if (hash_len == 32)
11778 {
11779 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11780
11781 if (parser_status < PARSER_GLOBAL_ZERO)
11782 {
11783 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11784
11785 continue;
11786 }
11787
11788 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11789
11790 hashes_cnt++;
11791
11792 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11793
11794 if (parser_status < PARSER_GLOBAL_ZERO)
11795 {
11796 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11797
11798 continue;
11799 }
11800
11801 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11802
11803 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);
11804
11805 hashes_cnt++;
11806
11807 // show / left
11808
11809 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);
11810 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);
11811 }
11812 else
11813 {
11814 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11815
11816 if (parser_status < PARSER_GLOBAL_ZERO)
11817 {
11818 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11819
11820 continue;
11821 }
11822
11823 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);
11824
11825 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11826 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11827
11828 hashes_cnt++;
11829 }
11830 }
11831 else
11832 {
11833 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11834
11835 if (parser_status < PARSER_GLOBAL_ZERO)
11836 {
11837 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11838
11839 continue;
11840 }
11841
11842 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);
11843
11844 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11845 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11846
11847 hashes_cnt++;
11848 }
11849 }
11850
11851 myfree (line_buf);
11852
11853 fclose (fp);
11854
11855 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11856
11857 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11858 }
11859 }
11860 else
11861 {
11862 if (isSalted)
11863 {
11864 hashes_buf[0].salt->salt_len = 8;
11865
11866 // special salt handling
11867
11868 switch (hash_mode)
11869 {
11870 case 1500: hashes_buf[0].salt->salt_len = 2;
11871 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11872 break;
11873 case 1731: hashes_buf[0].salt->salt_len = 4;
11874 break;
11875 case 2410: hashes_buf[0].salt->salt_len = 4;
11876 break;
11877 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11878 break;
11879 case 3100: hashes_buf[0].salt->salt_len = 1;
11880 break;
11881 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11882 break;
11883 case 5800: hashes_buf[0].salt->salt_len = 16;
11884 break;
11885 case 6800: hashes_buf[0].salt->salt_len = 32;
11886 break;
11887 case 8400: hashes_buf[0].salt->salt_len = 40;
11888 break;
11889 case 8800: hashes_buf[0].salt->salt_len = 16;
11890 break;
11891 case 8900: hashes_buf[0].salt->salt_len = 16;
11892 hashes_buf[0].salt->scrypt_N = 1024;
11893 hashes_buf[0].salt->scrypt_r = 1;
11894 hashes_buf[0].salt->scrypt_p = 1;
11895 break;
11896 case 9100: hashes_buf[0].salt->salt_len = 16;
11897 break;
11898 case 9300: hashes_buf[0].salt->salt_len = 14;
11899 hashes_buf[0].salt->scrypt_N = 16384;
11900 hashes_buf[0].salt->scrypt_r = 1;
11901 hashes_buf[0].salt->scrypt_p = 1;
11902 break;
11903 case 9400: hashes_buf[0].salt->salt_len = 16;
11904 break;
11905 case 9500: hashes_buf[0].salt->salt_len = 16;
11906 break;
11907 case 9600: hashes_buf[0].salt->salt_len = 16;
11908 break;
11909 case 9700: hashes_buf[0].salt->salt_len = 16;
11910 break;
11911 case 9710: hashes_buf[0].salt->salt_len = 16;
11912 break;
11913 case 9720: hashes_buf[0].salt->salt_len = 16;
11914 break;
11915 case 9800: hashes_buf[0].salt->salt_len = 16;
11916 break;
11917 case 9810: hashes_buf[0].salt->salt_len = 16;
11918 break;
11919 case 9820: hashes_buf[0].salt->salt_len = 16;
11920 break;
11921 case 10300: hashes_buf[0].salt->salt_len = 12;
11922 break;
11923 case 11500: hashes_buf[0].salt->salt_len = 4;
11924 break;
11925 case 11600: hashes_buf[0].salt->salt_len = 4;
11926 break;
11927 case 12400: hashes_buf[0].salt->salt_len = 4;
11928 break;
11929 case 12500: hashes_buf[0].salt->salt_len = 8;
11930 break;
11931 case 12600: hashes_buf[0].salt->salt_len = 64;
11932 break;
11933 }
11934
11935 // special esalt handling
11936
11937 switch (hash_mode)
11938 {
11939 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11940 break;
11941 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11942 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11943 break;
11944 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11945 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11946 break;
11947 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11948 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11949 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11950 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11951 break;
11952 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11953 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11954 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11955 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11956 break;
11957 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11958 break;
11959 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11960 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11961 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11962 break;
11963 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11964 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11965 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11966 break;
11967 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11968 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11969 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11970 break;
11971 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11972 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11973 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11974 break;
11975 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11976 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11977 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11978 break;
11979 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11980 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11981 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11982 break;
11983 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11984 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11985 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11986 break;
11987 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11988 break;
11989 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11990 break;
11991 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11992 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11993 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11994 break;
11995 }
11996 }
11997
11998 // set hashfile
11999
12000 switch (hash_mode)
12001 {
12002 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12003 break;
12004 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12005 break;
12006 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12007 break;
12008 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12009 break;
12010 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12011 break;
12012 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12013 break;
12014 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12015 break;
12016 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12017 break;
12018 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12019 break;
12020 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12021 break;
12022 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12023 break;
12024 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12025 break;
12026 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12027 break;
12028 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12029 break;
12030 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12031 break;
12032 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12033 break;
12034 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12035 break;
12036 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12037 break;
12038 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12039 break;
12040 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12041 break;
12042 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12043 break;
12044 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12045 break;
12046 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12047 break;
12048 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12049 break;
12050 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12051 break;
12052 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12053 break;
12054 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12055 break;
12056 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12057 break;
12058 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12059 break;
12060 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12061 break;
12062 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12063 break;
12064 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12065 break;
12066 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12067 break;
12068 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12069 break;
12070 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12071 break;
12072 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12073 break;
12074 }
12075
12076 // set default iterations
12077
12078 switch (hash_mode)
12079 {
12080 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12081 break;
12082 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12083 break;
12084 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12085 break;
12086 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12087 break;
12088 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12089 break;
12090 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12091 break;
12092 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12093 break;
12094 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12095 break;
12096 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12097 break;
12098 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12099 break;
12100 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12101 break;
12102 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12103 break;
12104 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12105 break;
12106 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12107 break;
12108 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12109 break;
12110 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12111 break;
12112 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12113 break;
12114 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12115 break;
12116 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12117 break;
12118 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12119 break;
12120 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12121 break;
12122 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12123 break;
12124 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12125 break;
12126 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12127 break;
12128 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12129 break;
12130 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12131 break;
12132 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12133 break;
12134 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12135 break;
12136 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12137 break;
12138 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12139 break;
12140 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12141 break;
12142 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12143 break;
12144 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12145 break;
12146 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12147 break;
12148 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12149 break;
12150 case 8900: hashes_buf[0].salt->salt_iter = 1;
12151 break;
12152 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12153 break;
12154 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12155 break;
12156 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12157 break;
12158 case 9300: hashes_buf[0].salt->salt_iter = 1;
12159 break;
12160 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12161 break;
12162 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12163 break;
12164 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12165 break;
12166 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12167 break;
12168 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12169 break;
12170 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12171 break;
12172 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12173 break;
12174 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12175 break;
12176 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12177 break;
12178 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12179 break;
12180 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12181 break;
12182 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12183 break;
12184 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12185 break;
12186 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12187 break;
12188 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12189 break;
12190 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12191 break;
12192 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12193 break;
12194 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12195 break;
12196 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12197 break;
12198 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12199 break;
12200 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12201 break;
12202 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12203 break;
12204 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12205 break;
12206 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12207 break;
12208 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12209 break;
12210 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12211 break;
12212 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12213 break;
12214 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12215 break;
12216 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12217 break;
12218 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12219 break;
12220 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12221 break;
12222 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12223 break;
12224 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12225 break;
12226 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12227 break;
12228 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12229 break;
12230 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12231 break;
12232 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12233 break;
12234 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12235 break;
12236 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12237 break;
12238 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12239 break;
12240 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12241 break;
12242 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12243 break;
12244 }
12245
12246 hashes_cnt = 1;
12247 }
12248
12249 if (show == 1 || left == 1)
12250 {
12251 for (uint i = 0; i < pot_cnt; i++)
12252 {
12253 pot_t *pot_ptr = &pot[i];
12254
12255 hash_t *hashes_buf = &pot_ptr->hash;
12256
12257 local_free (hashes_buf->digest);
12258
12259 if (isSalted)
12260 {
12261 local_free (hashes_buf->salt);
12262 }
12263 }
12264
12265 local_free (pot);
12266
12267 if (data.quiet == 0) log_info_nn ("");
12268
12269 return (0);
12270 }
12271
12272 if (keyspace == 0)
12273 {
12274 if (hashes_cnt == 0)
12275 {
12276 log_error ("ERROR: No hashes loaded");
12277
12278 return (-1);
12279 }
12280 }
12281
12282 /**
12283 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12284 */
12285
12286 if (data.outfile != NULL)
12287 {
12288 if (data.hashfile != NULL)
12289 {
12290 #ifdef _POSIX
12291 struct stat tmpstat_outfile;
12292 struct stat tmpstat_hashfile;
12293 #endif
12294
12295 #ifdef _WIN
12296 struct stat64 tmpstat_outfile;
12297 struct stat64 tmpstat_hashfile;
12298 #endif
12299
12300 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12301
12302 if (tmp_outfile_fp)
12303 {
12304 #ifdef _POSIX
12305 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12306 #endif
12307
12308 #ifdef _WIN
12309 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12310 #endif
12311
12312 fclose (tmp_outfile_fp);
12313 }
12314
12315 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12316
12317 if (tmp_hashfile_fp)
12318 {
12319 #ifdef _POSIX
12320 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12321 #endif
12322
12323 #ifdef _WIN
12324 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12325 #endif
12326
12327 fclose (tmp_hashfile_fp);
12328 }
12329
12330 if (tmp_outfile_fp && tmp_outfile_fp)
12331 {
12332 tmpstat_outfile.st_mode = 0;
12333 tmpstat_outfile.st_nlink = 0;
12334 tmpstat_outfile.st_uid = 0;
12335 tmpstat_outfile.st_gid = 0;
12336 tmpstat_outfile.st_rdev = 0;
12337 tmpstat_outfile.st_atime = 0;
12338
12339 tmpstat_hashfile.st_mode = 0;
12340 tmpstat_hashfile.st_nlink = 0;
12341 tmpstat_hashfile.st_uid = 0;
12342 tmpstat_hashfile.st_gid = 0;
12343 tmpstat_hashfile.st_rdev = 0;
12344 tmpstat_hashfile.st_atime = 0;
12345
12346 #ifdef _POSIX
12347 tmpstat_outfile.st_blksize = 0;
12348 tmpstat_outfile.st_blocks = 0;
12349
12350 tmpstat_hashfile.st_blksize = 0;
12351 tmpstat_hashfile.st_blocks = 0;
12352 #endif
12353
12354 #ifdef _POSIX
12355 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12356 {
12357 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12358
12359 return (-1);
12360 }
12361 #endif
12362
12363 #ifdef _WIN
12364 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12365 {
12366 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12367
12368 return (-1);
12369 }
12370 #endif
12371 }
12372 }
12373 }
12374
12375 /**
12376 * Remove duplicates
12377 */
12378
12379 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12380
12381 if (isSalted)
12382 {
12383 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12384 }
12385 else
12386 {
12387 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12388 }
12389
12390 uint hashes_cnt_orig = hashes_cnt;
12391
12392 hashes_cnt = 1;
12393
12394 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12395 {
12396 if (isSalted)
12397 {
12398 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12399 {
12400 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12401 }
12402 }
12403 else
12404 {
12405 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12406 }
12407
12408 if (hashes_pos > hashes_cnt)
12409 {
12410 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12411 }
12412
12413 hashes_cnt++;
12414 }
12415
12416 /**
12417 * Potfile removes
12418 */
12419
12420 uint potfile_remove_cracks = 0;
12421
12422 if (potfile_disable == 0)
12423 {
12424 hash_t hash_buf;
12425
12426 hash_buf.digest = mymalloc (dgst_size);
12427 hash_buf.salt = NULL;
12428 hash_buf.esalt = NULL;
12429 hash_buf.hash_info = NULL;
12430 hash_buf.cracked = 0;
12431
12432 if (isSalted)
12433 {
12434 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12435 }
12436
12437 if (esalt_size)
12438 {
12439 hash_buf.esalt = mymalloc (esalt_size);
12440 }
12441
12442 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12443
12444 // no solution for these special hash types (for instane because they use hashfile in output etc)
12445 if ((hash_mode != 5200) &&
12446 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12447 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12448 (hash_mode != 9000))
12449 {
12450 FILE *fp = fopen (potfile, "rb");
12451
12452 if (fp != NULL)
12453 {
12454 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12455
12456 // to be safe work with a copy (because of line_len loop, i etc)
12457 // moved up here because it's easier to handle continue case
12458 // it's just 64kb
12459
12460 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12461
12462 while (!feof (fp))
12463 {
12464 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12465
12466 if (ptr == NULL) break;
12467
12468 int line_len = strlen (line_buf);
12469
12470 if (line_len == 0) continue;
12471
12472 int iter = MAX_CUT_TRIES;
12473
12474 for (int i = line_len - 1; i && iter; i--, line_len--)
12475 {
12476 if (line_buf[i] != ':') continue;
12477
12478 if (isSalted)
12479 {
12480 memset (hash_buf.salt, 0, sizeof (salt_t));
12481 }
12482
12483 hash_t *found = NULL;
12484
12485 if (hash_mode == 6800)
12486 {
12487 if (i < 64) // 64 = 16 * uint in salt_buf[]
12488 {
12489 // manipulate salt_buf
12490 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12491
12492 hash_buf.salt->salt_len = i;
12493
12494 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12495 }
12496 }
12497 else if (hash_mode == 2500)
12498 {
12499 if (i < 64) // 64 = 16 * uint in salt_buf[]
12500 {
12501 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12502 // manipulate salt_buf
12503
12504 memcpy (line_buf_cpy, line_buf, i);
12505
12506 char *mac2_pos = strrchr (line_buf_cpy, ':');
12507
12508 if (mac2_pos == NULL) continue;
12509
12510 mac2_pos[0] = 0;
12511 mac2_pos++;
12512
12513 if (strlen (mac2_pos) != 12) continue;
12514
12515 char *mac1_pos = strrchr (line_buf_cpy, ':');
12516
12517 if (mac1_pos == NULL) continue;
12518
12519 mac1_pos[0] = 0;
12520 mac1_pos++;
12521
12522 if (strlen (mac1_pos) != 12) continue;
12523
12524 uint essid_length = mac1_pos - line_buf_cpy - 1;
12525
12526 // here we need the ESSID
12527 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12528
12529 hash_buf.salt->salt_len = essid_length;
12530
12531 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12532
12533 if (found)
12534 {
12535 wpa_t *wpa = (wpa_t *) found->esalt;
12536
12537 // compare hex string(s) vs binary MAC address(es)
12538
12539 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12540 {
12541 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12542 {
12543 found = NULL;
12544
12545 break;
12546 }
12547 }
12548
12549 // early skip ;)
12550 if (!found) continue;
12551
12552 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12553 {
12554 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12555 {
12556 found = NULL;
12557
12558 break;
12559 }
12560 }
12561 }
12562 }
12563 }
12564 else
12565 {
12566 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12567
12568 if (parser_status == PARSER_OK)
12569 {
12570 if (isSalted)
12571 {
12572 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12573 }
12574 else
12575 {
12576 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12577 }
12578 }
12579 }
12580
12581 if (found == NULL) continue;
12582
12583 if (!found->cracked) potfile_remove_cracks++;
12584
12585 found->cracked = 1;
12586
12587 if (found) break;
12588
12589 iter--;
12590 }
12591 }
12592
12593 myfree (line_buf_cpy);
12594
12595 myfree (line_buf);
12596
12597 fclose (fp);
12598 }
12599 }
12600
12601 if (esalt_size)
12602 {
12603 local_free (hash_buf.esalt);
12604 }
12605
12606 if (isSalted)
12607 {
12608 local_free (hash_buf.salt);
12609 }
12610
12611 local_free (hash_buf.digest);
12612 }
12613
12614 /**
12615 * Now generate all the buffers required for later
12616 */
12617
12618 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12619
12620 salt_t *salts_buf_new = NULL;
12621 void *esalts_buf_new = NULL;
12622
12623 if (isSalted)
12624 {
12625 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12626
12627 if (esalt_size)
12628 {
12629 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12630 }
12631 }
12632 else
12633 {
12634 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12635 }
12636
12637 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12638
12639 uint digests_cnt = hashes_cnt;
12640 uint digests_done = 0;
12641
12642 size_t size_digests = digests_cnt * dgst_size;
12643 size_t size_shown = digests_cnt * sizeof (uint);
12644
12645 uint *digests_shown = (uint *) mymalloc (size_shown);
12646 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12647
12648 uint salts_cnt = 0;
12649 uint salts_done = 0;
12650
12651 hashinfo_t **hash_info = NULL;
12652
12653 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12654 {
12655 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12656
12657 if (username && (remove || show))
12658 {
12659 uint user_pos;
12660
12661 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12662 {
12663 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12664
12665 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12666 }
12667 }
12668 }
12669
12670 uint *salts_shown = (uint *) mymalloc (size_shown);
12671
12672 salt_t *salt_buf;
12673
12674 {
12675 // copied from inner loop
12676
12677 salt_buf = &salts_buf_new[salts_cnt];
12678
12679 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12680
12681 if (esalt_size)
12682 {
12683 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12684 }
12685
12686 salt_buf->digests_cnt = 0;
12687 salt_buf->digests_done = 0;
12688 salt_buf->digests_offset = 0;
12689
12690 salts_cnt++;
12691 }
12692
12693 if (hashes_buf[0].cracked == 1)
12694 {
12695 digests_shown[0] = 1;
12696
12697 digests_done++;
12698
12699 salt_buf->digests_done++;
12700 }
12701
12702 salt_buf->digests_cnt++;
12703
12704 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12705
12706 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12707 {
12708 hash_info[0] = hashes_buf[0].hash_info;
12709 }
12710
12711 // copy from inner loop
12712
12713 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12714 {
12715 if (isSalted)
12716 {
12717 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12718 {
12719 salt_buf = &salts_buf_new[salts_cnt];
12720
12721 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12722
12723 if (esalt_size)
12724 {
12725 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12726 }
12727
12728 salt_buf->digests_cnt = 0;
12729 salt_buf->digests_done = 0;
12730 salt_buf->digests_offset = hashes_pos;
12731
12732 salts_cnt++;
12733 }
12734 }
12735
12736 if (hashes_buf[hashes_pos].cracked == 1)
12737 {
12738 digests_shown[hashes_pos] = 1;
12739
12740 digests_done++;
12741
12742 salt_buf->digests_done++;
12743 }
12744
12745 salt_buf->digests_cnt++;
12746
12747 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12748
12749 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12750 {
12751 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12752 }
12753 }
12754
12755 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12756 {
12757 salt_t *salt_buf = &salts_buf_new[salt_pos];
12758
12759 if (salt_buf->digests_done == salt_buf->digests_cnt)
12760 {
12761 salts_shown[salt_pos] = 1;
12762
12763 salts_done++;
12764 }
12765
12766 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12767 }
12768
12769 local_free (digests_buf);
12770 local_free (salts_buf);
12771 local_free (esalts_buf);
12772
12773 digests_buf = digests_buf_new;
12774 salts_buf = salts_buf_new;
12775 esalts_buf = esalts_buf_new;
12776
12777 local_free (hashes_buf);
12778
12779 /**
12780 * special modification not set from parser
12781 */
12782
12783 switch (hash_mode)
12784 {
12785 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12786 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12787 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12788 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12789 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12790 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12791 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12792 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12793 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12794 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12795 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12796 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12797 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12798 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12799 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12800 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12801 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12802 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12803 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12804 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12805 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12806 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12807 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12808 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12809 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12810 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12811 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12812 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12813 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12814 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12815 }
12816
12817 if (truecrypt_keyfiles)
12818 {
12819 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12820
12821 char *keyfiles = strdup (truecrypt_keyfiles);
12822
12823 char *keyfile = strtok (keyfiles, ",");
12824
12825 do
12826 {
12827 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12828
12829 } while ((keyfile = strtok (NULL, ",")) != NULL);
12830
12831 free (keyfiles);
12832 }
12833
12834 if (veracrypt_keyfiles)
12835 {
12836 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12837
12838 char *keyfiles = strdup (veracrypt_keyfiles);
12839
12840 char *keyfile = strtok (keyfiles, ",");
12841
12842 do
12843 {
12844 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12845
12846 } while ((keyfile = strtok (NULL, ",")) != NULL);
12847
12848 free (keyfiles);
12849 }
12850
12851 data.digests_cnt = digests_cnt;
12852 data.digests_done = digests_done;
12853 data.digests_buf = digests_buf;
12854 data.digests_shown = digests_shown;
12855 data.digests_shown_tmp = digests_shown_tmp;
12856
12857 data.salts_cnt = salts_cnt;
12858 data.salts_done = salts_done;
12859 data.salts_buf = salts_buf;
12860 data.salts_shown = salts_shown;
12861
12862 data.esalts_buf = esalts_buf;
12863 data.hash_info = hash_info;
12864
12865 /**
12866 * Automatic Optimizers
12867 */
12868
12869 if (salts_cnt == 1)
12870 opti_type |= OPTI_TYPE_SINGLE_SALT;
12871
12872 if (digests_cnt == 1)
12873 opti_type |= OPTI_TYPE_SINGLE_HASH;
12874
12875 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12876 opti_type |= OPTI_TYPE_NOT_ITERATED;
12877
12878 if (attack_mode == ATTACK_MODE_BF)
12879 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12880
12881 data.opti_type = opti_type;
12882
12883 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12884 {
12885 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12886 {
12887 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12888 {
12889 if (opts_type & OPTS_TYPE_ST_ADD80)
12890 {
12891 opts_type &= ~OPTS_TYPE_ST_ADD80;
12892 opts_type |= OPTS_TYPE_PT_ADD80;
12893 }
12894
12895 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12896 {
12897 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12898 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12899 }
12900
12901 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12902 {
12903 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12904 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12905 }
12906 }
12907 }
12908 }
12909
12910 /**
12911 * Some algorithm, like descrypt, can benefit from JIT compilation
12912 */
12913
12914 int force_jit_compilation = -1;
12915
12916 if (hash_mode == 8900)
12917 {
12918 force_jit_compilation = 8900;
12919 }
12920 else if (hash_mode == 9300)
12921 {
12922 force_jit_compilation = 8900;
12923 }
12924 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12925 {
12926 force_jit_compilation = 1500;
12927 }
12928
12929 /**
12930 * generate bitmap tables
12931 */
12932
12933 const uint bitmap_shift1 = 5;
12934 const uint bitmap_shift2 = 13;
12935
12936 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12937
12938 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12939 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12940 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12941 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12942 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12943 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12944 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12945 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12946
12947 uint bitmap_bits;
12948 uint bitmap_nums;
12949 uint bitmap_mask;
12950 uint bitmap_size;
12951
12952 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12953 {
12954 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12955
12956 bitmap_nums = 1 << bitmap_bits;
12957
12958 bitmap_mask = bitmap_nums - 1;
12959
12960 bitmap_size = bitmap_nums * sizeof (uint);
12961
12962 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12963
12964 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;
12965 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;
12966
12967 break;
12968 }
12969
12970 bitmap_nums = 1 << bitmap_bits;
12971
12972 bitmap_mask = bitmap_nums - 1;
12973
12974 bitmap_size = bitmap_nums * sizeof (uint);
12975
12976 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);
12977 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);
12978
12979 /**
12980 * prepare quick rule
12981 */
12982
12983 data.rule_buf_l = rule_buf_l;
12984 data.rule_buf_r = rule_buf_r;
12985
12986 int rule_len_l = (int) strlen (rule_buf_l);
12987 int rule_len_r = (int) strlen (rule_buf_r);
12988
12989 data.rule_len_l = rule_len_l;
12990 data.rule_len_r = rule_len_r;
12991
12992 /**
12993 * load rules
12994 */
12995
12996 uint *all_kernel_rules_cnt = NULL;
12997
12998 kernel_rule_t **all_kernel_rules_buf = NULL;
12999
13000 if (rp_files_cnt)
13001 {
13002 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13003
13004 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13005 }
13006
13007 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13008
13009 int rule_len = 0;
13010
13011 for (uint i = 0; i < rp_files_cnt; i++)
13012 {
13013 uint kernel_rules_avail = 0;
13014
13015 uint kernel_rules_cnt = 0;
13016
13017 kernel_rule_t *kernel_rules_buf = NULL;
13018
13019 char *rp_file = rp_files[i];
13020
13021 char in[BLOCK_SIZE] = { 0 };
13022 char out[BLOCK_SIZE] = { 0 };
13023
13024 FILE *fp = NULL;
13025
13026 uint rule_line = 0;
13027
13028 if ((fp = fopen (rp_file, "rb")) == NULL)
13029 {
13030 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13031
13032 return (-1);
13033 }
13034
13035 while (!feof (fp))
13036 {
13037 memset (rule_buf, 0, HCBUFSIZ);
13038
13039 rule_len = fgetl (fp, rule_buf);
13040
13041 rule_line++;
13042
13043 if (rule_len == 0) continue;
13044
13045 if (rule_buf[0] == '#') continue;
13046
13047 if (kernel_rules_avail == kernel_rules_cnt)
13048 {
13049 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13050
13051 kernel_rules_avail += INCR_RULES;
13052 }
13053
13054 memset (in, 0, BLOCK_SIZE);
13055 memset (out, 0, BLOCK_SIZE);
13056
13057 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13058
13059 if (result == -1)
13060 {
13061 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13062
13063 continue;
13064 }
13065
13066 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13067 {
13068 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13069
13070 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13071
13072 continue;
13073 }
13074
13075 /* its so slow
13076 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13077 {
13078 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13079
13080 continue;
13081 }
13082 */
13083
13084 kernel_rules_cnt++;
13085 }
13086
13087 fclose (fp);
13088
13089 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13090
13091 all_kernel_rules_buf[i] = kernel_rules_buf;
13092 }
13093
13094 /**
13095 * merge rules or automatic rule generator
13096 */
13097
13098 uint kernel_rules_cnt = 0;
13099
13100 kernel_rule_t *kernel_rules_buf = NULL;
13101
13102 if (attack_mode == ATTACK_MODE_STRAIGHT)
13103 {
13104 if (rp_files_cnt)
13105 {
13106 kernel_rules_cnt = 1;
13107
13108 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13109
13110 repeats[0] = kernel_rules_cnt;
13111
13112 for (uint i = 0; i < rp_files_cnt; i++)
13113 {
13114 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13115
13116 repeats[i + 1] = kernel_rules_cnt;
13117 }
13118
13119 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13120
13121 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13122
13123 for (uint i = 0; i < kernel_rules_cnt; i++)
13124 {
13125 uint out_pos = 0;
13126
13127 kernel_rule_t *out = &kernel_rules_buf[i];
13128
13129 for (uint j = 0; j < rp_files_cnt; j++)
13130 {
13131 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13132 uint in_pos;
13133
13134 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13135
13136 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13137 {
13138 if (out_pos == RULES_MAX - 1)
13139 {
13140 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13141
13142 break;
13143 }
13144
13145 out->cmds[out_pos] = in->cmds[in_pos];
13146 }
13147 }
13148 }
13149
13150 local_free (repeats);
13151 }
13152 else if (rp_gen)
13153 {
13154 uint kernel_rules_avail = 0;
13155
13156 while (kernel_rules_cnt < rp_gen)
13157 {
13158 if (kernel_rules_avail == kernel_rules_cnt)
13159 {
13160 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13161
13162 kernel_rules_avail += INCR_RULES;
13163 }
13164
13165 memset (rule_buf, 0, HCBUFSIZ);
13166
13167 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13168
13169 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13170
13171 kernel_rules_cnt++;
13172 }
13173 }
13174 }
13175
13176 myfree (rule_buf);
13177
13178 /**
13179 * generate NOP rules
13180 */
13181
13182 if (kernel_rules_cnt == 0)
13183 {
13184 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13185
13186 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13187
13188 kernel_rules_cnt++;
13189 }
13190
13191 data.kernel_rules_cnt = kernel_rules_cnt;
13192 data.kernel_rules_buf = kernel_rules_buf;
13193
13194 /**
13195 * OpenCL platforms: detect
13196 */
13197
13198 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13199 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13200
13201 cl_uint platforms_cnt = 0;
13202 cl_uint platform_devices_cnt = 0;
13203
13204 if (keyspace == 0)
13205 {
13206 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13207
13208 if (platforms_cnt == 0)
13209 {
13210 log_info ("");
13211 log_info ("ATTENTION! No OpenCL compatible platform found");
13212 log_info ("");
13213 log_info ("You're probably missing the OpenCL runtime installation");
13214 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13215 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13216 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13217 log_info ("");
13218
13219 return (-1);
13220 }
13221
13222 if (opencl_platforms_filter != (uint) -1)
13223 {
13224 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13225
13226 if (opencl_platforms_filter > platform_cnt_mask)
13227 {
13228 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13229
13230 return (-1);
13231 }
13232 }
13233 }
13234
13235 /**
13236 * OpenCL device types:
13237 * 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.
13238 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13239 */
13240
13241 if (opencl_device_types == NULL)
13242 {
13243 cl_device_type device_types_all = 0;
13244
13245 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13246 {
13247 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13248
13249 cl_platform_id platform = platforms[platform_id];
13250
13251 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13252
13253 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13254 {
13255 cl_device_id device = platform_devices[platform_devices_id];
13256
13257 cl_device_type device_type;
13258
13259 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13260
13261 device_types_all |= device_type;
13262 }
13263 }
13264
13265 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13266 {
13267 device_types_filter |= CL_DEVICE_TYPE_CPU;
13268 }
13269 }
13270
13271 /**
13272 * OpenCL devices: simply push all devices from all platforms into the same device array
13273 */
13274
13275 int need_adl = 0;
13276 int need_nvapi = 0;
13277 int need_nvml = 0;
13278
13279 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13280
13281 data.devices_param = devices_param;
13282
13283 uint devices_cnt = 0;
13284
13285 uint devices_active = 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 char platform_vendor[INFOSZ] = { 0 };
13296
13297 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13298
13299 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13300 // this causes trouble with vendor id based macros
13301 // we'll assign generic to those without special optimization available
13302
13303 cl_uint platform_vendor_id = 0;
13304
13305 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13306 {
13307 platform_vendor_id = VENDOR_ID_AMD;
13308 }
13309 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13310 {
13311 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13312 }
13313 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13314 {
13315 platform_vendor_id = VENDOR_ID_APPLE;
13316 }
13317 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13318 {
13319 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13320 }
13321 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13322 {
13323 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13324 }
13325 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13326 {
13327 platform_vendor_id = VENDOR_ID_MESA;
13328 }
13329 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13330 {
13331 platform_vendor_id = VENDOR_ID_NV;
13332 }
13333 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13334 {
13335 platform_vendor_id = VENDOR_ID_POCL;
13336 }
13337 else
13338 {
13339 platform_vendor_id = VENDOR_ID_GENERIC;
13340 }
13341
13342 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13343 {
13344 size_t param_value_size = 0;
13345
13346 const uint device_id = devices_cnt;
13347
13348 hc_device_param_t *device_param = &data.devices_param[device_id];
13349
13350 device_param->platform_vendor_id = platform_vendor_id;
13351
13352 device_param->device = platform_devices[platform_devices_id];
13353
13354 device_param->device_id = device_id;
13355
13356 device_param->platform_devices_id = platform_devices_id;
13357
13358 // device_type
13359
13360 cl_device_type device_type;
13361
13362 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13363
13364 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13365
13366 device_param->device_type = device_type;
13367
13368 // device_name
13369
13370 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13371
13372 char *device_name = (char *) mymalloc (param_value_size);
13373
13374 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13375
13376 device_param->device_name = device_name;
13377
13378 // device_vendor
13379
13380 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13381
13382 char *device_vendor = (char *) mymalloc (param_value_size);
13383
13384 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13385
13386 device_param->device_vendor = device_vendor;
13387
13388 cl_uint device_vendor_id = 0;
13389
13390 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13391 {
13392 device_vendor_id = VENDOR_ID_AMD;
13393 }
13394 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13395 {
13396 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13397 }
13398 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13399 {
13400 device_vendor_id = VENDOR_ID_APPLE;
13401 }
13402 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13403 {
13404 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13405 }
13406 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13407 {
13408 device_vendor_id = VENDOR_ID_INTEL_SDK;
13409 }
13410 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13411 {
13412 device_vendor_id = VENDOR_ID_MESA;
13413 }
13414 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13415 {
13416 device_vendor_id = VENDOR_ID_NV;
13417 }
13418 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13419 {
13420 device_vendor_id = VENDOR_ID_POCL;
13421 }
13422 else
13423 {
13424 device_vendor_id = VENDOR_ID_GENERIC;
13425 }
13426
13427 device_param->device_vendor_id = device_vendor_id;
13428
13429 // tuning db
13430
13431 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13432
13433 // device_version
13434
13435 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13436
13437 char *device_version = (char *) mymalloc (param_value_size);
13438
13439 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13440
13441 device_param->device_version = device_version;
13442
13443 // device_opencl_version
13444
13445 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13446
13447 char *device_opencl_version = (char *) mymalloc (param_value_size);
13448
13449 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13450
13451 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13452
13453 myfree (device_opencl_version);
13454
13455 // vector_width
13456
13457 cl_uint vector_width;
13458
13459 if (opencl_vector_width_chgd == 0)
13460 {
13461 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13462 {
13463 if (opti_type & OPTI_TYPE_USES_BITS_64)
13464 {
13465 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13466 }
13467 else
13468 {
13469 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13470 }
13471 }
13472 else
13473 {
13474 vector_width = (cl_uint) tuningdb_entry->vector_width;
13475 }
13476 }
13477 else
13478 {
13479 vector_width = opencl_vector_width;
13480 }
13481
13482 if (vector_width > 16) vector_width = 16;
13483
13484 device_param->vector_width = vector_width;
13485
13486 // max_compute_units
13487
13488 cl_uint device_processors;
13489
13490 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13491
13492 device_param->device_processors = device_processors;
13493
13494 // device_maxmem_alloc
13495 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13496
13497 cl_ulong device_maxmem_alloc;
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13500
13501 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13502
13503 // device_global_mem
13504
13505 cl_ulong device_global_mem;
13506
13507 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13508
13509 device_param->device_global_mem = device_global_mem;
13510
13511 // max_work_group_size
13512
13513 size_t device_maxworkgroup_size;
13514
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13516
13517 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13518
13519 // max_clock_frequency
13520
13521 cl_uint device_maxclock_frequency;
13522
13523 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13524
13525 device_param->device_maxclock_frequency = device_maxclock_frequency;
13526
13527 // device_endian_little
13528
13529 cl_bool device_endian_little;
13530
13531 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13532
13533 if (device_endian_little == CL_FALSE)
13534 {
13535 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13536
13537 device_param->skipped = 1;
13538 }
13539
13540 // device_available
13541
13542 cl_bool device_available;
13543
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13545
13546 if (device_available == CL_FALSE)
13547 {
13548 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13549
13550 device_param->skipped = 1;
13551 }
13552
13553 // device_compiler_available
13554
13555 cl_bool device_compiler_available;
13556
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13558
13559 if (device_compiler_available == CL_FALSE)
13560 {
13561 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13562
13563 device_param->skipped = 1;
13564 }
13565
13566 // device_execution_capabilities
13567
13568 cl_device_exec_capabilities device_execution_capabilities;
13569
13570 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13571
13572 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13573 {
13574 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13575
13576 device_param->skipped = 1;
13577 }
13578
13579 // device_extensions
13580
13581 size_t device_extensions_size;
13582
13583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13584
13585 char *device_extensions = mymalloc (device_extensions_size + 1);
13586
13587 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13588
13589 if (strstr (device_extensions, "base_atomics") == 0)
13590 {
13591 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13592
13593 device_param->skipped = 1;
13594 }
13595
13596 if (strstr (device_extensions, "byte_addressable_store") == 0)
13597 {
13598 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13599
13600 device_param->skipped = 1;
13601 }
13602
13603 myfree (device_extensions);
13604
13605 // device_local_mem_size
13606
13607 cl_ulong device_local_mem_size;
13608
13609 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13610
13611 if (device_local_mem_size < 32768)
13612 {
13613 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13614
13615 device_param->skipped = 1;
13616 }
13617
13618 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13619 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13620 // This results in both utilizing it for 50%
13621 // However, Intel has much better SIMD control over their own hardware
13622 // It makes sense to give them full control over their own hardware
13623
13624 if (device_type & CL_DEVICE_TYPE_CPU)
13625 {
13626 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13627 {
13628 if (data.force == 0)
13629 {
13630 if (algorithm_pos == 0)
13631 {
13632 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13633 log_info (" You can use --force to override this but do not post error reports if you do so");
13634 }
13635
13636 device_param->skipped = 1;
13637 }
13638 }
13639 }
13640
13641 // skipped
13642
13643 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13644 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13645
13646 // driver_version
13647
13648 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13649
13650 char *driver_version = (char *) mymalloc (param_value_size);
13651
13652 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13653
13654 device_param->driver_version = driver_version;
13655
13656 // device_name_chksum
13657
13658 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13659
13660 #if __x86_64__
13661 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);
13662 #else
13663 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);
13664 #endif
13665
13666 uint device_name_digest[4] = { 0 };
13667
13668 md5_64 ((uint *) device_name_chksum, device_name_digest);
13669
13670 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13671
13672 device_param->device_name_chksum = device_name_chksum;
13673
13674 // device_processor_cores
13675
13676 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13677 {
13678 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13679 {
13680 need_adl = 1;
13681 }
13682
13683 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13684 {
13685 need_nvml = 1;
13686
13687 #ifdef _WIN
13688 need_nvapi = 1;
13689 #endif
13690 }
13691 }
13692
13693 // device_processor_cores
13694
13695 if (device_type & CL_DEVICE_TYPE_CPU)
13696 {
13697 cl_uint device_processor_cores = 1;
13698
13699 device_param->device_processor_cores = device_processor_cores;
13700 }
13701
13702 if (device_type & CL_DEVICE_TYPE_GPU)
13703 {
13704 if (device_vendor_id == VENDOR_ID_AMD)
13705 {
13706 cl_uint device_processor_cores = 0;
13707
13708 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13709
13710 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13711
13712 device_param->device_processor_cores = device_processor_cores;
13713 }
13714 else if (device_vendor_id == VENDOR_ID_NV)
13715 {
13716 cl_uint kernel_exec_timeout = 0;
13717
13718 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13719
13720 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13721
13722 device_param->kernel_exec_timeout = kernel_exec_timeout;
13723
13724 cl_uint device_processor_cores = 0;
13725
13726 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13727
13728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13729
13730 device_param->device_processor_cores = device_processor_cores;
13731
13732 cl_uint sm_minor = 0;
13733 cl_uint sm_major = 0;
13734
13735 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13736 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13737
13738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13740
13741 device_param->sm_minor = sm_minor;
13742 device_param->sm_major = sm_major;
13743 }
13744 else
13745 {
13746 cl_uint device_processor_cores = 1;
13747
13748 device_param->device_processor_cores = device_processor_cores;
13749 }
13750 }
13751
13752 // display results
13753
13754 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13755 {
13756 if (machine_readable == 0)
13757 {
13758 if (device_param->skipped == 0)
13759 {
13760 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13761 device_id + 1,
13762 device_name,
13763 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13764 (unsigned int) (device_global_mem / 1024 / 1024),
13765 (unsigned int) device_processors);
13766 }
13767 else
13768 {
13769 log_info ("Device #%u: %s, skipped",
13770 device_id + 1,
13771 device_name);
13772 }
13773 }
13774 }
13775
13776 // common driver check
13777
13778 if (device_param->skipped == 0)
13779 {
13780 if (device_type & CL_DEVICE_TYPE_GPU)
13781 {
13782 if (platform_vendor_id == VENDOR_ID_AMD)
13783 {
13784 int catalyst_check = (force == 1) ? 0 : 1;
13785
13786 int catalyst_warn = 0;
13787
13788 int catalyst_broken = 0;
13789
13790 if (catalyst_check == 1)
13791 {
13792 catalyst_warn = 1;
13793
13794 // v14.9 and higher
13795 if (atoi (device_param->driver_version) >= 1573)
13796 {
13797 catalyst_warn = 0;
13798 }
13799
13800 catalyst_check = 0;
13801 }
13802
13803 if (catalyst_broken == 1)
13804 {
13805 log_info ("");
13806 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13807 log_info ("It will pass over cracked hashes and does not report them as cracked");
13808 log_info ("You are STRONGLY encouraged not to use it");
13809 log_info ("You can use --force to override this but do not post error reports if you do so");
13810 log_info ("");
13811
13812 return (-1);
13813 }
13814
13815 if (catalyst_warn == 1)
13816 {
13817 log_info ("");
13818 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13819 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13820 log_info ("See hashcat's homepage for official supported catalyst drivers");
13821 #ifdef _WIN
13822 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13823 #endif
13824 log_info ("You can use --force to override this but do not post error reports if you do so");
13825 log_info ("");
13826
13827 return (-1);
13828 }
13829 }
13830 else if (platform_vendor_id == VENDOR_ID_NV)
13831 {
13832 if (device_param->kernel_exec_timeout != 0)
13833 {
13834 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);
13835 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13836 }
13837 }
13838 }
13839
13840 /* turns out pocl still creates segfaults (because of llvm)
13841 if (device_type & CL_DEVICE_TYPE_CPU)
13842 {
13843 if (platform_vendor_id == VENDOR_ID_AMD)
13844 {
13845 if (force == 0)
13846 {
13847 log_info ("");
13848 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13849 log_info ("You are STRONGLY encouraged not to use it");
13850 log_info ("You can use --force to override this but do not post error reports if you do so");
13851 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13852 log_info ("");
13853
13854 return (-1);
13855 }
13856 }
13857 }
13858 */
13859
13860 /**
13861 * kernel accel and loops tuning db adjustment
13862 */
13863
13864 device_param->kernel_accel_min = 1;
13865 device_param->kernel_accel_max = 1024;
13866
13867 device_param->kernel_loops_min = 1;
13868 device_param->kernel_loops_max = 1024;
13869
13870 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13871
13872 if (tuningdb_entry)
13873 {
13874 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13875 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13876
13877 if (_kernel_accel)
13878 {
13879 device_param->kernel_accel_min = _kernel_accel;
13880 device_param->kernel_accel_max = _kernel_accel;
13881 }
13882
13883 if (_kernel_loops)
13884 {
13885 if (workload_profile == 1)
13886 {
13887 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13888 }
13889 else if (workload_profile == 2)
13890 {
13891 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13892 }
13893
13894 device_param->kernel_loops_min = _kernel_loops;
13895 device_param->kernel_loops_max = _kernel_loops;
13896 }
13897 }
13898
13899 // commandline parameters overwrite tuningdb entries
13900
13901 if (kernel_accel)
13902 {
13903 device_param->kernel_accel_min = kernel_accel;
13904 device_param->kernel_accel_max = kernel_accel;
13905 }
13906
13907 if (kernel_loops)
13908 {
13909 device_param->kernel_loops_min = kernel_loops;
13910 device_param->kernel_loops_max = kernel_loops;
13911 }
13912
13913 /**
13914 * activate device
13915 */
13916
13917 devices_active++;
13918 }
13919
13920 // next please
13921
13922 devices_cnt++;
13923 }
13924 }
13925
13926 if (keyspace == 0 && devices_active == 0)
13927 {
13928 log_error ("ERROR: No devices found/left");
13929
13930 return (-1);
13931 }
13932
13933 // 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)
13934
13935 if (devices_filter != (uint) -1)
13936 {
13937 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13938
13939 if (devices_filter > devices_cnt_mask)
13940 {
13941 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13942
13943 return (-1);
13944 }
13945 }
13946
13947 data.devices_cnt = devices_cnt;
13948
13949 data.devices_active = devices_active;
13950
13951 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13952 {
13953 if (machine_readable == 0)
13954 {
13955 log_info ("");
13956 }
13957 }
13958
13959 /**
13960 * HM devices: init
13961 */
13962
13963 #ifdef HAVE_HWMON
13964 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
13965 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
13966 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
13967
13968 if (gpu_temp_disable == 0)
13969 {
13970 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13971 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13972 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13973
13974 data.hm_adl = NULL;
13975 data.hm_nvapi = NULL;
13976 data.hm_nvml = NULL;
13977
13978 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
13979 {
13980 data.hm_nvml = nvml;
13981 }
13982
13983 if (data.hm_nvml)
13984 {
13985 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
13986 {
13987 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
13988
13989 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
13990
13991 int tmp_out = 0;
13992
13993 for (int i = 0; i < tmp_in; i++)
13994 {
13995 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
13996 }
13997
13998 for (int i = 0; i < tmp_out; i++)
13999 {
14000 unsigned int speed;
14001
14002 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14003
14004 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14005
14006 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14007 }
14008 }
14009 }
14010
14011 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14012 {
14013 data.hm_nvapi = nvapi;
14014 }
14015
14016 if (data.hm_nvapi)
14017 {
14018 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14019 {
14020 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14021
14022 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14023
14024 int tmp_out = 0;
14025
14026 for (int i = 0; i < tmp_in; i++)
14027 {
14028 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14029 }
14030 }
14031 }
14032
14033 if ((need_adl == 1) && (adl_init (adl) == 0))
14034 {
14035 data.hm_adl = adl;
14036 }
14037
14038 if (data.hm_adl)
14039 {
14040 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14041 {
14042 // total number of adapters
14043
14044 int hm_adapters_num;
14045
14046 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14047
14048 // adapter info
14049
14050 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14051
14052 if (lpAdapterInfo == NULL) return (-1);
14053
14054 // get a list (of ids of) valid/usable adapters
14055
14056 int num_adl_adapters = 0;
14057
14058 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14059
14060 if (num_adl_adapters > 0)
14061 {
14062 hc_thread_mutex_lock (mux_adl);
14063
14064 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14065
14066 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14067
14068 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14069 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14070
14071 hc_thread_mutex_unlock (mux_adl);
14072 }
14073
14074 myfree (valid_adl_device_list);
14075 myfree (lpAdapterInfo);
14076 }
14077 }
14078
14079 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14080 {
14081 gpu_temp_disable = 1;
14082 }
14083 }
14084
14085 /**
14086 * OpenCL devices: allocate buffer for device specific information
14087 */
14088
14089 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14090 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14091
14092 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14093
14094 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14095
14096 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14097
14098 /**
14099 * User-defined GPU temp handling
14100 */
14101
14102 if (gpu_temp_disable == 1)
14103 {
14104 gpu_temp_abort = 0;
14105 gpu_temp_retain = 0;
14106 }
14107
14108 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14109 {
14110 if (gpu_temp_abort < gpu_temp_retain)
14111 {
14112 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14113
14114 return (-1);
14115 }
14116 }
14117
14118 data.gpu_temp_disable = gpu_temp_disable;
14119 data.gpu_temp_abort = gpu_temp_abort;
14120 data.gpu_temp_retain = gpu_temp_retain;
14121 #endif
14122
14123 /**
14124 * enable custom signal handler(s)
14125 */
14126
14127 if (benchmark == 0)
14128 {
14129 hc_signal (sigHandler_default);
14130 }
14131 else
14132 {
14133 hc_signal (sigHandler_benchmark);
14134 }
14135
14136 /**
14137 * inform the user
14138 */
14139
14140 if (data.quiet == 0)
14141 {
14142 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14143
14144 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);
14145
14146 if (attack_mode == ATTACK_MODE_STRAIGHT)
14147 {
14148 log_info ("Rules: %u", kernel_rules_cnt);
14149 }
14150
14151 if (opti_type)
14152 {
14153 log_info ("Applicable Optimizers:");
14154
14155 for (uint i = 0; i < 32; i++)
14156 {
14157 const uint opti_bit = 1u << i;
14158
14159 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14160 }
14161 }
14162
14163 /**
14164 * Watchdog and Temperature balance
14165 */
14166
14167 #ifdef HAVE_HWMON
14168 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14169 {
14170 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14171 }
14172
14173 if (gpu_temp_abort == 0)
14174 {
14175 log_info ("Watchdog: Temperature abort trigger disabled");
14176 }
14177 else
14178 {
14179 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14180 }
14181
14182 if (gpu_temp_retain == 0)
14183 {
14184 log_info ("Watchdog: Temperature retain trigger disabled");
14185 }
14186 else
14187 {
14188 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14189 }
14190
14191 if (data.quiet == 0) log_info ("");
14192 #endif
14193 }
14194
14195 #ifdef HAVE_HWMON
14196
14197 /**
14198 * HM devices: copy
14199 */
14200
14201 if (gpu_temp_disable == 0)
14202 {
14203 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14204 {
14205 hc_device_param_t *device_param = &data.devices_param[device_id];
14206
14207 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14208
14209 if (device_param->skipped) continue;
14210
14211 const uint platform_devices_id = device_param->platform_devices_id;
14212
14213 if (device_param->device_vendor_id == VENDOR_ID_NV)
14214 {
14215 memcpy (&data.hm_device[device_id], &hm_adapters_nvml[platform_devices_id], sizeof (hm_attrs_t));
14216 }
14217
14218 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14219 {
14220 memcpy (&data.hm_device[device_id], &hm_adapters_adl[platform_devices_id], sizeof (hm_attrs_t));
14221 }
14222 }
14223 }
14224
14225 /**
14226 * powertune on user request
14227 */
14228
14229 if (powertune_enable == 1)
14230 {
14231 hc_thread_mutex_lock (mux_adl);
14232
14233 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14234 {
14235 hc_device_param_t *device_param = &data.devices_param[device_id];
14236
14237 if (device_param->skipped) continue;
14238
14239 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14240 {
14241 /**
14242 * Temporary fix:
14243 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14244 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14245 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14246 * Driver / ADL bug?
14247 */
14248
14249 if (data.hm_device[device_id].od_version == 6)
14250 {
14251 int ADL_rc;
14252
14253 // check powertune capabilities first, if not available then skip device
14254
14255 int powertune_supported = 0;
14256
14257 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14258 {
14259 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14260
14261 return (-1);
14262 }
14263
14264 // first backup current value, we will restore it later
14265
14266 if (powertune_supported != 0)
14267 {
14268 // powercontrol settings
14269
14270 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14271
14272 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14273 {
14274 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14275 }
14276
14277 if (ADL_rc != ADL_OK)
14278 {
14279 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14280
14281 return (-1);
14282 }
14283
14284 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14285 {
14286 log_error ("ERROR: Failed to set new ADL PowerControl values");
14287
14288 return (-1);
14289 }
14290
14291 // clocks
14292
14293 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14294
14295 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14296
14297 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14298 {
14299 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14300
14301 return (-1);
14302 }
14303
14304 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14305
14306 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14307
14308 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14309 {
14310 log_error ("ERROR: Failed to get ADL device capabilities");
14311
14312 return (-1);
14313 }
14314
14315 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14316 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14317
14318 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14319 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14320
14321 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14322 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14323
14324 // warning if profile has too low max values
14325
14326 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14327 {
14328 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14329 }
14330
14331 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14332 {
14333 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14334 }
14335
14336 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14337
14338 performance_state->iNumberOfPerformanceLevels = 2;
14339
14340 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14341 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14342 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14343 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14344
14345 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14346 {
14347 log_info ("ERROR: Failed to set ADL performance state");
14348
14349 return (-1);
14350 }
14351
14352 local_free (performance_state);
14353 }
14354
14355 // set powertune value only
14356
14357 if (powertune_supported != 0)
14358 {
14359 // powertune set
14360 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14361
14362 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14363 {
14364 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14365
14366 return (-1);
14367 }
14368
14369 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14370 {
14371 log_error ("ERROR: Failed to set new ADL PowerControl values");
14372
14373 return (-1);
14374 }
14375 }
14376 }
14377 }
14378
14379 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14380 {
14381 // first backup current value, we will restore it later
14382
14383 unsigned int limit;
14384
14385 int powertune_supported = 0;
14386
14387 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14388 {
14389 powertune_supported = 1;
14390 }
14391
14392 // if backup worked, activate the maximum allowed
14393
14394 if (powertune_supported != 0)
14395 {
14396 unsigned int minLimit;
14397 unsigned int maxLimit;
14398
14399 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14400 {
14401 if (maxLimit > 0)
14402 {
14403 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14404 {
14405 // now we can be sure we need to reset later
14406
14407 nvml_power_limit[device_id] = limit;
14408 }
14409 }
14410 }
14411 }
14412 }
14413 }
14414
14415 hc_thread_mutex_unlock (mux_adl);
14416 }
14417
14418 #endif // HAVE_HWMON
14419
14420 #ifdef DEBUG
14421 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14422 #endif
14423
14424 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14425
14426 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14427 {
14428 /**
14429 * host buffer
14430 */
14431
14432 hc_device_param_t *device_param = &data.devices_param[device_id];
14433
14434 if (device_param->skipped) continue;
14435
14436 /**
14437 * device properties
14438 */
14439
14440 const char *device_name_chksum = device_param->device_name_chksum;
14441 const u32 device_processors = device_param->device_processors;
14442 const u32 device_processor_cores = device_param->device_processor_cores;
14443
14444 /**
14445 * create context for each device
14446 */
14447
14448 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14449
14450 /**
14451 * create command-queue
14452 */
14453
14454 // not supported with NV
14455 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14456
14457 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14458
14459 /**
14460 * kernel threads: some algorithms need a fixed kernel-threads count
14461 * because of shared memory usage or bitslice
14462 * there needs to be some upper limit, otherwise there's too much overhead
14463 */
14464
14465 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14466
14467 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14468 {
14469 kernel_threads = KERNEL_THREADS_MAX_CPU;
14470 }
14471
14472 if (hash_mode == 1500) kernel_threads = 64; // DES
14473 if (hash_mode == 3000) kernel_threads = 64; // DES
14474 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14475 if (hash_mode == 7500) kernel_threads = 64; // RC4
14476 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14477 if (hash_mode == 9700) kernel_threads = 64; // RC4
14478 if (hash_mode == 9710) kernel_threads = 64; // RC4
14479 if (hash_mode == 9800) kernel_threads = 64; // RC4
14480 if (hash_mode == 9810) kernel_threads = 64; // RC4
14481 if (hash_mode == 10400) kernel_threads = 64; // RC4
14482 if (hash_mode == 10410) kernel_threads = 64; // RC4
14483 if (hash_mode == 10500) kernel_threads = 64; // RC4
14484 if (hash_mode == 13100) kernel_threads = 64; // RC4
14485
14486 device_param->kernel_threads = kernel_threads;
14487
14488 /**
14489 * create input buffers on device : calculate size of fixed memory buffers
14490 */
14491
14492 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14493 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14494
14495 device_param->size_root_css = size_root_css;
14496 device_param->size_markov_css = size_markov_css;
14497
14498 size_t size_results = sizeof (uint);
14499
14500 device_param->size_results = size_results;
14501
14502 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14503 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14504
14505 size_t size_plains = digests_cnt * sizeof (plain_t);
14506 size_t size_salts = salts_cnt * sizeof (salt_t);
14507 size_t size_esalts = salts_cnt * esalt_size;
14508
14509 device_param->size_plains = size_plains;
14510 device_param->size_digests = size_digests;
14511 device_param->size_shown = size_shown;
14512 device_param->size_salts = size_salts;
14513
14514 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14515 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14516 size_t size_tm = 32 * sizeof (bs_word_t);
14517
14518 // scryptV stuff
14519
14520 size_t size_scryptV = 1;
14521
14522 if ((hash_mode == 8900) || (hash_mode == 9300))
14523 {
14524 uint tmto_start = 0;
14525 uint tmto_stop = 10;
14526
14527 if (scrypt_tmto)
14528 {
14529 tmto_start = scrypt_tmto;
14530 }
14531 else
14532 {
14533 // in case the user did not specify the tmto manually
14534 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14535 // but set the lower end only in case the user has a device with too less memory
14536
14537 if (hash_mode == 8900)
14538 {
14539 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14540 {
14541 tmto_start = 1;
14542 }
14543 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14544 {
14545 tmto_start = 2;
14546 }
14547 }
14548 else if (hash_mode == 9300)
14549 {
14550 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14551 {
14552 tmto_start = 2;
14553 }
14554 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14555 {
14556 tmto_start = 2;
14557 }
14558 }
14559 }
14560
14561 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14562 {
14563 // TODO: in theory the following calculation needs to be done per salt, not global
14564 // we assume all hashes have the same scrypt settings
14565
14566 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14567
14568 size_scryptV /= 1 << tmto;
14569
14570 size_scryptV *= device_processors * device_processor_cores;
14571
14572 if (size_scryptV > device_param->device_maxmem_alloc)
14573 {
14574 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14575
14576 continue;
14577 }
14578
14579 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14580 {
14581 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14582 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14583 }
14584
14585 break;
14586 }
14587
14588 if (data.salts_buf[0].scrypt_phy == 0)
14589 {
14590 log_error ("ERROR: can't allocate enough device memory");
14591
14592 return -1;
14593 }
14594
14595 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14596 }
14597
14598 /**
14599 * some algorithms need a fixed kernel-loops count
14600 */
14601
14602 if (hash_mode == 1500)
14603 {
14604 const u32 kernel_loops_fixed = 1024;
14605
14606 device_param->kernel_loops_min = kernel_loops_fixed;
14607 device_param->kernel_loops_max = kernel_loops_fixed;
14608 }
14609
14610 if (hash_mode == 3000)
14611 {
14612 const u32 kernel_loops_fixed = 1024;
14613
14614 device_param->kernel_loops_min = kernel_loops_fixed;
14615 device_param->kernel_loops_max = kernel_loops_fixed;
14616 }
14617
14618 if (hash_mode == 8900)
14619 {
14620 const u32 kernel_loops_fixed = 1;
14621
14622 device_param->kernel_loops_min = kernel_loops_fixed;
14623 device_param->kernel_loops_max = kernel_loops_fixed;
14624 }
14625
14626 if (hash_mode == 9300)
14627 {
14628 const u32 kernel_loops_fixed = 1;
14629
14630 device_param->kernel_loops_min = kernel_loops_fixed;
14631 device_param->kernel_loops_max = kernel_loops_fixed;
14632 }
14633
14634 if (hash_mode == 12500)
14635 {
14636 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14637
14638 device_param->kernel_loops_min = kernel_loops_fixed;
14639 device_param->kernel_loops_max = kernel_loops_fixed;
14640 }
14641
14642 /**
14643 * some algorithms have a maximum kernel-loops count
14644 */
14645
14646 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14647 {
14648 u32 innerloop_cnt = 0;
14649
14650 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14651 {
14652 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14653 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14654 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14655 }
14656 else
14657 {
14658 innerloop_cnt = data.salts_buf[0].salt_iter;
14659 }
14660
14661 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14662 (innerloop_cnt <= device_param->kernel_loops_max))
14663 {
14664 device_param->kernel_loops_max = innerloop_cnt;
14665 }
14666 }
14667
14668 u32 kernel_accel_min = device_param->kernel_accel_min;
14669 u32 kernel_accel_max = device_param->kernel_accel_max;
14670
14671 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14672
14673 size_t size_pws = 4;
14674 size_t size_tmps = 4;
14675 size_t size_hooks = 4;
14676
14677 while (kernel_accel_max >= kernel_accel_min)
14678 {
14679 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14680
14681 // size_pws
14682
14683 size_pws = kernel_power_max * sizeof (pw_t);
14684
14685 // size_tmps
14686
14687 switch (hash_mode)
14688 {
14689 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14690 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14691 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14692 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14693 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14694 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14695 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14696 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14697 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14698 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14699 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14700 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14701 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14702 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14703 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14704 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14705 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14706 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14707 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14708 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14709 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14710 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14711 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14712 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14713 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14714 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14715 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14716 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14717 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14718 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14719 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14720 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14721 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14722 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14723 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14724 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14725 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14726 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14727 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14728 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14729 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14730 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14731 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14732 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14733 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14734 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14735 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14736 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14737 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14738 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14739 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14740 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14741 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14742 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14743 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14744 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14745 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14746 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14747 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14748 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14749 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14750 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14751 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14752 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14753 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14754 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14755 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14756 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14757 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14758 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14759 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14760 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14761 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14762 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14763 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14764 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14765 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14766 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14767 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14768 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14769 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14770 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14771 };
14772
14773 // size_hooks
14774
14775 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14776 {
14777 // none yet
14778 }
14779
14780 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14781 // if not, decrease amplifier and try again
14782
14783 int skip = 0;
14784
14785 const u64 size_total
14786 = bitmap_size
14787 + bitmap_size
14788 + bitmap_size
14789 + bitmap_size
14790 + bitmap_size
14791 + bitmap_size
14792 + bitmap_size
14793 + bitmap_size
14794 + size_bfs
14795 + size_combs
14796 + size_digests
14797 + size_esalts
14798 + size_hooks
14799 + size_markov_css
14800 + size_plains
14801 + size_pws
14802 + size_pws // not a bug
14803 + size_results
14804 + size_root_css
14805 + size_rules
14806 + size_rules_c
14807 + size_salts
14808 + size_scryptV
14809 + size_shown
14810 + size_tm
14811 + size_tmps;
14812
14813 // Don't ask me, ask AMD!
14814
14815 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14816 if (size_total > device_param->device_global_mem) skip = 1;
14817
14818 if (skip == 1)
14819 {
14820 kernel_accel_max--;
14821
14822 continue;
14823 }
14824
14825 break;
14826 }
14827
14828 /*
14829 if (kernel_accel_max == 0)
14830 {
14831 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14832
14833 return -1;
14834 }
14835 */
14836
14837 device_param->kernel_accel_min = kernel_accel_min;
14838 device_param->kernel_accel_max = kernel_accel_max;
14839
14840 /*
14841 if (kernel_accel_max < kernel_accel)
14842 {
14843 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14844
14845 device_param->kernel_accel = kernel_accel_max;
14846 }
14847 */
14848
14849 device_param->size_bfs = size_bfs;
14850 device_param->size_combs = size_combs;
14851 device_param->size_rules = size_rules;
14852 device_param->size_rules_c = size_rules_c;
14853 device_param->size_pws = size_pws;
14854 device_param->size_tmps = size_tmps;
14855 device_param->size_hooks = size_hooks;
14856
14857 /**
14858 * default building options
14859 */
14860
14861 char build_opts[1024] = { 0 };
14862
14863 // we don't have sm_* on vendors not NV but it doesn't matter
14864
14865 #if _WIN
14866 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);
14867 #else
14868 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);
14869 #endif
14870
14871 char build_opts_new[1024] = { 0 };
14872
14873 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);
14874
14875 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14876
14877 /*
14878 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14879 {
14880 // we do vectorizing much better than the auto-vectorizer
14881
14882 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14883
14884 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14885 }
14886 */
14887
14888 #ifdef DEBUG
14889 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14890 #endif
14891
14892 /**
14893 * main kernel
14894 */
14895
14896 {
14897 /**
14898 * kernel source filename
14899 */
14900
14901 char source_file[256] = { 0 };
14902
14903 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14904
14905 struct stat sst;
14906
14907 if (stat (source_file, &sst) == -1)
14908 {
14909 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14910
14911 return -1;
14912 }
14913
14914 /**
14915 * kernel cached filename
14916 */
14917
14918 char cached_file[256] = { 0 };
14919
14920 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14921
14922 int cached = 1;
14923
14924 struct stat cst;
14925
14926 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14927 {
14928 cached = 0;
14929 }
14930
14931 /**
14932 * kernel compile or load
14933 */
14934
14935 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14936
14937 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14938
14939 if (force_jit_compilation == -1)
14940 {
14941 if (cached == 0)
14942 {
14943 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14944
14945 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14946
14947 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14948
14949 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14950
14951 #ifdef DEBUG
14952 size_t build_log_size = 0;
14953
14954 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14955
14956 if (build_log_size > 1)
14957 {
14958 char *build_log = (char *) malloc (build_log_size + 1);
14959
14960 memset (build_log, 0, build_log_size + 1);
14961
14962 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14963
14964 puts (build_log);
14965
14966 free (build_log);
14967 }
14968 #endif
14969
14970 if (rc != 0)
14971 {
14972 device_param->skipped = true;
14973
14974 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14975
14976 continue;
14977 }
14978
14979 size_t binary_size;
14980
14981 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14982
14983 u8 *binary = (u8 *) mymalloc (binary_size);
14984
14985 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14986
14987 writeProgramBin (cached_file, binary, binary_size);
14988
14989 local_free (binary);
14990 }
14991 else
14992 {
14993 #ifdef DEBUG
14994 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14995 #endif
14996
14997 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14998
14999 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15000
15001 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15002 }
15003 }
15004 else
15005 {
15006 #ifdef DEBUG
15007 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15008 #endif
15009
15010 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15011
15012 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15013
15014 char build_opts_update[1024] = { 0 };
15015
15016 if (force_jit_compilation == 1500)
15017 {
15018 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15019 }
15020 else if (force_jit_compilation == 8900)
15021 {
15022 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);
15023 }
15024 else
15025 {
15026 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15027 }
15028
15029 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15030
15031 #ifdef DEBUG
15032 size_t build_log_size = 0;
15033
15034 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15035
15036 if (build_log_size > 1)
15037 {
15038 char *build_log = (char *) malloc (build_log_size + 1);
15039
15040 memset (build_log, 0, build_log_size + 1);
15041
15042 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15043
15044 puts (build_log);
15045
15046 free (build_log);
15047 }
15048 #endif
15049
15050 if (rc != 0)
15051 {
15052 device_param->skipped = true;
15053
15054 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15055 }
15056 }
15057
15058 local_free (kernel_lengths);
15059 local_free (kernel_sources[0]);
15060 local_free (kernel_sources);
15061 }
15062
15063 /**
15064 * word generator kernel
15065 */
15066
15067 if (attack_mode != ATTACK_MODE_STRAIGHT)
15068 {
15069 /**
15070 * kernel mp source filename
15071 */
15072
15073 char source_file[256] = { 0 };
15074
15075 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15076
15077 struct stat sst;
15078
15079 if (stat (source_file, &sst) == -1)
15080 {
15081 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15082
15083 return -1;
15084 }
15085
15086 /**
15087 * kernel mp cached filename
15088 */
15089
15090 char cached_file[256] = { 0 };
15091
15092 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15093
15094 int cached = 1;
15095
15096 struct stat cst;
15097
15098 if (stat (cached_file, &cst) == -1)
15099 {
15100 cached = 0;
15101 }
15102
15103 /**
15104 * kernel compile or load
15105 */
15106
15107 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15108
15109 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15110
15111 if (cached == 0)
15112 {
15113 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15114 if (quiet == 0) log_info ("");
15115
15116 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15117
15118 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15119
15120 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15121
15122 if (rc != 0)
15123 {
15124 device_param->skipped = true;
15125
15126 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15127
15128 continue;
15129 }
15130
15131 size_t binary_size;
15132
15133 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15134
15135 u8 *binary = (u8 *) mymalloc (binary_size);
15136
15137 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15138
15139 writeProgramBin (cached_file, binary, binary_size);
15140
15141 local_free (binary);
15142 }
15143 else
15144 {
15145 #ifdef DEBUG
15146 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15147 #endif
15148
15149 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15150
15151 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15152
15153 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15154 }
15155
15156 local_free (kernel_lengths);
15157 local_free (kernel_sources[0]);
15158 local_free (kernel_sources);
15159 }
15160
15161 /**
15162 * amplifier kernel
15163 */
15164
15165 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15166 {
15167
15168 }
15169 else
15170 {
15171 /**
15172 * kernel amp source filename
15173 */
15174
15175 char source_file[256] = { 0 };
15176
15177 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15178
15179 struct stat sst;
15180
15181 if (stat (source_file, &sst) == -1)
15182 {
15183 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15184
15185 return -1;
15186 }
15187
15188 /**
15189 * kernel amp cached filename
15190 */
15191
15192 char cached_file[256] = { 0 };
15193
15194 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15195
15196 int cached = 1;
15197
15198 struct stat cst;
15199
15200 if (stat (cached_file, &cst) == -1)
15201 {
15202 cached = 0;
15203 }
15204
15205 /**
15206 * kernel compile or load
15207 */
15208
15209 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15210
15211 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15212
15213 if (cached == 0)
15214 {
15215 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15216 if (quiet == 0) log_info ("");
15217
15218 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15219
15220 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15221
15222 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15223
15224 if (rc != 0)
15225 {
15226 device_param->skipped = true;
15227
15228 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15229
15230 continue;
15231 }
15232
15233 size_t binary_size;
15234
15235 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15236
15237 u8 *binary = (u8 *) mymalloc (binary_size);
15238
15239 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15240
15241 writeProgramBin (cached_file, binary, binary_size);
15242
15243 local_free (binary);
15244 }
15245 else
15246 {
15247 #ifdef DEBUG
15248 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15249 #endif
15250
15251 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15252
15253 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15254
15255 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15256 }
15257
15258 local_free (kernel_lengths);
15259 local_free (kernel_sources[0]);
15260 local_free (kernel_sources);
15261 }
15262
15263 // some algorithm collide too fast, make that impossible
15264
15265 if (benchmark == 1)
15266 {
15267 ((uint *) digests_buf)[0] = -1;
15268 ((uint *) digests_buf)[1] = -1;
15269 ((uint *) digests_buf)[2] = -1;
15270 ((uint *) digests_buf)[3] = -1;
15271 }
15272
15273 /**
15274 * global buffers
15275 */
15276
15277 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15278 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15279 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15280 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15281 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15282 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15283 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15284 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15285 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15286 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15287 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15288 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15289 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15290 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15291 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15292 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15293 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15294 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15295
15296 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);
15297 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);
15298 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);
15299 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);
15300 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);
15301 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);
15302 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);
15303 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);
15304 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15305 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15306 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15307
15308 /**
15309 * special buffers
15310 */
15311
15312 if (attack_kern == ATTACK_KERN_STRAIGHT)
15313 {
15314 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15315 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15316
15317 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15318 }
15319 else if (attack_kern == ATTACK_KERN_COMBI)
15320 {
15321 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15322 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15323 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15324 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15325 }
15326 else if (attack_kern == ATTACK_KERN_BF)
15327 {
15328 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15329 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15330 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15331 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15332 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15333 }
15334
15335 if (size_esalts)
15336 {
15337 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15338
15339 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15340 }
15341
15342 /**
15343 * main host data
15344 */
15345
15346 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15347
15348 device_param->pws_buf = pws_buf;
15349
15350 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15351
15352 device_param->combs_buf = combs_buf;
15353
15354 void *hooks_buf = mymalloc (size_hooks);
15355
15356 device_param->hooks_buf = hooks_buf;
15357
15358 /**
15359 * kernel args
15360 */
15361
15362 device_param->kernel_params_buf32[21] = bitmap_mask;
15363 device_param->kernel_params_buf32[22] = bitmap_shift1;
15364 device_param->kernel_params_buf32[23] = bitmap_shift2;
15365 device_param->kernel_params_buf32[24] = 0; // salt_pos
15366 device_param->kernel_params_buf32[25] = 0; // loop_pos
15367 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15368 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15369 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15370 device_param->kernel_params_buf32[29] = 0; // digests_offset
15371 device_param->kernel_params_buf32[30] = 0; // combs_mode
15372 device_param->kernel_params_buf32[31] = 0; // gid_max
15373
15374 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15375 ? &device_param->d_pws_buf
15376 : &device_param->d_pws_amp_buf;
15377 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15378 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15379 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15380 device_param->kernel_params[ 4] = &device_param->d_tmps;
15381 device_param->kernel_params[ 5] = &device_param->d_hooks;
15382 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15383 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15384 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15385 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15386 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15387 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15388 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15389 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15390 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15391 device_param->kernel_params[15] = &device_param->d_digests_buf;
15392 device_param->kernel_params[16] = &device_param->d_digests_shown;
15393 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15394 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15395 device_param->kernel_params[19] = &device_param->d_result;
15396 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15397 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15398 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15399 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15400 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15401 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15402 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15403 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15404 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15405 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15406 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15407 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15408
15409 device_param->kernel_params_mp_buf64[3] = 0;
15410 device_param->kernel_params_mp_buf32[4] = 0;
15411 device_param->kernel_params_mp_buf32[5] = 0;
15412 device_param->kernel_params_mp_buf32[6] = 0;
15413 device_param->kernel_params_mp_buf32[7] = 0;
15414 device_param->kernel_params_mp_buf32[8] = 0;
15415
15416 device_param->kernel_params_mp[0] = NULL;
15417 device_param->kernel_params_mp[1] = NULL;
15418 device_param->kernel_params_mp[2] = NULL;
15419 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15420 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15421 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15422 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15423 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15424 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15425
15426 device_param->kernel_params_mp_l_buf64[3] = 0;
15427 device_param->kernel_params_mp_l_buf32[4] = 0;
15428 device_param->kernel_params_mp_l_buf32[5] = 0;
15429 device_param->kernel_params_mp_l_buf32[6] = 0;
15430 device_param->kernel_params_mp_l_buf32[7] = 0;
15431 device_param->kernel_params_mp_l_buf32[8] = 0;
15432 device_param->kernel_params_mp_l_buf32[9] = 0;
15433
15434 device_param->kernel_params_mp_l[0] = NULL;
15435 device_param->kernel_params_mp_l[1] = NULL;
15436 device_param->kernel_params_mp_l[2] = NULL;
15437 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15438 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15439 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15440 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15441 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15442 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15443 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15444
15445 device_param->kernel_params_mp_r_buf64[3] = 0;
15446 device_param->kernel_params_mp_r_buf32[4] = 0;
15447 device_param->kernel_params_mp_r_buf32[5] = 0;
15448 device_param->kernel_params_mp_r_buf32[6] = 0;
15449 device_param->kernel_params_mp_r_buf32[7] = 0;
15450 device_param->kernel_params_mp_r_buf32[8] = 0;
15451
15452 device_param->kernel_params_mp_r[0] = NULL;
15453 device_param->kernel_params_mp_r[1] = NULL;
15454 device_param->kernel_params_mp_r[2] = NULL;
15455 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15456 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15457 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15458 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15459 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15460 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15461
15462 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15463 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15464
15465 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15466 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15467 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15468 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15469 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15470 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15471 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15472
15473 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15474 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15475
15476 device_param->kernel_params_memset_buf32[1] = 0; // value
15477 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15478
15479 device_param->kernel_params_memset[0] = NULL;
15480 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15481 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15482
15483 /**
15484 * kernel name
15485 */
15486
15487 size_t kernel_wgs_tmp;
15488
15489 char kernel_name[64] = { 0 };
15490
15491 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15492 {
15493 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15494 {
15495 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15496
15497 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15498
15499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15500
15501 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15502
15503 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15504
15505 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15506 }
15507 else
15508 {
15509 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15510
15511 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15512
15513 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15514
15515 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15516
15517 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15518
15519 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15520 }
15521
15522 if (data.attack_mode == ATTACK_MODE_BF)
15523 {
15524 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15525 {
15526 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15527
15528 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15529
15530 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);
15531 }
15532 }
15533 }
15534 else
15535 {
15536 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15537
15538 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15539
15540 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15541
15542 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15543
15544 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15545
15546 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15547
15548 if (opts_type & OPTS_TYPE_HOOK12)
15549 {
15550 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15551
15552 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15553
15554 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);
15555 }
15556
15557 if (opts_type & OPTS_TYPE_HOOK23)
15558 {
15559 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15560
15561 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15562
15563 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);
15564 }
15565 }
15566
15567 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);
15568 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);
15569 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);
15570
15571 for (uint i = 0; i <= 20; i++)
15572 {
15573 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15574 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15575 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15576
15577 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15578 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15579 }
15580
15581 for (uint i = 21; i <= 31; i++)
15582 {
15583 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15584 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15585 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15586
15587 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15588 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15589 }
15590
15591 // GPU memset
15592
15593 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15594
15595 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);
15596
15597 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15598 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15599 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15600
15601 // MP start
15602
15603 if (attack_mode == ATTACK_MODE_BF)
15604 {
15605 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15606 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15607
15608 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);
15609 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);
15610
15611 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15612 {
15613 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15614 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15615 }
15616 }
15617 else if (attack_mode == ATTACK_MODE_HYBRID1)
15618 {
15619 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15620
15621 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);
15622 }
15623 else if (attack_mode == ATTACK_MODE_HYBRID2)
15624 {
15625 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15626
15627 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);
15628 }
15629
15630 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15631 {
15632 // nothing to do
15633 }
15634 else
15635 {
15636 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15637
15638 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);
15639 }
15640
15641 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15642 {
15643 // nothing to do
15644 }
15645 else
15646 {
15647 for (uint i = 0; i < 5; i++)
15648 {
15649 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15650 }
15651
15652 for (uint i = 5; i < 7; i++)
15653 {
15654 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15655 }
15656 }
15657
15658 // maybe this has been updated by clGetKernelWorkGroupInfo()
15659 // value can only be decreased, so we don't need to reallocate buffers
15660
15661 device_param->kernel_threads = kernel_threads;
15662
15663 // zero some data buffers
15664
15665 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15666 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15667 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15668 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15669 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15670 run_kernel_bzero (device_param, device_param->d_result, size_results);
15671
15672 /**
15673 * special buffers
15674 */
15675
15676 if (attack_kern == ATTACK_KERN_STRAIGHT)
15677 {
15678 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15679 }
15680 else if (attack_kern == ATTACK_KERN_COMBI)
15681 {
15682 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15683 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15684 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15685 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15686 }
15687 else if (attack_kern == ATTACK_KERN_BF)
15688 {
15689 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15690 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15691 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15692 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15693 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15694 }
15695
15696 #if defined(HAVE_HWMON)
15697
15698 /**
15699 * Store initial fanspeed if gpu_temp_retain is enabled
15700 */
15701
15702 if (gpu_temp_disable == 0)
15703 {
15704 if (gpu_temp_retain != 0)
15705 {
15706 hc_thread_mutex_lock (mux_adl);
15707
15708 if (data.hm_device[device_id].fan_get_supported == 1)
15709 {
15710 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15711 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15712
15713 temp_retain_fanspeed_value[device_id] = fanspeed;
15714 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15715
15716 // we also set it to tell the OS we take control over the fan and it's automatic controller
15717 // if it was set to automatic. we do not control user-defined fanspeeds.
15718
15719 if (fanpolicy == 1)
15720 {
15721 data.hm_device[device_id].fan_set_supported = 1;
15722
15723 int rc = -1;
15724
15725 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15726 {
15727 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15728 }
15729 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15730 {
15731
15732 }
15733
15734 if (rc == 0)
15735 {
15736 data.hm_device[device_id].fan_set_supported = 1;
15737 }
15738 else
15739 {
15740 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15741
15742 data.hm_device[device_id].fan_set_supported = 0;
15743 }
15744 }
15745 else
15746 {
15747 data.hm_device[device_id].fan_set_supported = 0;
15748 }
15749 }
15750
15751 hc_thread_mutex_unlock (mux_adl);
15752 }
15753 }
15754
15755 #endif // HAVE_HWMON
15756 }
15757
15758 if (data.quiet == 0) log_info_nn ("");
15759
15760 /**
15761 * In benchmark-mode, inform user which algorithm is checked
15762 */
15763
15764 if (benchmark == 1)
15765 {
15766 if (machine_readable == 0)
15767 {
15768 quiet = 0;
15769
15770 data.quiet = quiet;
15771
15772 char *hash_type = strhashtype (data.hash_mode); // not a bug
15773
15774 log_info ("Hashtype: %s", hash_type);
15775 log_info ("");
15776 }
15777 }
15778
15779 /**
15780 * keep track of the progress
15781 */
15782
15783 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15784 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15785 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15786
15787 /**
15788 * open filehandles
15789 */
15790
15791 #if _WIN
15792 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15793 {
15794 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15795
15796 return (-1);
15797 }
15798
15799 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15800 {
15801 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15802
15803 return (-1);
15804 }
15805
15806 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15807 {
15808 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15809
15810 return (-1);
15811 }
15812 #endif
15813
15814 /**
15815 * dictionary pad
15816 */
15817
15818 segment_size *= (1024 * 1024);
15819
15820 data.segment_size = segment_size;
15821
15822 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15823
15824 wl_data->buf = (char *) mymalloc (segment_size);
15825 wl_data->avail = segment_size;
15826 wl_data->incr = segment_size;
15827 wl_data->cnt = 0;
15828 wl_data->pos = 0;
15829
15830 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15831
15832 data.wordlist_mode = wordlist_mode;
15833
15834 cs_t *css_buf = NULL;
15835 uint css_cnt = 0;
15836 uint dictcnt = 0;
15837 uint maskcnt = 1;
15838 char **masks = NULL;
15839 char **dictfiles = NULL;
15840
15841 uint mask_from_file = 0;
15842
15843 if (attack_mode == ATTACK_MODE_STRAIGHT)
15844 {
15845 if (wordlist_mode == WL_MODE_FILE)
15846 {
15847 int wls_left = myargc - (optind + 1);
15848
15849 for (int i = 0; i < wls_left; i++)
15850 {
15851 char *l0_filename = myargv[optind + 1 + i];
15852
15853 struct stat l0_stat;
15854
15855 if (stat (l0_filename, &l0_stat) == -1)
15856 {
15857 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15858
15859 return (-1);
15860 }
15861
15862 uint is_dir = S_ISDIR (l0_stat.st_mode);
15863
15864 if (is_dir == 0)
15865 {
15866 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15867
15868 dictcnt++;
15869
15870 dictfiles[dictcnt - 1] = l0_filename;
15871 }
15872 else
15873 {
15874 // do not allow --keyspace w/ a directory
15875
15876 if (keyspace == 1)
15877 {
15878 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15879
15880 return (-1);
15881 }
15882
15883 char **dictionary_files = NULL;
15884
15885 dictionary_files = scan_directory (l0_filename);
15886
15887 if (dictionary_files != NULL)
15888 {
15889 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15890
15891 for (int d = 0; dictionary_files[d] != NULL; d++)
15892 {
15893 char *l1_filename = dictionary_files[d];
15894
15895 struct stat l1_stat;
15896
15897 if (stat (l1_filename, &l1_stat) == -1)
15898 {
15899 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15900
15901 return (-1);
15902 }
15903
15904 if (S_ISREG (l1_stat.st_mode))
15905 {
15906 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15907
15908 dictcnt++;
15909
15910 dictfiles[dictcnt - 1] = strdup (l1_filename);
15911 }
15912 }
15913 }
15914
15915 local_free (dictionary_files);
15916 }
15917 }
15918
15919 if (dictcnt < 1)
15920 {
15921 log_error ("ERROR: No usable dictionary file found.");
15922
15923 return (-1);
15924 }
15925 }
15926 else if (wordlist_mode == WL_MODE_STDIN)
15927 {
15928 dictcnt = 1;
15929 }
15930 }
15931 else if (attack_mode == ATTACK_MODE_COMBI)
15932 {
15933 // display
15934
15935 char *dictfile1 = myargv[optind + 1 + 0];
15936 char *dictfile2 = myargv[optind + 1 + 1];
15937
15938 // find the bigger dictionary and use as base
15939
15940 FILE *fp1 = NULL;
15941 FILE *fp2 = NULL;
15942
15943 struct stat tmp_stat;
15944
15945 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15946 {
15947 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15948
15949 return (-1);
15950 }
15951
15952 if (stat (dictfile1, &tmp_stat) == -1)
15953 {
15954 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15955
15956 fclose (fp1);
15957
15958 return (-1);
15959 }
15960
15961 if (S_ISDIR (tmp_stat.st_mode))
15962 {
15963 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15964
15965 fclose (fp1);
15966
15967 return (-1);
15968 }
15969
15970 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15971 {
15972 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15973
15974 fclose (fp1);
15975
15976 return (-1);
15977 }
15978
15979 if (stat (dictfile2, &tmp_stat) == -1)
15980 {
15981 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15982
15983 fclose (fp1);
15984 fclose (fp2);
15985
15986 return (-1);
15987 }
15988
15989 if (S_ISDIR (tmp_stat.st_mode))
15990 {
15991 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15992
15993 fclose (fp1);
15994 fclose (fp2);
15995
15996 return (-1);
15997 }
15998
15999 data.combs_cnt = 1;
16000
16001 data.quiet = 1;
16002
16003 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16004
16005 data.quiet = quiet;
16006
16007 if (words1_cnt == 0)
16008 {
16009 log_error ("ERROR: %s: empty file", dictfile1);
16010
16011 fclose (fp1);
16012 fclose (fp2);
16013
16014 return (-1);
16015 }
16016
16017 data.combs_cnt = 1;
16018
16019 data.quiet = 1;
16020
16021 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16022
16023 data.quiet = quiet;
16024
16025 if (words2_cnt == 0)
16026 {
16027 log_error ("ERROR: %s: empty file", dictfile2);
16028
16029 fclose (fp1);
16030 fclose (fp2);
16031
16032 return (-1);
16033 }
16034
16035 fclose (fp1);
16036 fclose (fp2);
16037
16038 data.dictfile = dictfile1;
16039 data.dictfile2 = dictfile2;
16040
16041 if (words1_cnt >= words2_cnt)
16042 {
16043 data.combs_cnt = words2_cnt;
16044 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16045
16046 dictfiles = &data.dictfile;
16047
16048 dictcnt = 1;
16049 }
16050 else
16051 {
16052 data.combs_cnt = words1_cnt;
16053 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16054
16055 dictfiles = &data.dictfile2;
16056
16057 dictcnt = 1;
16058
16059 // we also have to switch wordlist related rules!
16060
16061 char *tmpc = data.rule_buf_l;
16062
16063 data.rule_buf_l = data.rule_buf_r;
16064 data.rule_buf_r = tmpc;
16065
16066 int tmpi = data.rule_len_l;
16067
16068 data.rule_len_l = data.rule_len_r;
16069 data.rule_len_r = tmpi;
16070 }
16071 }
16072 else if (attack_mode == ATTACK_MODE_BF)
16073 {
16074 char *mask = NULL;
16075
16076 maskcnt = 0;
16077
16078 if (benchmark == 0)
16079 {
16080 mask = myargv[optind + 1];
16081
16082 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16083
16084 if ((optind + 2) <= myargc)
16085 {
16086 struct stat file_stat;
16087
16088 if (stat (mask, &file_stat) == -1)
16089 {
16090 maskcnt = 1;
16091
16092 masks[maskcnt - 1] = mystrdup (mask);
16093 }
16094 else
16095 {
16096 int wls_left = myargc - (optind + 1);
16097
16098 uint masks_avail = INCR_MASKS;
16099
16100 for (int i = 0; i < wls_left; i++)
16101 {
16102 if (i != 0)
16103 {
16104 mask = myargv[optind + 1 + i];
16105
16106 if (stat (mask, &file_stat) == -1)
16107 {
16108 log_error ("ERROR: %s: %s", mask, strerror (errno));
16109
16110 return (-1);
16111 }
16112 }
16113
16114 uint is_file = S_ISREG (file_stat.st_mode);
16115
16116 if (is_file == 1)
16117 {
16118 FILE *mask_fp;
16119
16120 if ((mask_fp = fopen (mask, "r")) == NULL)
16121 {
16122 log_error ("ERROR: %s: %s", mask, strerror (errno));
16123
16124 return (-1);
16125 }
16126
16127 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16128
16129 while (!feof (mask_fp))
16130 {
16131 memset (line_buf, 0, HCBUFSIZ);
16132
16133 int line_len = fgetl (mask_fp, line_buf);
16134
16135 if (line_len == 0) continue;
16136
16137 if (line_buf[0] == '#') continue;
16138
16139 if (masks_avail == maskcnt)
16140 {
16141 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16142
16143 masks_avail += INCR_MASKS;
16144 }
16145
16146 masks[maskcnt] = mystrdup (line_buf);
16147
16148 maskcnt++;
16149 }
16150
16151 myfree (line_buf);
16152
16153 fclose (mask_fp);
16154 }
16155 else
16156 {
16157 log_error ("ERROR: %s: unsupported file-type", mask);
16158
16159 return (-1);
16160 }
16161 }
16162
16163 mask_from_file = 1;
16164 }
16165 }
16166 else
16167 {
16168 custom_charset_1 = (char *) "?l?d?u";
16169 custom_charset_2 = (char *) "?l?d";
16170 custom_charset_3 = (char *) "?l?d*!$@_";
16171
16172 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16173 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16174 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16175
16176 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16177
16178 wordlist_mode = WL_MODE_MASK;
16179
16180 data.wordlist_mode = wordlist_mode;
16181
16182 increment = 1;
16183
16184 maskcnt = 1;
16185 }
16186 }
16187 else
16188 {
16189 /**
16190 * generate full masks and charsets
16191 */
16192
16193 masks = (char **) mymalloc (sizeof (char *));
16194
16195 switch (hash_mode)
16196 {
16197 case 1731: pw_min = 5;
16198 pw_max = 5;
16199 mask = mystrdup ("?b?b?b?b?b");
16200 break;
16201 case 12500: pw_min = 5;
16202 pw_max = 5;
16203 mask = mystrdup ("?b?b?b?b?b");
16204 break;
16205 default: pw_min = 7;
16206 pw_max = 7;
16207 mask = mystrdup ("?b?b?b?b?b?b?b");
16208 break;
16209 }
16210
16211 maskcnt = 1;
16212
16213 masks[maskcnt - 1] = mystrdup (mask);
16214
16215 wordlist_mode = WL_MODE_MASK;
16216
16217 data.wordlist_mode = wordlist_mode;
16218
16219 increment = 1;
16220 }
16221
16222 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16223
16224 if (increment)
16225 {
16226 if (increment_min > pw_min) pw_min = increment_min;
16227
16228 if (increment_max < pw_max) pw_max = increment_max;
16229 }
16230 }
16231 else if (attack_mode == ATTACK_MODE_HYBRID1)
16232 {
16233 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16234
16235 // display
16236
16237 char *mask = myargv[myargc - 1];
16238
16239 maskcnt = 0;
16240
16241 masks = (char **) mymalloc (1 * sizeof (char *));
16242
16243 // mod
16244
16245 struct stat file_stat;
16246
16247 if (stat (mask, &file_stat) == -1)
16248 {
16249 maskcnt = 1;
16250
16251 masks[maskcnt - 1] = mystrdup (mask);
16252 }
16253 else
16254 {
16255 uint is_file = S_ISREG (file_stat.st_mode);
16256
16257 if (is_file == 1)
16258 {
16259 FILE *mask_fp;
16260
16261 if ((mask_fp = fopen (mask, "r")) == NULL)
16262 {
16263 log_error ("ERROR: %s: %s", mask, strerror (errno));
16264
16265 return (-1);
16266 }
16267
16268 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16269
16270 uint masks_avail = 1;
16271
16272 while (!feof (mask_fp))
16273 {
16274 memset (line_buf, 0, HCBUFSIZ);
16275
16276 int line_len = fgetl (mask_fp, line_buf);
16277
16278 if (line_len == 0) continue;
16279
16280 if (line_buf[0] == '#') continue;
16281
16282 if (masks_avail == maskcnt)
16283 {
16284 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16285
16286 masks_avail += INCR_MASKS;
16287 }
16288
16289 masks[maskcnt] = mystrdup (line_buf);
16290
16291 maskcnt++;
16292 }
16293
16294 myfree (line_buf);
16295
16296 fclose (mask_fp);
16297
16298 mask_from_file = 1;
16299 }
16300 else
16301 {
16302 maskcnt = 1;
16303
16304 masks[maskcnt - 1] = mystrdup (mask);
16305 }
16306 }
16307
16308 // base
16309
16310 int wls_left = myargc - (optind + 2);
16311
16312 for (int i = 0; i < wls_left; i++)
16313 {
16314 char *filename = myargv[optind + 1 + i];
16315
16316 struct stat file_stat;
16317
16318 if (stat (filename, &file_stat) == -1)
16319 {
16320 log_error ("ERROR: %s: %s", filename, strerror (errno));
16321
16322 return (-1);
16323 }
16324
16325 uint is_dir = S_ISDIR (file_stat.st_mode);
16326
16327 if (is_dir == 0)
16328 {
16329 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16330
16331 dictcnt++;
16332
16333 dictfiles[dictcnt - 1] = filename;
16334 }
16335 else
16336 {
16337 // do not allow --keyspace w/ a directory
16338
16339 if (keyspace == 1)
16340 {
16341 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16342
16343 return (-1);
16344 }
16345
16346 char **dictionary_files = NULL;
16347
16348 dictionary_files = scan_directory (filename);
16349
16350 if (dictionary_files != NULL)
16351 {
16352 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16353
16354 for (int d = 0; dictionary_files[d] != NULL; d++)
16355 {
16356 char *l1_filename = dictionary_files[d];
16357
16358 struct stat l1_stat;
16359
16360 if (stat (l1_filename, &l1_stat) == -1)
16361 {
16362 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16363
16364 return (-1);
16365 }
16366
16367 if (S_ISREG (l1_stat.st_mode))
16368 {
16369 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16370
16371 dictcnt++;
16372
16373 dictfiles[dictcnt - 1] = strdup (l1_filename);
16374 }
16375 }
16376 }
16377
16378 local_free (dictionary_files);
16379 }
16380 }
16381
16382 if (dictcnt < 1)
16383 {
16384 log_error ("ERROR: No usable dictionary file found.");
16385
16386 return (-1);
16387 }
16388
16389 if (increment)
16390 {
16391 maskcnt = 0;
16392
16393 uint mask_min = increment_min; // we can't reject smaller masks here
16394 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16395
16396 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16397 {
16398 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16399
16400 if (cur_mask == NULL) break;
16401
16402 masks[maskcnt] = cur_mask;
16403
16404 maskcnt++;
16405
16406 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16407 }
16408 }
16409 }
16410 else if (attack_mode == ATTACK_MODE_HYBRID2)
16411 {
16412 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16413
16414 // display
16415
16416 char *mask = myargv[optind + 1 + 0];
16417
16418 maskcnt = 0;
16419
16420 masks = (char **) mymalloc (1 * sizeof (char *));
16421
16422 // mod
16423
16424 struct stat file_stat;
16425
16426 if (stat (mask, &file_stat) == -1)
16427 {
16428 maskcnt = 1;
16429
16430 masks[maskcnt - 1] = mystrdup (mask);
16431 }
16432 else
16433 {
16434 uint is_file = S_ISREG (file_stat.st_mode);
16435
16436 if (is_file == 1)
16437 {
16438 FILE *mask_fp;
16439
16440 if ((mask_fp = fopen (mask, "r")) == NULL)
16441 {
16442 log_error ("ERROR: %s: %s", mask, strerror (errno));
16443
16444 return (-1);
16445 }
16446
16447 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16448
16449 uint masks_avail = 1;
16450
16451 while (!feof (mask_fp))
16452 {
16453 memset (line_buf, 0, HCBUFSIZ);
16454
16455 int line_len = fgetl (mask_fp, line_buf);
16456
16457 if (line_len == 0) continue;
16458
16459 if (line_buf[0] == '#') continue;
16460
16461 if (masks_avail == maskcnt)
16462 {
16463 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16464
16465 masks_avail += INCR_MASKS;
16466 }
16467
16468 masks[maskcnt] = mystrdup (line_buf);
16469
16470 maskcnt++;
16471 }
16472
16473 myfree (line_buf);
16474
16475 fclose (mask_fp);
16476
16477 mask_from_file = 1;
16478 }
16479 else
16480 {
16481 maskcnt = 1;
16482
16483 masks[maskcnt - 1] = mystrdup (mask);
16484 }
16485 }
16486
16487 // base
16488
16489 int wls_left = myargc - (optind + 2);
16490
16491 for (int i = 0; i < wls_left; i++)
16492 {
16493 char *filename = myargv[optind + 2 + i];
16494
16495 struct stat file_stat;
16496
16497 if (stat (filename, &file_stat) == -1)
16498 {
16499 log_error ("ERROR: %s: %s", filename, strerror (errno));
16500
16501 return (-1);
16502 }
16503
16504 uint is_dir = S_ISDIR (file_stat.st_mode);
16505
16506 if (is_dir == 0)
16507 {
16508 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16509
16510 dictcnt++;
16511
16512 dictfiles[dictcnt - 1] = filename;
16513 }
16514 else
16515 {
16516 // do not allow --keyspace w/ a directory
16517
16518 if (keyspace == 1)
16519 {
16520 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16521
16522 return (-1);
16523 }
16524
16525 char **dictionary_files = NULL;
16526
16527 dictionary_files = scan_directory (filename);
16528
16529 if (dictionary_files != NULL)
16530 {
16531 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16532
16533 for (int d = 0; dictionary_files[d] != NULL; d++)
16534 {
16535 char *l1_filename = dictionary_files[d];
16536
16537 struct stat l1_stat;
16538
16539 if (stat (l1_filename, &l1_stat) == -1)
16540 {
16541 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16542
16543 return (-1);
16544 }
16545
16546 if (S_ISREG (l1_stat.st_mode))
16547 {
16548 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16549
16550 dictcnt++;
16551
16552 dictfiles[dictcnt - 1] = strdup (l1_filename);
16553 }
16554 }
16555 }
16556
16557 local_free (dictionary_files);
16558 }
16559 }
16560
16561 if (dictcnt < 1)
16562 {
16563 log_error ("ERROR: No usable dictionary file found.");
16564
16565 return (-1);
16566 }
16567
16568 if (increment)
16569 {
16570 maskcnt = 0;
16571
16572 uint mask_min = increment_min; // we can't reject smaller masks here
16573 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16574
16575 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16576 {
16577 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16578
16579 if (cur_mask == NULL) break;
16580
16581 masks[maskcnt] = cur_mask;
16582
16583 maskcnt++;
16584
16585 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16586 }
16587 }
16588 }
16589
16590 data.pw_min = pw_min;
16591 data.pw_max = pw_max;
16592
16593 /**
16594 * weak hash check
16595 */
16596
16597 if (weak_hash_threshold >= salts_cnt)
16598 {
16599 hc_device_param_t *device_param = NULL;
16600
16601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16602 {
16603 device_param = &data.devices_param[device_id];
16604
16605 if (device_param->skipped) continue;
16606
16607 break;
16608 }
16609
16610 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16611
16612 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16613 {
16614 weak_hash_check (device_param, salt_pos);
16615 }
16616
16617 // Display hack, guarantee that there is at least one \r before real start
16618
16619 //if (data.quiet == 0) log_info ("");
16620 }
16621
16622 /**
16623 * status and monitor threads
16624 */
16625
16626 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16627
16628 hc_thread_t i_thread = 0;
16629
16630 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16631 {
16632 hc_thread_create (i_thread, thread_keypress, &benchmark);
16633 }
16634
16635 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16636
16637 uint ni_threads_cnt = 0;
16638
16639 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16640
16641 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16642
16643 ni_threads_cnt++;
16644
16645 /**
16646 * Outfile remove
16647 */
16648
16649 if (keyspace == 0)
16650 {
16651 if (outfile_check_timer != 0)
16652 {
16653 if (data.outfile_check_directory != NULL)
16654 {
16655 if ((hash_mode != 5200) &&
16656 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16657 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16658 (hash_mode != 9000))
16659 {
16660 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16661
16662 ni_threads_cnt++;
16663 }
16664 else
16665 {
16666 outfile_check_timer = 0;
16667 }
16668 }
16669 else
16670 {
16671 outfile_check_timer = 0;
16672 }
16673 }
16674 }
16675
16676 /**
16677 * Inform the user if we got some hashes remove because of the pot file remove feature
16678 */
16679
16680 if (data.quiet == 0)
16681 {
16682 if (potfile_remove_cracks > 0)
16683 {
16684 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16685 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16686 }
16687 }
16688
16689 data.outfile_check_timer = outfile_check_timer;
16690
16691 /**
16692 * main loop
16693 */
16694
16695 char **induction_dictionaries = NULL;
16696
16697 int induction_dictionaries_cnt = 0;
16698
16699 hcstat_table_t *root_table_buf = NULL;
16700 hcstat_table_t *markov_table_buf = NULL;
16701
16702 uint initial_restore_done = 0;
16703
16704 data.maskcnt = maskcnt;
16705
16706 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16707 {
16708 if (data.devices_status == STATUS_CRACKED) break;
16709
16710 data.devices_status = STATUS_INIT;
16711
16712 if (maskpos > rd->maskpos)
16713 {
16714 rd->dictpos = 0;
16715 }
16716
16717 rd->maskpos = maskpos;
16718 data.maskpos = maskpos;
16719
16720 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16721 {
16722 char *mask = masks[maskpos];
16723
16724 if (mask_from_file == 1)
16725 {
16726 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16727
16728 char *str_ptr;
16729 uint str_pos;
16730
16731 uint mask_offset = 0;
16732
16733 uint separator_cnt;
16734
16735 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16736 {
16737 str_ptr = strstr (mask + mask_offset, ",");
16738
16739 if (str_ptr == NULL) break;
16740
16741 str_pos = str_ptr - mask;
16742
16743 // escaped separator, i.e. "\,"
16744
16745 if (str_pos > 0)
16746 {
16747 if (mask[str_pos - 1] == '\\')
16748 {
16749 separator_cnt --;
16750
16751 mask_offset = str_pos + 1;
16752
16753 continue;
16754 }
16755 }
16756
16757 // reset the offset
16758
16759 mask_offset = 0;
16760
16761 mask[str_pos] = '\0';
16762
16763 switch (separator_cnt)
16764 {
16765 case 0:
16766 mp_reset_usr (mp_usr, 0);
16767
16768 custom_charset_1 = mask;
16769 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16770 break;
16771
16772 case 1:
16773 mp_reset_usr (mp_usr, 1);
16774
16775 custom_charset_2 = mask;
16776 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16777 break;
16778
16779 case 2:
16780 mp_reset_usr (mp_usr, 2);
16781
16782 custom_charset_3 = mask;
16783 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16784 break;
16785
16786 case 3:
16787 mp_reset_usr (mp_usr, 3);
16788
16789 custom_charset_4 = mask;
16790 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16791 break;
16792 }
16793
16794 mask = mask + str_pos + 1;
16795 }
16796 }
16797
16798 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16799 {
16800 if (maskpos > 0)
16801 {
16802 local_free (css_buf);
16803 local_free (data.root_css_buf);
16804 local_free (data.markov_css_buf);
16805
16806 local_free (masks[maskpos - 1]);
16807 }
16808
16809 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16810
16811 data.mask = mask;
16812 data.css_cnt = css_cnt;
16813 data.css_buf = css_buf;
16814
16815 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16816
16817 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16818
16819 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16820 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16821
16822 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16823
16824 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16825
16826 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16827 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16828
16829 data.root_css_buf = root_css_buf;
16830 data.markov_css_buf = markov_css_buf;
16831
16832 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16833
16834 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16835
16836 local_free (root_table_buf);
16837 local_free (markov_table_buf);
16838
16839 // args
16840
16841 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16842 {
16843 hc_device_param_t *device_param = &data.devices_param[device_id];
16844
16845 if (device_param->skipped) continue;
16846
16847 device_param->kernel_params_mp[0] = &device_param->d_combs;
16848 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16849 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16850
16851 device_param->kernel_params_mp_buf64[3] = 0;
16852 device_param->kernel_params_mp_buf32[4] = css_cnt;
16853 device_param->kernel_params_mp_buf32[5] = 0;
16854 device_param->kernel_params_mp_buf32[6] = 0;
16855 device_param->kernel_params_mp_buf32[7] = 0;
16856
16857 if (attack_mode == ATTACK_MODE_HYBRID1)
16858 {
16859 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16860 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16861 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16862 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16863 }
16864 else if (attack_mode == ATTACK_MODE_HYBRID2)
16865 {
16866 device_param->kernel_params_mp_buf32[5] = 0;
16867 device_param->kernel_params_mp_buf32[6] = 0;
16868 device_param->kernel_params_mp_buf32[7] = 0;
16869 }
16870
16871 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]);
16872 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]);
16873 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]);
16874
16875 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);
16876 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);
16877 }
16878 }
16879 else if (attack_mode == ATTACK_MODE_BF)
16880 {
16881 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16882
16883 if (increment)
16884 {
16885 for (uint i = 0; i < dictcnt; i++)
16886 {
16887 local_free (dictfiles[i]);
16888 }
16889
16890 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16891 {
16892 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16893
16894 if (l1_filename == NULL) break;
16895
16896 dictcnt++;
16897
16898 dictfiles[dictcnt - 1] = l1_filename;
16899 }
16900 }
16901 else
16902 {
16903 dictcnt++;
16904
16905 dictfiles[dictcnt - 1] = mask;
16906 }
16907
16908 if (dictcnt == 0)
16909 {
16910 log_error ("ERROR: Mask is too small");
16911
16912 return (-1);
16913 }
16914 }
16915 }
16916
16917 free (induction_dictionaries);
16918
16919 // induction_dictionaries_cnt = 0; // implied
16920
16921 if (attack_mode != ATTACK_MODE_BF)
16922 {
16923 if (keyspace == 0)
16924 {
16925 induction_dictionaries = scan_directory (induction_directory);
16926
16927 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16928 }
16929 }
16930
16931 if (induction_dictionaries_cnt)
16932 {
16933 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16934 }
16935
16936 /**
16937 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16938 */
16939 if (keyspace == 1)
16940 {
16941 if ((maskcnt > 1) || (dictcnt > 1))
16942 {
16943 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16944
16945 return (-1);
16946 }
16947 }
16948
16949 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16950 {
16951 char *subid = logfile_generate_subid ();
16952
16953 data.subid = subid;
16954
16955 logfile_sub_msg ("START");
16956
16957 data.devices_status = STATUS_INIT;
16958
16959 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16960 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16961 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16962
16963 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16964
16965 data.cpt_pos = 0;
16966
16967 data.cpt_start = time (NULL);
16968
16969 data.cpt_total = 0;
16970
16971 if (data.restore == 0)
16972 {
16973 rd->words_cur = skip;
16974
16975 skip = 0;
16976
16977 data.skip = 0;
16978 }
16979
16980 data.ms_paused = 0;
16981
16982 data.kernel_power_div = 0;
16983
16984 data.words_cur = rd->words_cur;
16985
16986 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16987 {
16988 hc_device_param_t *device_param = &data.devices_param[device_id];
16989
16990 if (device_param->skipped) continue;
16991
16992 device_param->speed_pos = 0;
16993
16994 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16995 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16996
16997 device_param->exec_pos = 0;
16998
16999 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17000
17001 device_param->outerloop_pos = 0;
17002 device_param->outerloop_left = 0;
17003 device_param->innerloop_pos = 0;
17004 device_param->innerloop_left = 0;
17005
17006 // some more resets:
17007
17008 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17009
17010 device_param->pws_cnt = 0;
17011
17012 device_param->words_off = 0;
17013 device_param->words_done = 0;
17014 }
17015
17016 // figure out some workload
17017
17018 if (attack_mode == ATTACK_MODE_STRAIGHT)
17019 {
17020 if (data.wordlist_mode == WL_MODE_FILE)
17021 {
17022 char *dictfile = NULL;
17023
17024 if (induction_dictionaries_cnt)
17025 {
17026 dictfile = induction_dictionaries[0];
17027 }
17028 else
17029 {
17030 dictfile = dictfiles[dictpos];
17031 }
17032
17033 data.dictfile = dictfile;
17034
17035 logfile_sub_string (dictfile);
17036
17037 for (uint i = 0; i < rp_files_cnt; i++)
17038 {
17039 logfile_sub_var_string ("rulefile", rp_files[i]);
17040 }
17041
17042 FILE *fd2 = fopen (dictfile, "rb");
17043
17044 if (fd2 == NULL)
17045 {
17046 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17047
17048 return (-1);
17049 }
17050
17051 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17052
17053 fclose (fd2);
17054
17055 if (data.words_cnt == 0)
17056 {
17057 if (data.devices_status == STATUS_CRACKED) break;
17058 if (data.devices_status == STATUS_ABORTED) break;
17059
17060 dictpos++;
17061
17062 continue;
17063 }
17064 }
17065 }
17066 else if (attack_mode == ATTACK_MODE_COMBI)
17067 {
17068 char *dictfile = data.dictfile;
17069 char *dictfile2 = data.dictfile2;
17070
17071 logfile_sub_string (dictfile);
17072 logfile_sub_string (dictfile2);
17073
17074 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17075 {
17076 FILE *fd2 = fopen (dictfile, "rb");
17077
17078 if (fd2 == NULL)
17079 {
17080 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17081
17082 return (-1);
17083 }
17084
17085 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17086
17087 fclose (fd2);
17088 }
17089 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17090 {
17091 FILE *fd2 = fopen (dictfile2, "rb");
17092
17093 if (fd2 == NULL)
17094 {
17095 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17096
17097 return (-1);
17098 }
17099
17100 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17101
17102 fclose (fd2);
17103 }
17104
17105 if (data.words_cnt == 0)
17106 {
17107 if (data.devices_status == STATUS_CRACKED) break;
17108 if (data.devices_status == STATUS_ABORTED) break;
17109
17110 dictpos++;
17111
17112 continue;
17113 }
17114 }
17115 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17116 {
17117 char *dictfile = NULL;
17118
17119 if (induction_dictionaries_cnt)
17120 {
17121 dictfile = induction_dictionaries[0];
17122 }
17123 else
17124 {
17125 dictfile = dictfiles[dictpos];
17126 }
17127
17128 data.dictfile = dictfile;
17129
17130 char *mask = data.mask;
17131
17132 logfile_sub_string (dictfile);
17133 logfile_sub_string (mask);
17134
17135 FILE *fd2 = fopen (dictfile, "rb");
17136
17137 if (fd2 == NULL)
17138 {
17139 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17140
17141 return (-1);
17142 }
17143
17144 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17145
17146 fclose (fd2);
17147
17148 if (data.words_cnt == 0)
17149 {
17150 if (data.devices_status == STATUS_CRACKED) break;
17151 if (data.devices_status == STATUS_ABORTED) break;
17152
17153 dictpos++;
17154
17155 continue;
17156 }
17157 }
17158 else if (attack_mode == ATTACK_MODE_BF)
17159 {
17160 local_free (css_buf);
17161 local_free (data.root_css_buf);
17162 local_free (data.markov_css_buf);
17163
17164 char *mask = dictfiles[dictpos];
17165
17166 logfile_sub_string (mask);
17167
17168 // base
17169
17170 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17171
17172 if (opts_type & OPTS_TYPE_PT_UNICODE)
17173 {
17174 uint css_cnt_unicode = css_cnt * 2;
17175
17176 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17177
17178 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17179 {
17180 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17181
17182 css_buf_unicode[j + 1].cs_buf[0] = 0;
17183 css_buf_unicode[j + 1].cs_len = 1;
17184 }
17185
17186 free (css_buf);
17187
17188 css_buf = css_buf_unicode;
17189 css_cnt = css_cnt_unicode;
17190 }
17191
17192 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17193
17194 uint mask_min = pw_min;
17195 uint mask_max = pw_max;
17196
17197 if (opts_type & OPTS_TYPE_PT_UNICODE)
17198 {
17199 mask_min *= 2;
17200 mask_max *= 2;
17201 }
17202
17203 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17204 {
17205 if (css_cnt < mask_min)
17206 {
17207 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17208 }
17209
17210 if (css_cnt > mask_max)
17211 {
17212 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17213 }
17214
17215 // skip to next mask
17216
17217 dictpos++;
17218
17219 rd->dictpos = dictpos;
17220
17221 logfile_sub_msg ("STOP");
17222
17223 continue;
17224 }
17225
17226 uint save_css_cnt = css_cnt;
17227
17228 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17229 {
17230 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17231 {
17232 uint salt_len = (uint) data.salts_buf[0].salt_len;
17233 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17234
17235 uint css_cnt_salt = css_cnt + salt_len;
17236
17237 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17238
17239 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17240
17241 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17242 {
17243 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17244 css_buf_salt[j].cs_len = 1;
17245 }
17246
17247 free (css_buf);
17248
17249 css_buf = css_buf_salt;
17250 css_cnt = css_cnt_salt;
17251 }
17252 }
17253
17254 data.mask = mask;
17255 data.css_cnt = css_cnt;
17256 data.css_buf = css_buf;
17257
17258 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17259
17260 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17261
17262 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17263
17264 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17265 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17266
17267 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17268
17269 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17270
17271 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17272 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17273
17274 data.root_css_buf = root_css_buf;
17275 data.markov_css_buf = markov_css_buf;
17276
17277 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17278
17279 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17280
17281 local_free (root_table_buf);
17282 local_free (markov_table_buf);
17283
17284 // copy + args
17285
17286 uint css_cnt_l = css_cnt;
17287 uint css_cnt_r;
17288
17289 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17290 {
17291 if (save_css_cnt < 6)
17292 {
17293 css_cnt_r = 1;
17294 }
17295 else if (save_css_cnt == 6)
17296 {
17297 css_cnt_r = 2;
17298 }
17299 else
17300 {
17301 if (opts_type & OPTS_TYPE_PT_UNICODE)
17302 {
17303 if (save_css_cnt == 8 || save_css_cnt == 10)
17304 {
17305 css_cnt_r = 2;
17306 }
17307 else
17308 {
17309 css_cnt_r = 4;
17310 }
17311 }
17312 else
17313 {
17314 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17315 {
17316 css_cnt_r = 3;
17317 }
17318 else
17319 {
17320 css_cnt_r = 4;
17321 }
17322 }
17323 }
17324 }
17325 else
17326 {
17327 css_cnt_r = 1;
17328
17329 /* unfinished code?
17330 int sum = css_buf[css_cnt_r - 1].cs_len;
17331
17332 for (uint i = 1; i < 4 && i < css_cnt; i++)
17333 {
17334 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17335
17336 css_cnt_r++;
17337
17338 sum *= css_buf[css_cnt_r - 1].cs_len;
17339 }
17340 */
17341 }
17342
17343 css_cnt_l -= css_cnt_r;
17344
17345 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17346
17347 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17348 {
17349 hc_device_param_t *device_param = &data.devices_param[device_id];
17350
17351 if (device_param->skipped) continue;
17352
17353 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17354 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17355 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17356
17357 device_param->kernel_params_mp_l_buf64[3] = 0;
17358 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17359 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17360 device_param->kernel_params_mp_l_buf32[6] = 0;
17361 device_param->kernel_params_mp_l_buf32[7] = 0;
17362 device_param->kernel_params_mp_l_buf32[8] = 0;
17363
17364 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17365 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17366 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17367 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17368
17369 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17370 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17371 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17372
17373 device_param->kernel_params_mp_r_buf64[3] = 0;
17374 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17375 device_param->kernel_params_mp_r_buf32[5] = 0;
17376 device_param->kernel_params_mp_r_buf32[6] = 0;
17377 device_param->kernel_params_mp_r_buf32[7] = 0;
17378
17379 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]);
17380 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]);
17381 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]);
17382
17383 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]);
17384 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]);
17385 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]);
17386
17387 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);
17388 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);
17389 }
17390 }
17391
17392 u64 words_base = data.words_cnt;
17393
17394 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17395 {
17396 if (data.kernel_rules_cnt)
17397 {
17398 words_base /= data.kernel_rules_cnt;
17399 }
17400 }
17401 else if (data.attack_kern == ATTACK_KERN_COMBI)
17402 {
17403 if (data.combs_cnt)
17404 {
17405 words_base /= data.combs_cnt;
17406 }
17407 }
17408 else if (data.attack_kern == ATTACK_KERN_BF)
17409 {
17410 if (data.bfs_cnt)
17411 {
17412 words_base /= data.bfs_cnt;
17413 }
17414 }
17415
17416 data.words_base = words_base;
17417
17418 if (keyspace == 1)
17419 {
17420 log_info ("%llu", (unsigned long long int) words_base);
17421
17422 return (0);
17423 }
17424
17425 if (data.words_cur > data.words_base)
17426 {
17427 log_error ("ERROR: restore value greater keyspace");
17428
17429 return (-1);
17430 }
17431
17432 if (data.words_cur)
17433 {
17434 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17435 {
17436 for (uint i = 0; i < data.salts_cnt; i++)
17437 {
17438 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17439 }
17440 }
17441 else if (data.attack_kern == ATTACK_KERN_COMBI)
17442 {
17443 for (uint i = 0; i < data.salts_cnt; i++)
17444 {
17445 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17446 }
17447 }
17448 else if (data.attack_kern == ATTACK_KERN_BF)
17449 {
17450 for (uint i = 0; i < data.salts_cnt; i++)
17451 {
17452 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17453 }
17454 }
17455 }
17456
17457 /*
17458 * Update loopback file
17459 */
17460
17461 if (loopback == 1)
17462 {
17463 time_t now;
17464
17465 time (&now);
17466
17467 uint random_num = get_random_num (0, 9999);
17468
17469 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17470
17471 data.loopback_file = loopback_file;
17472 }
17473
17474 /*
17475 * Update dictionary statistic
17476 */
17477
17478 if (keyspace == 0)
17479 {
17480 dictstat_fp = fopen (dictstat, "wb");
17481
17482 if (dictstat_fp)
17483 {
17484 lock_file (dictstat_fp);
17485
17486 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17487
17488 fclose (dictstat_fp);
17489 }
17490 }
17491
17492 data.devices_status = STATUS_RUNNING;
17493
17494 if (initial_restore_done == 0)
17495 {
17496 if (data.restore_disable == 0) cycle_restore ();
17497
17498 initial_restore_done = 1;
17499 }
17500
17501 hc_timer_set (&data.timer_running);
17502
17503 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17504 {
17505 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17506 {
17507 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17508 if (quiet == 0) fflush (stdout);
17509 }
17510 }
17511 else if (wordlist_mode == WL_MODE_STDIN)
17512 {
17513 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17514 if (data.quiet == 0) log_info ("");
17515 }
17516
17517 /**
17518 * create autotune threads
17519 */
17520
17521 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17522
17523 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17524 {
17525 hc_device_param_t *device_param = &devices_param[device_id];
17526
17527 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17528 }
17529
17530 hc_thread_wait (data.devices_cnt, c_threads);
17531
17532 /*
17533 * Inform user about possible slow speeds
17534 */
17535
17536 uint kernel_power_all = 0;
17537
17538 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17539 {
17540 hc_device_param_t *device_param = &devices_param[device_id];
17541
17542 kernel_power_all += device_param->kernel_power;
17543 }
17544
17545 data.kernel_power_all = kernel_power_all;
17546
17547 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17548 {
17549 if (data.words_base < kernel_power_all)
17550 {
17551 if (quiet == 0)
17552 {
17553 log_info ("ATTENTION!");
17554 log_info (" The wordlist or mask you are using is too small.");
17555 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17556 log_info (" The cracking speed will drop.");
17557 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17558 log_info ("");
17559 }
17560 }
17561 }
17562
17563 /**
17564 * create cracker threads
17565 */
17566
17567 time_t runtime_start;
17568
17569 time (&runtime_start);
17570
17571 data.runtime_start = runtime_start;
17572
17573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17574 {
17575 hc_device_param_t *device_param = &devices_param[device_id];
17576
17577 if (wordlist_mode == WL_MODE_STDIN)
17578 {
17579 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17580 }
17581 else
17582 {
17583 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17584 }
17585 }
17586
17587 hc_thread_wait (data.devices_cnt, c_threads);
17588
17589 local_free (c_threads);
17590
17591 data.restore = 0;
17592
17593 // finalize task
17594
17595 logfile_sub_var_uint ("status-after-work", data.devices_status);
17596
17597 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17598
17599 if (data.devices_status == STATUS_CRACKED) break;
17600 if (data.devices_status == STATUS_ABORTED) break;
17601
17602 if (data.devices_status == STATUS_BYPASS)
17603 {
17604 data.devices_status = STATUS_RUNNING;
17605 }
17606
17607 if (induction_dictionaries_cnt)
17608 {
17609 unlink (induction_dictionaries[0]);
17610 }
17611
17612 free (induction_dictionaries);
17613
17614 if (attack_mode != ATTACK_MODE_BF)
17615 {
17616 induction_dictionaries = scan_directory (induction_directory);
17617
17618 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17619 }
17620
17621 if (benchmark == 0)
17622 {
17623 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17624 {
17625 if (quiet == 0) clear_prompt ();
17626
17627 if (quiet == 0) log_info ("");
17628
17629 if (status == 1)
17630 {
17631 status_display ();
17632 }
17633 else
17634 {
17635 if (quiet == 0) status_display ();
17636 }
17637
17638 if (quiet == 0) log_info ("");
17639 }
17640 }
17641
17642 if (attack_mode == ATTACK_MODE_BF)
17643 {
17644 dictpos++;
17645
17646 rd->dictpos = dictpos;
17647 }
17648 else
17649 {
17650 if (induction_dictionaries_cnt)
17651 {
17652 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17653 }
17654 else
17655 {
17656 dictpos++;
17657
17658 rd->dictpos = dictpos;
17659 }
17660 }
17661
17662 time_t runtime_stop;
17663
17664 time (&runtime_stop);
17665
17666 data.runtime_stop = runtime_stop;
17667
17668 logfile_sub_uint (runtime_start);
17669 logfile_sub_uint (runtime_stop);
17670
17671 logfile_sub_msg ("STOP");
17672
17673 global_free (subid);
17674 }
17675
17676 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17677
17678 if (data.devices_status == STATUS_CRACKED) break;
17679 if (data.devices_status == STATUS_ABORTED) break;
17680 if (data.devices_status == STATUS_QUIT) break;
17681
17682 if (data.devices_status == STATUS_BYPASS)
17683 {
17684 data.devices_status = STATUS_RUNNING;
17685 }
17686 }
17687
17688 // 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
17689
17690 if (attack_mode == ATTACK_MODE_STRAIGHT)
17691 {
17692 if (data.wordlist_mode == WL_MODE_FILE)
17693 {
17694 if (data.dictfile == NULL)
17695 {
17696 if (dictfiles != NULL)
17697 {
17698 data.dictfile = dictfiles[0];
17699
17700 hc_timer_set (&data.timer_running);
17701 }
17702 }
17703 }
17704 }
17705 // NOTE: combi is okay because it is already set beforehand
17706 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17707 {
17708 if (data.dictfile == NULL)
17709 {
17710 if (dictfiles != NULL)
17711 {
17712 hc_timer_set (&data.timer_running);
17713
17714 data.dictfile = dictfiles[0];
17715 }
17716 }
17717 }
17718 else if (attack_mode == ATTACK_MODE_BF)
17719 {
17720 if (data.mask == NULL)
17721 {
17722 hc_timer_set (&data.timer_running);
17723
17724 data.mask = masks[0];
17725 }
17726 }
17727
17728 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17729 {
17730 data.devices_status = STATUS_EXHAUSTED;
17731 }
17732
17733 // if cracked / aborted remove last induction dictionary
17734
17735 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17736 {
17737 struct stat induct_stat;
17738
17739 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17740 {
17741 unlink (induction_dictionaries[file_pos]);
17742 }
17743 }
17744
17745 // wait for non-interactive threads
17746
17747 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17748 {
17749 hc_thread_wait (1, &ni_threads[thread_idx]);
17750 }
17751
17752 local_free (ni_threads);
17753
17754 // wait for interactive threads
17755
17756 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17757 {
17758 hc_thread_wait (1, &i_thread);
17759 }
17760
17761 // we dont need restore file anymore
17762 if (data.restore_disable == 0)
17763 {
17764 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17765 {
17766 unlink (eff_restore_file);
17767 unlink (new_restore_file);
17768 }
17769 else
17770 {
17771 cycle_restore ();
17772 }
17773 }
17774
17775 // finally save left hashes
17776
17777 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17778 {
17779 save_hash ();
17780 }
17781
17782 /**
17783 * Clean up
17784 */
17785
17786 if (benchmark == 1)
17787 {
17788 status_benchmark ();
17789
17790 if (machine_readable == 0)
17791 {
17792 log_info ("");
17793 }
17794 }
17795 else
17796 {
17797 if (quiet == 0) clear_prompt ();
17798
17799 if (quiet == 0) log_info ("");
17800
17801 if (status == 1)
17802 {
17803 status_display ();
17804 }
17805 else
17806 {
17807 if (quiet == 0) status_display ();
17808 }
17809
17810 if (quiet == 0) log_info ("");
17811 }
17812
17813 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17814 {
17815 hc_device_param_t *device_param = &data.devices_param[device_id];
17816
17817 if (device_param->skipped) continue;
17818
17819 local_free (device_param->combs_buf);
17820
17821 local_free (device_param->hooks_buf);
17822
17823 local_free (device_param->device_name);
17824
17825 local_free (device_param->device_name_chksum);
17826
17827 local_free (device_param->device_version);
17828
17829 local_free (device_param->driver_version);
17830
17831 if (device_param->pws_buf) myfree (device_param->pws_buf);
17832 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17833 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17834 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17835 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17836 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17837 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17838 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17839 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17840 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17841 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17842 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17843 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17844 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17845 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17846 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17847 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17848 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17849 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17850 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17851 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17852 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17853 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17854 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17855 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17856 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17857 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17858 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17859 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17860
17861 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17862 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17863 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17864 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17865 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17866 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17867 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17868 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17869 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17870 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17871 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17872
17873 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17874 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17875 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17876
17877 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17878 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17879 }
17880
17881 // reset default fan speed
17882
17883 #ifdef HAVE_HWMON
17884 if (gpu_temp_disable == 0)
17885 {
17886 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17887 {
17888 hc_thread_mutex_lock (mux_adl);
17889
17890 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17891 {
17892 hc_device_param_t *device_param = &data.devices_param[device_id];
17893
17894 if (device_param->skipped) continue;
17895
17896 if (data.hm_device[device_id].fan_set_supported == 1)
17897 {
17898 int fanspeed = temp_retain_fanspeed_value[device_id];
17899 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17900
17901 if (fanpolicy == 1)
17902 {
17903 int rc = -1;
17904
17905 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17906 {
17907 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17908 }
17909 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17910 {
17911
17912 }
17913
17914 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17915 }
17916 }
17917 }
17918
17919 hc_thread_mutex_unlock (mux_adl);
17920 }
17921 }
17922
17923 // reset power tuning
17924
17925 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17926 {
17927 hc_thread_mutex_lock (mux_adl);
17928
17929 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17930 {
17931 hc_device_param_t *device_param = &data.devices_param[device_id];
17932
17933 if (device_param->skipped) continue;
17934
17935 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17936 {
17937 if (data.hm_device[device_id].od_version == 6)
17938 {
17939 // check powertune capabilities first, if not available then skip device
17940
17941 int powertune_supported = 0;
17942
17943 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
17944 {
17945 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17946
17947 return (-1);
17948 }
17949
17950 if (powertune_supported != 0)
17951 {
17952 // powercontrol settings
17953
17954 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
17955 {
17956 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17957
17958 return (-1);
17959 }
17960
17961 // clocks
17962
17963 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17964
17965 performance_state->iNumberOfPerformanceLevels = 2;
17966
17967 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17968 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17969 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17970 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17971
17972 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17973 {
17974 log_info ("ERROR: Failed to restore ADL performance state");
17975
17976 return (-1);
17977 }
17978
17979 local_free (performance_state);
17980 }
17981 }
17982 }
17983
17984 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
17985 {
17986 unsigned int limit = nvml_power_limit[device_id];
17987
17988 if (limit > 0)
17989 {
17990 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
17991 }
17992 }
17993 }
17994
17995 hc_thread_mutex_unlock (mux_adl);
17996 }
17997
17998 if (gpu_temp_disable == 0)
17999 {
18000 if (data.hm_nvml)
18001 {
18002 hm_NVML_nvmlShutdown (data.hm_nvml);
18003
18004 nvml_close (data.hm_nvml);
18005
18006 data.hm_nvml = NULL;
18007 }
18008
18009 if (data.hm_adl)
18010 {
18011 hm_ADL_Main_Control_Destroy (data.hm_adl);
18012
18013 adl_close (data.hm_adl);
18014
18015 data.hm_adl = NULL;
18016 }
18017 }
18018 #endif // HAVE_HWMON
18019
18020 // free memory
18021
18022 local_free (masks);
18023
18024 local_free (dictstat_base);
18025
18026 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18027 {
18028 pot_t *pot_ptr = &pot[pot_pos];
18029
18030 hash_t *hash = &pot_ptr->hash;
18031
18032 local_free (hash->digest);
18033
18034 if (isSalted)
18035 {
18036 local_free (hash->salt);
18037 }
18038 }
18039
18040 local_free (pot);
18041
18042 local_free (all_kernel_rules_cnt);
18043 local_free (all_kernel_rules_buf);
18044
18045 local_free (wl_data->buf);
18046 local_free (wl_data);
18047
18048 local_free (bitmap_s1_a);
18049 local_free (bitmap_s1_b);
18050 local_free (bitmap_s1_c);
18051 local_free (bitmap_s1_d);
18052 local_free (bitmap_s2_a);
18053 local_free (bitmap_s2_b);
18054 local_free (bitmap_s2_c);
18055 local_free (bitmap_s2_d);
18056
18057 #ifdef HAVE_HWMON
18058 local_free (temp_retain_fanspeed_value);
18059 local_free (od_clock_mem_status);
18060 local_free (od_power_control_status);
18061 local_free (nvml_power_limit);
18062 #endif
18063
18064 global_free (devices_param);
18065
18066 global_free (kernel_rules_buf);
18067
18068 global_free (root_css_buf);
18069 global_free (markov_css_buf);
18070
18071 global_free (digests_buf);
18072 global_free (digests_shown);
18073 global_free (digests_shown_tmp);
18074
18075 global_free (salts_buf);
18076 global_free (salts_shown);
18077
18078 global_free (esalts_buf);
18079
18080 global_free (words_progress_done);
18081 global_free (words_progress_rejected);
18082 global_free (words_progress_restored);
18083
18084 if (pot_fp) fclose (pot_fp);
18085
18086 if (data.devices_status == STATUS_QUIT) break;
18087 }
18088
18089 // destroy others mutex
18090
18091 hc_thread_mutex_delete (mux_dispatcher);
18092 hc_thread_mutex_delete (mux_counter);
18093 hc_thread_mutex_delete (mux_display);
18094 hc_thread_mutex_delete (mux_adl);
18095
18096 // free memory
18097
18098 local_free (eff_restore_file);
18099 local_free (new_restore_file);
18100
18101 local_free (rd);
18102
18103 // tuning db
18104
18105 tuning_db_destroy (tuning_db);
18106
18107 // loopback
18108
18109 local_free (loopback_file);
18110
18111 if (loopback == 1) unlink (loopback_file);
18112
18113 // induction directory
18114
18115 if (induction_dir == NULL)
18116 {
18117 if (attack_mode != ATTACK_MODE_BF)
18118 {
18119 if (rmdir (induction_directory) == -1)
18120 {
18121 if (errno == ENOENT)
18122 {
18123 // good, we can ignore
18124 }
18125 else if (errno == ENOTEMPTY)
18126 {
18127 // good, we can ignore
18128 }
18129 else
18130 {
18131 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18132
18133 return (-1);
18134 }
18135 }
18136
18137 local_free (induction_directory);
18138 }
18139 }
18140
18141 // outfile-check directory
18142
18143 if (outfile_check_dir == NULL)
18144 {
18145 if (rmdir (outfile_check_directory) == -1)
18146 {
18147 if (errno == ENOENT)
18148 {
18149 // good, we can ignore
18150 }
18151 else if (errno == ENOTEMPTY)
18152 {
18153 // good, we can ignore
18154 }
18155 else
18156 {
18157 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18158
18159 return (-1);
18160 }
18161 }
18162
18163 local_free (outfile_check_directory);
18164 }
18165
18166 time_t proc_stop;
18167
18168 time (&proc_stop);
18169
18170 logfile_top_uint (proc_start);
18171 logfile_top_uint (proc_stop);
18172
18173 logfile_top_msg ("STOP");
18174
18175 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18176 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18177
18178 if (data.ocl) ocl_close (data.ocl);
18179
18180 if (data.devices_status == STATUS_ABORTED) return 2;
18181 if (data.devices_status == STATUS_QUIT) return 2;
18182 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18183 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18184 if (data.devices_status == STATUS_CRACKED) return 0;
18185
18186 return -1;
18187 }
Hashcat additions to support pwdhash