projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Redesign some of the kernel_power features like too small wordlist detection etc...
[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 int slowdown_warnings = 0;
3822
3823 // these variables are mainly used for fan control
3824
3825 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3826
3827 // temperature controller "loopback" values
3828
3829 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3830 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3831
3832 int temp_threshold = 1; // degrees celcius
3833
3834 int fan_speed_min = 15; // in percentage
3835 int fan_speed_max = 100;
3836
3837 time_t last_temp_check_time;
3838 #endif // HAVE_HWMON
3839
3840 uint sleep_time = 1;
3841
3842 if (data.runtime)
3843 {
3844 runtime_check = 1;
3845 }
3846
3847 if (data.restore_timer)
3848 {
3849 restore_check = 1;
3850 }
3851
3852 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3853 {
3854 remove_check = 1;
3855 }
3856
3857 if (data.status == 1)
3858 {
3859 status_check = 1;
3860 }
3861
3862 #ifdef HAVE_HWMON
3863 if (data.gpu_temp_disable == 0)
3864 {
3865 time (&last_temp_check_time);
3866
3867 hwmon_check = 1;
3868 }
3869 #endif
3870
3871 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3872 {
3873 #ifdef HAVE_HWMON
3874 if (hwmon_check == 0)
3875 #endif
3876 return (p);
3877 }
3878
3879 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3880 {
3881 hc_sleep (sleep_time);
3882
3883 if (data.devices_status != STATUS_RUNNING) continue;
3884
3885 #ifdef HAVE_HWMON
3886
3887 if (1)
3888 {
3889 hc_thread_mutex_lock (mux_adl);
3890
3891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3892 {
3893 hc_device_param_t *device_param = &data.devices_param[device_id];
3894
3895 if (device_param->skipped) continue;
3896
3897 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3898
3899 const int temperature = hm_get_temperature_with_device_id (device_id);
3900
3901 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3902
3903 if (temperature >= threshold)
3904 {
3905 if (slowdown_warnings < 3)
3906 {
3907 if (data.quiet == 0) clear_prompt ();
3908
3909 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3910
3911 if (slowdown_warnings == 2)
3912 {
3913 log_info ("");
3914 }
3915
3916 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3917 if (data.quiet == 0) fflush (stdout);
3918
3919 slowdown_warnings++;
3920 }
3921 }
3922 else
3923 {
3924 slowdown_warnings = 0;
3925 }
3926 }
3927
3928 hc_thread_mutex_unlock (mux_adl);
3929 }
3930
3931 if (hwmon_check == 1)
3932 {
3933 hc_thread_mutex_lock (mux_adl);
3934
3935 time_t temp_check_time;
3936
3937 time (&temp_check_time);
3938
3939 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3940
3941 if (Ta == 0) Ta = 1;
3942
3943 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3944 {
3945 hc_device_param_t *device_param = &data.devices_param[device_id];
3946
3947 if (device_param->skipped) continue;
3948
3949 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3950
3951 const int temperature = hm_get_temperature_with_device_id (device_id);
3952
3953 if (temperature > (int) data.gpu_temp_abort)
3954 {
3955 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3956
3957 if (data.devices_status != STATUS_QUIT) myabort ();
3958
3959 break;
3960 }
3961
3962 const int gpu_temp_retain = data.gpu_temp_retain;
3963
3964 if (gpu_temp_retain)
3965 {
3966 if (data.hm_device[device_id].fan_set_supported == 1)
3967 {
3968 int temp_cur = temperature;
3969
3970 int temp_diff_new = gpu_temp_retain - temp_cur;
3971
3972 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3973
3974 // calculate Ta value (time difference in seconds between the last check and this check)
3975
3976 last_temp_check_time = temp_check_time;
3977
3978 float Kp = 1.8;
3979 float Ki = 0.005;
3980 float Kd = 6;
3981
3982 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3983
3984 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);
3985
3986 if (abs (fan_diff_required) >= temp_threshold)
3987 {
3988 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3989
3990 int fan_speed_level = fan_speed_cur;
3991
3992 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3993
3994 int fan_speed_new = fan_speed_level - fan_diff_required;
3995
3996 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3997 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3998
3999 if (fan_speed_new != fan_speed_cur)
4000 {
4001 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4002 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4003
4004 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4005 {
4006 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4007 {
4008 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new, 1);
4009 }
4010 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4011 {
4012
4013 }
4014
4015 fan_speed_chgd[device_id] = 1;
4016 }
4017
4018 temp_diff_old[device_id] = temp_diff_new;
4019 }
4020 }
4021 }
4022 }
4023 }
4024
4025 hc_thread_mutex_unlock (mux_adl);
4026 }
4027 #endif // HAVE_HWMON
4028
4029 if (restore_check == 1)
4030 {
4031 restore_left--;
4032
4033 if (restore_left == 0)
4034 {
4035 if (data.restore_disable == 0) cycle_restore ();
4036
4037 restore_left = data.restore_timer;
4038 }
4039 }
4040
4041 if ((runtime_check == 1) && (data.runtime_start > 0))
4042 {
4043 time_t runtime_cur;
4044
4045 time (&runtime_cur);
4046
4047 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4048
4049 if (runtime_left <= 0)
4050 {
4051 if (data.benchmark == 0)
4052 {
4053 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4054 }
4055
4056 if (data.devices_status != STATUS_QUIT) myabort ();
4057 }
4058 }
4059
4060 if (remove_check == 1)
4061 {
4062 remove_left--;
4063
4064 if (remove_left == 0)
4065 {
4066 if (data.digests_saved != data.digests_done)
4067 {
4068 data.digests_saved = data.digests_done;
4069
4070 save_hash ();
4071 }
4072
4073 remove_left = data.remove_timer;
4074 }
4075 }
4076
4077 if (status_check == 1)
4078 {
4079 status_left--;
4080
4081 if (status_left == 0)
4082 {
4083 //hc_thread_mutex_lock (mux_display);
4084
4085 if (data.quiet == 0) clear_prompt ();
4086
4087 if (data.quiet == 0) log_info ("");
4088
4089 status_display ();
4090
4091 if (data.quiet == 0) log_info ("");
4092
4093 //hc_thread_mutex_unlock (mux_display);
4094
4095 status_left = data.status_timer;
4096 }
4097 }
4098 }
4099
4100 #ifdef HAVE_HWMON
4101 myfree (fan_speed_chgd);
4102
4103 myfree (temp_diff_old);
4104 myfree (temp_diff_sum);
4105 #endif
4106
4107 p = NULL;
4108
4109 return (p);
4110 }
4111
4112 static void *thread_outfile_remove (void *p)
4113 {
4114 // some hash-dependent constants
4115 char *outfile_dir = data.outfile_check_directory;
4116 uint dgst_size = data.dgst_size;
4117 uint isSalted = data.isSalted;
4118 uint esalt_size = data.esalt_size;
4119 uint hash_mode = data.hash_mode;
4120
4121 uint outfile_check_timer = data.outfile_check_timer;
4122
4123 char separator = data.separator;
4124
4125 // some hash-dependent functions
4126 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4127 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4128
4129 // buffers
4130 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4131
4132 hash_buf.digest = mymalloc (dgst_size);
4133
4134 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4135
4136 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4137
4138 uint digest_buf[64] = { 0 };
4139
4140 outfile_data_t *out_info = NULL;
4141
4142 char **out_files = NULL;
4143
4144 time_t folder_mtime = 0;
4145
4146 int out_cnt = 0;
4147
4148 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4149
4150 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4151 {
4152 hc_sleep (1);
4153
4154 if (data.devices_status != STATUS_RUNNING) continue;
4155
4156 check_left--;
4157
4158 if (check_left == 0)
4159 {
4160 struct stat outfile_check_stat;
4161
4162 if (stat (outfile_dir, &outfile_check_stat) == 0)
4163 {
4164 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4165
4166 if (is_dir == 1)
4167 {
4168 if (outfile_check_stat.st_mtime > folder_mtime)
4169 {
4170 char **out_files_new = scan_directory (outfile_dir);
4171
4172 int out_cnt_new = count_dictionaries (out_files_new);
4173
4174 outfile_data_t *out_info_new = NULL;
4175
4176 if (out_cnt_new > 0)
4177 {
4178 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4179
4180 for (int i = 0; i < out_cnt_new; i++)
4181 {
4182 out_info_new[i].file_name = out_files_new[i];
4183
4184 // check if there are files that we have seen/checked before (and not changed)
4185
4186 for (int j = 0; j < out_cnt; j++)
4187 {
4188 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4189 {
4190 struct stat outfile_stat;
4191
4192 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4193 {
4194 if (outfile_stat.st_ctime == out_info[j].ctime)
4195 {
4196 out_info_new[i].ctime = out_info[j].ctime;
4197 out_info_new[i].seek = out_info[j].seek;
4198 }
4199 }
4200 }
4201 }
4202 }
4203 }
4204
4205 local_free (out_info);
4206 local_free (out_files);
4207
4208 out_files = out_files_new;
4209 out_cnt = out_cnt_new;
4210 out_info = out_info_new;
4211
4212 folder_mtime = outfile_check_stat.st_mtime;
4213 }
4214
4215 for (int j = 0; j < out_cnt; j++)
4216 {
4217 FILE *fp = fopen (out_info[j].file_name, "rb");
4218
4219 if (fp != NULL)
4220 {
4221 //hc_thread_mutex_lock (mux_display);
4222
4223 #ifdef _POSIX
4224 struct stat outfile_stat;
4225
4226 fstat (fileno (fp), &outfile_stat);
4227 #endif
4228
4229 #ifdef _WIN
4230 struct stat64 outfile_stat;
4231
4232 _fstat64 (fileno (fp), &outfile_stat);
4233 #endif
4234
4235 if (outfile_stat.st_ctime > out_info[j].ctime)
4236 {
4237 out_info[j].ctime = outfile_stat.st_ctime;
4238 out_info[j].seek = 0;
4239 }
4240
4241 fseek (fp, out_info[j].seek, SEEK_SET);
4242
4243 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4244
4245 while (!feof (fp))
4246 {
4247 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4248
4249 if (ptr == NULL) break;
4250
4251 int line_len = strlen (line_buf);
4252
4253 if (line_len <= 0) continue;
4254
4255 int iter = MAX_CUT_TRIES;
4256
4257 for (uint i = line_len - 1; i && iter; i--, line_len--)
4258 {
4259 if (line_buf[i] != separator) continue;
4260
4261 int parser_status = PARSER_OK;
4262
4263 if ((hash_mode != 2500) && (hash_mode != 6800))
4264 {
4265 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4266 }
4267
4268 uint found = 0;
4269
4270 if (parser_status == PARSER_OK)
4271 {
4272 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4273 {
4274 if (data.salts_shown[salt_pos] == 1) continue;
4275
4276 salt_t *salt_buf = &data.salts_buf[salt_pos];
4277
4278 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4279 {
4280 uint idx = salt_buf->digests_offset + digest_pos;
4281
4282 if (data.digests_shown[idx] == 1) continue;
4283
4284 uint cracked = 0;
4285
4286 if (hash_mode == 6800)
4287 {
4288 if (i == salt_buf->salt_len)
4289 {
4290 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4291 }
4292 }
4293 else if (hash_mode == 2500)
4294 {
4295 // BSSID : MAC1 : MAC2 (:plain)
4296 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4297 {
4298 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4299
4300 if (!cracked) continue;
4301
4302 // now compare MAC1 and MAC2 too, since we have this additional info
4303 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4304 char *mac2_pos = mac1_pos + 12 + 1;
4305
4306 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4307 wpa_t *wpa = &wpas[salt_pos];
4308
4309 // compare hex string(s) vs binary MAC address(es)
4310
4311 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4312 {
4313 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4314 {
4315 cracked = 0;
4316
4317 break;
4318 }
4319 }
4320
4321 // early skip ;)
4322 if (!cracked) continue;
4323
4324 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4325 {
4326 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4327 {
4328 cracked = 0;
4329
4330 break;
4331 }
4332 }
4333 }
4334 }
4335 else
4336 {
4337 char *digests_buf_ptr = (char *) data.digests_buf;
4338
4339 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4340
4341 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4342 }
4343
4344 if (cracked == 1)
4345 {
4346 found = 1;
4347
4348 data.digests_shown[idx] = 1;
4349
4350 data.digests_done++;
4351
4352 salt_buf->digests_done++;
4353
4354 if (salt_buf->digests_done == salt_buf->digests_cnt)
4355 {
4356 data.salts_shown[salt_pos] = 1;
4357
4358 data.salts_done++;
4359
4360 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4361 }
4362 }
4363 }
4364
4365 if (data.devices_status == STATUS_CRACKED) break;
4366 }
4367 }
4368
4369 if (found) break;
4370
4371 if (data.devices_status == STATUS_CRACKED) break;
4372
4373 iter--;
4374 }
4375
4376 if (data.devices_status == STATUS_CRACKED) break;
4377 }
4378
4379 myfree (line_buf);
4380
4381 out_info[j].seek = ftell (fp);
4382
4383 //hc_thread_mutex_unlock (mux_display);
4384
4385 fclose (fp);
4386 }
4387 }
4388 }
4389 }
4390
4391 check_left = outfile_check_timer;
4392 }
4393 }
4394
4395 if (esalt_size) local_free (hash_buf.esalt);
4396
4397 if (isSalted) local_free (hash_buf.salt);
4398
4399 local_free (hash_buf.digest);
4400
4401 local_free (out_info);
4402
4403 local_free (out_files);
4404
4405 p = NULL;
4406
4407 return (p);
4408 }
4409
4410 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4411 {
4412 //if (device_param->pws_cnt < device_param->kernel_power)
4413 //{
4414 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4415
4416 u8 *ptr = (u8 *) pw->i;
4417
4418 memcpy (ptr, pw_buf, pw_len);
4419
4420 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4421
4422 pw->pw_len = pw_len;
4423
4424 device_param->pws_cnt++;
4425 //}
4426 //else
4427 //{
4428 // fprintf (stderr, "BUG pw_add()!!\n");
4429 //
4430 // return;
4431 //}
4432 }
4433
4434 static u32 get_power (const u32 kernel_power)
4435 {
4436 if (data.kernel_power_div)
4437 {
4438 return (float) kernel_power * data.kernel_power_div;
4439 }
4440
4441 return kernel_power;
4442 }
4443
4444 static uint get_work (hc_device_param_t *device_param, const u64 max)
4445 {
4446 hc_thread_mutex_lock (mux_dispatcher);
4447
4448 const u64 words_cur = data.words_cur;
4449 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4450
4451 device_param->words_off = words_cur;
4452
4453 const u64 words_left = words_base - words_cur;
4454
4455 if (data.kernel_power_all > words_left)
4456 {
4457 if (data.kernel_power_div == 0)
4458 {
4459 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4460 }
4461 }
4462
4463 const u32 kernel_power = get_power (device_param->kernel_power);
4464
4465 uint work = MIN (words_left, kernel_power);
4466
4467 work = MIN (work, max);
4468
4469 data.words_cur += work;
4470
4471 hc_thread_mutex_unlock (mux_dispatcher);
4472
4473 return work;
4474 }
4475
4476 static void *thread_autotune (void *p)
4477 {
4478 hc_device_param_t *device_param = (hc_device_param_t *) p;
4479
4480 if (device_param->skipped) return NULL;
4481
4482 autotune (device_param);
4483
4484 return NULL;
4485 }
4486
4487 static void *thread_calc_stdin (void *p)
4488 {
4489 hc_device_param_t *device_param = (hc_device_param_t *) p;
4490
4491 if (device_param->skipped) return NULL;
4492
4493 char *buf = (char *) mymalloc (HCBUFSIZ);
4494
4495 const uint attack_kern = data.attack_kern;
4496
4497 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4498 {
4499 hc_thread_mutex_lock (mux_dispatcher);
4500
4501 if (feof (stdin) != 0)
4502 {
4503 hc_thread_mutex_unlock (mux_dispatcher);
4504
4505 break;
4506 }
4507
4508 uint words_cur = 0;
4509
4510 while (words_cur < get_power (device_param->kernel_power))
4511 {
4512 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4513
4514 if (line_buf == NULL) break;
4515
4516 uint line_len = in_superchop (line_buf);
4517
4518 line_len = convert_from_hex (line_buf, line_len);
4519
4520 // post-process rule engine
4521
4522 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4523 {
4524 char rule_buf_out[BLOCK_SIZE] = { 0 };
4525
4526 int rule_len_out = -1;
4527
4528 if (line_len < BLOCK_SIZE)
4529 {
4530 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4531 }
4532
4533 if (rule_len_out < 0) continue;
4534
4535 line_buf = rule_buf_out;
4536 line_len = rule_len_out;
4537 }
4538
4539 if (line_len > PW_MAX)
4540 {
4541 continue;
4542 }
4543
4544 if (attack_kern == ATTACK_KERN_STRAIGHT)
4545 {
4546 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4547 {
4548 hc_thread_mutex_lock (mux_counter);
4549
4550 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4551 {
4552 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4553 }
4554
4555 hc_thread_mutex_unlock (mux_counter);
4556
4557 continue;
4558 }
4559 }
4560 else if (attack_kern == ATTACK_KERN_COMBI)
4561 {
4562 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4563 // since we still need to combine the plains
4564
4565 if (line_len > data.pw_max)
4566 {
4567 hc_thread_mutex_lock (mux_counter);
4568
4569 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4570 {
4571 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4572 }
4573
4574 hc_thread_mutex_unlock (mux_counter);
4575
4576 continue;
4577 }
4578 }
4579
4580 pw_add (device_param, (u8 *) line_buf, line_len);
4581
4582 words_cur++;
4583
4584 if (data.devices_status == STATUS_CRACKED) break;
4585 if (data.devices_status == STATUS_ABORTED) break;
4586 if (data.devices_status == STATUS_QUIT) break;
4587 if (data.devices_status == STATUS_BYPASS) break;
4588 }
4589
4590 hc_thread_mutex_unlock (mux_dispatcher);
4591
4592 if (data.devices_status == STATUS_CRACKED) break;
4593 if (data.devices_status == STATUS_ABORTED) break;
4594 if (data.devices_status == STATUS_QUIT) break;
4595 if (data.devices_status == STATUS_BYPASS) break;
4596
4597 // flush
4598
4599 const uint pws_cnt = device_param->pws_cnt;
4600
4601 if (pws_cnt)
4602 {
4603 run_copy (device_param, pws_cnt);
4604
4605 run_cracker (device_param, pws_cnt);
4606
4607 device_param->pws_cnt = 0;
4608
4609 /*
4610 still required?
4611 if (attack_kern == ATTACK_KERN_STRAIGHT)
4612 {
4613 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4614 }
4615 else if (attack_kern == ATTACK_KERN_COMBI)
4616 {
4617 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4618 }
4619 */
4620 }
4621 }
4622
4623 device_param->kernel_accel = 0;
4624 device_param->kernel_loops = 0;
4625
4626 myfree (buf);
4627
4628 return NULL;
4629 }
4630
4631 static void *thread_calc (void *p)
4632 {
4633 hc_device_param_t *device_param = (hc_device_param_t *) p;
4634
4635 if (device_param->skipped) return NULL;
4636
4637 const uint attack_mode = data.attack_mode;
4638 const uint attack_kern = data.attack_kern;
4639
4640 if (attack_mode == ATTACK_MODE_BF)
4641 {
4642 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4643 {
4644 const uint work = get_work (device_param, -1);
4645
4646 if (work == 0) break;
4647
4648 const u64 words_off = device_param->words_off;
4649 const u64 words_fin = words_off + work;
4650
4651 const uint pws_cnt = work;
4652
4653 device_param->pws_cnt = pws_cnt;
4654
4655 if (pws_cnt)
4656 {
4657 run_copy (device_param, pws_cnt);
4658
4659 run_cracker (device_param, pws_cnt);
4660
4661 device_param->pws_cnt = 0;
4662
4663 /*
4664 still required?
4665 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4666 */
4667 }
4668
4669 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4670
4671 if (data.devices_status == STATUS_CRACKED) break;
4672 if (data.devices_status == STATUS_ABORTED) break;
4673 if (data.devices_status == STATUS_QUIT) break;
4674 if (data.devices_status == STATUS_BYPASS) break;
4675
4676 if (data.benchmark == 1) break;
4677
4678 device_param->words_done = words_fin;
4679 }
4680 }
4681 else
4682 {
4683 const uint segment_size = data.segment_size;
4684
4685 char *dictfile = data.dictfile;
4686
4687 if (attack_mode == ATTACK_MODE_COMBI)
4688 {
4689 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4690 {
4691 dictfile = data.dictfile2;
4692 }
4693 }
4694
4695 FILE *fd = fopen (dictfile, "rb");
4696
4697 if (fd == NULL)
4698 {
4699 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4700
4701 return NULL;
4702 }
4703
4704 if (attack_mode == ATTACK_MODE_COMBI)
4705 {
4706 const uint combs_mode = data.combs_mode;
4707
4708 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4709 {
4710 const char *dictfilec = data.dictfile2;
4711
4712 FILE *combs_fp = fopen (dictfilec, "rb");
4713
4714 if (combs_fp == NULL)
4715 {
4716 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4717
4718 fclose (fd);
4719
4720 return NULL;
4721 }
4722
4723 device_param->combs_fp = combs_fp;
4724 }
4725 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4726 {
4727 const char *dictfilec = data.dictfile;
4728
4729 FILE *combs_fp = fopen (dictfilec, "rb");
4730
4731 if (combs_fp == NULL)
4732 {
4733 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4734
4735 fclose (fd);
4736
4737 return NULL;
4738 }
4739
4740 device_param->combs_fp = combs_fp;
4741 }
4742 }
4743
4744 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4745
4746 wl_data->buf = (char *) mymalloc (segment_size);
4747 wl_data->avail = segment_size;
4748 wl_data->incr = segment_size;
4749 wl_data->cnt = 0;
4750 wl_data->pos = 0;
4751
4752 u64 words_cur = 0;
4753
4754 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4755 {
4756 u64 words_off = 0;
4757 u64 words_fin = 0;
4758
4759 u64 max = -1;
4760
4761 while (max)
4762 {
4763 const uint work = get_work (device_param, max);
4764
4765 if (work == 0) break;
4766
4767 max = 0;
4768
4769 words_off = device_param->words_off;
4770 words_fin = words_off + work;
4771
4772 char *line_buf;
4773 uint line_len;
4774
4775 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4776
4777 for ( ; words_cur < words_fin; words_cur++)
4778 {
4779 get_next_word (wl_data, fd, &line_buf, &line_len);
4780
4781 line_len = convert_from_hex (line_buf, line_len);
4782
4783 // post-process rule engine
4784
4785 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4786 {
4787 char rule_buf_out[BLOCK_SIZE] = { 0 };
4788
4789 int rule_len_out = -1;
4790
4791 if (line_len < BLOCK_SIZE)
4792 {
4793 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4794 }
4795
4796 if (rule_len_out < 0) continue;
4797
4798 line_buf = rule_buf_out;
4799 line_len = rule_len_out;
4800 }
4801
4802 if (attack_kern == ATTACK_KERN_STRAIGHT)
4803 {
4804 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4805 {
4806 max++;
4807
4808 hc_thread_mutex_lock (mux_counter);
4809
4810 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4811 {
4812 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4813 }
4814
4815 hc_thread_mutex_unlock (mux_counter);
4816
4817 continue;
4818 }
4819 }
4820 else if (attack_kern == ATTACK_KERN_COMBI)
4821 {
4822 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4823 // since we still need to combine the plains
4824
4825 if (line_len > data.pw_max)
4826 {
4827 max++;
4828
4829 hc_thread_mutex_lock (mux_counter);
4830
4831 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4832 {
4833 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4834 }
4835
4836 hc_thread_mutex_unlock (mux_counter);
4837
4838 continue;
4839 }
4840 }
4841
4842 pw_add (device_param, (u8 *) line_buf, line_len);
4843
4844 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4845
4846 if (data.devices_status == STATUS_CRACKED) break;
4847 if (data.devices_status == STATUS_ABORTED) break;
4848 if (data.devices_status == STATUS_QUIT) break;
4849 if (data.devices_status == STATUS_BYPASS) break;
4850 }
4851
4852 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4853
4854 if (data.devices_status == STATUS_CRACKED) break;
4855 if (data.devices_status == STATUS_ABORTED) break;
4856 if (data.devices_status == STATUS_QUIT) break;
4857 if (data.devices_status == STATUS_BYPASS) break;
4858 }
4859
4860 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4861
4862 if (data.devices_status == STATUS_CRACKED) break;
4863 if (data.devices_status == STATUS_ABORTED) break;
4864 if (data.devices_status == STATUS_QUIT) break;
4865 if (data.devices_status == STATUS_BYPASS) break;
4866
4867 //
4868 // flush
4869 //
4870
4871 const uint pws_cnt = device_param->pws_cnt;
4872
4873 if (pws_cnt)
4874 {
4875 run_copy (device_param, pws_cnt);
4876
4877 run_cracker (device_param, pws_cnt);
4878
4879 device_param->pws_cnt = 0;
4880
4881 /*
4882 still required?
4883 if (attack_kern == ATTACK_KERN_STRAIGHT)
4884 {
4885 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4886 }
4887 else if (attack_kern == ATTACK_KERN_COMBI)
4888 {
4889 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4890 }
4891 */
4892 }
4893
4894 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4895
4896 if (data.devices_status == STATUS_CRACKED) break;
4897 if (data.devices_status == STATUS_ABORTED) break;
4898 if (data.devices_status == STATUS_QUIT) break;
4899 if (data.devices_status == STATUS_BYPASS) break;
4900
4901 if (words_fin == 0) break;
4902
4903 device_param->words_done = words_fin;
4904 }
4905
4906 if (attack_mode == ATTACK_MODE_COMBI)
4907 {
4908 fclose (device_param->combs_fp);
4909 }
4910
4911 free (wl_data->buf);
4912 free (wl_data);
4913
4914 fclose (fd);
4915 }
4916
4917 device_param->kernel_accel = 0;
4918 device_param->kernel_loops = 0;
4919
4920 return NULL;
4921 }
4922
4923 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4924 {
4925 if (!device_param)
4926 {
4927 log_error ("ERROR: %s : Invalid argument", __func__);
4928
4929 exit (-1);
4930 }
4931
4932 salt_t *salt_buf = &data.salts_buf[salt_pos];
4933
4934 device_param->kernel_params_buf32[24] = salt_pos;
4935 device_param->kernel_params_buf32[27] = 1;
4936 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4937 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4938 device_param->kernel_params_buf32[30] = 0;
4939 device_param->kernel_params_buf32[31] = 1;
4940
4941 char *dictfile_old = data.dictfile;
4942
4943 const char *weak_hash_check = "weak-hash-check";
4944
4945 data.dictfile = (char *) weak_hash_check;
4946
4947 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4948
4949 data.kernel_rules_buf[0].cmds[0] = 0;
4950
4951 /**
4952 * run the kernel
4953 */
4954
4955 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4956 {
4957 run_kernel (KERN_RUN_1, device_param, 1, false);
4958 }
4959 else
4960 {
4961 run_kernel (KERN_RUN_1, device_param, 1, false);
4962
4963 uint loop_step = 16;
4964
4965 const uint iter = salt_buf->salt_iter;
4966
4967 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4968 {
4969 uint loop_left = iter - loop_pos;
4970
4971 loop_left = MIN (loop_left, loop_step);
4972
4973 device_param->kernel_params_buf32[25] = loop_pos;
4974 device_param->kernel_params_buf32[26] = loop_left;
4975
4976 run_kernel (KERN_RUN_2, device_param, 1, false);
4977 }
4978
4979 run_kernel (KERN_RUN_3, device_param, 1, false);
4980 }
4981
4982 /**
4983 * result
4984 */
4985
4986 check_cracked (device_param, salt_pos);
4987
4988 /**
4989 * cleanup
4990 */
4991
4992 device_param->kernel_params_buf32[24] = 0;
4993 device_param->kernel_params_buf32[25] = 0;
4994 device_param->kernel_params_buf32[26] = 0;
4995 device_param->kernel_params_buf32[27] = 0;
4996 device_param->kernel_params_buf32[28] = 0;
4997 device_param->kernel_params_buf32[29] = 0;
4998 device_param->kernel_params_buf32[30] = 0;
4999 device_param->kernel_params_buf32[31] = 0;
5000
5001 data.dictfile = dictfile_old;
5002
5003 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5004 }
5005
5006 // hlfmt hashcat
5007
5008 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5009 {
5010 if (data.username == 0)
5011 {
5012 *hashbuf_pos = line_buf;
5013 *hashbuf_len = line_len;
5014 }
5015 else
5016 {
5017 char *pos = line_buf;
5018 int len = line_len;
5019
5020 for (int i = 0; i < line_len; i++, pos++, len--)
5021 {
5022 if (line_buf[i] == data.separator)
5023 {
5024 pos++;
5025
5026 len--;
5027
5028 break;
5029 }
5030 }
5031
5032 *hashbuf_pos = pos;
5033 *hashbuf_len = len;
5034 }
5035 }
5036
5037 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5038 {
5039 char *pos = NULL;
5040 int len = 0;
5041
5042 int sep_cnt = 0;
5043
5044 for (int i = 0; i < line_len; i++)
5045 {
5046 if (line_buf[i] == data.separator)
5047 {
5048 sep_cnt++;
5049
5050 continue;
5051 }
5052
5053 if (sep_cnt == 0)
5054 {
5055 if (pos == NULL) pos = line_buf + i;
5056
5057 len++;
5058 }
5059 }
5060
5061 *userbuf_pos = pos;
5062 *userbuf_len = len;
5063 }
5064
5065 // hlfmt pwdump
5066
5067 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5068 {
5069 int sep_cnt = 0;
5070
5071 int sep2_len = 0;
5072 int sep3_len = 0;
5073
5074 for (int i = 0; i < line_len; i++)
5075 {
5076 if (line_buf[i] == ':')
5077 {
5078 sep_cnt++;
5079
5080 continue;
5081 }
5082
5083 if (sep_cnt == 2) sep2_len++;
5084 if (sep_cnt == 3) sep3_len++;
5085 }
5086
5087 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5088
5089 return 0;
5090 }
5091
5092 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5093 {
5094 char *pos = NULL;
5095 int len = 0;
5096
5097 int sep_cnt = 0;
5098
5099 for (int i = 0; i < line_len; i++)
5100 {
5101 if (line_buf[i] == ':')
5102 {
5103 sep_cnt++;
5104
5105 continue;
5106 }
5107
5108 if (data.hash_mode == 1000)
5109 {
5110 if (sep_cnt == 3)
5111 {
5112 if (pos == NULL) pos = line_buf + i;
5113
5114 len++;
5115 }
5116 }
5117 else if (data.hash_mode == 3000)
5118 {
5119 if (sep_cnt == 2)
5120 {
5121 if (pos == NULL) pos = line_buf + i;
5122
5123 len++;
5124 }
5125 }
5126 }
5127
5128 *hashbuf_pos = pos;
5129 *hashbuf_len = len;
5130 }
5131
5132 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5133 {
5134 char *pos = NULL;
5135 int len = 0;
5136
5137 int sep_cnt = 0;
5138
5139 for (int i = 0; i < line_len; i++)
5140 {
5141 if (line_buf[i] == ':')
5142 {
5143 sep_cnt++;
5144
5145 continue;
5146 }
5147
5148 if (sep_cnt == 0)
5149 {
5150 if (pos == NULL) pos = line_buf + i;
5151
5152 len++;
5153 }
5154 }
5155
5156 *userbuf_pos = pos;
5157 *userbuf_len = len;
5158 }
5159
5160 // hlfmt passwd
5161
5162 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5163 {
5164 int sep_cnt = 0;
5165
5166 char sep5_first = 0;
5167 char sep6_first = 0;
5168
5169 for (int i = 0; i < line_len; i++)
5170 {
5171 if (line_buf[i] == ':')
5172 {
5173 sep_cnt++;
5174
5175 continue;
5176 }
5177
5178 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5179 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5180 }
5181
5182 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5183
5184 return 0;
5185 }
5186
5187 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5188 {
5189 char *pos = NULL;
5190 int len = 0;
5191
5192 int sep_cnt = 0;
5193
5194 for (int i = 0; i < line_len; i++)
5195 {
5196 if (line_buf[i] == ':')
5197 {
5198 sep_cnt++;
5199
5200 continue;
5201 }
5202
5203 if (sep_cnt == 1)
5204 {
5205 if (pos == NULL) pos = line_buf + i;
5206
5207 len++;
5208 }
5209 }
5210
5211 *hashbuf_pos = pos;
5212 *hashbuf_len = len;
5213 }
5214
5215 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5216 {
5217 char *pos = NULL;
5218 int len = 0;
5219
5220 int sep_cnt = 0;
5221
5222 for (int i = 0; i < line_len; i++)
5223 {
5224 if (line_buf[i] == ':')
5225 {
5226 sep_cnt++;
5227
5228 continue;
5229 }
5230
5231 if (sep_cnt == 0)
5232 {
5233 if (pos == NULL) pos = line_buf + i;
5234
5235 len++;
5236 }
5237 }
5238
5239 *userbuf_pos = pos;
5240 *userbuf_len = len;
5241 }
5242
5243 // hlfmt shadow
5244
5245 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5246 {
5247 int sep_cnt = 0;
5248
5249 for (int i = 0; i < line_len; i++)
5250 {
5251 if (line_buf[i] == ':') sep_cnt++;
5252 }
5253
5254 if (sep_cnt == 8) return 1;
5255
5256 return 0;
5257 }
5258
5259 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5260 {
5261 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5262 }
5263
5264 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5265 {
5266 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5267 }
5268
5269 // hlfmt main
5270
5271 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5272 {
5273 switch (hashfile_format)
5274 {
5275 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5276 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5277 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5278 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5279 }
5280 }
5281
5282 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5283 {
5284 switch (hashfile_format)
5285 {
5286 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5287 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5288 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5289 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5290 }
5291 }
5292
5293 char *strhlfmt (const uint hashfile_format)
5294 {
5295 switch (hashfile_format)
5296 {
5297 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5298 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5299 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5300 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5301 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5302 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5303 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5304 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5305 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5306 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5307 }
5308
5309 return ((char *) "Unknown");
5310 }
5311
5312 static uint hlfmt_detect (FILE *fp, uint max_check)
5313 {
5314 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5315
5316 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5317 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5318
5319 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5320
5321 uint num_check = 0;
5322
5323 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5324
5325 while (!feof (fp))
5326 {
5327 int line_len = fgetl (fp, line_buf);
5328
5329 if (line_len == 0) continue;
5330
5331 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5332 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5333 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5334
5335 if (num_check == max_check) break;
5336
5337 num_check++;
5338 }
5339
5340 myfree (line_buf);
5341
5342 uint hashlist_format = HLFMT_HASHCAT;
5343
5344 for (int i = 1; i < HLFMTS_CNT; i++)
5345 {
5346 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5347
5348 hashlist_format = i;
5349 }
5350
5351 free (formats_cnt);
5352
5353 return hashlist_format;
5354 }
5355
5356 /**
5357 * some further helper function
5358 */
5359
5360 // wrapper around mymalloc for ADL
5361
5362 #if defined(HAVE_HWMON)
5363 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5364 {
5365 return mymalloc (iSize);
5366 }
5367 #endif
5368
5369 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)
5370 {
5371 u64 collisions = 0;
5372
5373 const uint dgst_pos0 = data.dgst_pos0;
5374 const uint dgst_pos1 = data.dgst_pos1;
5375 const uint dgst_pos2 = data.dgst_pos2;
5376 const uint dgst_pos3 = data.dgst_pos3;
5377
5378 memset (bitmap_a, 0, bitmap_size);
5379 memset (bitmap_b, 0, bitmap_size);
5380 memset (bitmap_c, 0, bitmap_size);
5381 memset (bitmap_d, 0, bitmap_size);
5382
5383 for (uint i = 0; i < digests_cnt; i++)
5384 {
5385 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5386
5387 uint *digest_ptr = (uint *) digests_buf_ptr;
5388
5389 digests_buf_ptr += dgst_size;
5390
5391 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5392 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5393 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5394 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5395
5396 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5397 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5398 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5399 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5400
5401 if (bitmap_a[idx0] & val0) collisions++;
5402 if (bitmap_b[idx1] & val1) collisions++;
5403 if (bitmap_c[idx2] & val2) collisions++;
5404 if (bitmap_d[idx3] & val3) collisions++;
5405
5406 bitmap_a[idx0] |= val0;
5407 bitmap_b[idx1] |= val1;
5408 bitmap_c[idx2] |= val2;
5409 bitmap_d[idx3] |= val3;
5410
5411 if (collisions >= collisions_max) return 0x7fffffff;
5412 }
5413
5414 return collisions;
5415 }
5416
5417 /**
5418 * main
5419 */
5420
5421 #ifdef _WIN
5422 void SetConsoleWindowSize (const int x)
5423 {
5424 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5425
5426 if (h == INVALID_HANDLE_VALUE) return;
5427
5428 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5429
5430 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5431
5432 SMALL_RECT *sr = &bufferInfo.srWindow;
5433
5434 sr->Right = MAX (sr->Right, x - 1);
5435
5436 COORD co;
5437
5438 co.X = sr->Right + 1;
5439 co.Y = sr->Bottom + 1;
5440
5441 if (!SetConsoleScreenBufferSize (h, co)) return;
5442
5443 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5444 }
5445 #endif
5446
5447 int main (int argc, char **argv)
5448 {
5449 #ifdef _WIN
5450 SetConsoleWindowSize (132);
5451 #endif
5452
5453 /**
5454 * To help users a bit
5455 */
5456
5457 char *compute = getenv ("COMPUTE");
5458
5459 if (compute)
5460 {
5461 static char display[100];
5462
5463 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5464
5465 putenv (display);
5466 }
5467 else
5468 {
5469 if (getenv ("DISPLAY") == NULL)
5470 putenv ((char *) "DISPLAY=:0");
5471 }
5472
5473 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5474 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5475
5476 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5477 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5478
5479 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5480 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5481
5482 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5483 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5484
5485 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5486 putenv ((char *) "POCL_KERNEL_CACHE=0");
5487
5488 umask (077);
5489
5490 /**
5491 * Real init
5492 */
5493
5494 memset (&data, 0, sizeof (hc_global_data_t));
5495
5496 time_t proc_start;
5497
5498 time (&proc_start);
5499
5500 data.proc_start = proc_start;
5501
5502 int myargc = argc;
5503 char **myargv = argv;
5504
5505 hc_thread_mutex_init (mux_dispatcher);
5506 hc_thread_mutex_init (mux_counter);
5507 hc_thread_mutex_init (mux_display);
5508 hc_thread_mutex_init (mux_adl);
5509
5510 /**
5511 * commandline parameters
5512 */
5513
5514 uint usage = USAGE;
5515 uint version = VERSION;
5516 uint quiet = QUIET;
5517 uint benchmark = BENCHMARK;
5518 uint show = SHOW;
5519 uint left = LEFT;
5520 uint username = USERNAME;
5521 uint remove = REMOVE;
5522 uint remove_timer = REMOVE_TIMER;
5523 u64 skip = SKIP;
5524 u64 limit = LIMIT;
5525 uint keyspace = KEYSPACE;
5526 uint potfile_disable = POTFILE_DISABLE;
5527 char *potfile_path = NULL;
5528 uint debug_mode = DEBUG_MODE;
5529 char *debug_file = NULL;
5530 char *induction_dir = NULL;
5531 char *outfile_check_dir = NULL;
5532 uint force = FORCE;
5533 uint runtime = RUNTIME;
5534 uint hash_mode = HASH_MODE;
5535 uint attack_mode = ATTACK_MODE;
5536 uint markov_disable = MARKOV_DISABLE;
5537 uint markov_classic = MARKOV_CLASSIC;
5538 uint markov_threshold = MARKOV_THRESHOLD;
5539 char *markov_hcstat = NULL;
5540 char *outfile = NULL;
5541 uint outfile_format = OUTFILE_FORMAT;
5542 uint outfile_autohex = OUTFILE_AUTOHEX;
5543 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5544 uint restore = RESTORE;
5545 uint restore_timer = RESTORE_TIMER;
5546 uint restore_disable = RESTORE_DISABLE;
5547 uint status = STATUS;
5548 uint status_timer = STATUS_TIMER;
5549 uint machine_readable = MACHINE_READABLE;
5550 uint loopback = LOOPBACK;
5551 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5552 char *session = NULL;
5553 uint hex_charset = HEX_CHARSET;
5554 uint hex_salt = HEX_SALT;
5555 uint hex_wordlist = HEX_WORDLIST;
5556 uint rp_gen = RP_GEN;
5557 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5558 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5559 uint rp_gen_seed = RP_GEN_SEED;
5560 char *rule_buf_l = (char *) RULE_BUF_L;
5561 char *rule_buf_r = (char *) RULE_BUF_R;
5562 uint increment = INCREMENT;
5563 uint increment_min = INCREMENT_MIN;
5564 uint increment_max = INCREMENT_MAX;
5565 char *cpu_affinity = NULL;
5566 OCL_PTR *ocl = NULL;
5567 char *opencl_devices = NULL;
5568 char *opencl_platforms = NULL;
5569 char *opencl_device_types = NULL;
5570 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5571 char *truecrypt_keyfiles = NULL;
5572 char *veracrypt_keyfiles = NULL;
5573 uint veracrypt_pim = 0;
5574 uint workload_profile = WORKLOAD_PROFILE;
5575 uint kernel_accel = KERNEL_ACCEL;
5576 uint kernel_loops = KERNEL_LOOPS;
5577 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5578 #ifdef HAVE_HWMON
5579 uint gpu_temp_abort = GPU_TEMP_ABORT;
5580 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5581 uint powertune_enable = POWERTUNE_ENABLE;
5582 #endif
5583 uint logfile_disable = LOGFILE_DISABLE;
5584 uint segment_size = SEGMENT_SIZE;
5585 uint scrypt_tmto = SCRYPT_TMTO;
5586 char separator = SEPARATOR;
5587 uint bitmap_min = BITMAP_MIN;
5588 uint bitmap_max = BITMAP_MAX;
5589 char *custom_charset_1 = NULL;
5590 char *custom_charset_2 = NULL;
5591 char *custom_charset_3 = NULL;
5592 char *custom_charset_4 = NULL;
5593
5594 #define IDX_HELP 'h'
5595 #define IDX_VERSION 'V'
5596 #define IDX_VERSION_LOWER 'v'
5597 #define IDX_QUIET 0xff02
5598 #define IDX_SHOW 0xff03
5599 #define IDX_LEFT 0xff04
5600 #define IDX_REMOVE 0xff05
5601 #define IDX_REMOVE_TIMER 0xff37
5602 #define IDX_SKIP 's'
5603 #define IDX_LIMIT 'l'
5604 #define IDX_KEYSPACE 0xff35
5605 #define IDX_POTFILE_DISABLE 0xff06
5606 #define IDX_POTFILE_PATH 0xffe0
5607 #define IDX_DEBUG_MODE 0xff43
5608 #define IDX_DEBUG_FILE 0xff44
5609 #define IDX_INDUCTION_DIR 0xff46
5610 #define IDX_OUTFILE_CHECK_DIR 0xff47
5611 #define IDX_USERNAME 0xff07
5612 #define IDX_FORCE 0xff08
5613 #define IDX_RUNTIME 0xff09
5614 #define IDX_BENCHMARK 'b'
5615 #define IDX_HASH_MODE 'm'
5616 #define IDX_ATTACK_MODE 'a'
5617 #define IDX_RP_FILE 'r'
5618 #define IDX_RP_GEN 'g'
5619 #define IDX_RP_GEN_FUNC_MIN 0xff10
5620 #define IDX_RP_GEN_FUNC_MAX 0xff11
5621 #define IDX_RP_GEN_SEED 0xff34
5622 #define IDX_RULE_BUF_L 'j'
5623 #define IDX_RULE_BUF_R 'k'
5624 #define IDX_INCREMENT 'i'
5625 #define IDX_INCREMENT_MIN 0xff12
5626 #define IDX_INCREMENT_MAX 0xff13
5627 #define IDX_OUTFILE 'o'
5628 #define IDX_OUTFILE_FORMAT 0xff14
5629 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5630 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5631 #define IDX_RESTORE 0xff15
5632 #define IDX_RESTORE_DISABLE 0xff27
5633 #define IDX_STATUS 0xff17
5634 #define IDX_STATUS_TIMER 0xff18
5635 #define IDX_MACHINE_READABLE 0xff50
5636 #define IDX_LOOPBACK 0xff38
5637 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5638 #define IDX_SESSION 0xff19
5639 #define IDX_HEX_CHARSET 0xff20
5640 #define IDX_HEX_SALT 0xff21
5641 #define IDX_HEX_WORDLIST 0xff40
5642 #define IDX_MARKOV_DISABLE 0xff22
5643 #define IDX_MARKOV_CLASSIC 0xff23
5644 #define IDX_MARKOV_THRESHOLD 't'
5645 #define IDX_MARKOV_HCSTAT 0xff24
5646 #define IDX_CPU_AFFINITY 0xff25
5647 #define IDX_OPENCL_DEVICES 'd'
5648 #define IDX_OPENCL_PLATFORMS 0xff72
5649 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5650 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5651 #define IDX_WORKLOAD_PROFILE 'w'
5652 #define IDX_KERNEL_ACCEL 'n'
5653 #define IDX_KERNEL_LOOPS 'u'
5654 #define IDX_GPU_TEMP_DISABLE 0xff29
5655 #define IDX_GPU_TEMP_ABORT 0xff30
5656 #define IDX_GPU_TEMP_RETAIN 0xff31
5657 #define IDX_POWERTUNE_ENABLE 0xff41
5658 #define IDX_LOGFILE_DISABLE 0xff51
5659 #define IDX_TRUECRYPT_KEYFILES 0xff52
5660 #define IDX_VERACRYPT_KEYFILES 0xff53
5661 #define IDX_VERACRYPT_PIM 0xff54
5662 #define IDX_SCRYPT_TMTO 0xff61
5663 #define IDX_SEGMENT_SIZE 'c'
5664 #define IDX_SEPARATOR 'p'
5665 #define IDX_BITMAP_MIN 0xff70
5666 #define IDX_BITMAP_MAX 0xff71
5667 #define IDX_CUSTOM_CHARSET_1 '1'
5668 #define IDX_CUSTOM_CHARSET_2 '2'
5669 #define IDX_CUSTOM_CHARSET_3 '3'
5670 #define IDX_CUSTOM_CHARSET_4 '4'
5671
5672 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5673
5674 struct option long_options[] =
5675 {
5676 {"help", no_argument, 0, IDX_HELP},
5677 {"version", no_argument, 0, IDX_VERSION},
5678 {"quiet", no_argument, 0, IDX_QUIET},
5679 {"show", no_argument, 0, IDX_SHOW},
5680 {"left", no_argument, 0, IDX_LEFT},
5681 {"username", no_argument, 0, IDX_USERNAME},
5682 {"remove", no_argument, 0, IDX_REMOVE},
5683 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5684 {"skip", required_argument, 0, IDX_SKIP},
5685 {"limit", required_argument, 0, IDX_LIMIT},
5686 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5687 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5688 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5689 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5690 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5691 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5692 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5693 {"force", no_argument, 0, IDX_FORCE},
5694 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5695 {"restore", no_argument, 0, IDX_RESTORE},
5696 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5697 {"status", no_argument, 0, IDX_STATUS},
5698 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5699 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5700 {"loopback", no_argument, 0, IDX_LOOPBACK},
5701 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5702 {"session", required_argument, 0, IDX_SESSION},
5703 {"runtime", required_argument, 0, IDX_RUNTIME},
5704 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5705 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5706 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5707 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5708 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5709 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5710 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5711 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5712 {"rules-file", required_argument, 0, IDX_RP_FILE},
5713 {"outfile", required_argument, 0, IDX_OUTFILE},
5714 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5715 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5716 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5717 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5718 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5719 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5720 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5721 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5722 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5723 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5724 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5725 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5726 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5727 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5728 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5729 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5730 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5731 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5732 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5733 #ifdef HAVE_HWMON
5734 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5735 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5736 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5737 #endif // HAVE_HWMON
5738 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5739 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5740 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5741 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5742 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5743 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5744 {"seperator", required_argument, 0, IDX_SEPARATOR},
5745 {"separator", required_argument, 0, IDX_SEPARATOR},
5746 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5747 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5748 {"increment", no_argument, 0, IDX_INCREMENT},
5749 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5750 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5751 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5752 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5753 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5754 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5755 {0, 0, 0, 0}
5756 };
5757
5758 uint rp_files_cnt = 0;
5759
5760 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5761
5762 int option_index = 0;
5763 int c = -1;
5764
5765 optind = 1;
5766 optopt = 0;
5767
5768 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5769 {
5770 switch (c)
5771 {
5772 case IDX_HELP: usage = 1; break;
5773 case IDX_VERSION:
5774 case IDX_VERSION_LOWER: version = 1; break;
5775 case IDX_RESTORE: restore = 1; break;
5776 case IDX_SESSION: session = optarg; break;
5777 case IDX_SHOW: show = 1; break;
5778 case IDX_LEFT: left = 1; break;
5779 case '?': return (-1);
5780 }
5781 }
5782
5783 if (optopt != 0)
5784 {
5785 log_error ("ERROR: Invalid argument specified");
5786
5787 return (-1);
5788 }
5789
5790 /**
5791 * exit functions
5792 */
5793
5794 if (version)
5795 {
5796 log_info ("%s", VERSION_TAG);
5797
5798 return (0);
5799 }
5800
5801 if (usage)
5802 {
5803 usage_big_print (PROGNAME);
5804
5805 return (0);
5806 }
5807
5808 /**
5809 * session needs to be set, always!
5810 */
5811
5812 if (session == NULL) session = (char *) PROGNAME;
5813
5814 /**
5815 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5816 */
5817
5818 char *exec_path = get_exec_path ();
5819
5820 #ifdef LINUX
5821
5822 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5823 char *resolved_exec_path = realpath (exec_path, NULL);
5824
5825 char *install_dir = get_install_dir (resolved_exec_path);
5826 char *profile_dir = NULL;
5827 char *session_dir = NULL;
5828 char *shared_dir = NULL;
5829
5830 if (strcmp (install_dir, resolved_install_folder) == 0)
5831 {
5832 struct passwd *pw = getpwuid (getuid ());
5833
5834 const char *homedir = pw->pw_dir;
5835
5836 profile_dir = get_profile_dir (homedir);
5837 session_dir = get_session_dir (profile_dir);
5838 shared_dir = strdup (SHARED_FOLDER);
5839
5840 mkdir (profile_dir, 0700);
5841 mkdir (session_dir, 0700);
5842 }
5843 else
5844 {
5845 profile_dir = install_dir;
5846 session_dir = install_dir;
5847 shared_dir = install_dir;
5848 }
5849
5850 myfree (resolved_install_folder);
5851 myfree (resolved_exec_path);
5852
5853 #else
5854
5855 char *install_dir = get_install_dir (exec_path);
5856 char *profile_dir = install_dir;
5857 char *session_dir = install_dir;
5858 char *shared_dir = install_dir;
5859
5860 #endif
5861
5862 data.install_dir = install_dir;
5863 data.profile_dir = profile_dir;
5864 data.session_dir = session_dir;
5865 data.shared_dir = shared_dir;
5866
5867 myfree (exec_path);
5868
5869 /**
5870 * kernel cache, we need to make sure folder exist
5871 */
5872
5873 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5874
5875 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5876
5877 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5878
5879 mkdir (kernels_folder, 0700);
5880
5881 myfree (kernels_folder);
5882
5883 /**
5884 * session
5885 */
5886
5887 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5888
5889 data.session = session;
5890
5891 char *eff_restore_file = (char *) mymalloc (session_size);
5892 char *new_restore_file = (char *) mymalloc (session_size);
5893
5894 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5895 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5896
5897 data.eff_restore_file = eff_restore_file;
5898 data.new_restore_file = new_restore_file;
5899
5900 if (((show == 1) || (left == 1)) && (restore == 1))
5901 {
5902 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5903 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5904
5905 return (-1);
5906 }
5907
5908 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5909 if ((show == 1) || (left == 1))
5910 {
5911 restore_disable = 1;
5912
5913 restore = 0;
5914 }
5915
5916 data.restore_disable = restore_disable;
5917
5918 restore_data_t *rd = init_restore (argc, argv);
5919
5920 data.rd = rd;
5921
5922 /**
5923 * restore file
5924 */
5925
5926 if (restore == 1)
5927 {
5928 read_restore (eff_restore_file, rd);
5929
5930 if (rd->version_bin < RESTORE_MIN)
5931 {
5932 log_error ("ERROR: Incompatible restore-file version");
5933
5934 return (-1);
5935 }
5936
5937 myargc = rd->argc;
5938 myargv = rd->argv;
5939
5940 #ifdef _POSIX
5941 rd->pid = getpid ();
5942 #elif _WIN
5943 rd->pid = GetCurrentProcessId ();
5944 #endif
5945 }
5946
5947 uint hash_mode_chgd = 0;
5948 uint runtime_chgd = 0;
5949 uint kernel_loops_chgd = 0;
5950 uint kernel_accel_chgd = 0;
5951 uint attack_mode_chgd = 0;
5952 uint outfile_format_chgd = 0;
5953 uint rp_gen_seed_chgd = 0;
5954 uint remove_timer_chgd = 0;
5955 uint increment_min_chgd = 0;
5956 uint increment_max_chgd = 0;
5957 uint workload_profile_chgd = 0;
5958 uint opencl_vector_width_chgd = 0;
5959
5960 optind = 1;
5961 optopt = 0;
5962 option_index = 0;
5963
5964 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5965 {
5966 switch (c)
5967 {
5968 //case IDX_HELP: usage = 1; break;
5969 //case IDX_VERSION: version = 1; break;
5970 //case IDX_RESTORE: restore = 1; break;
5971 case IDX_QUIET: quiet = 1; break;
5972 //case IDX_SHOW: show = 1; break;
5973 case IDX_SHOW: break;
5974 //case IDX_LEFT: left = 1; break;
5975 case IDX_LEFT: break;
5976 case IDX_USERNAME: username = 1; break;
5977 case IDX_REMOVE: remove = 1; break;
5978 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5979 remove_timer_chgd = 1; break;
5980 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5981 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5982 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5983 case IDX_DEBUG_FILE: debug_file = optarg; break;
5984 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5985 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5986 case IDX_FORCE: force = 1; break;
5987 case IDX_SKIP: skip = atoll (optarg); break;
5988 case IDX_LIMIT: limit = atoll (optarg); break;
5989 case IDX_KEYSPACE: keyspace = 1; break;
5990 case IDX_BENCHMARK: benchmark = 1; break;
5991 case IDX_RESTORE: break;
5992 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5993 case IDX_STATUS: status = 1; break;
5994 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5995 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5996 case IDX_LOOPBACK: loopback = 1; break;
5997 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5998 //case IDX_SESSION: session = optarg; break;
5999 case IDX_SESSION: break;
6000 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6001 hash_mode_chgd = 1; break;
6002 case IDX_RUNTIME: runtime = atoi (optarg);
6003 runtime_chgd = 1; break;
6004 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6005 attack_mode_chgd = 1; break;
6006 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6007 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6008 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6009 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6010 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6011 rp_gen_seed_chgd = 1; break;
6012 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6013 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6014 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6015 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6016 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6017 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6018 case IDX_OUTFILE: outfile = optarg; break;
6019 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6020 outfile_format_chgd = 1; break;
6021 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6022 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6023 case IDX_HEX_CHARSET: hex_charset = 1; break;
6024 case IDX_HEX_SALT: hex_salt = 1; break;
6025 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6026 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6027 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6028 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6029 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6030 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6031 opencl_vector_width_chgd = 1; break;
6032 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6033 workload_profile_chgd = 1; break;
6034 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6035 kernel_accel_chgd = 1; break;
6036 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6037 kernel_loops_chgd = 1; break;
6038 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6039 #ifdef HAVE_HWMON
6040 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6041 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6042 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6043 #endif // HAVE_HWMON
6044 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6045 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6046 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6047 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6048 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6049 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6050 case IDX_SEPARATOR: separator = optarg[0]; break;
6051 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6052 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6053 case IDX_INCREMENT: increment = 1; break;
6054 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6055 increment_min_chgd = 1; break;
6056 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6057 increment_max_chgd = 1; break;
6058 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6059 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6060 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6061 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6062
6063 default:
6064 log_error ("ERROR: Invalid argument specified");
6065 return (-1);
6066 }
6067 }
6068
6069 if (optopt != 0)
6070 {
6071 log_error ("ERROR: Invalid argument specified");
6072
6073 return (-1);
6074 }
6075
6076 /**
6077 * Inform user things getting started,
6078 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6079 * - we do not need to check algorithm_pos
6080 */
6081
6082 if (quiet == 0)
6083 {
6084 if (benchmark == 1)
6085 {
6086 if (machine_readable == 0)
6087 {
6088 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6089 log_info ("");
6090 }
6091 else
6092 {
6093 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6094 }
6095 }
6096 else if (restore == 1)
6097 {
6098 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6099 log_info ("");
6100 }
6101 else
6102 {
6103 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6104 log_info ("");
6105 }
6106 }
6107
6108 /**
6109 * sanity check
6110 */
6111
6112 if (attack_mode > 7)
6113 {
6114 log_error ("ERROR: Invalid attack-mode specified");
6115
6116 return (-1);
6117 }
6118
6119 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6120 {
6121 log_error ("ERROR: Invalid runtime specified");
6122
6123 return (-1);
6124 }
6125
6126 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6127 {
6128 log_error ("ERROR: Invalid hash-type specified");
6129
6130 return (-1);
6131 }
6132
6133 // renamed hash modes
6134
6135 if (hash_mode_chgd)
6136 {
6137 int n = -1;
6138
6139 switch (hash_mode)
6140 {
6141 case 123: n = 124;
6142 break;
6143 }
6144
6145 if (n >= 0)
6146 {
6147 log_error ("Old -m specified, use -m %d instead", n);
6148
6149 return (-1);
6150 }
6151 }
6152
6153 if (username == 1)
6154 {
6155 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6156 {
6157 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6158
6159 return (-1);
6160 }
6161 }
6162
6163 if (outfile_format > 16)
6164 {
6165 log_error ("ERROR: Invalid outfile-format specified");
6166
6167 return (-1);
6168 }
6169
6170 if (left == 1)
6171 {
6172 if (outfile_format_chgd == 1)
6173 {
6174 if (outfile_format > 1)
6175 {
6176 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6177
6178 return (-1);
6179 }
6180 }
6181 else
6182 {
6183 outfile_format = OUTFILE_FMT_HASH;
6184 }
6185 }
6186
6187 if (show == 1)
6188 {
6189 if (outfile_format_chgd == 1)
6190 {
6191 if ((outfile_format > 7) && (outfile_format < 16))
6192 {
6193 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6194
6195 return (-1);
6196 }
6197 }
6198 }
6199
6200 if (increment_min < INCREMENT_MIN)
6201 {
6202 log_error ("ERROR: Invalid increment-min specified");
6203
6204 return (-1);
6205 }
6206
6207 if (increment_max > INCREMENT_MAX)
6208 {
6209 log_error ("ERROR: Invalid increment-max specified");
6210
6211 return (-1);
6212 }
6213
6214 if (increment_min > increment_max)
6215 {
6216 log_error ("ERROR: Invalid increment-min specified");
6217
6218 return (-1);
6219 }
6220
6221 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6222 {
6223 log_error ("ERROR: increment is not allowed in attack-mode 0");
6224
6225 return (-1);
6226 }
6227
6228 if ((increment == 0) && (increment_min_chgd == 1))
6229 {
6230 log_error ("ERROR: increment-min is only supported together with increment switch");
6231
6232 return (-1);
6233 }
6234
6235 if ((increment == 0) && (increment_max_chgd == 1))
6236 {
6237 log_error ("ERROR: increment-max is only supported together with increment switch");
6238
6239 return (-1);
6240 }
6241
6242 if (rp_files_cnt && rp_gen)
6243 {
6244 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6245
6246 return (-1);
6247 }
6248
6249 if (rp_files_cnt || rp_gen)
6250 {
6251 if (attack_mode != ATTACK_MODE_STRAIGHT)
6252 {
6253 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6254
6255 return (-1);
6256 }
6257 }
6258
6259 if (rp_gen_func_min > rp_gen_func_max)
6260 {
6261 log_error ("ERROR: Invalid rp-gen-func-min specified");
6262
6263 return (-1);
6264 }
6265
6266 if (kernel_accel_chgd == 1)
6267 {
6268 if (force == 0)
6269 {
6270 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6271 log_info ("Please consider using the option -w instead");
6272 log_info ("You can use --force to override this but do not post error reports if you do so");
6273 log_info ("");
6274
6275 return (-1);
6276 }
6277
6278 if (kernel_accel < 1)
6279 {
6280 log_error ("ERROR: Invalid kernel-accel specified");
6281
6282 return (-1);
6283 }
6284
6285 if (kernel_accel > 1024)
6286 {
6287 log_error ("ERROR: Invalid kernel-accel specified");
6288
6289 return (-1);
6290 }
6291 }
6292
6293 if (kernel_loops_chgd == 1)
6294 {
6295 if (force == 0)
6296 {
6297 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6298 log_info ("Please consider using the option -w instead");
6299 log_info ("You can use --force to override this but do not post error reports if you do so");
6300 log_info ("");
6301
6302 return (-1);
6303 }
6304
6305 if (kernel_loops < 1)
6306 {
6307 log_error ("ERROR: Invalid kernel-loops specified");
6308
6309 return (-1);
6310 }
6311
6312 if (kernel_loops > 1024)
6313 {
6314 log_error ("ERROR: Invalid kernel-loops specified");
6315
6316 return (-1);
6317 }
6318 }
6319
6320 if ((workload_profile < 1) || (workload_profile > 4))
6321 {
6322 log_error ("ERROR: workload-profile %i not available", workload_profile);
6323
6324 return (-1);
6325 }
6326
6327 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6328 {
6329 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6330
6331 return (-1);
6332 }
6333
6334 if (show == 1 || left == 1)
6335 {
6336 attack_mode = ATTACK_MODE_NONE;
6337
6338 if (remove == 1)
6339 {
6340 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6341
6342 return (-1);
6343 }
6344
6345 if (potfile_disable == 1)
6346 {
6347 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 uint attack_kern = ATTACK_KERN_NONE;
6354
6355 switch (attack_mode)
6356 {
6357 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6358 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6359 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6360 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6361 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6362 }
6363
6364 if (benchmark == 0)
6365 {
6366 if (keyspace == 1)
6367 {
6368 int num_additional_params = 1;
6369
6370 if (attack_kern == ATTACK_KERN_COMBI)
6371 {
6372 num_additional_params = 2;
6373 }
6374
6375 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6376
6377 if (keyspace_wordlist_specified == 0) optind--;
6378 }
6379
6380 if (attack_kern == ATTACK_KERN_NONE)
6381 {
6382 if ((optind + 1) != myargc)
6383 {
6384 usage_mini_print (myargv[0]);
6385
6386 return (-1);
6387 }
6388 }
6389 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6390 {
6391 if ((optind + 1) > myargc)
6392 {
6393 usage_mini_print (myargv[0]);
6394
6395 return (-1);
6396 }
6397 }
6398 else if (attack_kern == ATTACK_KERN_COMBI)
6399 {
6400 if ((optind + 3) != myargc)
6401 {
6402 usage_mini_print (myargv[0]);
6403
6404 return (-1);
6405 }
6406 }
6407 else if (attack_kern == ATTACK_KERN_BF)
6408 {
6409 if ((optind + 1) > myargc)
6410 {
6411 usage_mini_print (myargv[0]);
6412
6413 return (-1);
6414 }
6415 }
6416 else
6417 {
6418 usage_mini_print (myargv[0]);
6419
6420 return (-1);
6421 }
6422 }
6423 else
6424 {
6425 if (myargv[optind] != 0)
6426 {
6427 log_error ("ERROR: Invalid argument for benchmark mode specified");
6428
6429 return (-1);
6430 }
6431
6432 if (attack_mode_chgd == 1)
6433 {
6434 if (attack_mode != ATTACK_MODE_BF)
6435 {
6436 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6437
6438 return (-1);
6439 }
6440 }
6441 }
6442
6443 if (skip != 0 && limit != 0)
6444 {
6445 limit += skip;
6446 }
6447
6448 if (keyspace == 1)
6449 {
6450 if (show == 1)
6451 {
6452 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6453
6454 return (-1);
6455 }
6456 else if (left == 1)
6457 {
6458 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6459
6460 return (-1);
6461 }
6462
6463 potfile_disable = 1;
6464
6465 restore_disable = 1;
6466
6467 restore = 0;
6468
6469 weak_hash_threshold = 0;
6470
6471 quiet = 1;
6472 }
6473
6474 if (remove_timer_chgd == 1)
6475 {
6476 if (remove == 0)
6477 {
6478 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6479
6480 return (-1);
6481 }
6482
6483 if (remove_timer < 1)
6484 {
6485 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6486
6487 return (-1);
6488 }
6489 }
6490
6491 if (loopback == 1)
6492 {
6493 if (attack_mode == ATTACK_MODE_STRAIGHT)
6494 {
6495 if ((rp_files_cnt == 0) && (rp_gen == 0))
6496 {
6497 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6498
6499 return (-1);
6500 }
6501 }
6502 else
6503 {
6504 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6505
6506 return (-1);
6507 }
6508 }
6509
6510 if (debug_mode > 0)
6511 {
6512 if (attack_mode != ATTACK_MODE_STRAIGHT)
6513 {
6514 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6515
6516 return (-1);
6517 }
6518
6519 if ((rp_files_cnt == 0) && (rp_gen == 0))
6520 {
6521 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6522
6523 return (-1);
6524 }
6525 }
6526
6527 if (debug_mode > 4)
6528 {
6529 log_error ("ERROR: Invalid debug-mode specified");
6530
6531 return (-1);
6532 }
6533
6534 if (debug_file != NULL)
6535 {
6536 if (debug_mode < 1)
6537 {
6538 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (induction_dir != NULL)
6545 {
6546 if (attack_mode == ATTACK_MODE_BF)
6547 {
6548 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6549
6550 return (-1);
6551 }
6552 }
6553
6554 if (attack_mode != ATTACK_MODE_STRAIGHT)
6555 {
6556 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6557 {
6558 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6559
6560 return (-1);
6561 }
6562
6563 weak_hash_threshold = 0;
6564 }
6565
6566 /**
6567 * induction directory
6568 */
6569
6570 char *induction_directory = NULL;
6571
6572 if (attack_mode != ATTACK_MODE_BF)
6573 {
6574 if (induction_dir == NULL)
6575 {
6576 induction_directory = (char *) mymalloc (session_size);
6577
6578 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6579
6580 // create induction folder if it does not already exist
6581
6582 if (keyspace == 0)
6583 {
6584 if (rmdir (induction_directory) == -1)
6585 {
6586 if (errno == ENOENT)
6587 {
6588 // good, we can ignore
6589 }
6590 else if (errno == ENOTEMPTY)
6591 {
6592 char *induction_directory_mv = (char *) mymalloc (session_size);
6593
6594 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6595
6596 if (rename (induction_directory, induction_directory_mv) != 0)
6597 {
6598 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6599
6600 return (-1);
6601 }
6602 }
6603 else
6604 {
6605 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6606
6607 return (-1);
6608 }
6609 }
6610
6611 if (mkdir (induction_directory, 0700) == -1)
6612 {
6613 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6614
6615 return (-1);
6616 }
6617 }
6618 }
6619 else
6620 {
6621 induction_directory = induction_dir;
6622 }
6623 }
6624
6625 data.induction_directory = induction_directory;
6626
6627 /**
6628 * loopback
6629 */
6630
6631 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6632
6633 char *loopback_file = (char *) mymalloc (loopback_size);
6634
6635 /**
6636 * tuning db
6637 */
6638
6639 char tuning_db_file[256] = { 0 };
6640
6641 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6642
6643 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6644
6645 /**
6646 * outfile-check directory
6647 */
6648
6649 char *outfile_check_directory = NULL;
6650
6651 if (outfile_check_dir == NULL)
6652 {
6653 outfile_check_directory = (char *) mymalloc (session_size);
6654
6655 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6656 }
6657 else
6658 {
6659 outfile_check_directory = outfile_check_dir;
6660 }
6661
6662 data.outfile_check_directory = outfile_check_directory;
6663
6664 if (keyspace == 0)
6665 {
6666 struct stat outfile_check_stat;
6667
6668 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6669 {
6670 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6671
6672 if (is_dir == 0)
6673 {
6674 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6675
6676 return (-1);
6677 }
6678 }
6679 else if (outfile_check_dir == NULL)
6680 {
6681 if (mkdir (outfile_check_directory, 0700) == -1)
6682 {
6683 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6684
6685 return (-1);
6686 }
6687 }
6688 }
6689
6690 /**
6691 * special other stuff
6692 */
6693
6694 if (hash_mode == 9710)
6695 {
6696 outfile_format = 5;
6697 outfile_format_chgd = 1;
6698 }
6699
6700 if (hash_mode == 9810)
6701 {
6702 outfile_format = 5;
6703 outfile_format_chgd = 1;
6704 }
6705
6706 if (hash_mode == 10410)
6707 {
6708 outfile_format = 5;
6709 outfile_format_chgd = 1;
6710 }
6711
6712 /**
6713 * store stuff
6714 */
6715
6716 data.hash_mode = hash_mode;
6717 data.restore = restore;
6718 data.restore_timer = restore_timer;
6719 data.restore_disable = restore_disable;
6720 data.status = status;
6721 data.status_timer = status_timer;
6722 data.machine_readable = machine_readable;
6723 data.loopback = loopback;
6724 data.runtime = runtime;
6725 data.remove = remove;
6726 data.remove_timer = remove_timer;
6727 data.debug_mode = debug_mode;
6728 data.debug_file = debug_file;
6729 data.username = username;
6730 data.quiet = quiet;
6731 data.outfile = outfile;
6732 data.outfile_format = outfile_format;
6733 data.outfile_autohex = outfile_autohex;
6734 data.hex_charset = hex_charset;
6735 data.hex_salt = hex_salt;
6736 data.hex_wordlist = hex_wordlist;
6737 data.separator = separator;
6738 data.rp_files = rp_files;
6739 data.rp_files_cnt = rp_files_cnt;
6740 data.rp_gen = rp_gen;
6741 data.rp_gen_seed = rp_gen_seed;
6742 data.force = force;
6743 data.benchmark = benchmark;
6744 data.skip = skip;
6745 data.limit = limit;
6746 #ifdef HAVE_HWMON
6747 data.powertune_enable = powertune_enable;
6748 #endif
6749 data.logfile_disable = logfile_disable;
6750 data.truecrypt_keyfiles = truecrypt_keyfiles;
6751 data.veracrypt_keyfiles = veracrypt_keyfiles;
6752 data.veracrypt_pim = veracrypt_pim;
6753 data.scrypt_tmto = scrypt_tmto;
6754 data.workload_profile = workload_profile;
6755
6756 /**
6757 * cpu affinity
6758 */
6759
6760 if (cpu_affinity)
6761 {
6762 set_cpu_affinity (cpu_affinity);
6763 }
6764
6765 if (rp_gen_seed_chgd == 0)
6766 {
6767 srand (proc_start);
6768 }
6769 else
6770 {
6771 srand (rp_gen_seed);
6772 }
6773
6774 /**
6775 * logfile init
6776 */
6777
6778 if (logfile_disable == 0)
6779 {
6780 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6781
6782 char *logfile = (char *) mymalloc (logfile_size);
6783
6784 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6785
6786 data.logfile = logfile;
6787
6788 char *topid = logfile_generate_topid ();
6789
6790 data.topid = topid;
6791 }
6792
6793 // logfile_append() checks for logfile_disable internally to make it easier from here
6794
6795 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6796 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6797 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6798 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6799 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6800 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6801 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6802 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6803 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6804 #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));
6805
6806 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6807 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6808 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6809 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6810 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6811 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6812 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6813 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6814
6815 logfile_top_msg ("START");
6816
6817 logfile_top_uint (attack_mode);
6818 logfile_top_uint (attack_kern);
6819 logfile_top_uint (benchmark);
6820 logfile_top_uint (bitmap_min);
6821 logfile_top_uint (bitmap_max);
6822 logfile_top_uint (debug_mode);
6823 logfile_top_uint (force);
6824 logfile_top_uint (kernel_accel);
6825 logfile_top_uint (kernel_loops);
6826 logfile_top_uint (gpu_temp_disable);
6827 #ifdef HAVE_HWMON
6828 logfile_top_uint (gpu_temp_abort);
6829 logfile_top_uint (gpu_temp_retain);
6830 #endif
6831 logfile_top_uint (hash_mode);
6832 logfile_top_uint (hex_charset);
6833 logfile_top_uint (hex_salt);
6834 logfile_top_uint (hex_wordlist);
6835 logfile_top_uint (increment);
6836 logfile_top_uint (increment_max);
6837 logfile_top_uint (increment_min);
6838 logfile_top_uint (keyspace);
6839 logfile_top_uint (left);
6840 logfile_top_uint (logfile_disable);
6841 logfile_top_uint (loopback);
6842 logfile_top_uint (markov_classic);
6843 logfile_top_uint (markov_disable);
6844 logfile_top_uint (markov_threshold);
6845 logfile_top_uint (outfile_autohex);
6846 logfile_top_uint (outfile_check_timer);
6847 logfile_top_uint (outfile_format);
6848 logfile_top_uint (potfile_disable);
6849 logfile_top_string (potfile_path);
6850 #if defined(HAVE_HWMON)
6851 logfile_top_uint (powertune_enable);
6852 #endif
6853 logfile_top_uint (scrypt_tmto);
6854 logfile_top_uint (quiet);
6855 logfile_top_uint (remove);
6856 logfile_top_uint (remove_timer);
6857 logfile_top_uint (restore);
6858 logfile_top_uint (restore_disable);
6859 logfile_top_uint (restore_timer);
6860 logfile_top_uint (rp_gen);
6861 logfile_top_uint (rp_gen_func_max);
6862 logfile_top_uint (rp_gen_func_min);
6863 logfile_top_uint (rp_gen_seed);
6864 logfile_top_uint (runtime);
6865 logfile_top_uint (segment_size);
6866 logfile_top_uint (show);
6867 logfile_top_uint (status);
6868 logfile_top_uint (machine_readable);
6869 logfile_top_uint (status_timer);
6870 logfile_top_uint (usage);
6871 logfile_top_uint (username);
6872 logfile_top_uint (version);
6873 logfile_top_uint (weak_hash_threshold);
6874 logfile_top_uint (workload_profile);
6875 logfile_top_uint64 (limit);
6876 logfile_top_uint64 (skip);
6877 logfile_top_char (separator);
6878 logfile_top_string (cpu_affinity);
6879 logfile_top_string (custom_charset_1);
6880 logfile_top_string (custom_charset_2);
6881 logfile_top_string (custom_charset_3);
6882 logfile_top_string (custom_charset_4);
6883 logfile_top_string (debug_file);
6884 logfile_top_string (opencl_devices);
6885 logfile_top_string (opencl_platforms);
6886 logfile_top_string (opencl_device_types);
6887 logfile_top_uint (opencl_vector_width);
6888 logfile_top_string (induction_dir);
6889 logfile_top_string (markov_hcstat);
6890 logfile_top_string (outfile);
6891 logfile_top_string (outfile_check_dir);
6892 logfile_top_string (rule_buf_l);
6893 logfile_top_string (rule_buf_r);
6894 logfile_top_string (session);
6895 logfile_top_string (truecrypt_keyfiles);
6896 logfile_top_string (veracrypt_keyfiles);
6897 logfile_top_uint (veracrypt_pim);
6898
6899 /**
6900 * Init OpenCL library loader
6901 */
6902
6903 if (keyspace == 0)
6904 {
6905 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6906
6907 ocl_init (ocl);
6908
6909 data.ocl = ocl;
6910 }
6911
6912 /**
6913 * OpenCL platform selection
6914 */
6915
6916 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6917
6918 /**
6919 * OpenCL device selection
6920 */
6921
6922 u32 devices_filter = setup_devices_filter (opencl_devices);
6923
6924 /**
6925 * OpenCL device type selection
6926 */
6927
6928 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6929
6930 /**
6931 * benchmark
6932 */
6933
6934 if (benchmark == 1)
6935 {
6936 /**
6937 * disable useless stuff for benchmark
6938 */
6939
6940 status_timer = 0;
6941 restore_timer = 0;
6942 restore_disable = 1;
6943 potfile_disable = 1;
6944 weak_hash_threshold = 0;
6945 gpu_temp_disable = 1;
6946
6947 #ifdef HAVE_HWMON
6948 powertune_enable = 1;
6949 #endif
6950
6951 data.status_timer = status_timer;
6952 data.restore_timer = restore_timer;
6953 data.restore_disable = restore_disable;
6954
6955 /**
6956 * force attack mode to be bruteforce
6957 */
6958
6959 attack_mode = ATTACK_MODE_BF;
6960 attack_kern = ATTACK_KERN_BF;
6961
6962 if (workload_profile_chgd == 0)
6963 {
6964 workload_profile = 3;
6965
6966 data.workload_profile = workload_profile;
6967 }
6968 }
6969
6970 /**
6971 * config
6972 */
6973
6974 uint hash_type = 0;
6975 uint salt_type = 0;
6976 uint attack_exec = 0;
6977 uint opts_type = 0;
6978 uint kern_type = 0;
6979 uint dgst_size = 0;
6980 uint esalt_size = 0;
6981 uint opti_type = 0;
6982 uint dgst_pos0 = -1;
6983 uint dgst_pos1 = -1;
6984 uint dgst_pos2 = -1;
6985 uint dgst_pos3 = -1;
6986
6987 int (*parse_func) (char *, uint, hash_t *);
6988 int (*sort_by_digest) (const void *, const void *);
6989
6990 uint algorithm_pos = 0;
6991 uint algorithm_max = 1;
6992
6993 uint *algorithms = default_benchmark_algorithms;
6994
6995 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6996
6997 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6998 {
6999 /*
7000 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7001 * the following algos are skipped entirely
7002 */
7003
7004 if (algorithm_pos > 0)
7005 {
7006 local_free (rd);
7007
7008 rd = init_restore (argc, argv);
7009
7010 data.rd = rd;
7011 }
7012
7013 /**
7014 * update hash_mode in case of multihash benchmark
7015 */
7016
7017 if (benchmark == 1)
7018 {
7019 if (hash_mode_chgd == 0)
7020 {
7021 hash_mode = algorithms[algorithm_pos];
7022
7023 data.hash_mode = hash_mode;
7024 }
7025
7026 quiet = 1;
7027
7028 data.quiet = quiet;
7029 }
7030
7031 switch (hash_mode)
7032 {
7033 case 0: hash_type = HASH_TYPE_MD5;
7034 salt_type = SALT_TYPE_NONE;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_LE
7037 | OPTS_TYPE_PT_ADD80
7038 | OPTS_TYPE_PT_ADDBITS14;
7039 kern_type = KERN_TYPE_MD5;
7040 dgst_size = DGST_SIZE_4_4;
7041 parse_func = md5_parse_hash;
7042 sort_by_digest = sort_by_digest_4_4;
7043 opti_type = OPTI_TYPE_ZERO_BYTE
7044 | OPTI_TYPE_PRECOMPUTE_INIT
7045 | OPTI_TYPE_PRECOMPUTE_MERKLE
7046 | OPTI_TYPE_MEET_IN_MIDDLE
7047 | OPTI_TYPE_EARLY_SKIP
7048 | OPTI_TYPE_NOT_ITERATED
7049 | OPTI_TYPE_NOT_SALTED
7050 | OPTI_TYPE_RAW_HASH;
7051 dgst_pos0 = 0;
7052 dgst_pos1 = 3;
7053 dgst_pos2 = 2;
7054 dgst_pos3 = 1;
7055 break;
7056
7057 case 10: hash_type = HASH_TYPE_MD5;
7058 salt_type = SALT_TYPE_INTERN;
7059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7060 opts_type = OPTS_TYPE_PT_GENERATE_LE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS14;
7063 kern_type = KERN_TYPE_MD5_PWSLT;
7064 dgst_size = DGST_SIZE_4_4;
7065 parse_func = md5s_parse_hash;
7066 sort_by_digest = sort_by_digest_4_4;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_MEET_IN_MIDDLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 0;
7076 dgst_pos1 = 3;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 11: hash_type = HASH_TYPE_MD5;
7082 salt_type = SALT_TYPE_INTERN;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_LE
7085 | OPTS_TYPE_ST_ADD80
7086 | OPTS_TYPE_ST_ADDBITS14;
7087 kern_type = KERN_TYPE_MD5_PWSLT;
7088 dgst_size = DGST_SIZE_4_4;
7089 parse_func = joomla_parse_hash;
7090 sort_by_digest = sort_by_digest_4_4;
7091 opti_type = OPTI_TYPE_ZERO_BYTE
7092 | OPTI_TYPE_PRECOMPUTE_INIT
7093 | OPTI_TYPE_PRECOMPUTE_MERKLE
7094 | OPTI_TYPE_MEET_IN_MIDDLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_APPENDED_SALT
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 0;
7100 dgst_pos1 = 3;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 12: hash_type = HASH_TYPE_MD5;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_LE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS14;
7111 kern_type = KERN_TYPE_MD5_PWSLT;
7112 dgst_size = DGST_SIZE_4_4;
7113 parse_func = postgresql_parse_hash;
7114 sort_by_digest = sort_by_digest_4_4;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_PRECOMPUTE_INIT
7117 | OPTI_TYPE_PRECOMPUTE_MERKLE
7118 | OPTI_TYPE_MEET_IN_MIDDLE
7119 | OPTI_TYPE_EARLY_SKIP
7120 | OPTI_TYPE_NOT_ITERATED
7121 | OPTI_TYPE_APPENDED_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 20: hash_type = HASH_TYPE_MD5;
7130 salt_type = SALT_TYPE_INTERN;
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 = md5s_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 21: hash_type = HASH_TYPE_MD5;
7153 salt_type = SALT_TYPE_INTERN;
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 = osc_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 22: hash_type = HASH_TYPE_MD5;
7176 salt_type = SALT_TYPE_EMBEDDED;
7177 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7178 opts_type = OPTS_TYPE_PT_GENERATE_LE
7179 | OPTS_TYPE_PT_ADD80
7180 | OPTS_TYPE_PT_ADDBITS14;
7181 kern_type = KERN_TYPE_MD5_SLTPW;
7182 dgst_size = DGST_SIZE_4_4;
7183 parse_func = netscreen_parse_hash;
7184 sort_by_digest = sort_by_digest_4_4;
7185 opti_type = OPTI_TYPE_ZERO_BYTE
7186 | OPTI_TYPE_PRECOMPUTE_INIT
7187 | OPTI_TYPE_PRECOMPUTE_MERKLE
7188 | OPTI_TYPE_EARLY_SKIP
7189 | OPTI_TYPE_NOT_ITERATED
7190 | OPTI_TYPE_PREPENDED_SALT
7191 | OPTI_TYPE_RAW_HASH;
7192 dgst_pos0 = 0;
7193 dgst_pos1 = 3;
7194 dgst_pos2 = 2;
7195 dgst_pos3 = 1;
7196 break;
7197
7198 case 23: hash_type = HASH_TYPE_MD5;
7199 salt_type = SALT_TYPE_EMBEDDED;
7200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7201 opts_type = OPTS_TYPE_PT_GENERATE_LE
7202 | OPTS_TYPE_PT_ADD80
7203 | OPTS_TYPE_PT_ADDBITS14;
7204 kern_type = KERN_TYPE_MD5_SLTPW;
7205 dgst_size = DGST_SIZE_4_4;
7206 parse_func = skype_parse_hash;
7207 sort_by_digest = sort_by_digest_4_4;
7208 opti_type = OPTI_TYPE_ZERO_BYTE
7209 | OPTI_TYPE_PRECOMPUTE_INIT
7210 | OPTI_TYPE_PRECOMPUTE_MERKLE
7211 | OPTI_TYPE_EARLY_SKIP
7212 | OPTI_TYPE_NOT_ITERATED
7213 | OPTI_TYPE_PREPENDED_SALT
7214 | OPTI_TYPE_RAW_HASH;
7215 dgst_pos0 = 0;
7216 dgst_pos1 = 3;
7217 dgst_pos2 = 2;
7218 dgst_pos3 = 1;
7219 break;
7220
7221 case 30: hash_type = HASH_TYPE_MD5;
7222 salt_type = SALT_TYPE_INTERN;
7223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7224 opts_type = OPTS_TYPE_PT_GENERATE_LE
7225 | OPTS_TYPE_PT_UNICODE
7226 | OPTS_TYPE_ST_ADD80
7227 | OPTS_TYPE_ST_ADDBITS14;
7228 kern_type = KERN_TYPE_MD5_PWUSLT;
7229 dgst_size = DGST_SIZE_4_4;
7230 parse_func = md5s_parse_hash;
7231 sort_by_digest = sort_by_digest_4_4;
7232 opti_type = OPTI_TYPE_ZERO_BYTE
7233 | OPTI_TYPE_PRECOMPUTE_INIT
7234 | OPTI_TYPE_PRECOMPUTE_MERKLE
7235 | OPTI_TYPE_MEET_IN_MIDDLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_APPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 0;
7241 dgst_pos1 = 3;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 40: hash_type = HASH_TYPE_MD5;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_LE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS14
7252 | OPTS_TYPE_PT_UNICODE;
7253 kern_type = KERN_TYPE_MD5_SLTPWU;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = md5s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_EARLY_SKIP
7261 | OPTI_TYPE_NOT_ITERATED
7262 | OPTI_TYPE_PREPENDED_SALT
7263 | OPTI_TYPE_RAW_HASH;
7264 dgst_pos0 = 0;
7265 dgst_pos1 = 3;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 1;
7268 break;
7269
7270 case 50: hash_type = HASH_TYPE_MD5;
7271 salt_type = SALT_TYPE_INTERN;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_LE
7274 | OPTS_TYPE_ST_ADD80
7275 | OPTS_TYPE_ST_ADDBITS14;
7276 kern_type = KERN_TYPE_HMACMD5_PW;
7277 dgst_size = DGST_SIZE_4_4;
7278 parse_func = hmacmd5_parse_hash;
7279 sort_by_digest = sort_by_digest_4_4;
7280 opti_type = OPTI_TYPE_ZERO_BYTE
7281 | OPTI_TYPE_NOT_ITERATED;
7282 dgst_pos0 = 0;
7283 dgst_pos1 = 3;
7284 dgst_pos2 = 2;
7285 dgst_pos3 = 1;
7286 break;
7287
7288 case 60: hash_type = HASH_TYPE_MD5;
7289 salt_type = SALT_TYPE_INTERN;
7290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7291 opts_type = OPTS_TYPE_PT_GENERATE_LE
7292 | OPTS_TYPE_PT_ADD80
7293 | OPTS_TYPE_PT_ADDBITS14;
7294 kern_type = KERN_TYPE_HMACMD5_SLT;
7295 dgst_size = DGST_SIZE_4_4;
7296 parse_func = hmacmd5_parse_hash;
7297 sort_by_digest = sort_by_digest_4_4;
7298 opti_type = OPTI_TYPE_ZERO_BYTE
7299 | OPTI_TYPE_NOT_ITERATED;
7300 dgst_pos0 = 0;
7301 dgst_pos1 = 3;
7302 dgst_pos2 = 2;
7303 dgst_pos3 = 1;
7304 break;
7305
7306 case 100: hash_type = HASH_TYPE_SHA1;
7307 salt_type = SALT_TYPE_NONE;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_BE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS15;
7312 kern_type = KERN_TYPE_SHA1;
7313 dgst_size = DGST_SIZE_4_5;
7314 parse_func = sha1_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_NOT_SALTED
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 101: hash_type = HASH_TYPE_SHA1;
7330 salt_type = SALT_TYPE_NONE;
7331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7332 opts_type = OPTS_TYPE_PT_GENERATE_BE
7333 | OPTS_TYPE_PT_ADD80
7334 | OPTS_TYPE_PT_ADDBITS15;
7335 kern_type = KERN_TYPE_SHA1;
7336 dgst_size = DGST_SIZE_4_5;
7337 parse_func = sha1b64_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_NOT_SALTED
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 110: 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 kern_type = KERN_TYPE_SHA1_PWSLT;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = sha1s_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_APPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 111: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_EMBEDDED;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_ST_ADD80
7380 | OPTS_TYPE_ST_ADDBITS15;
7381 kern_type = KERN_TYPE_SHA1_PWSLT;
7382 dgst_size = DGST_SIZE_4_5;
7383 parse_func = sha1b64s_parse_hash;
7384 sort_by_digest = sort_by_digest_4_5;
7385 opti_type = OPTI_TYPE_ZERO_BYTE
7386 | OPTI_TYPE_PRECOMPUTE_INIT
7387 | OPTI_TYPE_PRECOMPUTE_MERKLE
7388 | OPTI_TYPE_EARLY_SKIP
7389 | OPTI_TYPE_NOT_ITERATED
7390 | OPTI_TYPE_APPENDED_SALT
7391 | OPTI_TYPE_RAW_HASH;
7392 dgst_pos0 = 3;
7393 dgst_pos1 = 4;
7394 dgst_pos2 = 2;
7395 dgst_pos3 = 1;
7396 break;
7397
7398 case 112: hash_type = HASH_TYPE_SHA1;
7399 salt_type = SALT_TYPE_INTERN;
7400 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7401 opts_type = OPTS_TYPE_PT_GENERATE_BE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = oracles_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 120: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_INTERN;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_ADD80
7427 | OPTS_TYPE_PT_ADDBITS15;
7428 kern_type = KERN_TYPE_SHA1_SLTPW;
7429 dgst_size = DGST_SIZE_4_5;
7430 parse_func = sha1s_parse_hash;
7431 sort_by_digest = sort_by_digest_4_5;
7432 opti_type = OPTI_TYPE_ZERO_BYTE
7433 | OPTI_TYPE_PRECOMPUTE_INIT
7434 | OPTI_TYPE_PRECOMPUTE_MERKLE
7435 | OPTI_TYPE_EARLY_SKIP
7436 | OPTI_TYPE_NOT_ITERATED
7437 | OPTI_TYPE_PREPENDED_SALT
7438 | OPTI_TYPE_RAW_HASH;
7439 dgst_pos0 = 3;
7440 dgst_pos1 = 4;
7441 dgst_pos2 = 2;
7442 dgst_pos3 = 1;
7443 break;
7444
7445 case 121: hash_type = HASH_TYPE_SHA1;
7446 salt_type = SALT_TYPE_INTERN;
7447 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7448 opts_type = OPTS_TYPE_PT_GENERATE_BE
7449 | OPTS_TYPE_PT_ADD80
7450 | OPTS_TYPE_PT_ADDBITS15
7451 | OPTS_TYPE_ST_LOWER;
7452 kern_type = KERN_TYPE_SHA1_SLTPW;
7453 dgst_size = DGST_SIZE_4_5;
7454 parse_func = smf_parse_hash;
7455 sort_by_digest = sort_by_digest_4_5;
7456 opti_type = OPTI_TYPE_ZERO_BYTE
7457 | OPTI_TYPE_PRECOMPUTE_INIT
7458 | OPTI_TYPE_PRECOMPUTE_MERKLE
7459 | OPTI_TYPE_EARLY_SKIP
7460 | OPTI_TYPE_NOT_ITERATED
7461 | OPTI_TYPE_PREPENDED_SALT
7462 | OPTI_TYPE_RAW_HASH;
7463 dgst_pos0 = 3;
7464 dgst_pos1 = 4;
7465 dgst_pos2 = 2;
7466 dgst_pos3 = 1;
7467 break;
7468
7469 case 122: hash_type = HASH_TYPE_SHA1;
7470 salt_type = SALT_TYPE_EMBEDDED;
7471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7472 opts_type = OPTS_TYPE_PT_GENERATE_BE
7473 | OPTS_TYPE_PT_ADD80
7474 | OPTS_TYPE_PT_ADDBITS15
7475 | OPTS_TYPE_ST_HEX;
7476 kern_type = KERN_TYPE_SHA1_SLTPW;
7477 dgst_size = DGST_SIZE_4_5;
7478 parse_func = osx1_parse_hash;
7479 sort_by_digest = sort_by_digest_4_5;
7480 opti_type = OPTI_TYPE_ZERO_BYTE
7481 | OPTI_TYPE_PRECOMPUTE_INIT
7482 | OPTI_TYPE_PRECOMPUTE_MERKLE
7483 | OPTI_TYPE_EARLY_SKIP
7484 | OPTI_TYPE_NOT_ITERATED
7485 | OPTI_TYPE_PREPENDED_SALT
7486 | OPTI_TYPE_RAW_HASH;
7487 dgst_pos0 = 3;
7488 dgst_pos1 = 4;
7489 dgst_pos2 = 2;
7490 dgst_pos3 = 1;
7491 break;
7492
7493 case 124: hash_type = HASH_TYPE_SHA1;
7494 salt_type = SALT_TYPE_EMBEDDED;
7495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7496 opts_type = OPTS_TYPE_PT_GENERATE_BE
7497 | OPTS_TYPE_PT_ADD80
7498 | OPTS_TYPE_PT_ADDBITS15;
7499 kern_type = KERN_TYPE_SHA1_SLTPW;
7500 dgst_size = DGST_SIZE_4_5;
7501 parse_func = djangosha1_parse_hash;
7502 sort_by_digest = sort_by_digest_4_5;
7503 opti_type = OPTI_TYPE_ZERO_BYTE
7504 | OPTI_TYPE_PRECOMPUTE_INIT
7505 | OPTI_TYPE_PRECOMPUTE_MERKLE
7506 | OPTI_TYPE_EARLY_SKIP
7507 | OPTI_TYPE_NOT_ITERATED
7508 | OPTI_TYPE_PREPENDED_SALT
7509 | OPTI_TYPE_RAW_HASH;
7510 dgst_pos0 = 3;
7511 dgst_pos1 = 4;
7512 dgst_pos2 = 2;
7513 dgst_pos3 = 1;
7514 break;
7515
7516 case 125: hash_type = HASH_TYPE_SHA1;
7517 salt_type = SALT_TYPE_EMBEDDED;
7518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7519 opts_type = OPTS_TYPE_PT_GENERATE_BE
7520 | OPTS_TYPE_PT_ADD80
7521 | OPTS_TYPE_PT_ADDBITS15
7522 | OPTS_TYPE_ST_HEX;
7523 kern_type = KERN_TYPE_SHA1_SLTPW;
7524 dgst_size = DGST_SIZE_4_5;
7525 parse_func = arubaos_parse_hash;
7526 sort_by_digest = sort_by_digest_4_5;
7527 opti_type = OPTI_TYPE_ZERO_BYTE
7528 | OPTI_TYPE_PRECOMPUTE_INIT
7529 | OPTI_TYPE_PRECOMPUTE_MERKLE
7530 | OPTI_TYPE_EARLY_SKIP
7531 | OPTI_TYPE_NOT_ITERATED
7532 | OPTI_TYPE_PREPENDED_SALT
7533 | OPTI_TYPE_RAW_HASH;
7534 dgst_pos0 = 3;
7535 dgst_pos1 = 4;
7536 dgst_pos2 = 2;
7537 dgst_pos3 = 1;
7538 break;
7539
7540 case 130: hash_type = HASH_TYPE_SHA1;
7541 salt_type = SALT_TYPE_INTERN;
7542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7543 opts_type = OPTS_TYPE_PT_GENERATE_BE
7544 | OPTS_TYPE_PT_UNICODE
7545 | OPTS_TYPE_ST_ADD80
7546 | OPTS_TYPE_ST_ADDBITS15;
7547 kern_type = KERN_TYPE_SHA1_PWUSLT;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = sha1s_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_PRECOMPUTE_INIT
7553 | OPTI_TYPE_PRECOMPUTE_MERKLE
7554 | OPTI_TYPE_EARLY_SKIP
7555 | OPTI_TYPE_NOT_ITERATED
7556 | OPTI_TYPE_APPENDED_SALT
7557 | OPTI_TYPE_RAW_HASH;
7558 dgst_pos0 = 3;
7559 dgst_pos1 = 4;
7560 dgst_pos2 = 2;
7561 dgst_pos3 = 1;
7562 break;
7563
7564 case 131: hash_type = HASH_TYPE_SHA1;
7565 salt_type = SALT_TYPE_EMBEDDED;
7566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7567 opts_type = OPTS_TYPE_PT_GENERATE_BE
7568 | OPTS_TYPE_PT_UNICODE
7569 | OPTS_TYPE_PT_UPPER
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS15
7572 | OPTS_TYPE_ST_HEX;
7573 kern_type = KERN_TYPE_SHA1_PWUSLT;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = mssql2000_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_APPENDED_SALT
7583 | OPTI_TYPE_RAW_HASH;
7584 dgst_pos0 = 3;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 2;
7587 dgst_pos3 = 1;
7588 break;
7589
7590 case 132: hash_type = HASH_TYPE_SHA1;
7591 salt_type = SALT_TYPE_EMBEDDED;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = OPTS_TYPE_PT_GENERATE_BE
7594 | OPTS_TYPE_PT_UNICODE
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15
7597 | OPTS_TYPE_ST_HEX;
7598 kern_type = KERN_TYPE_SHA1_PWUSLT;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = mssql2005_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_APPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 133: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_EMBEDDED;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15;
7622 kern_type = KERN_TYPE_SHA1_PWUSLT;
7623 dgst_size = DGST_SIZE_4_5;
7624 parse_func = peoplesoft_parse_hash;
7625 sort_by_digest = sort_by_digest_4_5;
7626 opti_type = OPTI_TYPE_ZERO_BYTE
7627 | OPTI_TYPE_PRECOMPUTE_INIT
7628 | OPTI_TYPE_PRECOMPUTE_MERKLE
7629 | OPTI_TYPE_EARLY_SKIP
7630 | OPTI_TYPE_NOT_ITERATED
7631 | OPTI_TYPE_APPENDED_SALT
7632 | OPTI_TYPE_RAW_HASH;
7633 dgst_pos0 = 3;
7634 dgst_pos1 = 4;
7635 dgst_pos2 = 2;
7636 dgst_pos3 = 1;
7637 break;
7638
7639 case 140: hash_type = HASH_TYPE_SHA1;
7640 salt_type = SALT_TYPE_INTERN;
7641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7642 opts_type = OPTS_TYPE_PT_GENERATE_BE
7643 | OPTS_TYPE_PT_ADD80
7644 | OPTS_TYPE_PT_ADDBITS15
7645 | OPTS_TYPE_PT_UNICODE;
7646 kern_type = KERN_TYPE_SHA1_SLTPWU;
7647 dgst_size = DGST_SIZE_4_5;
7648 parse_func = sha1s_parse_hash;
7649 sort_by_digest = sort_by_digest_4_5;
7650 opti_type = OPTI_TYPE_ZERO_BYTE
7651 | OPTI_TYPE_PRECOMPUTE_INIT
7652 | OPTI_TYPE_PRECOMPUTE_MERKLE
7653 | OPTI_TYPE_EARLY_SKIP
7654 | OPTI_TYPE_NOT_ITERATED
7655 | OPTI_TYPE_PREPENDED_SALT
7656 | OPTI_TYPE_RAW_HASH;
7657 dgst_pos0 = 3;
7658 dgst_pos1 = 4;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 1;
7661 break;
7662
7663 case 141: hash_type = HASH_TYPE_SHA1;
7664 salt_type = SALT_TYPE_EMBEDDED;
7665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_BE
7667 | OPTS_TYPE_PT_ADD80
7668 | OPTS_TYPE_PT_ADDBITS15
7669 | OPTS_TYPE_PT_UNICODE
7670 | OPTS_TYPE_ST_BASE64;
7671 kern_type = KERN_TYPE_SHA1_SLTPWU;
7672 dgst_size = DGST_SIZE_4_5;
7673 parse_func = episerver_parse_hash;
7674 sort_by_digest = sort_by_digest_4_5;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 4;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 150: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_INTERN;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_ST_ADD80
7693 | OPTS_TYPE_ST_ADDBITS15;
7694 kern_type = KERN_TYPE_HMACSHA1_PW;
7695 dgst_size = DGST_SIZE_4_5;
7696 parse_func = hmacsha1_parse_hash;
7697 sort_by_digest = sort_by_digest_4_5;
7698 opti_type = OPTI_TYPE_ZERO_BYTE
7699 | OPTI_TYPE_NOT_ITERATED;
7700 dgst_pos0 = 3;
7701 dgst_pos1 = 4;
7702 dgst_pos2 = 2;
7703 dgst_pos3 = 1;
7704 break;
7705
7706 case 160: hash_type = HASH_TYPE_SHA1;
7707 salt_type = SALT_TYPE_INTERN;
7708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7709 opts_type = OPTS_TYPE_PT_GENERATE_BE
7710 | OPTS_TYPE_PT_ADD80
7711 | OPTS_TYPE_PT_ADDBITS15;
7712 kern_type = KERN_TYPE_HMACSHA1_SLT;
7713 dgst_size = DGST_SIZE_4_5;
7714 parse_func = hmacsha1_parse_hash;
7715 sort_by_digest = sort_by_digest_4_5;
7716 opti_type = OPTI_TYPE_ZERO_BYTE
7717 | OPTI_TYPE_NOT_ITERATED;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 4;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 190: hash_type = HASH_TYPE_SHA1;
7725 salt_type = SALT_TYPE_NONE;
7726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_BE
7728 | OPTS_TYPE_PT_ADD80
7729 | OPTS_TYPE_PT_ADDBITS15;
7730 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7731 dgst_size = DGST_SIZE_4_5;
7732 parse_func = sha1linkedin_parse_hash;
7733 sort_by_digest = sort_by_digest_4_5;
7734 opti_type = OPTI_TYPE_ZERO_BYTE
7735 | OPTI_TYPE_PRECOMPUTE_INIT
7736 | OPTI_TYPE_EARLY_SKIP
7737 | OPTI_TYPE_NOT_ITERATED
7738 | OPTI_TYPE_NOT_SALTED;
7739 dgst_pos0 = 0;
7740 dgst_pos1 = 4;
7741 dgst_pos2 = 3;
7742 dgst_pos3 = 2;
7743 break;
7744
7745 case 200: hash_type = HASH_TYPE_MYSQL;
7746 salt_type = SALT_TYPE_NONE;
7747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7748 opts_type = 0;
7749 kern_type = KERN_TYPE_MYSQL;
7750 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7751 parse_func = mysql323_parse_hash;
7752 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7753 opti_type = OPTI_TYPE_ZERO_BYTE;
7754 dgst_pos0 = 0;
7755 dgst_pos1 = 1;
7756 dgst_pos2 = 2;
7757 dgst_pos3 = 3;
7758 break;
7759
7760 case 300: hash_type = HASH_TYPE_SHA1;
7761 salt_type = SALT_TYPE_NONE;
7762 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7763 opts_type = OPTS_TYPE_PT_GENERATE_BE
7764 | OPTS_TYPE_PT_ADD80
7765 | OPTS_TYPE_PT_ADDBITS15;
7766 kern_type = KERN_TYPE_MYSQL41;
7767 dgst_size = DGST_SIZE_4_5;
7768 parse_func = sha1_parse_hash;
7769 sort_by_digest = sort_by_digest_4_5;
7770 opti_type = OPTI_TYPE_ZERO_BYTE
7771 | OPTI_TYPE_PRECOMPUTE_INIT
7772 | OPTI_TYPE_PRECOMPUTE_MERKLE
7773 | OPTI_TYPE_EARLY_SKIP
7774 | OPTI_TYPE_NOT_ITERATED
7775 | OPTI_TYPE_NOT_SALTED;
7776 dgst_pos0 = 3;
7777 dgst_pos1 = 4;
7778 dgst_pos2 = 2;
7779 dgst_pos3 = 1;
7780 break;
7781
7782 case 400: hash_type = HASH_TYPE_MD5;
7783 salt_type = SALT_TYPE_EMBEDDED;
7784 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7785 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7786 kern_type = KERN_TYPE_PHPASS;
7787 dgst_size = DGST_SIZE_4_4;
7788 parse_func = phpass_parse_hash;
7789 sort_by_digest = sort_by_digest_4_4;
7790 opti_type = OPTI_TYPE_ZERO_BYTE
7791 | OPTI_TYPE_SLOW_HASH_SIMD;
7792 dgst_pos0 = 0;
7793 dgst_pos1 = 1;
7794 dgst_pos2 = 2;
7795 dgst_pos3 = 3;
7796 break;
7797
7798 case 500: hash_type = HASH_TYPE_MD5;
7799 salt_type = SALT_TYPE_EMBEDDED;
7800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7801 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7802 kern_type = KERN_TYPE_MD5CRYPT;
7803 dgst_size = DGST_SIZE_4_4;
7804 parse_func = md5crypt_parse_hash;
7805 sort_by_digest = sort_by_digest_4_4;
7806 opti_type = OPTI_TYPE_ZERO_BYTE;
7807 dgst_pos0 = 0;
7808 dgst_pos1 = 1;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 3;
7811 break;
7812
7813 case 501: hash_type = HASH_TYPE_MD5;
7814 salt_type = SALT_TYPE_EMBEDDED;
7815 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_LE
7817 | OPTS_TYPE_HASH_COPY;
7818 kern_type = KERN_TYPE_MD5CRYPT;
7819 dgst_size = DGST_SIZE_4_4;
7820 parse_func = juniper_parse_hash;
7821 sort_by_digest = sort_by_digest_4_4;
7822 opti_type = OPTI_TYPE_ZERO_BYTE;
7823 dgst_pos0 = 0;
7824 dgst_pos1 = 1;
7825 dgst_pos2 = 2;
7826 dgst_pos3 = 3;
7827 break;
7828
7829 case 900: hash_type = HASH_TYPE_MD4;
7830 salt_type = SALT_TYPE_NONE;
7831 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7832 opts_type = OPTS_TYPE_PT_GENERATE_LE
7833 | OPTS_TYPE_PT_ADD80
7834 | OPTS_TYPE_PT_ADDBITS14;
7835 kern_type = KERN_TYPE_MD4;
7836 dgst_size = DGST_SIZE_4_4;
7837 parse_func = md4_parse_hash;
7838 sort_by_digest = sort_by_digest_4_4;
7839 opti_type = OPTI_TYPE_ZERO_BYTE
7840 | OPTI_TYPE_PRECOMPUTE_INIT
7841 | OPTI_TYPE_PRECOMPUTE_MERKLE
7842 | OPTI_TYPE_MEET_IN_MIDDLE
7843 | OPTI_TYPE_EARLY_SKIP
7844 | OPTI_TYPE_NOT_ITERATED
7845 | OPTI_TYPE_NOT_SALTED
7846 | OPTI_TYPE_RAW_HASH;
7847 dgst_pos0 = 0;
7848 dgst_pos1 = 3;
7849 dgst_pos2 = 2;
7850 dgst_pos3 = 1;
7851 break;
7852
7853 case 1000: hash_type = HASH_TYPE_MD4;
7854 salt_type = SALT_TYPE_NONE;
7855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7856 opts_type = OPTS_TYPE_PT_GENERATE_LE
7857 | OPTS_TYPE_PT_ADD80
7858 | OPTS_TYPE_PT_ADDBITS14
7859 | OPTS_TYPE_PT_UNICODE;
7860 kern_type = KERN_TYPE_MD4_PWU;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = md4_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_MEET_IN_MIDDLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 1100: hash_type = HASH_TYPE_MD4;
7879 salt_type = SALT_TYPE_INTERN;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14
7884 | OPTS_TYPE_PT_UNICODE
7885 | OPTS_TYPE_ST_ADD80
7886 | OPTS_TYPE_ST_UNICODE
7887 | OPTS_TYPE_ST_LOWER;
7888 kern_type = KERN_TYPE_MD44_PWUSLT;
7889 dgst_size = DGST_SIZE_4_4;
7890 parse_func = dcc_parse_hash;
7891 sort_by_digest = sort_by_digest_4_4;
7892 opti_type = OPTI_TYPE_ZERO_BYTE
7893 | OPTI_TYPE_PRECOMPUTE_INIT
7894 | OPTI_TYPE_PRECOMPUTE_MERKLE
7895 | OPTI_TYPE_EARLY_SKIP
7896 | OPTI_TYPE_NOT_ITERATED;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1400: hash_type = HASH_TYPE_SHA256;
7904 salt_type = SALT_TYPE_NONE;
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;
7910 dgst_size = DGST_SIZE_4_8;
7911 parse_func = sha256_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_NOT_SALTED
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 1410: hash_type = HASH_TYPE_SHA256;
7927 salt_type = SALT_TYPE_INTERN;
7928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7929 opts_type = OPTS_TYPE_PT_GENERATE_BE
7930 | OPTS_TYPE_ST_ADD80
7931 | OPTS_TYPE_ST_ADDBITS15;
7932 kern_type = KERN_TYPE_SHA256_PWSLT;
7933 dgst_size = DGST_SIZE_4_8;
7934 parse_func = sha256s_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_APPENDED_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 1420: 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_ADD80
7954 | OPTS_TYPE_PT_ADDBITS15;
7955 kern_type = KERN_TYPE_SHA256_SLTPW;
7956 dgst_size = DGST_SIZE_4_8;
7957 parse_func = sha256s_parse_hash;
7958 sort_by_digest = sort_by_digest_4_8;
7959 opti_type = OPTI_TYPE_ZERO_BYTE
7960 | OPTI_TYPE_PRECOMPUTE_INIT
7961 | OPTI_TYPE_PRECOMPUTE_MERKLE
7962 | OPTI_TYPE_EARLY_SKIP
7963 | OPTI_TYPE_NOT_ITERATED
7964 | OPTI_TYPE_PREPENDED_SALT
7965 | OPTI_TYPE_RAW_HASH;
7966 dgst_pos0 = 3;
7967 dgst_pos1 = 7;
7968 dgst_pos2 = 2;
7969 dgst_pos3 = 6;
7970 break;
7971
7972 case 1421: hash_type = HASH_TYPE_SHA256;
7973 salt_type = SALT_TYPE_EMBEDDED;
7974 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7975 opts_type = OPTS_TYPE_PT_GENERATE_BE
7976 | OPTS_TYPE_PT_ADD80
7977 | OPTS_TYPE_PT_ADDBITS15;
7978 kern_type = KERN_TYPE_SHA256_SLTPW;
7979 dgst_size = DGST_SIZE_4_8;
7980 parse_func = hmailserver_parse_hash;
7981 sort_by_digest = sort_by_digest_4_8;
7982 opti_type = OPTI_TYPE_ZERO_BYTE
7983 | OPTI_TYPE_PRECOMPUTE_INIT
7984 | OPTI_TYPE_PRECOMPUTE_MERKLE
7985 | OPTI_TYPE_EARLY_SKIP
7986 | OPTI_TYPE_NOT_ITERATED
7987 | OPTI_TYPE_PREPENDED_SALT
7988 | OPTI_TYPE_RAW_HASH;
7989 dgst_pos0 = 3;
7990 dgst_pos1 = 7;
7991 dgst_pos2 = 2;
7992 dgst_pos3 = 6;
7993 break;
7994
7995 case 1430: hash_type = HASH_TYPE_SHA256;
7996 salt_type = SALT_TYPE_INTERN;
7997 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7998 opts_type = OPTS_TYPE_PT_GENERATE_BE
7999 | OPTS_TYPE_PT_UNICODE
8000 | OPTS_TYPE_ST_ADD80
8001 | OPTS_TYPE_ST_ADDBITS15;
8002 kern_type = KERN_TYPE_SHA256_PWUSLT;
8003 dgst_size = DGST_SIZE_4_8;
8004 parse_func = sha256s_parse_hash;
8005 sort_by_digest = sort_by_digest_4_8;
8006 opti_type = OPTI_TYPE_ZERO_BYTE
8007 | OPTI_TYPE_PRECOMPUTE_INIT
8008 | OPTI_TYPE_PRECOMPUTE_MERKLE
8009 | OPTI_TYPE_EARLY_SKIP
8010 | OPTI_TYPE_NOT_ITERATED
8011 | OPTI_TYPE_APPENDED_SALT
8012 | OPTI_TYPE_RAW_HASH;
8013 dgst_pos0 = 3;
8014 dgst_pos1 = 7;
8015 dgst_pos2 = 2;
8016 dgst_pos3 = 6;
8017 break;
8018
8019 case 1440: hash_type = HASH_TYPE_SHA256;
8020 salt_type = SALT_TYPE_INTERN;
8021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8022 opts_type = OPTS_TYPE_PT_GENERATE_BE
8023 | OPTS_TYPE_PT_ADD80
8024 | OPTS_TYPE_PT_ADDBITS15
8025 | OPTS_TYPE_PT_UNICODE;
8026 kern_type = KERN_TYPE_SHA256_SLTPWU;
8027 dgst_size = DGST_SIZE_4_8;
8028 parse_func = sha256s_parse_hash;
8029 sort_by_digest = sort_by_digest_4_8;
8030 opti_type = OPTI_TYPE_ZERO_BYTE
8031 | OPTI_TYPE_PRECOMPUTE_INIT
8032 | OPTI_TYPE_PRECOMPUTE_MERKLE
8033 | OPTI_TYPE_EARLY_SKIP
8034 | OPTI_TYPE_NOT_ITERATED
8035 | OPTI_TYPE_PREPENDED_SALT
8036 | OPTI_TYPE_RAW_HASH;
8037 dgst_pos0 = 3;
8038 dgst_pos1 = 7;
8039 dgst_pos2 = 2;
8040 dgst_pos3 = 6;
8041 break;
8042
8043 case 1441: hash_type = HASH_TYPE_SHA256;
8044 salt_type = SALT_TYPE_EMBEDDED;
8045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8046 opts_type = OPTS_TYPE_PT_GENERATE_BE
8047 | OPTS_TYPE_PT_ADD80
8048 | OPTS_TYPE_PT_ADDBITS15
8049 | OPTS_TYPE_PT_UNICODE
8050 | OPTS_TYPE_ST_BASE64;
8051 kern_type = KERN_TYPE_SHA256_SLTPWU;
8052 dgst_size = DGST_SIZE_4_8;
8053 parse_func = episerver4_parse_hash;
8054 sort_by_digest = sort_by_digest_4_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 7;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 6;
8066 break;
8067
8068 case 1450: hash_type = HASH_TYPE_SHA256;
8069 salt_type = SALT_TYPE_INTERN;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_ST_ADD80;
8073 kern_type = KERN_TYPE_HMACSHA256_PW;
8074 dgst_size = DGST_SIZE_4_8;
8075 parse_func = hmacsha256_parse_hash;
8076 sort_by_digest = sort_by_digest_4_8;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_NOT_ITERATED;
8079 dgst_pos0 = 3;
8080 dgst_pos1 = 7;
8081 dgst_pos2 = 2;
8082 dgst_pos3 = 6;
8083 break;
8084
8085 case 1460: hash_type = HASH_TYPE_SHA256;
8086 salt_type = SALT_TYPE_INTERN;
8087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8088 opts_type = OPTS_TYPE_PT_GENERATE_BE
8089 | OPTS_TYPE_PT_ADD80
8090 | OPTS_TYPE_PT_ADDBITS15;
8091 kern_type = KERN_TYPE_HMACSHA256_SLT;
8092 dgst_size = DGST_SIZE_4_8;
8093 parse_func = hmacsha256_parse_hash;
8094 sort_by_digest = sort_by_digest_4_8;
8095 opti_type = OPTI_TYPE_ZERO_BYTE
8096 | OPTI_TYPE_NOT_ITERATED;
8097 dgst_pos0 = 3;
8098 dgst_pos1 = 7;
8099 dgst_pos2 = 2;
8100 dgst_pos3 = 6;
8101 break;
8102
8103 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8104 salt_type = SALT_TYPE_EMBEDDED;
8105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8106 opts_type = OPTS_TYPE_PT_GENERATE_LE
8107 | OPTS_TYPE_PT_BITSLICE;
8108 kern_type = KERN_TYPE_DESCRYPT;
8109 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8110 parse_func = descrypt_parse_hash;
8111 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8114 dgst_pos0 = 0;
8115 dgst_pos1 = 1;
8116 dgst_pos2 = 2;
8117 dgst_pos3 = 3;
8118 break;
8119
8120 case 1600: hash_type = HASH_TYPE_MD5;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8124 kern_type = KERN_TYPE_APR1CRYPT;
8125 dgst_size = DGST_SIZE_4_4;
8126 parse_func = md5apr1_parse_hash;
8127 sort_by_digest = sort_by_digest_4_4;
8128 opti_type = OPTI_TYPE_ZERO_BYTE;
8129 dgst_pos0 = 0;
8130 dgst_pos1 = 1;
8131 dgst_pos2 = 2;
8132 dgst_pos3 = 3;
8133 break;
8134
8135 case 1700: hash_type = HASH_TYPE_SHA512;
8136 salt_type = SALT_TYPE_NONE;
8137 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8138 opts_type = OPTS_TYPE_PT_GENERATE_BE
8139 | OPTS_TYPE_PT_ADD80
8140 | OPTS_TYPE_PT_ADDBITS15;
8141 kern_type = KERN_TYPE_SHA512;
8142 dgst_size = DGST_SIZE_8_8;
8143 parse_func = sha512_parse_hash;
8144 sort_by_digest = sort_by_digest_8_8;
8145 opti_type = OPTI_TYPE_ZERO_BYTE
8146 | OPTI_TYPE_PRECOMPUTE_INIT
8147 | OPTI_TYPE_PRECOMPUTE_MERKLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_ITERATED
8150 | OPTI_TYPE_NOT_SALTED
8151 | OPTI_TYPE_USES_BITS_64
8152 | OPTI_TYPE_RAW_HASH;
8153 dgst_pos0 = 14;
8154 dgst_pos1 = 15;
8155 dgst_pos2 = 6;
8156 dgst_pos3 = 7;
8157 break;
8158
8159 case 1710: hash_type = HASH_TYPE_SHA512;
8160 salt_type = SALT_TYPE_INTERN;
8161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8162 opts_type = OPTS_TYPE_PT_GENERATE_BE
8163 | OPTS_TYPE_ST_ADD80
8164 | OPTS_TYPE_ST_ADDBITS15;
8165 kern_type = KERN_TYPE_SHA512_PWSLT;
8166 dgst_size = DGST_SIZE_8_8;
8167 parse_func = sha512s_parse_hash;
8168 sort_by_digest = sort_by_digest_8_8;
8169 opti_type = OPTI_TYPE_ZERO_BYTE
8170 | OPTI_TYPE_PRECOMPUTE_INIT
8171 | OPTI_TYPE_PRECOMPUTE_MERKLE
8172 | OPTI_TYPE_EARLY_SKIP
8173 | OPTI_TYPE_NOT_ITERATED
8174 | OPTI_TYPE_APPENDED_SALT
8175 | OPTI_TYPE_USES_BITS_64
8176 | OPTI_TYPE_RAW_HASH;
8177 dgst_pos0 = 14;
8178 dgst_pos1 = 15;
8179 dgst_pos2 = 6;
8180 dgst_pos3 = 7;
8181 break;
8182
8183 case 1711: hash_type = HASH_TYPE_SHA512;
8184 salt_type = SALT_TYPE_EMBEDDED;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_ST_ADD80
8188 | OPTS_TYPE_ST_ADDBITS15;
8189 kern_type = KERN_TYPE_SHA512_PWSLT;
8190 dgst_size = DGST_SIZE_8_8;
8191 parse_func = sha512b64s_parse_hash;
8192 sort_by_digest = sort_by_digest_8_8;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_ITERATED
8198 | OPTI_TYPE_APPENDED_SALT
8199 | OPTI_TYPE_USES_BITS_64
8200 | OPTI_TYPE_RAW_HASH;
8201 dgst_pos0 = 14;
8202 dgst_pos1 = 15;
8203 dgst_pos2 = 6;
8204 dgst_pos3 = 7;
8205 break;
8206
8207 case 1720: hash_type = HASH_TYPE_SHA512;
8208 salt_type = SALT_TYPE_INTERN;
8209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8210 opts_type = OPTS_TYPE_PT_GENERATE_BE
8211 | OPTS_TYPE_PT_ADD80
8212 | OPTS_TYPE_PT_ADDBITS15;
8213 kern_type = KERN_TYPE_SHA512_SLTPW;
8214 dgst_size = DGST_SIZE_8_8;
8215 parse_func = sha512s_parse_hash;
8216 sort_by_digest = sort_by_digest_8_8;
8217 opti_type = OPTI_TYPE_ZERO_BYTE
8218 | OPTI_TYPE_PRECOMPUTE_INIT
8219 | OPTI_TYPE_PRECOMPUTE_MERKLE
8220 | OPTI_TYPE_EARLY_SKIP
8221 | OPTI_TYPE_NOT_ITERATED
8222 | OPTI_TYPE_PREPENDED_SALT
8223 | OPTI_TYPE_USES_BITS_64
8224 | OPTI_TYPE_RAW_HASH;
8225 dgst_pos0 = 14;
8226 dgst_pos1 = 15;
8227 dgst_pos2 = 6;
8228 dgst_pos3 = 7;
8229 break;
8230
8231 case 1722: hash_type = HASH_TYPE_SHA512;
8232 salt_type = SALT_TYPE_EMBEDDED;
8233 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8234 opts_type = OPTS_TYPE_PT_GENERATE_BE
8235 | OPTS_TYPE_PT_ADD80
8236 | OPTS_TYPE_PT_ADDBITS15
8237 | OPTS_TYPE_ST_HEX;
8238 kern_type = KERN_TYPE_SHA512_SLTPW;
8239 dgst_size = DGST_SIZE_8_8;
8240 parse_func = osx512_parse_hash;
8241 sort_by_digest = sort_by_digest_8_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED
8247 | OPTI_TYPE_PREPENDED_SALT
8248 | OPTI_TYPE_USES_BITS_64
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 14;
8251 dgst_pos1 = 15;
8252 dgst_pos2 = 6;
8253 dgst_pos3 = 7;
8254 break;
8255
8256 case 1730: hash_type = HASH_TYPE_SHA512;
8257 salt_type = SALT_TYPE_INTERN;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_UNICODE
8261 | OPTS_TYPE_ST_ADD80
8262 | OPTS_TYPE_ST_ADDBITS15;
8263 kern_type = KERN_TYPE_SHA512_PWSLTU;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = sha512s_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_APPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1731: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_UNICODE
8286 | OPTS_TYPE_ST_ADD80
8287 | OPTS_TYPE_ST_ADDBITS15
8288 | OPTS_TYPE_ST_HEX;
8289 kern_type = KERN_TYPE_SHA512_PWSLTU;
8290 dgst_size = DGST_SIZE_8_8;
8291 parse_func = mssql2012_parse_hash;
8292 sort_by_digest = sort_by_digest_8_8;
8293 opti_type = OPTI_TYPE_ZERO_BYTE
8294 | OPTI_TYPE_PRECOMPUTE_INIT
8295 | OPTI_TYPE_PRECOMPUTE_MERKLE
8296 | OPTI_TYPE_EARLY_SKIP
8297 | OPTI_TYPE_NOT_ITERATED
8298 | OPTI_TYPE_APPENDED_SALT
8299 | OPTI_TYPE_USES_BITS_64
8300 | OPTI_TYPE_RAW_HASH;
8301 dgst_pos0 = 14;
8302 dgst_pos1 = 15;
8303 dgst_pos2 = 6;
8304 dgst_pos3 = 7;
8305 break;
8306
8307 case 1740: hash_type = HASH_TYPE_SHA512;
8308 salt_type = SALT_TYPE_INTERN;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_BE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS15
8313 | OPTS_TYPE_PT_UNICODE;
8314 kern_type = KERN_TYPE_SHA512_SLTPWU;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = sha512s_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_PREPENDED_SALT
8324 | OPTI_TYPE_USES_BITS_64
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 14;
8327 dgst_pos1 = 15;
8328 dgst_pos2 = 6;
8329 dgst_pos3 = 7;
8330 break;
8331
8332 case 1750: hash_type = HASH_TYPE_SHA512;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_ST_ADD80;
8337 kern_type = KERN_TYPE_HMACSHA512_PW;
8338 dgst_size = DGST_SIZE_8_8;
8339 parse_func = hmacsha512_parse_hash;
8340 sort_by_digest = sort_by_digest_8_8;
8341 opti_type = OPTI_TYPE_ZERO_BYTE
8342 | OPTI_TYPE_USES_BITS_64
8343 | OPTI_TYPE_NOT_ITERATED;
8344 dgst_pos0 = 14;
8345 dgst_pos1 = 15;
8346 dgst_pos2 = 6;
8347 dgst_pos3 = 7;
8348 break;
8349
8350 case 1760: hash_type = HASH_TYPE_SHA512;
8351 salt_type = SALT_TYPE_INTERN;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_BE
8354 | OPTS_TYPE_PT_ADD80
8355 | OPTS_TYPE_PT_ADDBITS15;
8356 kern_type = KERN_TYPE_HMACSHA512_SLT;
8357 dgst_size = DGST_SIZE_8_8;
8358 parse_func = hmacsha512_parse_hash;
8359 sort_by_digest = sort_by_digest_8_8;
8360 opti_type = OPTI_TYPE_ZERO_BYTE
8361 | OPTI_TYPE_USES_BITS_64
8362 | OPTI_TYPE_NOT_ITERATED;
8363 dgst_pos0 = 14;
8364 dgst_pos1 = 15;
8365 dgst_pos2 = 6;
8366 dgst_pos3 = 7;
8367 break;
8368
8369 case 1800: hash_type = HASH_TYPE_SHA512;
8370 salt_type = SALT_TYPE_EMBEDDED;
8371 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8372 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8373 kern_type = KERN_TYPE_SHA512CRYPT;
8374 dgst_size = DGST_SIZE_8_8;
8375 parse_func = sha512crypt_parse_hash;
8376 sort_by_digest = sort_by_digest_8_8;
8377 opti_type = OPTI_TYPE_ZERO_BYTE
8378 | OPTI_TYPE_USES_BITS_64;
8379 dgst_pos0 = 0;
8380 dgst_pos1 = 1;
8381 dgst_pos2 = 2;
8382 dgst_pos3 = 3;
8383 break;
8384
8385 case 2100: hash_type = HASH_TYPE_DCC2;
8386 salt_type = SALT_TYPE_EMBEDDED;
8387 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8388 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8389 | OPTS_TYPE_ST_LOWER
8390 | OPTS_TYPE_ST_UNICODE;
8391 kern_type = KERN_TYPE_DCC2;
8392 dgst_size = DGST_SIZE_4_4;
8393 parse_func = dcc2_parse_hash;
8394 sort_by_digest = sort_by_digest_4_4;
8395 opti_type = OPTI_TYPE_ZERO_BYTE
8396 | OPTI_TYPE_SLOW_HASH_SIMD;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 2400: hash_type = HASH_TYPE_MD5;
8404 salt_type = SALT_TYPE_NONE;
8405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8407 kern_type = KERN_TYPE_MD5PIX;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5pix_parse_hash;
8410 sort_by_digest = sort_by_digest_4_4;
8411 opti_type = OPTI_TYPE_ZERO_BYTE
8412 | OPTI_TYPE_PRECOMPUTE_INIT
8413 | OPTI_TYPE_PRECOMPUTE_MERKLE
8414 | OPTI_TYPE_EARLY_SKIP
8415 | OPTI_TYPE_NOT_ITERATED
8416 | OPTI_TYPE_NOT_SALTED;
8417 dgst_pos0 = 0;
8418 dgst_pos1 = 3;
8419 dgst_pos2 = 2;
8420 dgst_pos3 = 1;
8421 break;
8422
8423 case 2410: hash_type = HASH_TYPE_MD5;
8424 salt_type = SALT_TYPE_INTERN;
8425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8426 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8427 kern_type = KERN_TYPE_MD5ASA;
8428 dgst_size = DGST_SIZE_4_4;
8429 parse_func = md5asa_parse_hash;
8430 sort_by_digest = sort_by_digest_4_4;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_ITERATED;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 2500: hash_type = HASH_TYPE_WPA;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8446 kern_type = KERN_TYPE_WPA;
8447 dgst_size = DGST_SIZE_4_4;
8448 parse_func = wpa_parse_hash;
8449 sort_by_digest = sort_by_digest_4_4;
8450 opti_type = OPTI_TYPE_ZERO_BYTE
8451 | OPTI_TYPE_SLOW_HASH_SIMD;
8452 dgst_pos0 = 0;
8453 dgst_pos1 = 1;
8454 dgst_pos2 = 2;
8455 dgst_pos3 = 3;
8456 break;
8457
8458 case 2600: hash_type = HASH_TYPE_MD5;
8459 salt_type = SALT_TYPE_VIRTUAL;
8460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8461 opts_type = OPTS_TYPE_PT_GENERATE_LE
8462 | OPTS_TYPE_PT_ADD80
8463 | OPTS_TYPE_PT_ADDBITS14
8464 | OPTS_TYPE_ST_ADD80;
8465 kern_type = KERN_TYPE_MD55_PWSLT1;
8466 dgst_size = DGST_SIZE_4_4;
8467 parse_func = md5md5_parse_hash;
8468 sort_by_digest = sort_by_digest_4_4;
8469 opti_type = OPTI_TYPE_ZERO_BYTE
8470 | OPTI_TYPE_PRECOMPUTE_INIT
8471 | OPTI_TYPE_PRECOMPUTE_MERKLE
8472 | OPTI_TYPE_EARLY_SKIP;
8473 dgst_pos0 = 0;
8474 dgst_pos1 = 3;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 1;
8477 break;
8478
8479 case 2611: hash_type = HASH_TYPE_MD5;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_LE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS14
8485 | OPTS_TYPE_ST_ADD80;
8486 kern_type = KERN_TYPE_MD55_PWSLT1;
8487 dgst_size = DGST_SIZE_4_4;
8488 parse_func = vb3_parse_hash;
8489 sort_by_digest = sort_by_digest_4_4;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP;
8494 dgst_pos0 = 0;
8495 dgst_pos1 = 3;
8496 dgst_pos2 = 2;
8497 dgst_pos3 = 1;
8498 break;
8499
8500 case 2612: hash_type = HASH_TYPE_MD5;
8501 salt_type = SALT_TYPE_EMBEDDED;
8502 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8503 opts_type = OPTS_TYPE_PT_GENERATE_LE
8504 | OPTS_TYPE_PT_ADD80
8505 | OPTS_TYPE_PT_ADDBITS14
8506 | OPTS_TYPE_ST_ADD80
8507 | OPTS_TYPE_ST_HEX;
8508 kern_type = KERN_TYPE_MD55_PWSLT1;
8509 dgst_size = DGST_SIZE_4_4;
8510 parse_func = phps_parse_hash;
8511 sort_by_digest = sort_by_digest_4_4;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_PRECOMPUTE_INIT
8514 | OPTI_TYPE_PRECOMPUTE_MERKLE
8515 | OPTI_TYPE_EARLY_SKIP;
8516 dgst_pos0 = 0;
8517 dgst_pos1 = 3;
8518 dgst_pos2 = 2;
8519 dgst_pos3 = 1;
8520 break;
8521
8522 case 2711: hash_type = HASH_TYPE_MD5;
8523 salt_type = SALT_TYPE_INTERN;
8524 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8525 opts_type = OPTS_TYPE_PT_GENERATE_LE
8526 | OPTS_TYPE_PT_ADD80
8527 | OPTS_TYPE_PT_ADDBITS14
8528 | OPTS_TYPE_ST_ADD80;
8529 kern_type = KERN_TYPE_MD55_PWSLT2;
8530 dgst_size = DGST_SIZE_4_4;
8531 parse_func = vb30_parse_hash;
8532 sort_by_digest = sort_by_digest_4_4;
8533 opti_type = OPTI_TYPE_ZERO_BYTE
8534 | OPTI_TYPE_PRECOMPUTE_INIT
8535 | OPTI_TYPE_EARLY_SKIP;
8536 dgst_pos0 = 0;
8537 dgst_pos1 = 3;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 1;
8540 break;
8541
8542 case 2811: hash_type = HASH_TYPE_MD5;
8543 salt_type = SALT_TYPE_INTERN;
8544 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE
8546 | OPTS_TYPE_PT_ADD80
8547 | OPTS_TYPE_PT_ADDBITS14;
8548 kern_type = KERN_TYPE_MD55_SLTPW;
8549 dgst_size = DGST_SIZE_4_4;
8550 parse_func = ipb2_parse_hash;
8551 sort_by_digest = sort_by_digest_4_4;
8552 opti_type = OPTI_TYPE_ZERO_BYTE
8553 | OPTI_TYPE_PRECOMPUTE_INIT
8554 | OPTI_TYPE_EARLY_SKIP;
8555 dgst_pos0 = 0;
8556 dgst_pos1 = 3;
8557 dgst_pos2 = 2;
8558 dgst_pos3 = 1;
8559 break;
8560
8561 case 3000: hash_type = HASH_TYPE_LM;
8562 salt_type = SALT_TYPE_NONE;
8563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_LE
8565 | OPTS_TYPE_PT_UPPER
8566 | OPTS_TYPE_PT_BITSLICE;
8567 kern_type = KERN_TYPE_LM;
8568 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8569 parse_func = lm_parse_hash;
8570 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8571 opti_type = OPTI_TYPE_ZERO_BYTE
8572 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 1;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 3;
8577 break;
8578
8579 case 3100: hash_type = HASH_TYPE_ORACLEH;
8580 salt_type = SALT_TYPE_INTERN;
8581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_LE
8583 | OPTS_TYPE_PT_UPPER
8584 | OPTS_TYPE_ST_UPPER;
8585 kern_type = KERN_TYPE_ORACLEH;
8586 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8587 parse_func = oracleh_parse_hash;
8588 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8589 opti_type = OPTI_TYPE_ZERO_BYTE;
8590 dgst_pos0 = 0;
8591 dgst_pos1 = 1;
8592 dgst_pos2 = 2;
8593 dgst_pos3 = 3;
8594 break;
8595
8596 case 3200: hash_type = HASH_TYPE_BCRYPT;
8597 salt_type = SALT_TYPE_EMBEDDED;
8598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8599 opts_type = OPTS_TYPE_PT_GENERATE_LE
8600 | OPTS_TYPE_ST_GENERATE_LE;
8601 kern_type = KERN_TYPE_BCRYPT;
8602 dgst_size = DGST_SIZE_4_6;
8603 parse_func = bcrypt_parse_hash;
8604 sort_by_digest = sort_by_digest_4_6;
8605 opti_type = OPTI_TYPE_ZERO_BYTE;
8606 dgst_pos0 = 0;
8607 dgst_pos1 = 1;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 3;
8610 break;
8611
8612 case 3710: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_INTERN;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADD80
8617 | OPTS_TYPE_PT_ADDBITS14;
8618 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8619 dgst_size = DGST_SIZE_4_4;
8620 parse_func = md5s_parse_hash;
8621 sort_by_digest = sort_by_digest_4_4;
8622 opti_type = OPTI_TYPE_ZERO_BYTE
8623 | OPTI_TYPE_PRECOMPUTE_INIT
8624 | OPTI_TYPE_PRECOMPUTE_MERKLE
8625 | OPTI_TYPE_EARLY_SKIP;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 3;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 1;
8630 break;
8631
8632 case 3711: hash_type = HASH_TYPE_MD5;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_PT_ADD80
8637 | OPTS_TYPE_PT_ADDBITS14;
8638 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8639 dgst_size = DGST_SIZE_4_4;
8640 parse_func = mediawiki_b_parse_hash;
8641 sort_by_digest = sort_by_digest_4_4;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_EARLY_SKIP;
8646 dgst_pos0 = 0;
8647 dgst_pos1 = 3;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 3800: hash_type = HASH_TYPE_MD5;
8653 salt_type = SALT_TYPE_INTERN;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_ST_ADDBITS14;
8657 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8658 dgst_size = DGST_SIZE_4_4;
8659 parse_func = md5s_parse_hash;
8660 sort_by_digest = sort_by_digest_4_4;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_PRECOMPUTE_INIT
8663 | OPTI_TYPE_PRECOMPUTE_MERKLE
8664 | OPTI_TYPE_EARLY_SKIP
8665 | OPTI_TYPE_NOT_ITERATED
8666 | OPTI_TYPE_RAW_HASH;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 3;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 1;
8671 break;
8672
8673 case 4300: hash_type = HASH_TYPE_MD5;
8674 salt_type = SALT_TYPE_VIRTUAL;
8675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE
8677 | OPTS_TYPE_PT_ADD80
8678 | OPTS_TYPE_PT_ADDBITS14
8679 | OPTS_TYPE_ST_ADD80;
8680 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8681 dgst_size = DGST_SIZE_4_4;
8682 parse_func = md5md5_parse_hash;
8683 sort_by_digest = sort_by_digest_4_4;
8684 opti_type = OPTI_TYPE_ZERO_BYTE
8685 | OPTI_TYPE_PRECOMPUTE_INIT
8686 | OPTI_TYPE_PRECOMPUTE_MERKLE
8687 | OPTI_TYPE_EARLY_SKIP;
8688 dgst_pos0 = 0;
8689 dgst_pos1 = 3;
8690 dgst_pos2 = 2;
8691 dgst_pos3 = 1;
8692 break;
8693
8694
8695 case 4400: hash_type = HASH_TYPE_MD5;
8696 salt_type = SALT_TYPE_NONE;
8697 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8698 opts_type = OPTS_TYPE_PT_GENERATE_BE
8699 | OPTS_TYPE_PT_ADD80
8700 | OPTS_TYPE_PT_ADDBITS15;
8701 kern_type = KERN_TYPE_MD5_SHA1;
8702 dgst_size = DGST_SIZE_4_4;
8703 parse_func = md5_parse_hash;
8704 sort_by_digest = sort_by_digest_4_4;
8705 opti_type = OPTI_TYPE_ZERO_BYTE
8706 | OPTI_TYPE_PRECOMPUTE_INIT
8707 | OPTI_TYPE_PRECOMPUTE_MERKLE
8708 | OPTI_TYPE_EARLY_SKIP
8709 | OPTI_TYPE_NOT_ITERATED
8710 | OPTI_TYPE_NOT_SALTED
8711 | OPTI_TYPE_RAW_HASH;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 3;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 1;
8716 break;
8717
8718 case 4500: hash_type = HASH_TYPE_SHA1;
8719 salt_type = SALT_TYPE_NONE;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_BE
8722 | OPTS_TYPE_PT_ADD80
8723 | OPTS_TYPE_PT_ADDBITS15;
8724 kern_type = KERN_TYPE_SHA11;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = sha1_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE
8729 | OPTI_TYPE_PRECOMPUTE_INIT
8730 | OPTI_TYPE_PRECOMPUTE_MERKLE
8731 | OPTI_TYPE_EARLY_SKIP
8732 | OPTI_TYPE_NOT_SALTED;
8733 dgst_pos0 = 3;
8734 dgst_pos1 = 4;
8735 dgst_pos2 = 2;
8736 dgst_pos3 = 1;
8737 break;
8738
8739 case 4700: hash_type = HASH_TYPE_SHA1;
8740 salt_type = SALT_TYPE_NONE;
8741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8742 opts_type = OPTS_TYPE_PT_GENERATE_LE
8743 | OPTS_TYPE_PT_ADD80
8744 | OPTS_TYPE_PT_ADDBITS14;
8745 kern_type = KERN_TYPE_SHA1_MD5;
8746 dgst_size = DGST_SIZE_4_5;
8747 parse_func = sha1_parse_hash;
8748 sort_by_digest = sort_by_digest_4_5;
8749 opti_type = OPTI_TYPE_ZERO_BYTE
8750 | OPTI_TYPE_PRECOMPUTE_INIT
8751 | OPTI_TYPE_PRECOMPUTE_MERKLE
8752 | OPTI_TYPE_EARLY_SKIP
8753 | OPTI_TYPE_NOT_ITERATED
8754 | OPTI_TYPE_NOT_SALTED
8755 | OPTI_TYPE_RAW_HASH;
8756 dgst_pos0 = 3;
8757 dgst_pos1 = 4;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 1;
8760 break;
8761
8762 case 4800: hash_type = HASH_TYPE_MD5;
8763 salt_type = SALT_TYPE_EMBEDDED;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE
8766 | OPTS_TYPE_PT_ADDBITS14;
8767 kern_type = KERN_TYPE_MD5_CHAP;
8768 dgst_size = DGST_SIZE_4_4;
8769 parse_func = chap_parse_hash;
8770 sort_by_digest = sort_by_digest_4_4;
8771 opti_type = OPTI_TYPE_ZERO_BYTE
8772 | OPTI_TYPE_PRECOMPUTE_INIT
8773 | OPTI_TYPE_PRECOMPUTE_MERKLE
8774 | OPTI_TYPE_MEET_IN_MIDDLE
8775 | OPTI_TYPE_EARLY_SKIP
8776 | OPTI_TYPE_NOT_ITERATED
8777 | OPTI_TYPE_RAW_HASH;
8778 dgst_pos0 = 0;
8779 dgst_pos1 = 3;
8780 dgst_pos2 = 2;
8781 dgst_pos3 = 1;
8782 break;
8783
8784 case 4900: hash_type = HASH_TYPE_SHA1;
8785 salt_type = SALT_TYPE_INTERN;
8786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8788 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8789 dgst_size = DGST_SIZE_4_5;
8790 parse_func = sha1s_parse_hash;
8791 sort_by_digest = sort_by_digest_4_5;
8792 opti_type = OPTI_TYPE_ZERO_BYTE
8793 | OPTI_TYPE_PRECOMPUTE_INIT
8794 | OPTI_TYPE_PRECOMPUTE_MERKLE
8795 | OPTI_TYPE_EARLY_SKIP;
8796 dgst_pos0 = 3;
8797 dgst_pos1 = 4;
8798 dgst_pos2 = 2;
8799 dgst_pos3 = 1;
8800 break;
8801
8802 case 5000: hash_type = HASH_TYPE_KECCAK;
8803 salt_type = SALT_TYPE_EMBEDDED;
8804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8805 opts_type = OPTS_TYPE_PT_GENERATE_LE
8806 | OPTS_TYPE_PT_ADD01;
8807 kern_type = KERN_TYPE_KECCAK;
8808 dgst_size = DGST_SIZE_8_25;
8809 parse_func = keccak_parse_hash;
8810 sort_by_digest = sort_by_digest_8_25;
8811 opti_type = OPTI_TYPE_ZERO_BYTE
8812 | OPTI_TYPE_USES_BITS_64
8813 | OPTI_TYPE_RAW_HASH;
8814 dgst_pos0 = 2;
8815 dgst_pos1 = 3;
8816 dgst_pos2 = 4;
8817 dgst_pos3 = 5;
8818 break;
8819
8820 case 5100: hash_type = HASH_TYPE_MD5H;
8821 salt_type = SALT_TYPE_NONE;
8822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8823 opts_type = OPTS_TYPE_PT_GENERATE_LE
8824 | OPTS_TYPE_PT_ADD80
8825 | OPTS_TYPE_PT_ADDBITS14;
8826 kern_type = KERN_TYPE_MD5H;
8827 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8828 parse_func = md5half_parse_hash;
8829 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8830 opti_type = OPTI_TYPE_ZERO_BYTE
8831 | OPTI_TYPE_RAW_HASH;
8832 dgst_pos0 = 0;
8833 dgst_pos1 = 1;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 3;
8836 break;
8837
8838 case 5200: hash_type = HASH_TYPE_SHA256;
8839 salt_type = SALT_TYPE_EMBEDDED;
8840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8842 kern_type = KERN_TYPE_PSAFE3;
8843 dgst_size = DGST_SIZE_4_8;
8844 parse_func = psafe3_parse_hash;
8845 sort_by_digest = sort_by_digest_4_8;
8846 opti_type = OPTI_TYPE_ZERO_BYTE;
8847 dgst_pos0 = 0;
8848 dgst_pos1 = 1;
8849 dgst_pos2 = 2;
8850 dgst_pos3 = 3;
8851 break;
8852
8853 case 5300: hash_type = HASH_TYPE_MD5;
8854 salt_type = SALT_TYPE_EMBEDDED;
8855 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8856 opts_type = OPTS_TYPE_PT_GENERATE_LE
8857 | OPTS_TYPE_ST_ADD80;
8858 kern_type = KERN_TYPE_IKEPSK_MD5;
8859 dgst_size = DGST_SIZE_4_4;
8860 parse_func = ikepsk_md5_parse_hash;
8861 sort_by_digest = sort_by_digest_4_4;
8862 opti_type = OPTI_TYPE_ZERO_BYTE;
8863 dgst_pos0 = 0;
8864 dgst_pos1 = 3;
8865 dgst_pos2 = 2;
8866 dgst_pos3 = 1;
8867 break;
8868
8869 case 5400: hash_type = HASH_TYPE_SHA1;
8870 salt_type = SALT_TYPE_EMBEDDED;
8871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8872 opts_type = OPTS_TYPE_PT_GENERATE_BE
8873 | OPTS_TYPE_ST_ADD80;
8874 kern_type = KERN_TYPE_IKEPSK_SHA1;
8875 dgst_size = DGST_SIZE_4_5;
8876 parse_func = ikepsk_sha1_parse_hash;
8877 sort_by_digest = sort_by_digest_4_5;
8878 opti_type = OPTI_TYPE_ZERO_BYTE;
8879 dgst_pos0 = 3;
8880 dgst_pos1 = 4;
8881 dgst_pos2 = 2;
8882 dgst_pos3 = 1;
8883 break;
8884
8885 case 5500: hash_type = HASH_TYPE_NETNTLM;
8886 salt_type = SALT_TYPE_EMBEDDED;
8887 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8888 opts_type = OPTS_TYPE_PT_GENERATE_LE
8889 | OPTS_TYPE_PT_ADD80
8890 | OPTS_TYPE_PT_ADDBITS14
8891 | OPTS_TYPE_PT_UNICODE
8892 | OPTS_TYPE_ST_HEX;
8893 kern_type = KERN_TYPE_NETNTLMv1;
8894 dgst_size = DGST_SIZE_4_4;
8895 parse_func = netntlmv1_parse_hash;
8896 sort_by_digest = sort_by_digest_4_4;
8897 opti_type = OPTI_TYPE_ZERO_BYTE
8898 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 5600: hash_type = HASH_TYPE_MD5;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE
8909 | OPTS_TYPE_PT_ADD80
8910 | OPTS_TYPE_PT_ADDBITS14
8911 | OPTS_TYPE_PT_UNICODE;
8912 kern_type = KERN_TYPE_NETNTLMv2;
8913 dgst_size = DGST_SIZE_4_4;
8914 parse_func = netntlmv2_parse_hash;
8915 sort_by_digest = sort_by_digest_4_4;
8916 opti_type = OPTI_TYPE_ZERO_BYTE;
8917 dgst_pos0 = 0;
8918 dgst_pos1 = 3;
8919 dgst_pos2 = 2;
8920 dgst_pos3 = 1;
8921 break;
8922
8923 case 5700: hash_type = HASH_TYPE_SHA256;
8924 salt_type = SALT_TYPE_NONE;
8925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8926 opts_type = OPTS_TYPE_PT_GENERATE_BE
8927 | OPTS_TYPE_PT_ADD80
8928 | OPTS_TYPE_PT_ADDBITS15;
8929 kern_type = KERN_TYPE_SHA256;
8930 dgst_size = DGST_SIZE_4_8;
8931 parse_func = cisco4_parse_hash;
8932 sort_by_digest = sort_by_digest_4_8;
8933 opti_type = OPTI_TYPE_ZERO_BYTE
8934 | OPTI_TYPE_PRECOMPUTE_INIT
8935 | OPTI_TYPE_PRECOMPUTE_MERKLE
8936 | OPTI_TYPE_EARLY_SKIP
8937 | OPTI_TYPE_NOT_ITERATED
8938 | OPTI_TYPE_NOT_SALTED
8939 | OPTI_TYPE_RAW_HASH;
8940 dgst_pos0 = 3;
8941 dgst_pos1 = 7;
8942 dgst_pos2 = 2;
8943 dgst_pos3 = 6;
8944 break;
8945
8946 case 5800: hash_type = HASH_TYPE_SHA1;
8947 salt_type = SALT_TYPE_INTERN;
8948 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8949 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8950 | OPTS_TYPE_ST_ADD80;
8951 kern_type = KERN_TYPE_ANDROIDPIN;
8952 dgst_size = DGST_SIZE_4_5;
8953 parse_func = androidpin_parse_hash;
8954 sort_by_digest = sort_by_digest_4_5;
8955 opti_type = OPTI_TYPE_ZERO_BYTE;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8963 salt_type = SALT_TYPE_NONE;
8964 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_LE
8966 | OPTS_TYPE_PT_ADD80;
8967 kern_type = KERN_TYPE_RIPEMD160;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = ripemd160_parse_hash;
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 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8979 salt_type = SALT_TYPE_NONE;
8980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_BE
8982 | OPTS_TYPE_PT_ADD80;
8983 kern_type = KERN_TYPE_WHIRLPOOL;
8984 dgst_size = DGST_SIZE_4_16;
8985 parse_func = whirlpool_parse_hash;
8986 sort_by_digest = sort_by_digest_4_16;
8987 opti_type = OPTI_TYPE_ZERO_BYTE;
8988 dgst_pos0 = 0;
8989 dgst_pos1 = 1;
8990 dgst_pos2 = 2;
8991 dgst_pos3 = 3;
8992 break;
8993
8994 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8995 salt_type = SALT_TYPE_EMBEDDED;
8996 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8997 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8998 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8999 dgst_size = DGST_SIZE_4_5;
9000 parse_func = truecrypt_parse_hash_2k;
9001 sort_by_digest = sort_by_digest_4_5;
9002 opti_type = OPTI_TYPE_ZERO_BYTE;
9003 dgst_pos0 = 0;
9004 dgst_pos1 = 1;
9005 dgst_pos2 = 2;
9006 dgst_pos3 = 3;
9007 break;
9008
9009 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9010 salt_type = SALT_TYPE_EMBEDDED;
9011 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9012 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9013 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9014 dgst_size = DGST_SIZE_4_5;
9015 parse_func = truecrypt_parse_hash_2k;
9016 sort_by_digest = sort_by_digest_4_5;
9017 opti_type = OPTI_TYPE_ZERO_BYTE;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9029 dgst_size = DGST_SIZE_4_5;
9030 parse_func = truecrypt_parse_hash_2k;
9031 sort_by_digest = sort_by_digest_4_5;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6221: hash_type = HASH_TYPE_SHA512;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_TCSHA512_XTS512;
9044 dgst_size = DGST_SIZE_8_8;
9045 parse_func = truecrypt_parse_hash_1k;
9046 sort_by_digest = sort_by_digest_8_8;
9047 opti_type = OPTI_TYPE_ZERO_BYTE
9048 | OPTI_TYPE_USES_BITS_64;
9049 dgst_pos0 = 0;
9050 dgst_pos1 = 1;
9051 dgst_pos2 = 2;
9052 dgst_pos3 = 3;
9053 break;
9054
9055 case 6222: hash_type = HASH_TYPE_SHA512;
9056 salt_type = SALT_TYPE_EMBEDDED;
9057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9058 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9059 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9060 dgst_size = DGST_SIZE_8_8;
9061 parse_func = truecrypt_parse_hash_1k;
9062 sort_by_digest = sort_by_digest_8_8;
9063 opti_type = OPTI_TYPE_ZERO_BYTE
9064 | OPTI_TYPE_USES_BITS_64;
9065 dgst_pos0 = 0;
9066 dgst_pos1 = 1;
9067 dgst_pos2 = 2;
9068 dgst_pos3 = 3;
9069 break;
9070
9071 case 6223: hash_type = HASH_TYPE_SHA512;
9072 salt_type = SALT_TYPE_EMBEDDED;
9073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9074 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9075 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9076 dgst_size = DGST_SIZE_8_8;
9077 parse_func = truecrypt_parse_hash_1k;
9078 sort_by_digest = sort_by_digest_8_8;
9079 opti_type = OPTI_TYPE_ZERO_BYTE
9080 | OPTI_TYPE_USES_BITS_64;
9081 dgst_pos0 = 0;
9082 dgst_pos1 = 1;
9083 dgst_pos2 = 2;
9084 dgst_pos3 = 3;
9085 break;
9086
9087 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9088 salt_type = SALT_TYPE_EMBEDDED;
9089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9091 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9092 dgst_size = DGST_SIZE_4_8;
9093 parse_func = truecrypt_parse_hash_1k;
9094 sort_by_digest = sort_by_digest_4_8;
9095 opti_type = OPTI_TYPE_ZERO_BYTE;
9096 dgst_pos0 = 0;
9097 dgst_pos1 = 1;
9098 dgst_pos2 = 2;
9099 dgst_pos3 = 3;
9100 break;
9101
9102 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9103 salt_type = SALT_TYPE_EMBEDDED;
9104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9106 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9107 dgst_size = DGST_SIZE_4_8;
9108 parse_func = truecrypt_parse_hash_1k;
9109 sort_by_digest = sort_by_digest_4_8;
9110 opti_type = OPTI_TYPE_ZERO_BYTE;
9111 dgst_pos0 = 0;
9112 dgst_pos1 = 1;
9113 dgst_pos2 = 2;
9114 dgst_pos3 = 3;
9115 break;
9116
9117 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9118 salt_type = SALT_TYPE_EMBEDDED;
9119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9120 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9121 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9122 dgst_size = DGST_SIZE_4_8;
9123 parse_func = truecrypt_parse_hash_1k;
9124 sort_by_digest = sort_by_digest_4_8;
9125 opti_type = OPTI_TYPE_ZERO_BYTE;
9126 dgst_pos0 = 0;
9127 dgst_pos1 = 1;
9128 dgst_pos2 = 2;
9129 dgst_pos3 = 3;
9130 break;
9131
9132 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9133 salt_type = SALT_TYPE_EMBEDDED;
9134 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9136 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9137 dgst_size = DGST_SIZE_4_5;
9138 parse_func = truecrypt_parse_hash_1k;
9139 sort_by_digest = sort_by_digest_4_5;
9140 opti_type = OPTI_TYPE_ZERO_BYTE;
9141 dgst_pos0 = 0;
9142 dgst_pos1 = 1;
9143 dgst_pos2 = 2;
9144 dgst_pos3 = 3;
9145 break;
9146
9147 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9148 salt_type = SALT_TYPE_EMBEDDED;
9149 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9150 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9151 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9152 dgst_size = DGST_SIZE_4_5;
9153 parse_func = truecrypt_parse_hash_1k;
9154 sort_by_digest = sort_by_digest_4_5;
9155 opti_type = OPTI_TYPE_ZERO_BYTE;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9166 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9167 dgst_size = DGST_SIZE_4_5;
9168 parse_func = truecrypt_parse_hash_1k;
9169 sort_by_digest = sort_by_digest_4_5;
9170 opti_type = OPTI_TYPE_ZERO_BYTE;
9171 dgst_pos0 = 0;
9172 dgst_pos1 = 1;
9173 dgst_pos2 = 2;
9174 dgst_pos3 = 3;
9175 break;
9176
9177 case 6300: hash_type = HASH_TYPE_MD5;
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_MD5AIX;
9182 dgst_size = DGST_SIZE_4_4;
9183 parse_func = md5aix_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
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_SHA256AIX;
9197 dgst_size = DGST_SIZE_4_8;
9198 parse_func = sha256aix_parse_hash;
9199 sort_by_digest = sort_by_digest_4_8;
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 6500: hash_type = HASH_TYPE_SHA512;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9211 kern_type = KERN_TYPE_SHA512AIX;
9212 dgst_size = DGST_SIZE_8_8;
9213 parse_func = sha512aix_parse_hash;
9214 sort_by_digest = sort_by_digest_8_8;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_USES_BITS_64;
9217 dgst_pos0 = 0;
9218 dgst_pos1 = 1;
9219 dgst_pos2 = 2;
9220 dgst_pos3 = 3;
9221 break;
9222
9223 case 6600: hash_type = HASH_TYPE_AES;
9224 salt_type = SALT_TYPE_EMBEDDED;
9225 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9227 kern_type = KERN_TYPE_AGILEKEY;
9228 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9229 parse_func = agilekey_parse_hash;
9230 sort_by_digest = sort_by_digest_4_5;
9231 opti_type = OPTI_TYPE_ZERO_BYTE;
9232 dgst_pos0 = 0;
9233 dgst_pos1 = 1;
9234 dgst_pos2 = 2;
9235 dgst_pos3 = 3;
9236 break;
9237
9238 case 6700: hash_type = HASH_TYPE_SHA1;
9239 salt_type = SALT_TYPE_EMBEDDED;
9240 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9241 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9242 kern_type = KERN_TYPE_SHA1AIX;
9243 dgst_size = DGST_SIZE_4_5;
9244 parse_func = sha1aix_parse_hash;
9245 sort_by_digest = sort_by_digest_4_5;
9246 opti_type = OPTI_TYPE_ZERO_BYTE;
9247 dgst_pos0 = 0;
9248 dgst_pos1 = 1;
9249 dgst_pos2 = 2;
9250 dgst_pos3 = 3;
9251 break;
9252
9253 case 6800: hash_type = HASH_TYPE_AES;
9254 salt_type = SALT_TYPE_EMBEDDED;
9255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9257 kern_type = KERN_TYPE_LASTPASS;
9258 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9259 parse_func = lastpass_parse_hash;
9260 sort_by_digest = sort_by_digest_4_8;
9261 opti_type = OPTI_TYPE_ZERO_BYTE;
9262 dgst_pos0 = 0;
9263 dgst_pos1 = 1;
9264 dgst_pos2 = 2;
9265 dgst_pos3 = 3;
9266 break;
9267
9268 case 6900: hash_type = HASH_TYPE_GOST;
9269 salt_type = SALT_TYPE_NONE;
9270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9272 kern_type = KERN_TYPE_GOST;
9273 dgst_size = DGST_SIZE_4_8;
9274 parse_func = gost_parse_hash;
9275 sort_by_digest = sort_by_digest_4_8;
9276 opti_type = OPTI_TYPE_ZERO_BYTE;
9277 dgst_pos0 = 0;
9278 dgst_pos1 = 1;
9279 dgst_pos2 = 2;
9280 dgst_pos3 = 3;
9281 break;
9282
9283 case 7100: hash_type = HASH_TYPE_SHA512;
9284 salt_type = SALT_TYPE_EMBEDDED;
9285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9286 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9287 kern_type = KERN_TYPE_PBKDF2_SHA512;
9288 dgst_size = DGST_SIZE_8_16;
9289 parse_func = sha512osx_parse_hash;
9290 sort_by_digest = sort_by_digest_8_16;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_USES_BITS_64
9293 | OPTI_TYPE_SLOW_HASH_SIMD;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 7200: hash_type = HASH_TYPE_SHA512;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9304 kern_type = KERN_TYPE_PBKDF2_SHA512;
9305 dgst_size = DGST_SIZE_8_16;
9306 parse_func = sha512grub_parse_hash;
9307 sort_by_digest = sort_by_digest_8_16;
9308 opti_type = OPTI_TYPE_ZERO_BYTE
9309 | OPTI_TYPE_USES_BITS_64
9310 | OPTI_TYPE_SLOW_HASH_SIMD;
9311 dgst_pos0 = 0;
9312 dgst_pos1 = 1;
9313 dgst_pos2 = 2;
9314 dgst_pos3 = 3;
9315 break;
9316
9317 case 7300: hash_type = HASH_TYPE_SHA1;
9318 salt_type = SALT_TYPE_EMBEDDED;
9319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9320 opts_type = OPTS_TYPE_PT_GENERATE_BE
9321 | OPTS_TYPE_ST_ADD80
9322 | OPTS_TYPE_ST_ADDBITS15;
9323 kern_type = KERN_TYPE_RAKP;
9324 dgst_size = DGST_SIZE_4_5;
9325 parse_func = rakp_parse_hash;
9326 sort_by_digest = sort_by_digest_4_5;
9327 opti_type = OPTI_TYPE_ZERO_BYTE
9328 | OPTI_TYPE_NOT_ITERATED;
9329 dgst_pos0 = 3;
9330 dgst_pos1 = 4;
9331 dgst_pos2 = 2;
9332 dgst_pos3 = 1;
9333 break;
9334
9335 case 7400: hash_type = HASH_TYPE_SHA256;
9336 salt_type = SALT_TYPE_EMBEDDED;
9337 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9338 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9339 kern_type = KERN_TYPE_SHA256CRYPT;
9340 dgst_size = DGST_SIZE_4_8;
9341 parse_func = sha256crypt_parse_hash;
9342 sort_by_digest = sort_by_digest_4_8;
9343 opti_type = OPTI_TYPE_ZERO_BYTE;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 7500: hash_type = HASH_TYPE_KRB5PA;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9354 kern_type = KERN_TYPE_KRB5PA;
9355 dgst_size = DGST_SIZE_4_4;
9356 parse_func = krb5pa_parse_hash;
9357 sort_by_digest = sort_by_digest_4_4;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_NOT_ITERATED;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 7600: hash_type = HASH_TYPE_SHA1;
9367 salt_type = SALT_TYPE_INTERN;
9368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_BE
9370 | OPTS_TYPE_PT_ADD80
9371 | OPTS_TYPE_PT_ADDBITS15;
9372 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9373 dgst_size = DGST_SIZE_4_5;
9374 parse_func = redmine_parse_hash;
9375 sort_by_digest = sort_by_digest_4_5;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_PRECOMPUTE_INIT
9378 | OPTI_TYPE_EARLY_SKIP
9379 | OPTI_TYPE_NOT_ITERATED
9380 | OPTI_TYPE_PREPENDED_SALT;
9381 dgst_pos0 = 3;
9382 dgst_pos1 = 4;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 1;
9385 break;
9386
9387 case 7700: hash_type = HASH_TYPE_SAPB;
9388 salt_type = SALT_TYPE_EMBEDDED;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_PT_UPPER
9392 | OPTS_TYPE_ST_UPPER;
9393 kern_type = KERN_TYPE_SAPB;
9394 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9395 parse_func = sapb_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_PRECOMPUTE_INIT
9399 | OPTI_TYPE_NOT_ITERATED;
9400 dgst_pos0 = 0;
9401 dgst_pos1 = 1;
9402 dgst_pos2 = 2;
9403 dgst_pos3 = 3;
9404 break;
9405
9406 case 7800: hash_type = HASH_TYPE_SAPG;
9407 salt_type = SALT_TYPE_EMBEDDED;
9408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9409 opts_type = OPTS_TYPE_PT_GENERATE_BE
9410 | OPTS_TYPE_ST_ADD80
9411 | OPTS_TYPE_ST_UPPER;
9412 kern_type = KERN_TYPE_SAPG;
9413 dgst_size = DGST_SIZE_4_5;
9414 parse_func = sapg_parse_hash;
9415 sort_by_digest = sort_by_digest_4_5;
9416 opti_type = OPTI_TYPE_ZERO_BYTE
9417 | OPTI_TYPE_PRECOMPUTE_INIT
9418 | OPTI_TYPE_NOT_ITERATED;
9419 dgst_pos0 = 3;
9420 dgst_pos1 = 4;
9421 dgst_pos2 = 2;
9422 dgst_pos3 = 1;
9423 break;
9424
9425 case 7900: hash_type = HASH_TYPE_SHA512;
9426 salt_type = SALT_TYPE_EMBEDDED;
9427 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9428 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9429 kern_type = KERN_TYPE_DRUPAL7;
9430 dgst_size = DGST_SIZE_8_8;
9431 parse_func = drupal7_parse_hash;
9432 sort_by_digest = sort_by_digest_8_8;
9433 opti_type = OPTI_TYPE_ZERO_BYTE
9434 | OPTI_TYPE_USES_BITS_64;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 8000: hash_type = HASH_TYPE_SHA256;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_BE
9445 | OPTS_TYPE_PT_UNICODE
9446 | OPTS_TYPE_ST_ADD80
9447 | OPTS_TYPE_ST_HEX;
9448 kern_type = KERN_TYPE_SYBASEASE;
9449 dgst_size = DGST_SIZE_4_8;
9450 parse_func = sybasease_parse_hash;
9451 sort_by_digest = sort_by_digest_4_8;
9452 opti_type = OPTI_TYPE_ZERO_BYTE
9453 | OPTI_TYPE_PRECOMPUTE_INIT
9454 | OPTI_TYPE_EARLY_SKIP
9455 | OPTI_TYPE_NOT_ITERATED
9456 | OPTI_TYPE_RAW_HASH;
9457 dgst_pos0 = 3;
9458 dgst_pos1 = 7;
9459 dgst_pos2 = 2;
9460 dgst_pos3 = 6;
9461 break;
9462
9463 case 8100: hash_type = HASH_TYPE_SHA1;
9464 salt_type = SALT_TYPE_EMBEDDED;
9465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9466 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9467 kern_type = KERN_TYPE_NETSCALER;
9468 dgst_size = DGST_SIZE_4_5;
9469 parse_func = netscaler_parse_hash;
9470 sort_by_digest = sort_by_digest_4_5;
9471 opti_type = OPTI_TYPE_ZERO_BYTE
9472 | OPTI_TYPE_PRECOMPUTE_INIT
9473 | OPTI_TYPE_PRECOMPUTE_MERKLE
9474 | OPTI_TYPE_EARLY_SKIP
9475 | OPTI_TYPE_NOT_ITERATED
9476 | OPTI_TYPE_PREPENDED_SALT
9477 | OPTI_TYPE_RAW_HASH;
9478 dgst_pos0 = 3;
9479 dgst_pos1 = 4;
9480 dgst_pos2 = 2;
9481 dgst_pos3 = 1;
9482 break;
9483
9484 case 8200: hash_type = HASH_TYPE_SHA256;
9485 salt_type = SALT_TYPE_EMBEDDED;
9486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9487 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9488 kern_type = KERN_TYPE_CLOUDKEY;
9489 dgst_size = DGST_SIZE_4_8;
9490 parse_func = cloudkey_parse_hash;
9491 sort_by_digest = sort_by_digest_4_8;
9492 opti_type = OPTI_TYPE_ZERO_BYTE;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 8300: hash_type = HASH_TYPE_SHA1;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_BE
9503 | OPTS_TYPE_ST_HEX
9504 | OPTS_TYPE_ST_ADD80;
9505 kern_type = KERN_TYPE_NSEC3;
9506 dgst_size = DGST_SIZE_4_5;
9507 parse_func = nsec3_parse_hash;
9508 sort_by_digest = sort_by_digest_4_5;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 3;
9511 dgst_pos1 = 4;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 1;
9514 break;
9515
9516 case 8400: hash_type = HASH_TYPE_SHA1;
9517 salt_type = SALT_TYPE_INTERN;
9518 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_BE
9520 | OPTS_TYPE_PT_ADD80
9521 | OPTS_TYPE_PT_ADDBITS15;
9522 kern_type = KERN_TYPE_WBB3;
9523 dgst_size = DGST_SIZE_4_5;
9524 parse_func = wbb3_parse_hash;
9525 sort_by_digest = sort_by_digest_4_5;
9526 opti_type = OPTI_TYPE_ZERO_BYTE
9527 | OPTI_TYPE_PRECOMPUTE_INIT
9528 | OPTI_TYPE_NOT_ITERATED;
9529 dgst_pos0 = 3;
9530 dgst_pos1 = 4;
9531 dgst_pos2 = 2;
9532 dgst_pos3 = 1;
9533 break;
9534
9535 case 8500: hash_type = HASH_TYPE_DESRACF;
9536 salt_type = SALT_TYPE_EMBEDDED;
9537 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9538 opts_type = OPTS_TYPE_PT_GENERATE_LE
9539 | OPTS_TYPE_ST_UPPER;
9540 kern_type = KERN_TYPE_RACF;
9541 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9542 parse_func = racf_parse_hash;
9543 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9544 opti_type = OPTI_TYPE_ZERO_BYTE
9545 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 1;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 3;
9550 break;
9551
9552 case 8600: hash_type = HASH_TYPE_LOTUS5;
9553 salt_type = SALT_TYPE_NONE;
9554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9556 kern_type = KERN_TYPE_LOTUS5;
9557 dgst_size = DGST_SIZE_4_4;
9558 parse_func = lotus5_parse_hash;
9559 sort_by_digest = sort_by_digest_4_4;
9560 opti_type = OPTI_TYPE_EARLY_SKIP
9561 | OPTI_TYPE_NOT_ITERATED
9562 | OPTI_TYPE_NOT_SALTED
9563 | OPTI_TYPE_RAW_HASH;
9564 dgst_pos0 = 0;
9565 dgst_pos1 = 1;
9566 dgst_pos2 = 2;
9567 dgst_pos3 = 3;
9568 break;
9569
9570 case 8700: hash_type = HASH_TYPE_LOTUS6;
9571 salt_type = SALT_TYPE_EMBEDDED;
9572 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9573 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9574 kern_type = KERN_TYPE_LOTUS6;
9575 dgst_size = DGST_SIZE_4_4;
9576 parse_func = lotus6_parse_hash;
9577 sort_by_digest = sort_by_digest_4_4;
9578 opti_type = OPTI_TYPE_EARLY_SKIP
9579 | OPTI_TYPE_NOT_ITERATED
9580 | OPTI_TYPE_RAW_HASH;
9581 dgst_pos0 = 0;
9582 dgst_pos1 = 1;
9583 dgst_pos2 = 2;
9584 dgst_pos3 = 3;
9585 break;
9586
9587 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
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_ANDROIDFDE;
9592 dgst_size = DGST_SIZE_4_4;
9593 parse_func = androidfde_parse_hash;
9594 sort_by_digest = sort_by_digest_4_4;
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 8900: hash_type = HASH_TYPE_SCRYPT;
9603 salt_type = SALT_TYPE_EMBEDDED;
9604 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9605 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9606 kern_type = KERN_TYPE_SCRYPT;
9607 dgst_size = DGST_SIZE_4_8;
9608 parse_func = scrypt_parse_hash;
9609 sort_by_digest = sort_by_digest_4_8;
9610 opti_type = OPTI_TYPE_ZERO_BYTE;
9611 dgst_pos0 = 0;
9612 dgst_pos1 = 1;
9613 dgst_pos2 = 2;
9614 dgst_pos3 = 3;
9615 break;
9616
9617 case 9000: hash_type = HASH_TYPE_SHA1;
9618 salt_type = SALT_TYPE_EMBEDDED;
9619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9620 opts_type = OPTS_TYPE_PT_GENERATE_LE
9621 | OPTS_TYPE_ST_GENERATE_LE;
9622 kern_type = KERN_TYPE_PSAFE2;
9623 dgst_size = DGST_SIZE_4_5;
9624 parse_func = psafe2_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
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 9100: hash_type = HASH_TYPE_LOTUS8;
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_LOTUS8;
9638 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9639 parse_func = lotus8_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 9200: hash_type = HASH_TYPE_SHA256;
9649 salt_type = SALT_TYPE_EMBEDDED;
9650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9651 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9652 kern_type = KERN_TYPE_PBKDF2_SHA256;
9653 dgst_size = DGST_SIZE_4_32;
9654 parse_func = cisco8_parse_hash;
9655 sort_by_digest = sort_by_digest_4_32;
9656 opti_type = OPTI_TYPE_ZERO_BYTE
9657 | OPTI_TYPE_SLOW_HASH_SIMD;
9658 dgst_pos0 = 0;
9659 dgst_pos1 = 1;
9660 dgst_pos2 = 2;
9661 dgst_pos3 = 3;
9662 break;
9663
9664 case 9300: hash_type = HASH_TYPE_SCRYPT;
9665 salt_type = SALT_TYPE_EMBEDDED;
9666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9668 kern_type = KERN_TYPE_SCRYPT;
9669 dgst_size = DGST_SIZE_4_8;
9670 parse_func = cisco9_parse_hash;
9671 sort_by_digest = sort_by_digest_4_8;
9672 opti_type = OPTI_TYPE_ZERO_BYTE;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9683 kern_type = KERN_TYPE_OFFICE2007;
9684 dgst_size = DGST_SIZE_4_4;
9685 parse_func = office2007_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4;
9687 opti_type = OPTI_TYPE_ZERO_BYTE;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9698 kern_type = KERN_TYPE_OFFICE2010;
9699 dgst_size = DGST_SIZE_4_4;
9700 parse_func = office2010_parse_hash;
9701 sort_by_digest = sort_by_digest_4_4;
9702 opti_type = OPTI_TYPE_ZERO_BYTE;
9703 dgst_pos0 = 0;
9704 dgst_pos1 = 1;
9705 dgst_pos2 = 2;
9706 dgst_pos3 = 3;
9707 break;
9708
9709 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9710 salt_type = SALT_TYPE_EMBEDDED;
9711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9712 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9713 kern_type = KERN_TYPE_OFFICE2013;
9714 dgst_size = DGST_SIZE_4_4;
9715 parse_func = office2013_parse_hash;
9716 sort_by_digest = sort_by_digest_4_4;
9717 opti_type = OPTI_TYPE_ZERO_BYTE;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_PT_ADD80
9729 | OPTS_TYPE_PT_UNICODE;
9730 kern_type = KERN_TYPE_OLDOFFICE01;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = oldoffice01_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_PRECOMPUTE_INIT
9736 | OPTI_TYPE_NOT_ITERATED;
9737 dgst_pos0 = 0;
9738 dgst_pos1 = 1;
9739 dgst_pos2 = 2;
9740 dgst_pos3 = 3;
9741 break;
9742
9743 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9744 salt_type = SALT_TYPE_EMBEDDED;
9745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9746 opts_type = OPTS_TYPE_PT_GENERATE_LE
9747 | OPTS_TYPE_PT_ADD80;
9748 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9749 dgst_size = DGST_SIZE_4_4;
9750 parse_func = oldoffice01cm1_parse_hash;
9751 sort_by_digest = sort_by_digest_4_4;
9752 opti_type = OPTI_TYPE_ZERO_BYTE
9753 | OPTI_TYPE_PRECOMPUTE_INIT
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE
9765 | OPTS_TYPE_PT_ADD80
9766 | OPTS_TYPE_PT_UNICODE
9767 | OPTS_TYPE_PT_NEVERCRACK;
9768 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9769 dgst_size = DGST_SIZE_4_4;
9770 parse_func = oldoffice01cm2_parse_hash;
9771 sort_by_digest = sort_by_digest_4_4;
9772 opti_type = OPTI_TYPE_ZERO_BYTE
9773 | OPTI_TYPE_PRECOMPUTE_INIT
9774 | OPTI_TYPE_NOT_ITERATED;
9775 dgst_pos0 = 0;
9776 dgst_pos1 = 1;
9777 dgst_pos2 = 2;
9778 dgst_pos3 = 3;
9779 break;
9780
9781 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9782 salt_type = SALT_TYPE_EMBEDDED;
9783 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9784 opts_type = OPTS_TYPE_PT_GENERATE_BE
9785 | OPTS_TYPE_PT_ADD80
9786 | OPTS_TYPE_PT_UNICODE;
9787 kern_type = KERN_TYPE_OLDOFFICE34;
9788 dgst_size = DGST_SIZE_4_4;
9789 parse_func = oldoffice34_parse_hash;
9790 sort_by_digest = sort_by_digest_4_4;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_PRECOMPUTE_INIT
9793 | OPTI_TYPE_NOT_ITERATED;
9794 dgst_pos0 = 0;
9795 dgst_pos1 = 1;
9796 dgst_pos2 = 2;
9797 dgst_pos3 = 3;
9798 break;
9799
9800 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9801 salt_type = SALT_TYPE_EMBEDDED;
9802 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9803 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9804 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9805 dgst_size = DGST_SIZE_4_4;
9806 parse_func = oldoffice34cm1_parse_hash;
9807 sort_by_digest = sort_by_digest_4_4;
9808 opti_type = OPTI_TYPE_ZERO_BYTE
9809 | OPTI_TYPE_PRECOMPUTE_INIT
9810 | OPTI_TYPE_NOT_ITERATED;
9811 dgst_pos0 = 0;
9812 dgst_pos1 = 1;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 3;
9815 break;
9816
9817 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_BE
9821 | OPTS_TYPE_PT_ADD80
9822 | OPTS_TYPE_PT_UNICODE
9823 | OPTS_TYPE_PT_NEVERCRACK;
9824 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = oldoffice34cm2_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_PRECOMPUTE_INIT
9830 | OPTI_TYPE_NOT_ITERATED;
9831 dgst_pos0 = 0;
9832 dgst_pos1 = 1;
9833 dgst_pos2 = 2;
9834 dgst_pos3 = 3;
9835 break;
9836
9837 case 9900: hash_type = HASH_TYPE_MD5;
9838 salt_type = SALT_TYPE_NONE;
9839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9840 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9841 kern_type = KERN_TYPE_RADMIN2;
9842 dgst_size = DGST_SIZE_4_4;
9843 parse_func = radmin2_parse_hash;
9844 sort_by_digest = sort_by_digest_4_4;
9845 opti_type = OPTI_TYPE_ZERO_BYTE
9846 | OPTI_TYPE_PRECOMPUTE_INIT
9847 | OPTI_TYPE_EARLY_SKIP
9848 | OPTI_TYPE_NOT_ITERATED
9849 | OPTI_TYPE_NOT_SALTED;
9850 dgst_pos0 = 0;
9851 dgst_pos1 = 3;
9852 dgst_pos2 = 2;
9853 dgst_pos3 = 1;
9854 break;
9855
9856 case 10000: hash_type = HASH_TYPE_SHA256;
9857 salt_type = SALT_TYPE_EMBEDDED;
9858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9859 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9860 kern_type = KERN_TYPE_PBKDF2_SHA256;
9861 dgst_size = DGST_SIZE_4_32;
9862 parse_func = djangopbkdf2_parse_hash;
9863 sort_by_digest = sort_by_digest_4_32;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_SLOW_HASH_SIMD;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 1;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 3;
9870 break;
9871
9872 case 10100: hash_type = HASH_TYPE_SIPHASH;
9873 salt_type = SALT_TYPE_EMBEDDED;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9876 kern_type = KERN_TYPE_SIPHASH;
9877 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9878 parse_func = siphash_parse_hash;
9879 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9880 opti_type = OPTI_TYPE_ZERO_BYTE
9881 | OPTI_TYPE_NOT_ITERATED
9882 | OPTI_TYPE_RAW_HASH;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 1;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 3;
9887 break;
9888
9889 case 10200: hash_type = HASH_TYPE_MD5;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE
9893 | OPTS_TYPE_ST_ADD80
9894 | OPTS_TYPE_ST_ADDBITS14;
9895 kern_type = KERN_TYPE_HMACMD5_PW;
9896 dgst_size = DGST_SIZE_4_4;
9897 parse_func = crammd5_parse_hash;
9898 sort_by_digest = sort_by_digest_4_4;
9899 opti_type = OPTI_TYPE_ZERO_BYTE
9900 | OPTI_TYPE_NOT_ITERATED;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 3;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 1;
9905 break;
9906
9907 case 10300: hash_type = HASH_TYPE_SHA1;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9911 kern_type = KERN_TYPE_SAPH_SHA1;
9912 dgst_size = DGST_SIZE_4_5;
9913 parse_func = saph_sha1_parse_hash;
9914 sort_by_digest = sort_by_digest_4_5;
9915 opti_type = OPTI_TYPE_ZERO_BYTE;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 10400: hash_type = HASH_TYPE_PDFU16;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_PDF11;
9927 dgst_size = DGST_SIZE_4_4;
9928 parse_func = pdf11_parse_hash;
9929 sort_by_digest = sort_by_digest_4_4;
9930 opti_type = OPTI_TYPE_ZERO_BYTE
9931 | OPTI_TYPE_NOT_ITERATED;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 1;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 3;
9936 break;
9937
9938 case 10410: hash_type = HASH_TYPE_PDFU16;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9942 kern_type = KERN_TYPE_PDF11CM1;
9943 dgst_size = DGST_SIZE_4_4;
9944 parse_func = pdf11cm1_parse_hash;
9945 sort_by_digest = sort_by_digest_4_4;
9946 opti_type = OPTI_TYPE_ZERO_BYTE
9947 | OPTI_TYPE_NOT_ITERATED;
9948 dgst_pos0 = 0;
9949 dgst_pos1 = 1;
9950 dgst_pos2 = 2;
9951 dgst_pos3 = 3;
9952 break;
9953
9954 case 10420: hash_type = HASH_TYPE_PDFU16;
9955 salt_type = SALT_TYPE_EMBEDDED;
9956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9958 kern_type = KERN_TYPE_PDF11CM2;
9959 dgst_size = DGST_SIZE_4_4;
9960 parse_func = pdf11cm2_parse_hash;
9961 sort_by_digest = sort_by_digest_4_4;
9962 opti_type = OPTI_TYPE_ZERO_BYTE
9963 | OPTI_TYPE_NOT_ITERATED;
9964 dgst_pos0 = 0;
9965 dgst_pos1 = 1;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 3;
9968 break;
9969
9970 case 10500: hash_type = HASH_TYPE_PDFU16;
9971 salt_type = SALT_TYPE_EMBEDDED;
9972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9974 kern_type = KERN_TYPE_PDF14;
9975 dgst_size = DGST_SIZE_4_4;
9976 parse_func = pdf14_parse_hash;
9977 sort_by_digest = sort_by_digest_4_4;
9978 opti_type = OPTI_TYPE_ZERO_BYTE
9979 | OPTI_TYPE_NOT_ITERATED;
9980 dgst_pos0 = 0;
9981 dgst_pos1 = 1;
9982 dgst_pos2 = 2;
9983 dgst_pos3 = 3;
9984 break;
9985
9986 case 10600: hash_type = HASH_TYPE_SHA256;
9987 salt_type = SALT_TYPE_EMBEDDED;
9988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9989 opts_type = OPTS_TYPE_PT_GENERATE_BE
9990 | OPTS_TYPE_ST_ADD80
9991 | OPTS_TYPE_ST_ADDBITS15
9992 | OPTS_TYPE_HASH_COPY;
9993 kern_type = KERN_TYPE_SHA256_PWSLT;
9994 dgst_size = DGST_SIZE_4_8;
9995 parse_func = pdf17l3_parse_hash;
9996 sort_by_digest = sort_by_digest_4_8;
9997 opti_type = OPTI_TYPE_ZERO_BYTE
9998 | OPTI_TYPE_PRECOMPUTE_INIT
9999 | OPTI_TYPE_PRECOMPUTE_MERKLE
10000 | OPTI_TYPE_EARLY_SKIP
10001 | OPTI_TYPE_NOT_ITERATED
10002 | OPTI_TYPE_APPENDED_SALT
10003 | OPTI_TYPE_RAW_HASH;
10004 dgst_pos0 = 3;
10005 dgst_pos1 = 7;
10006 dgst_pos2 = 2;
10007 dgst_pos3 = 6;
10008 break;
10009
10010 case 10700: hash_type = HASH_TYPE_PDFU32;
10011 salt_type = SALT_TYPE_EMBEDDED;
10012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10013 opts_type = OPTS_TYPE_PT_GENERATE_LE
10014 | OPTS_TYPE_HASH_COPY;
10015 kern_type = KERN_TYPE_PDF17L8;
10016 dgst_size = DGST_SIZE_4_8;
10017 parse_func = pdf17l8_parse_hash;
10018 sort_by_digest = sort_by_digest_4_8;
10019 opti_type = OPTI_TYPE_ZERO_BYTE
10020 | OPTI_TYPE_NOT_ITERATED;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 10800: hash_type = HASH_TYPE_SHA384;
10028 salt_type = SALT_TYPE_NONE;
10029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_BE
10031 | OPTS_TYPE_PT_ADD80
10032 | OPTS_TYPE_PT_ADDBITS15;
10033 kern_type = KERN_TYPE_SHA384;
10034 dgst_size = DGST_SIZE_8_8;
10035 parse_func = sha384_parse_hash;
10036 sort_by_digest = sort_by_digest_8_8;
10037 opti_type = OPTI_TYPE_ZERO_BYTE
10038 | OPTI_TYPE_PRECOMPUTE_INIT
10039 | OPTI_TYPE_PRECOMPUTE_MERKLE
10040 | OPTI_TYPE_EARLY_SKIP
10041 | OPTI_TYPE_NOT_ITERATED
10042 | OPTI_TYPE_NOT_SALTED
10043 | OPTI_TYPE_USES_BITS_64
10044 | OPTI_TYPE_RAW_HASH;
10045 dgst_pos0 = 6;
10046 dgst_pos1 = 7;
10047 dgst_pos2 = 4;
10048 dgst_pos3 = 5;
10049 break;
10050
10051 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10052 salt_type = SALT_TYPE_EMBEDDED;
10053 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10054 opts_type = OPTS_TYPE_PT_GENERATE_LE
10055 | OPTS_TYPE_ST_BASE64
10056 | OPTS_TYPE_HASH_COPY;
10057 kern_type = KERN_TYPE_PBKDF2_SHA256;
10058 dgst_size = DGST_SIZE_4_32;
10059 parse_func = pbkdf2_sha256_parse_hash;
10060 sort_by_digest = sort_by_digest_4_32;
10061 opti_type = OPTI_TYPE_ZERO_BYTE
10062 | OPTI_TYPE_SLOW_HASH_SIMD;
10063 dgst_pos0 = 0;
10064 dgst_pos1 = 1;
10065 dgst_pos2 = 2;
10066 dgst_pos3 = 3;
10067 break;
10068
10069 case 11000: hash_type = HASH_TYPE_MD5;
10070 salt_type = SALT_TYPE_INTERN;
10071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_LE
10073 | OPTS_TYPE_PT_ADD80;
10074 kern_type = KERN_TYPE_PRESTASHOP;
10075 dgst_size = DGST_SIZE_4_4;
10076 parse_func = prestashop_parse_hash;
10077 sort_by_digest = sort_by_digest_4_4;
10078 opti_type = OPTI_TYPE_ZERO_BYTE
10079 | OPTI_TYPE_PRECOMPUTE_INIT
10080 | OPTI_TYPE_NOT_ITERATED
10081 | OPTI_TYPE_PREPENDED_SALT;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 3;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 1;
10086 break;
10087
10088 case 11100: hash_type = HASH_TYPE_MD5;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE
10092 | OPTS_TYPE_ST_ADD80;
10093 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10094 dgst_size = DGST_SIZE_4_4;
10095 parse_func = postgresql_auth_parse_hash;
10096 sort_by_digest = sort_by_digest_4_4;
10097 opti_type = OPTI_TYPE_ZERO_BYTE
10098 | OPTI_TYPE_PRECOMPUTE_INIT
10099 | OPTI_TYPE_PRECOMPUTE_MERKLE
10100 | OPTI_TYPE_EARLY_SKIP;
10101 dgst_pos0 = 0;
10102 dgst_pos1 = 3;
10103 dgst_pos2 = 2;
10104 dgst_pos3 = 1;
10105 break;
10106
10107 case 11200: hash_type = HASH_TYPE_SHA1;
10108 salt_type = SALT_TYPE_EMBEDDED;
10109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10110 opts_type = OPTS_TYPE_PT_GENERATE_BE
10111 | OPTS_TYPE_PT_ADD80
10112 | OPTS_TYPE_ST_HEX;
10113 kern_type = KERN_TYPE_MYSQL_AUTH;
10114 dgst_size = DGST_SIZE_4_5;
10115 parse_func = mysql_auth_parse_hash;
10116 sort_by_digest = sort_by_digest_4_5;
10117 opti_type = OPTI_TYPE_ZERO_BYTE
10118 | OPTI_TYPE_EARLY_SKIP;
10119 dgst_pos0 = 3;
10120 dgst_pos1 = 4;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 1;
10123 break;
10124
10125 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE
10129 | OPTS_TYPE_ST_HEX
10130 | OPTS_TYPE_ST_ADD80;
10131 kern_type = KERN_TYPE_BITCOIN_WALLET;
10132 dgst_size = DGST_SIZE_4_4;
10133 parse_func = bitcoin_wallet_parse_hash;
10134 sort_by_digest = sort_by_digest_4_4;
10135 opti_type = OPTI_TYPE_ZERO_BYTE;
10136 dgst_pos0 = 0;
10137 dgst_pos1 = 1;
10138 dgst_pos2 = 2;
10139 dgst_pos3 = 3;
10140 break;
10141
10142 case 11400: hash_type = HASH_TYPE_MD5;
10143 salt_type = SALT_TYPE_EMBEDDED;
10144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10145 opts_type = OPTS_TYPE_PT_GENERATE_LE
10146 | OPTS_TYPE_PT_ADD80
10147 | OPTS_TYPE_HASH_COPY;
10148 kern_type = KERN_TYPE_SIP_AUTH;
10149 dgst_size = DGST_SIZE_4_4;
10150 parse_func = sip_auth_parse_hash;
10151 sort_by_digest = sort_by_digest_4_4;
10152 opti_type = OPTI_TYPE_ZERO_BYTE;
10153 dgst_pos0 = 0;
10154 dgst_pos1 = 3;
10155 dgst_pos2 = 2;
10156 dgst_pos3 = 1;
10157 break;
10158
10159 case 11500: hash_type = HASH_TYPE_CRC32;
10160 salt_type = SALT_TYPE_INTERN;
10161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10162 opts_type = OPTS_TYPE_PT_GENERATE_LE
10163 | OPTS_TYPE_ST_GENERATE_LE
10164 | OPTS_TYPE_ST_HEX;
10165 kern_type = KERN_TYPE_CRC32;
10166 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10167 parse_func = crc32_parse_hash;
10168 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10169 opti_type = OPTI_TYPE_ZERO_BYTE;
10170 dgst_pos0 = 0;
10171 dgst_pos1 = 1;
10172 dgst_pos2 = 2;
10173 dgst_pos3 = 3;
10174 break;
10175
10176 case 11600: hash_type = HASH_TYPE_AES;
10177 salt_type = SALT_TYPE_EMBEDDED;
10178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10179 opts_type = OPTS_TYPE_PT_GENERATE_LE
10180 | OPTS_TYPE_PT_NEVERCRACK;
10181 kern_type = KERN_TYPE_SEVEN_ZIP;
10182 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10183 parse_func = seven_zip_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10193 salt_type = SALT_TYPE_NONE;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_LE
10196 | OPTS_TYPE_PT_ADD01;
10197 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10198 dgst_size = DGST_SIZE_4_8;
10199 parse_func = gost2012sbog_256_parse_hash;
10200 sort_by_digest = sort_by_digest_4_8;
10201 opti_type = OPTI_TYPE_ZERO_BYTE;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10209 salt_type = SALT_TYPE_NONE;
10210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE
10212 | OPTS_TYPE_PT_ADD01;
10213 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10214 dgst_size = DGST_SIZE_4_16;
10215 parse_func = gost2012sbog_512_parse_hash;
10216 sort_by_digest = sort_by_digest_4_16;
10217 opti_type = OPTI_TYPE_ZERO_BYTE;
10218 dgst_pos0 = 0;
10219 dgst_pos1 = 1;
10220 dgst_pos2 = 2;
10221 dgst_pos3 = 3;
10222 break;
10223
10224 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10225 salt_type = SALT_TYPE_EMBEDDED;
10226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10227 opts_type = OPTS_TYPE_PT_GENERATE_LE
10228 | OPTS_TYPE_ST_BASE64
10229 | OPTS_TYPE_HASH_COPY;
10230 kern_type = KERN_TYPE_PBKDF2_MD5;
10231 dgst_size = DGST_SIZE_4_32;
10232 parse_func = pbkdf2_md5_parse_hash;
10233 sort_by_digest = sort_by_digest_4_32;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_SLOW_HASH_SIMD;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE
10246 | OPTS_TYPE_ST_BASE64
10247 | OPTS_TYPE_HASH_COPY;
10248 kern_type = KERN_TYPE_PBKDF2_SHA1;
10249 dgst_size = DGST_SIZE_4_32;
10250 parse_func = pbkdf2_sha1_parse_hash;
10251 sort_by_digest = sort_by_digest_4_32;
10252 opti_type = OPTI_TYPE_ZERO_BYTE
10253 | OPTI_TYPE_SLOW_HASH_SIMD;
10254 dgst_pos0 = 0;
10255 dgst_pos1 = 1;
10256 dgst_pos2 = 2;
10257 dgst_pos3 = 3;
10258 break;
10259
10260 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10261 salt_type = SALT_TYPE_EMBEDDED;
10262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10263 opts_type = OPTS_TYPE_PT_GENERATE_LE
10264 | OPTS_TYPE_ST_BASE64
10265 | OPTS_TYPE_HASH_COPY;
10266 kern_type = KERN_TYPE_PBKDF2_SHA512;
10267 dgst_size = DGST_SIZE_8_16;
10268 parse_func = pbkdf2_sha512_parse_hash;
10269 sort_by_digest = sort_by_digest_8_16;
10270 opti_type = OPTI_TYPE_ZERO_BYTE
10271 | OPTI_TYPE_USES_BITS_64
10272 | OPTI_TYPE_SLOW_HASH_SIMD;
10273 dgst_pos0 = 0;
10274 dgst_pos1 = 1;
10275 dgst_pos2 = 2;
10276 dgst_pos3 = 3;
10277 break;
10278
10279 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10280 salt_type = SALT_TYPE_EMBEDDED;
10281 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10282 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10283 kern_type = KERN_TYPE_ECRYPTFS;
10284 dgst_size = DGST_SIZE_8_8;
10285 parse_func = ecryptfs_parse_hash;
10286 sort_by_digest = sort_by_digest_8_8;
10287 opti_type = OPTI_TYPE_ZERO_BYTE
10288 | OPTI_TYPE_USES_BITS_64;
10289 dgst_pos0 = 0;
10290 dgst_pos1 = 1;
10291 dgst_pos2 = 2;
10292 dgst_pos3 = 3;
10293 break;
10294
10295 case 12300: hash_type = HASH_TYPE_ORACLET;
10296 salt_type = SALT_TYPE_EMBEDDED;
10297 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10298 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10299 kern_type = KERN_TYPE_ORACLET;
10300 dgst_size = DGST_SIZE_8_16;
10301 parse_func = oraclet_parse_hash;
10302 sort_by_digest = sort_by_digest_8_16;
10303 opti_type = OPTI_TYPE_ZERO_BYTE
10304 | OPTI_TYPE_USES_BITS_64;
10305 dgst_pos0 = 0;
10306 dgst_pos1 = 1;
10307 dgst_pos2 = 2;
10308 dgst_pos3 = 3;
10309 break;
10310
10311 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10312 salt_type = SALT_TYPE_EMBEDDED;
10313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10314 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10315 kern_type = KERN_TYPE_BSDICRYPT;
10316 dgst_size = DGST_SIZE_4_4;
10317 parse_func = bsdicrypt_parse_hash;
10318 sort_by_digest = sort_by_digest_4_4;
10319 opti_type = OPTI_TYPE_ZERO_BYTE
10320 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10321 dgst_pos0 = 0;
10322 dgst_pos1 = 1;
10323 dgst_pos2 = 2;
10324 dgst_pos3 = 3;
10325 break;
10326
10327 case 12500: hash_type = HASH_TYPE_RAR3HP;
10328 salt_type = SALT_TYPE_EMBEDDED;
10329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10331 kern_type = KERN_TYPE_RAR3;
10332 dgst_size = DGST_SIZE_4_4;
10333 parse_func = rar3hp_parse_hash;
10334 sort_by_digest = sort_by_digest_4_4;
10335 opti_type = OPTI_TYPE_ZERO_BYTE;
10336 dgst_pos0 = 0;
10337 dgst_pos1 = 1;
10338 dgst_pos2 = 2;
10339 dgst_pos3 = 3;
10340 break;
10341
10342 case 12600: hash_type = HASH_TYPE_SHA256;
10343 salt_type = SALT_TYPE_INTERN;
10344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10345 opts_type = OPTS_TYPE_PT_GENERATE_BE
10346 | OPTS_TYPE_PT_ADD80;
10347 kern_type = KERN_TYPE_CF10;
10348 dgst_size = DGST_SIZE_4_8;
10349 parse_func = cf10_parse_hash;
10350 sort_by_digest = sort_by_digest_4_8;
10351 opti_type = OPTI_TYPE_ZERO_BYTE
10352 | OPTI_TYPE_PRECOMPUTE_INIT
10353 | OPTI_TYPE_EARLY_SKIP
10354 | OPTI_TYPE_NOT_ITERATED;
10355 dgst_pos0 = 3;
10356 dgst_pos1 = 7;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 6;
10359 break;
10360
10361 case 12700: hash_type = HASH_TYPE_AES;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE
10365 | OPTS_TYPE_HASH_COPY;
10366 kern_type = KERN_TYPE_MYWALLET;
10367 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10368 parse_func = mywallet_parse_hash;
10369 sort_by_digest = sort_by_digest_4_5;
10370 opti_type = OPTI_TYPE_ZERO_BYTE;
10371 dgst_pos0 = 0;
10372 dgst_pos1 = 1;
10373 dgst_pos2 = 2;
10374 dgst_pos3 = 3;
10375 break;
10376
10377 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10378 salt_type = SALT_TYPE_EMBEDDED;
10379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10381 kern_type = KERN_TYPE_MS_DRSR;
10382 dgst_size = DGST_SIZE_4_8;
10383 parse_func = ms_drsr_parse_hash;
10384 sort_by_digest = sort_by_digest_4_8;
10385 opti_type = OPTI_TYPE_ZERO_BYTE;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
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_ANDROIDFDE_SAMSUNG;
10397 dgst_size = DGST_SIZE_4_8;
10398 parse_func = androidfde_samsung_parse_hash;
10399 sort_by_digest = sort_by_digest_4_8;
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 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10408 salt_type = SALT_TYPE_EMBEDDED;
10409 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10410 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10411 kern_type = KERN_TYPE_RAR5;
10412 dgst_size = DGST_SIZE_4_4;
10413 parse_func = rar5_parse_hash;
10414 sort_by_digest = sort_by_digest_4_4;
10415 opti_type = OPTI_TYPE_ZERO_BYTE;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10423 salt_type = SALT_TYPE_EMBEDDED;
10424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10426 kern_type = KERN_TYPE_KRB5TGS;
10427 dgst_size = DGST_SIZE_4_4;
10428 parse_func = krb5tgs_parse_hash;
10429 sort_by_digest = sort_by_digest_4_4;
10430 opti_type = OPTI_TYPE_ZERO_BYTE
10431 | OPTI_TYPE_NOT_ITERATED;
10432 dgst_pos0 = 0;
10433 dgst_pos1 = 1;
10434 dgst_pos2 = 2;
10435 dgst_pos3 = 3;
10436 break;
10437
10438 case 13200: hash_type = HASH_TYPE_AES;
10439 salt_type = SALT_TYPE_EMBEDDED;
10440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10441 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10442 kern_type = KERN_TYPE_AXCRYPT;
10443 dgst_size = DGST_SIZE_4_4;
10444 parse_func = axcrypt_parse_hash;
10445 sort_by_digest = sort_by_digest_4_4;
10446 opti_type = OPTI_TYPE_ZERO_BYTE;
10447 dgst_pos0 = 0;
10448 dgst_pos1 = 1;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 3;
10451 break;
10452
10453 case 13300: hash_type = HASH_TYPE_SHA1;
10454 salt_type = SALT_TYPE_NONE;
10455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_BE
10457 | OPTS_TYPE_PT_ADD80
10458 | OPTS_TYPE_PT_ADDBITS15;
10459 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10460 dgst_size = DGST_SIZE_4_5;
10461 parse_func = sha1axcrypt_parse_hash;
10462 sort_by_digest = sort_by_digest_4_5;
10463 opti_type = OPTI_TYPE_ZERO_BYTE
10464 | OPTI_TYPE_PRECOMPUTE_INIT
10465 | OPTI_TYPE_EARLY_SKIP
10466 | OPTI_TYPE_NOT_ITERATED
10467 | OPTI_TYPE_NOT_SALTED;
10468 dgst_pos0 = 0;
10469 dgst_pos1 = 4;
10470 dgst_pos2 = 3;
10471 dgst_pos3 = 2;
10472 break;
10473
10474 case 13400: hash_type = HASH_TYPE_AES;
10475 salt_type = SALT_TYPE_EMBEDDED;
10476 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10477 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10478 kern_type = KERN_TYPE_KEEPASS;
10479 dgst_size = DGST_SIZE_4_4;
10480 parse_func = keepass_parse_hash;
10481 sort_by_digest = sort_by_digest_4_4;
10482 opti_type = OPTI_TYPE_ZERO_BYTE;
10483 dgst_pos0 = 0;
10484 dgst_pos1 = 1;
10485 dgst_pos2 = 2;
10486 dgst_pos3 = 3;
10487 break;
10488
10489 case 13500: hash_type = HASH_TYPE_SHA1;
10490 salt_type = SALT_TYPE_EMBEDDED;
10491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10492 opts_type = OPTS_TYPE_PT_GENERATE_BE
10493 | OPTS_TYPE_PT_UNICODE
10494 | OPTS_TYPE_PT_ADD80;
10495 kern_type = KERN_TYPE_PSTOKEN;
10496 dgst_size = DGST_SIZE_4_5;
10497 parse_func = pstoken_parse_hash;
10498 sort_by_digest = sort_by_digest_4_5;
10499 opti_type = OPTI_TYPE_ZERO_BYTE
10500 | OPTI_TYPE_PRECOMPUTE_INIT
10501 | OPTI_TYPE_EARLY_SKIP
10502 | OPTI_TYPE_NOT_ITERATED
10503 | OPTI_TYPE_PREPENDED_SALT
10504 | OPTI_TYPE_RAW_HASH;
10505 dgst_pos0 = 3;
10506 dgst_pos1 = 4;
10507 dgst_pos2 = 2;
10508 dgst_pos3 = 1;
10509 break;
10510
10511 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10512 salt_type = SALT_TYPE_EMBEDDED;
10513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10515 kern_type = KERN_TYPE_ZIP2;
10516 dgst_size = DGST_SIZE_4_4;
10517 parse_func = zip2_parse_hash;
10518 sort_by_digest = sort_by_digest_4_4;
10519 opti_type = OPTI_TYPE_ZERO_BYTE;
10520 dgst_pos0 = 0;
10521 dgst_pos1 = 1;
10522 dgst_pos2 = 2;
10523 dgst_pos3 = 3;
10524 break;
10525
10526 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10527 salt_type = SALT_TYPE_EMBEDDED;
10528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10529 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10530 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10531 dgst_size = DGST_SIZE_4_5;
10532 parse_func = veracrypt_parse_hash_655331;
10533 sort_by_digest = sort_by_digest_4_5;
10534 opti_type = OPTI_TYPE_ZERO_BYTE;
10535 dgst_pos0 = 0;
10536 dgst_pos1 = 1;
10537 dgst_pos2 = 2;
10538 dgst_pos3 = 3;
10539 break;
10540
10541 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10542 salt_type = SALT_TYPE_EMBEDDED;
10543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10545 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10546 dgst_size = DGST_SIZE_4_5;
10547 parse_func = veracrypt_parse_hash_655331;
10548 sort_by_digest = sort_by_digest_4_5;
10549 opti_type = OPTI_TYPE_ZERO_BYTE;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10560 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10561 dgst_size = DGST_SIZE_4_5;
10562 parse_func = veracrypt_parse_hash_655331;
10563 sort_by_digest = sort_by_digest_4_5;
10564 opti_type = OPTI_TYPE_ZERO_BYTE;
10565 dgst_pos0 = 0;
10566 dgst_pos1 = 1;
10567 dgst_pos2 = 2;
10568 dgst_pos3 = 3;
10569 break;
10570
10571 case 13721: hash_type = HASH_TYPE_SHA512;
10572 salt_type = SALT_TYPE_EMBEDDED;
10573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10575 kern_type = KERN_TYPE_TCSHA512_XTS512;
10576 dgst_size = DGST_SIZE_8_8;
10577 parse_func = veracrypt_parse_hash_500000;
10578 sort_by_digest = sort_by_digest_8_8;
10579 opti_type = OPTI_TYPE_ZERO_BYTE
10580 | OPTI_TYPE_USES_BITS_64;
10581 dgst_pos0 = 0;
10582 dgst_pos1 = 1;
10583 dgst_pos2 = 2;
10584 dgst_pos3 = 3;
10585 break;
10586
10587 case 13722: hash_type = HASH_TYPE_SHA512;
10588 salt_type = SALT_TYPE_EMBEDDED;
10589 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10590 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10591 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10592 dgst_size = DGST_SIZE_8_8;
10593 parse_func = veracrypt_parse_hash_500000;
10594 sort_by_digest = sort_by_digest_8_8;
10595 opti_type = OPTI_TYPE_ZERO_BYTE
10596 | OPTI_TYPE_USES_BITS_64;
10597 dgst_pos0 = 0;
10598 dgst_pos1 = 1;
10599 dgst_pos2 = 2;
10600 dgst_pos3 = 3;
10601 break;
10602
10603 case 13723: hash_type = HASH_TYPE_SHA512;
10604 salt_type = SALT_TYPE_EMBEDDED;
10605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10606 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10607 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10608 dgst_size = DGST_SIZE_8_8;
10609 parse_func = veracrypt_parse_hash_500000;
10610 sort_by_digest = sort_by_digest_8_8;
10611 opti_type = OPTI_TYPE_ZERO_BYTE
10612 | OPTI_TYPE_USES_BITS_64;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10623 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_500000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10638 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10639 dgst_size = DGST_SIZE_4_8;
10640 parse_func = veracrypt_parse_hash_500000;
10641 sort_by_digest = sort_by_digest_4_8;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10650 salt_type = SALT_TYPE_EMBEDDED;
10651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10653 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10654 dgst_size = DGST_SIZE_4_8;
10655 parse_func = veracrypt_parse_hash_500000;
10656 sort_by_digest = sort_by_digest_4_8;
10657 opti_type = OPTI_TYPE_ZERO_BYTE;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10668 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10669 dgst_size = DGST_SIZE_4_5;
10670 parse_func = veracrypt_parse_hash_327661;
10671 sort_by_digest = sort_by_digest_4_5;
10672 opti_type = OPTI_TYPE_ZERO_BYTE;
10673 dgst_pos0 = 0;
10674 dgst_pos1 = 1;
10675 dgst_pos2 = 2;
10676 dgst_pos3 = 3;
10677 break;
10678
10679 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10680 salt_type = SALT_TYPE_EMBEDDED;
10681 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10683 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10684 dgst_size = DGST_SIZE_4_5;
10685 parse_func = veracrypt_parse_hash_327661;
10686 sort_by_digest = sort_by_digest_4_5;
10687 opti_type = OPTI_TYPE_ZERO_BYTE;
10688 dgst_pos0 = 0;
10689 dgst_pos1 = 1;
10690 dgst_pos2 = 2;
10691 dgst_pos3 = 3;
10692 break;
10693
10694 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10695 salt_type = SALT_TYPE_EMBEDDED;
10696 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10697 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10698 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10699 dgst_size = DGST_SIZE_4_5;
10700 parse_func = veracrypt_parse_hash_327661;
10701 sort_by_digest = sort_by_digest_4_5;
10702 opti_type = OPTI_TYPE_ZERO_BYTE;
10703 dgst_pos0 = 0;
10704 dgst_pos1 = 1;
10705 dgst_pos2 = 2;
10706 dgst_pos3 = 3;
10707 break;
10708
10709 case 13751: hash_type = HASH_TYPE_SHA256;
10710 salt_type = SALT_TYPE_EMBEDDED;
10711 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10712 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10713 kern_type = KERN_TYPE_VCSHA256_XTS512;
10714 dgst_size = DGST_SIZE_4_8;
10715 parse_func = veracrypt_parse_hash_500000;
10716 sort_by_digest = sort_by_digest_4_8;
10717 opti_type = OPTI_TYPE_ZERO_BYTE;
10718 dgst_pos0 = 0;
10719 dgst_pos1 = 1;
10720 dgst_pos2 = 2;
10721 dgst_pos3 = 3;
10722 break;
10723
10724 case 13752: hash_type = HASH_TYPE_SHA256;
10725 salt_type = SALT_TYPE_EMBEDDED;
10726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10727 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10728 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10729 dgst_size = DGST_SIZE_4_8;
10730 parse_func = veracrypt_parse_hash_500000;
10731 sort_by_digest = sort_by_digest_4_8;
10732 opti_type = OPTI_TYPE_ZERO_BYTE;
10733 dgst_pos0 = 0;
10734 dgst_pos1 = 1;
10735 dgst_pos2 = 2;
10736 dgst_pos3 = 3;
10737 break;
10738
10739 case 13753: hash_type = HASH_TYPE_SHA256;
10740 salt_type = SALT_TYPE_EMBEDDED;
10741 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10742 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10743 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10744 dgst_size = DGST_SIZE_4_8;
10745 parse_func = veracrypt_parse_hash_500000;
10746 sort_by_digest = sort_by_digest_4_8;
10747 opti_type = OPTI_TYPE_ZERO_BYTE;
10748 dgst_pos0 = 0;
10749 dgst_pos1 = 1;
10750 dgst_pos2 = 2;
10751 dgst_pos3 = 3;
10752 break;
10753
10754 case 13761: hash_type = HASH_TYPE_SHA256;
10755 salt_type = SALT_TYPE_EMBEDDED;
10756 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10757 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10758 kern_type = KERN_TYPE_VCSHA256_XTS512;
10759 dgst_size = DGST_SIZE_4_8;
10760 parse_func = veracrypt_parse_hash_200000;
10761 sort_by_digest = sort_by_digest_4_8;
10762 opti_type = OPTI_TYPE_ZERO_BYTE;
10763 dgst_pos0 = 0;
10764 dgst_pos1 = 1;
10765 dgst_pos2 = 2;
10766 dgst_pos3 = 3;
10767 break;
10768
10769 case 13762: hash_type = HASH_TYPE_SHA256;
10770 salt_type = SALT_TYPE_EMBEDDED;
10771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10772 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10773 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10774 dgst_size = DGST_SIZE_4_8;
10775 parse_func = veracrypt_parse_hash_200000;
10776 sort_by_digest = sort_by_digest_4_8;
10777 opti_type = OPTI_TYPE_ZERO_BYTE;
10778 dgst_pos0 = 0;
10779 dgst_pos1 = 1;
10780 dgst_pos2 = 2;
10781 dgst_pos3 = 3;
10782 break;
10783
10784 case 13763: hash_type = HASH_TYPE_SHA256;
10785 salt_type = SALT_TYPE_EMBEDDED;
10786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10787 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10788 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10789 dgst_size = DGST_SIZE_4_8;
10790 parse_func = veracrypt_parse_hash_200000;
10791 sort_by_digest = sort_by_digest_4_8;
10792 opti_type = OPTI_TYPE_ZERO_BYTE;
10793 dgst_pos0 = 0;
10794 dgst_pos1 = 1;
10795 dgst_pos2 = 2;
10796 dgst_pos3 = 3;
10797 break;
10798
10799
10800 default: usage_mini_print (PROGNAME); return (-1);
10801 }
10802
10803 /**
10804 * parser
10805 */
10806
10807 data.parse_func = parse_func;
10808
10809 /**
10810 * misc stuff
10811 */
10812
10813 if (hex_salt)
10814 {
10815 if (salt_type == SALT_TYPE_INTERN)
10816 {
10817 opts_type |= OPTS_TYPE_ST_HEX;
10818 }
10819 else
10820 {
10821 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10822
10823 return (-1);
10824 }
10825 }
10826
10827 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10828 | (salt_type == SALT_TYPE_EXTERN)
10829 | (salt_type == SALT_TYPE_EMBEDDED)
10830 | (salt_type == SALT_TYPE_VIRTUAL));
10831
10832 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10833
10834 data.hash_type = hash_type;
10835 data.attack_mode = attack_mode;
10836 data.attack_kern = attack_kern;
10837 data.attack_exec = attack_exec;
10838 data.kern_type = kern_type;
10839 data.opts_type = opts_type;
10840 data.dgst_size = dgst_size;
10841 data.salt_type = salt_type;
10842 data.isSalted = isSalted;
10843 data.sort_by_digest = sort_by_digest;
10844 data.dgst_pos0 = dgst_pos0;
10845 data.dgst_pos1 = dgst_pos1;
10846 data.dgst_pos2 = dgst_pos2;
10847 data.dgst_pos3 = dgst_pos3;
10848
10849 esalt_size = 0;
10850
10851 switch (hash_mode)
10852 {
10853 case 2500: esalt_size = sizeof (wpa_t); break;
10854 case 5300: esalt_size = sizeof (ikepsk_t); break;
10855 case 5400: esalt_size = sizeof (ikepsk_t); break;
10856 case 5500: esalt_size = sizeof (netntlm_t); break;
10857 case 5600: esalt_size = sizeof (netntlm_t); break;
10858 case 6211: esalt_size = sizeof (tc_t); break;
10859 case 6212: esalt_size = sizeof (tc_t); break;
10860 case 6213: esalt_size = sizeof (tc_t); break;
10861 case 6221: esalt_size = sizeof (tc_t); break;
10862 case 6222: esalt_size = sizeof (tc_t); break;
10863 case 6223: esalt_size = sizeof (tc_t); break;
10864 case 6231: esalt_size = sizeof (tc_t); break;
10865 case 6232: esalt_size = sizeof (tc_t); break;
10866 case 6233: esalt_size = sizeof (tc_t); break;
10867 case 6241: esalt_size = sizeof (tc_t); break;
10868 case 6242: esalt_size = sizeof (tc_t); break;
10869 case 6243: esalt_size = sizeof (tc_t); break;
10870 case 6600: esalt_size = sizeof (agilekey_t); break;
10871 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10872 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10873 case 7300: esalt_size = sizeof (rakp_t); break;
10874 case 7500: esalt_size = sizeof (krb5pa_t); break;
10875 case 8200: esalt_size = sizeof (cloudkey_t); break;
10876 case 8800: esalt_size = sizeof (androidfde_t); break;
10877 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10878 case 9400: esalt_size = sizeof (office2007_t); break;
10879 case 9500: esalt_size = sizeof (office2010_t); break;
10880 case 9600: esalt_size = sizeof (office2013_t); break;
10881 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10882 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10883 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10884 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10885 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10886 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10887 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10888 case 10200: esalt_size = sizeof (cram_md5_t); break;
10889 case 10400: esalt_size = sizeof (pdf_t); break;
10890 case 10410: esalt_size = sizeof (pdf_t); break;
10891 case 10420: esalt_size = sizeof (pdf_t); break;
10892 case 10500: esalt_size = sizeof (pdf_t); break;
10893 case 10600: esalt_size = sizeof (pdf_t); break;
10894 case 10700: esalt_size = sizeof (pdf_t); break;
10895 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10896 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10897 case 11400: esalt_size = sizeof (sip_t); break;
10898 case 11600: esalt_size = sizeof (seven_zip_t); break;
10899 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10900 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10901 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10902 case 13000: esalt_size = sizeof (rar5_t); break;
10903 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10904 case 13400: esalt_size = sizeof (keepass_t); break;
10905 case 13500: esalt_size = sizeof (pstoken_t); break;
10906 case 13600: esalt_size = sizeof (zip2_t); break;
10907 case 13711: esalt_size = sizeof (tc_t); break;
10908 case 13712: esalt_size = sizeof (tc_t); break;
10909 case 13713: esalt_size = sizeof (tc_t); break;
10910 case 13721: esalt_size = sizeof (tc_t); break;
10911 case 13722: esalt_size = sizeof (tc_t); break;
10912 case 13723: esalt_size = sizeof (tc_t); break;
10913 case 13731: esalt_size = sizeof (tc_t); break;
10914 case 13732: esalt_size = sizeof (tc_t); break;
10915 case 13733: esalt_size = sizeof (tc_t); break;
10916 case 13741: esalt_size = sizeof (tc_t); break;
10917 case 13742: esalt_size = sizeof (tc_t); break;
10918 case 13743: esalt_size = sizeof (tc_t); break;
10919 case 13751: esalt_size = sizeof (tc_t); break;
10920 case 13752: esalt_size = sizeof (tc_t); break;
10921 case 13753: esalt_size = sizeof (tc_t); break;
10922 case 13761: esalt_size = sizeof (tc_t); break;
10923 case 13762: esalt_size = sizeof (tc_t); break;
10924 case 13763: esalt_size = sizeof (tc_t); break;
10925 }
10926
10927 data.esalt_size = esalt_size;
10928
10929 /**
10930 * choose dictionary parser
10931 */
10932
10933 if (hash_type == HASH_TYPE_LM)
10934 {
10935 get_next_word_func = get_next_word_lm;
10936 }
10937 else if (opts_type & OPTS_TYPE_PT_UPPER)
10938 {
10939 get_next_word_func = get_next_word_uc;
10940 }
10941 else
10942 {
10943 get_next_word_func = get_next_word_std;
10944 }
10945
10946 /**
10947 * dictstat
10948 */
10949
10950 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10951
10952 #ifdef _POSIX
10953 size_t dictstat_nmemb = 0;
10954 #endif
10955
10956 #ifdef _WIN
10957 uint dictstat_nmemb = 0;
10958 #endif
10959
10960 char dictstat[256] = { 0 };
10961
10962 FILE *dictstat_fp = NULL;
10963
10964 if (keyspace == 0)
10965 {
10966 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10967
10968 dictstat_fp = fopen (dictstat, "rb");
10969
10970 if (dictstat_fp)
10971 {
10972 #ifdef _POSIX
10973 struct stat tmpstat;
10974
10975 fstat (fileno (dictstat_fp), &tmpstat);
10976 #endif
10977
10978 #ifdef _WIN
10979 struct stat64 tmpstat;
10980
10981 _fstat64 (fileno (dictstat_fp), &tmpstat);
10982 #endif
10983
10984 if (tmpstat.st_mtime < COMPTIME)
10985 {
10986 /* with v0.15 the format changed so we have to ensure user is using a good version
10987 since there is no version-header in the dictstat file */
10988
10989 fclose (dictstat_fp);
10990
10991 unlink (dictstat);
10992 }
10993 else
10994 {
10995 while (!feof (dictstat_fp))
10996 {
10997 dictstat_t d;
10998
10999 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11000
11001 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11002
11003 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11004 {
11005 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11006
11007 return -1;
11008 }
11009 }
11010
11011 fclose (dictstat_fp);
11012 }
11013 }
11014 }
11015
11016 /**
11017 * potfile
11018 */
11019
11020 char potfile[256] = { 0 };
11021
11022 if (potfile_path == NULL)
11023 {
11024 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11025 }
11026 else
11027 {
11028 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11029 }
11030
11031 data.pot_fp = NULL;
11032
11033 FILE *out_fp = NULL;
11034 FILE *pot_fp = NULL;
11035
11036 if (show == 1 || left == 1)
11037 {
11038 pot_fp = fopen (potfile, "rb");
11039
11040 if (pot_fp == NULL)
11041 {
11042 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11043
11044 return (-1);
11045 }
11046
11047 if (outfile != NULL)
11048 {
11049 if ((out_fp = fopen (outfile, "ab")) == NULL)
11050 {
11051 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11052
11053 fclose (pot_fp);
11054
11055 return (-1);
11056 }
11057 }
11058 else
11059 {
11060 out_fp = stdout;
11061 }
11062 }
11063 else
11064 {
11065 if (potfile_disable == 0)
11066 {
11067 pot_fp = fopen (potfile, "ab");
11068
11069 if (pot_fp == NULL)
11070 {
11071 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11072
11073 return (-1);
11074 }
11075
11076 data.pot_fp = pot_fp;
11077 }
11078 }
11079
11080 pot_t *pot = NULL;
11081
11082 uint pot_cnt = 0;
11083 uint pot_avail = 0;
11084
11085 if (show == 1 || left == 1)
11086 {
11087 SUPPRESS_OUTPUT = 1;
11088
11089 pot_avail = count_lines (pot_fp);
11090
11091 rewind (pot_fp);
11092
11093 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11094
11095 uint pot_hashes_avail = 0;
11096
11097 uint line_num = 0;
11098
11099 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11100
11101 while (!feof (pot_fp))
11102 {
11103 line_num++;
11104
11105 int line_len = fgetl (pot_fp, line_buf);
11106
11107 if (line_len == 0) continue;
11108
11109 char *plain_buf = line_buf + line_len;
11110
11111 pot_t *pot_ptr = &pot[pot_cnt];
11112
11113 hash_t *hashes_buf = &pot_ptr->hash;
11114
11115 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11116 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11117
11118 if (pot_cnt == pot_hashes_avail)
11119 {
11120 uint pos = 0;
11121
11122 for (pos = 0; pos < INCR_POT; pos++)
11123 {
11124 if ((pot_cnt + pos) >= pot_avail) break;
11125
11126 pot_t *tmp_pot = &pot[pot_cnt + pos];
11127
11128 hash_t *tmp_hash = &tmp_pot->hash;
11129
11130 tmp_hash->digest = mymalloc (dgst_size);
11131
11132 if (isSalted)
11133 {
11134 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11135 }
11136
11137 if (esalt_size)
11138 {
11139 tmp_hash->esalt = mymalloc (esalt_size);
11140 }
11141
11142 pot_hashes_avail++;
11143 }
11144 }
11145
11146 int plain_len = 0;
11147
11148 int parser_status;
11149
11150 int iter = MAX_CUT_TRIES;
11151
11152 do
11153 {
11154 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11155 {
11156 if (line_buf[i] == ':')
11157 {
11158 line_len--;
11159
11160 break;
11161 }
11162 }
11163
11164 if (data.hash_mode != 2500)
11165 {
11166 parser_status = parse_func (line_buf, line_len, hashes_buf);
11167 }
11168 else
11169 {
11170 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11171
11172 if (line_len > max_salt_size)
11173 {
11174 parser_status = PARSER_GLOBAL_LENGTH;
11175 }
11176 else
11177 {
11178 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11179
11180 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11181
11182 hashes_buf->salt->salt_len = line_len;
11183
11184 parser_status = PARSER_OK;
11185 }
11186 }
11187
11188 // if NOT parsed without error, we add the ":" to the plain
11189
11190 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11191 {
11192 plain_len++;
11193 plain_buf--;
11194 }
11195
11196 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11197
11198 if (parser_status < PARSER_GLOBAL_ZERO)
11199 {
11200 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11201
11202 continue;
11203 }
11204
11205 if (plain_len >= 255) continue;
11206
11207 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11208
11209 pot_ptr->plain_len = plain_len;
11210
11211 pot_cnt++;
11212 }
11213
11214 myfree (line_buf);
11215
11216 fclose (pot_fp);
11217
11218 SUPPRESS_OUTPUT = 0;
11219
11220 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11221 }
11222
11223 /**
11224 * word len
11225 */
11226
11227 uint pw_min = PW_MIN;
11228 uint pw_max = PW_MAX;
11229
11230 switch (hash_mode)
11231 {
11232 case 125: if (pw_max > 32) pw_max = 32;
11233 break;
11234 case 400: if (pw_max > 40) pw_max = 40;
11235 break;
11236 case 500: if (pw_max > 16) pw_max = 16;
11237 break;
11238 case 1500: if (pw_max > 8) pw_max = 8;
11239 break;
11240 case 1600: if (pw_max > 16) pw_max = 16;
11241 break;
11242 case 1800: if (pw_max > 16) pw_max = 16;
11243 break;
11244 case 2100: if (pw_max > 16) pw_max = 16;
11245 break;
11246 case 2500: if (pw_min < 8) pw_min = 8;
11247 break;
11248 case 3000: if (pw_max > 7) pw_max = 7;
11249 break;
11250 case 5200: if (pw_max > 24) pw_max = 24;
11251 break;
11252 case 5800: if (pw_max > 16) pw_max = 16;
11253 break;
11254 case 6300: if (pw_max > 16) pw_max = 16;
11255 break;
11256 case 7400: if (pw_max > 16) pw_max = 16;
11257 break;
11258 case 7500: if (pw_max > 8) pw_max = 8;
11259 break;
11260 case 7900: if (pw_max > 48) pw_max = 48;
11261 break;
11262 case 8500: if (pw_max > 8) pw_max = 8;
11263 break;
11264 case 8600: if (pw_max > 16) pw_max = 16;
11265 break;
11266 case 9710: pw_min = 5;
11267 pw_max = 5;
11268 break;
11269 case 9810: pw_min = 5;
11270 pw_max = 5;
11271 break;
11272 case 10410: pw_min = 5;
11273 pw_max = 5;
11274 break;
11275 case 10300: if (pw_max < 3) pw_min = 3;
11276 if (pw_max > 40) pw_max = 40;
11277 break;
11278 case 10500: if (pw_max < 3) pw_min = 3;
11279 if (pw_max > 40) pw_max = 40;
11280 break;
11281 case 10700: if (pw_max > 16) pw_max = 16;
11282 break;
11283 case 11300: if (pw_max > 40) pw_max = 40;
11284 break;
11285 case 11600: if (pw_max > 32) pw_max = 32;
11286 break;
11287 case 12500: if (pw_max > 20) pw_max = 20;
11288 break;
11289 case 12800: if (pw_max > 24) pw_max = 24;
11290 break;
11291 }
11292
11293 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11294 {
11295 switch (attack_kern)
11296 {
11297 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11298 break;
11299 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11300 break;
11301 }
11302 }
11303
11304 /**
11305 * charsets : keep them together for more easy maintainnce
11306 */
11307
11308 cs_t mp_sys[6] = { { { 0 }, 0 } };
11309 cs_t mp_usr[4] = { { { 0 }, 0 } };
11310
11311 mp_setup_sys (mp_sys);
11312
11313 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11314 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11315 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11316 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11317
11318 /**
11319 * load hashes, part I: find input mode, count hashes
11320 */
11321
11322 uint hashlist_mode = 0;
11323 uint hashlist_format = HLFMT_HASHCAT;
11324
11325 uint hashes_avail = 0;
11326
11327 if (benchmark == 0)
11328 {
11329 struct stat f;
11330
11331 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11332
11333 if ((hash_mode == 2500) ||
11334 (hash_mode == 5200) ||
11335 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11336 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11337 (hash_mode == 9000))
11338 {
11339 hashlist_mode = HL_MODE_ARG;
11340
11341 char *hashfile = myargv[optind];
11342
11343 data.hashfile = hashfile;
11344
11345 logfile_top_var_string ("target", hashfile);
11346 }
11347
11348 if (hashlist_mode == HL_MODE_ARG)
11349 {
11350 if (hash_mode == 2500)
11351 {
11352 struct stat st;
11353
11354 if (stat (data.hashfile, &st) == -1)
11355 {
11356 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11357
11358 return (-1);
11359 }
11360
11361 hashes_avail = st.st_size / sizeof (hccap_t);
11362 }
11363 else
11364 {
11365 hashes_avail = 1;
11366 }
11367 }
11368 else if (hashlist_mode == HL_MODE_FILE)
11369 {
11370 char *hashfile = myargv[optind];
11371
11372 data.hashfile = hashfile;
11373
11374 logfile_top_var_string ("target", hashfile);
11375
11376 FILE *fp = NULL;
11377
11378 if ((fp = fopen (hashfile, "rb")) == NULL)
11379 {
11380 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11381
11382 return (-1);
11383 }
11384
11385 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11386
11387 hashes_avail = count_lines (fp);
11388
11389 rewind (fp);
11390
11391 if (hashes_avail == 0)
11392 {
11393 log_error ("ERROR: hashfile is empty or corrupt");
11394
11395 fclose (fp);
11396
11397 return (-1);
11398 }
11399
11400 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11401
11402 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11403 {
11404 log_error ("ERROR: remove not supported in native hashfile-format mode");
11405
11406 fclose (fp);
11407
11408 return (-1);
11409 }
11410
11411 fclose (fp);
11412 }
11413 }
11414 else
11415 {
11416 hashlist_mode = HL_MODE_ARG;
11417
11418 hashes_avail = 1;
11419 }
11420
11421 if (hash_mode == 3000) hashes_avail *= 2;
11422
11423 data.hashlist_mode = hashlist_mode;
11424 data.hashlist_format = hashlist_format;
11425
11426 logfile_top_uint (hashlist_mode);
11427 logfile_top_uint (hashlist_format);
11428
11429 /**
11430 * load hashes, part II: allocate required memory, set pointers
11431 */
11432
11433 hash_t *hashes_buf = NULL;
11434 void *digests_buf = NULL;
11435 salt_t *salts_buf = NULL;
11436 void *esalts_buf = NULL;
11437
11438 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11439
11440 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11441
11442 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11443 {
11444 u32 hash_pos;
11445
11446 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11447 {
11448 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11449
11450 hashes_buf[hash_pos].hash_info = hash_info;
11451
11452 if (username && (remove || show || left))
11453 {
11454 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11455 }
11456
11457 if (benchmark)
11458 {
11459 hash_info->orighash = (char *) mymalloc (256);
11460 }
11461 }
11462 }
11463
11464 if (isSalted)
11465 {
11466 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11467
11468 if (esalt_size)
11469 {
11470 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11471 }
11472 }
11473 else
11474 {
11475 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11476 }
11477
11478 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11479 {
11480 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11481
11482 if (isSalted)
11483 {
11484 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11485
11486 if (esalt_size)
11487 {
11488 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11489 }
11490 }
11491 else
11492 {
11493 hashes_buf[hash_pos].salt = &salts_buf[0];
11494 }
11495 }
11496
11497 /**
11498 * load hashes, part III: parse hashes or generate them if benchmark
11499 */
11500
11501 uint hashes_cnt = 0;
11502
11503 if (benchmark == 0)
11504 {
11505 if (keyspace == 1)
11506 {
11507 // useless to read hash file for keyspace, cheat a little bit w/ optind
11508 }
11509 else if (hashes_avail == 0)
11510 {
11511 }
11512 else if (hashlist_mode == HL_MODE_ARG)
11513 {
11514 char *input_buf = myargv[optind];
11515
11516 uint input_len = strlen (input_buf);
11517
11518 logfile_top_var_string ("target", input_buf);
11519
11520 char *hash_buf = NULL;
11521 int hash_len = 0;
11522
11523 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11524
11525 bool hash_fmt_error = 0;
11526
11527 if (hash_len < 1) hash_fmt_error = 1;
11528 if (hash_buf == NULL) hash_fmt_error = 1;
11529
11530 if (hash_fmt_error)
11531 {
11532 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11533 }
11534 else
11535 {
11536 if (opts_type & OPTS_TYPE_HASH_COPY)
11537 {
11538 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11539
11540 hash_info_tmp->orighash = mystrdup (hash_buf);
11541 }
11542
11543 if (isSalted)
11544 {
11545 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11546 }
11547
11548 int parser_status = PARSER_OK;
11549
11550 if (hash_mode == 2500)
11551 {
11552 if (hash_len == 0)
11553 {
11554 log_error ("ERROR: hccap file not specified");
11555
11556 return (-1);
11557 }
11558
11559 hashlist_mode = HL_MODE_FILE;
11560
11561 data.hashlist_mode = hashlist_mode;
11562
11563 FILE *fp = fopen (hash_buf, "rb");
11564
11565 if (fp == NULL)
11566 {
11567 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11568
11569 return (-1);
11570 }
11571
11572 if (hashes_avail < 1)
11573 {
11574 log_error ("ERROR: hccap file is empty or corrupt");
11575
11576 fclose (fp);
11577
11578 return (-1);
11579 }
11580
11581 uint hccap_size = sizeof (hccap_t);
11582
11583 char *in = (char *) mymalloc (hccap_size);
11584
11585 while (!feof (fp))
11586 {
11587 int n = fread (in, hccap_size, 1, fp);
11588
11589 if (n != 1)
11590 {
11591 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11592
11593 break;
11594 }
11595
11596 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11597
11598 if (parser_status != PARSER_OK)
11599 {
11600 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11601
11602 continue;
11603 }
11604
11605 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11606
11607 if ((show == 1) || (left == 1))
11608 {
11609 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11610
11611 char *salt_ptr = (char *) tmp_salt->salt_buf;
11612
11613 int cur_pos = tmp_salt->salt_len;
11614 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11615
11616 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11617
11618 // do the appending task
11619
11620 snprintf (salt_ptr + cur_pos,
11621 rem_len,
11622 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11623 wpa->orig_mac1[0],
11624 wpa->orig_mac1[1],
11625 wpa->orig_mac1[2],
11626 wpa->orig_mac1[3],
11627 wpa->orig_mac1[4],
11628 wpa->orig_mac1[5],
11629 wpa->orig_mac2[0],
11630 wpa->orig_mac2[1],
11631 wpa->orig_mac2[2],
11632 wpa->orig_mac2[3],
11633 wpa->orig_mac2[4],
11634 wpa->orig_mac2[5]);
11635
11636 // memset () the remaining part of the salt
11637
11638 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11639 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11640
11641 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11642
11643 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11644 }
11645
11646 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);
11647 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);
11648
11649 hashes_cnt++;
11650 }
11651
11652 fclose (fp);
11653
11654 myfree (in);
11655 }
11656 else if (hash_mode == 3000)
11657 {
11658 if (hash_len == 32)
11659 {
11660 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11661
11662 hash_t *lm_hash_left = NULL;
11663
11664 if (parser_status == PARSER_OK)
11665 {
11666 lm_hash_left = &hashes_buf[hashes_cnt];
11667
11668 hashes_cnt++;
11669 }
11670 else
11671 {
11672 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11673 }
11674
11675 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11676
11677 hash_t *lm_hash_right = NULL;
11678
11679 if (parser_status == PARSER_OK)
11680 {
11681 lm_hash_right = &hashes_buf[hashes_cnt];
11682
11683 hashes_cnt++;
11684 }
11685 else
11686 {
11687 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11688 }
11689
11690 // show / left
11691
11692 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11693 {
11694 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);
11695 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);
11696 }
11697 }
11698 else
11699 {
11700 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11701
11702 if (parser_status == PARSER_OK)
11703 {
11704 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11705 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11706 }
11707
11708 if (parser_status == PARSER_OK)
11709 {
11710 hashes_cnt++;
11711 }
11712 else
11713 {
11714 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11715 }
11716 }
11717 }
11718 else
11719 {
11720 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11721
11722 if (parser_status == PARSER_OK)
11723 {
11724 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11725 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11726 }
11727
11728 if (parser_status == PARSER_OK)
11729 {
11730 hashes_cnt++;
11731 }
11732 else
11733 {
11734 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11735 }
11736 }
11737 }
11738 }
11739 else if (hashlist_mode == HL_MODE_FILE)
11740 {
11741 char *hashfile = data.hashfile;
11742
11743 FILE *fp;
11744
11745 if ((fp = fopen (hashfile, "rb")) == NULL)
11746 {
11747 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11748
11749 return (-1);
11750 }
11751
11752 uint line_num = 0;
11753
11754 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11755
11756 while (!feof (fp))
11757 {
11758 line_num++;
11759
11760 int line_len = fgetl (fp, line_buf);
11761
11762 if (line_len == 0) continue;
11763
11764 char *hash_buf = NULL;
11765 int hash_len = 0;
11766
11767 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11768
11769 bool hash_fmt_error = 0;
11770
11771 if (hash_len < 1) hash_fmt_error = 1;
11772 if (hash_buf == NULL) hash_fmt_error = 1;
11773
11774 if (hash_fmt_error)
11775 {
11776 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11777
11778 continue;
11779 }
11780
11781 if (username)
11782 {
11783 char *user_buf = NULL;
11784 int user_len = 0;
11785
11786 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11787
11788 if (remove || show)
11789 {
11790 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11791
11792 *user = (user_t *) mymalloc (sizeof (user_t));
11793
11794 user_t *user_ptr = *user;
11795
11796 if (user_buf != NULL)
11797 {
11798 user_ptr->user_name = mystrdup (user_buf);
11799 }
11800 else
11801 {
11802 user_ptr->user_name = mystrdup ("");
11803 }
11804
11805 user_ptr->user_len = user_len;
11806 }
11807 }
11808
11809 if (opts_type & OPTS_TYPE_HASH_COPY)
11810 {
11811 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11812
11813 hash_info_tmp->orighash = mystrdup (hash_buf);
11814 }
11815
11816 if (isSalted)
11817 {
11818 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11819 }
11820
11821 if (hash_mode == 3000)
11822 {
11823 if (hash_len == 32)
11824 {
11825 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11826
11827 if (parser_status < PARSER_GLOBAL_ZERO)
11828 {
11829 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11830
11831 continue;
11832 }
11833
11834 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11835
11836 hashes_cnt++;
11837
11838 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11839
11840 if (parser_status < PARSER_GLOBAL_ZERO)
11841 {
11842 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11843
11844 continue;
11845 }
11846
11847 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11848
11849 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);
11850
11851 hashes_cnt++;
11852
11853 // show / left
11854
11855 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);
11856 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);
11857 }
11858 else
11859 {
11860 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11861
11862 if (parser_status < PARSER_GLOBAL_ZERO)
11863 {
11864 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11865
11866 continue;
11867 }
11868
11869 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);
11870
11871 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11872 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11873
11874 hashes_cnt++;
11875 }
11876 }
11877 else
11878 {
11879 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11880
11881 if (parser_status < PARSER_GLOBAL_ZERO)
11882 {
11883 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11884
11885 continue;
11886 }
11887
11888 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);
11889
11890 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11891 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11892
11893 hashes_cnt++;
11894 }
11895 }
11896
11897 myfree (line_buf);
11898
11899 fclose (fp);
11900
11901 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11902
11903 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11904 }
11905 }
11906 else
11907 {
11908 if (isSalted)
11909 {
11910 hashes_buf[0].salt->salt_len = 8;
11911
11912 // special salt handling
11913
11914 switch (hash_mode)
11915 {
11916 case 1500: hashes_buf[0].salt->salt_len = 2;
11917 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11918 break;
11919 case 1731: hashes_buf[0].salt->salt_len = 4;
11920 break;
11921 case 2410: hashes_buf[0].salt->salt_len = 4;
11922 break;
11923 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11924 break;
11925 case 3100: hashes_buf[0].salt->salt_len = 1;
11926 break;
11927 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11928 break;
11929 case 5800: hashes_buf[0].salt->salt_len = 16;
11930 break;
11931 case 6800: hashes_buf[0].salt->salt_len = 32;
11932 break;
11933 case 8400: hashes_buf[0].salt->salt_len = 40;
11934 break;
11935 case 8800: hashes_buf[0].salt->salt_len = 16;
11936 break;
11937 case 8900: hashes_buf[0].salt->salt_len = 16;
11938 hashes_buf[0].salt->scrypt_N = 1024;
11939 hashes_buf[0].salt->scrypt_r = 1;
11940 hashes_buf[0].salt->scrypt_p = 1;
11941 break;
11942 case 9100: hashes_buf[0].salt->salt_len = 16;
11943 break;
11944 case 9300: hashes_buf[0].salt->salt_len = 14;
11945 hashes_buf[0].salt->scrypt_N = 16384;
11946 hashes_buf[0].salt->scrypt_r = 1;
11947 hashes_buf[0].salt->scrypt_p = 1;
11948 break;
11949 case 9400: hashes_buf[0].salt->salt_len = 16;
11950 break;
11951 case 9500: hashes_buf[0].salt->salt_len = 16;
11952 break;
11953 case 9600: hashes_buf[0].salt->salt_len = 16;
11954 break;
11955 case 9700: hashes_buf[0].salt->salt_len = 16;
11956 break;
11957 case 9710: hashes_buf[0].salt->salt_len = 16;
11958 break;
11959 case 9720: hashes_buf[0].salt->salt_len = 16;
11960 break;
11961 case 9800: hashes_buf[0].salt->salt_len = 16;
11962 break;
11963 case 9810: hashes_buf[0].salt->salt_len = 16;
11964 break;
11965 case 9820: hashes_buf[0].salt->salt_len = 16;
11966 break;
11967 case 10300: hashes_buf[0].salt->salt_len = 12;
11968 break;
11969 case 11500: hashes_buf[0].salt->salt_len = 4;
11970 break;
11971 case 11600: hashes_buf[0].salt->salt_len = 4;
11972 break;
11973 case 12400: hashes_buf[0].salt->salt_len = 4;
11974 break;
11975 case 12500: hashes_buf[0].salt->salt_len = 8;
11976 break;
11977 case 12600: hashes_buf[0].salt->salt_len = 64;
11978 break;
11979 }
11980
11981 // special esalt handling
11982
11983 switch (hash_mode)
11984 {
11985 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11986 break;
11987 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11988 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11989 break;
11990 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11991 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11992 break;
11993 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11994 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11995 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11996 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11997 break;
11998 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11999 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12000 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12001 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12002 break;
12003 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12004 break;
12005 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12006 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12007 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12008 break;
12009 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12010 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12011 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12012 break;
12013 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12014 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12015 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12016 break;
12017 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12018 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12019 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12020 break;
12021 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12022 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12023 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12024 break;
12025 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12026 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12027 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12028 break;
12029 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12030 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12031 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12032 break;
12033 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12034 break;
12035 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12036 break;
12037 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12038 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12039 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12040 break;
12041 }
12042 }
12043
12044 // set hashfile
12045
12046 switch (hash_mode)
12047 {
12048 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12049 break;
12050 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12051 break;
12052 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12053 break;
12054 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12055 break;
12056 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12057 break;
12058 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12059 break;
12060 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12061 break;
12062 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12063 break;
12064 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12065 break;
12066 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12067 break;
12068 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12069 break;
12070 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12071 break;
12072 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12073 break;
12074 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12075 break;
12076 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12077 break;
12078 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12079 break;
12080 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12081 break;
12082 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12083 break;
12084 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12085 break;
12086 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12087 break;
12088 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12089 break;
12090 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12091 break;
12092 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12093 break;
12094 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12095 break;
12096 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12097 break;
12098 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12099 break;
12100 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12101 break;
12102 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12103 break;
12104 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12105 break;
12106 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12107 break;
12108 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12109 break;
12110 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12111 break;
12112 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12113 break;
12114 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12115 break;
12116 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12117 break;
12118 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12119 break;
12120 }
12121
12122 // set default iterations
12123
12124 switch (hash_mode)
12125 {
12126 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12127 break;
12128 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12129 break;
12130 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12131 break;
12132 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12133 break;
12134 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12135 break;
12136 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12137 break;
12138 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12139 break;
12140 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12141 break;
12142 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12143 break;
12144 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12145 break;
12146 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12147 break;
12148 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12149 break;
12150 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12151 break;
12152 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12153 break;
12154 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12155 break;
12156 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12157 break;
12158 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12159 break;
12160 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12161 break;
12162 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12163 break;
12164 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12165 break;
12166 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12167 break;
12168 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12169 break;
12170 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12171 break;
12172 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12173 break;
12174 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12175 break;
12176 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12177 break;
12178 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12179 break;
12180 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12181 break;
12182 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12183 break;
12184 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12185 break;
12186 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12187 break;
12188 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12189 break;
12190 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12191 break;
12192 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12193 break;
12194 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12195 break;
12196 case 8900: hashes_buf[0].salt->salt_iter = 1;
12197 break;
12198 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12199 break;
12200 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12201 break;
12202 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12203 break;
12204 case 9300: hashes_buf[0].salt->salt_iter = 1;
12205 break;
12206 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12207 break;
12208 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12209 break;
12210 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12211 break;
12212 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12213 break;
12214 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12215 break;
12216 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12217 break;
12218 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12219 break;
12220 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12221 break;
12222 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12223 break;
12224 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12225 break;
12226 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12227 break;
12228 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12229 break;
12230 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12231 break;
12232 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12233 break;
12234 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12235 break;
12236 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12237 break;
12238 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12239 break;
12240 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12241 break;
12242 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12243 break;
12244 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12245 break;
12246 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12247 break;
12248 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12249 break;
12250 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12251 break;
12252 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12253 break;
12254 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12255 break;
12256 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12257 break;
12258 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12259 break;
12260 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12261 break;
12262 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12263 break;
12264 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12265 break;
12266 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12267 break;
12268 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12269 break;
12270 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12271 break;
12272 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12273 break;
12274 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12275 break;
12276 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12277 break;
12278 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12279 break;
12280 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12281 break;
12282 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12283 break;
12284 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12285 break;
12286 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12287 break;
12288 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12289 break;
12290 }
12291
12292 hashes_cnt = 1;
12293 }
12294
12295 if (show == 1 || left == 1)
12296 {
12297 for (uint i = 0; i < pot_cnt; i++)
12298 {
12299 pot_t *pot_ptr = &pot[i];
12300
12301 hash_t *hashes_buf = &pot_ptr->hash;
12302
12303 local_free (hashes_buf->digest);
12304
12305 if (isSalted)
12306 {
12307 local_free (hashes_buf->salt);
12308 }
12309 }
12310
12311 local_free (pot);
12312
12313 if (data.quiet == 0) log_info_nn ("");
12314
12315 return (0);
12316 }
12317
12318 if (keyspace == 0)
12319 {
12320 if (hashes_cnt == 0)
12321 {
12322 log_error ("ERROR: No hashes loaded");
12323
12324 return (-1);
12325 }
12326 }
12327
12328 /**
12329 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12330 */
12331
12332 if (data.outfile != NULL)
12333 {
12334 if (data.hashfile != NULL)
12335 {
12336 #ifdef _POSIX
12337 struct stat tmpstat_outfile;
12338 struct stat tmpstat_hashfile;
12339 #endif
12340
12341 #ifdef _WIN
12342 struct stat64 tmpstat_outfile;
12343 struct stat64 tmpstat_hashfile;
12344 #endif
12345
12346 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12347
12348 if (tmp_outfile_fp)
12349 {
12350 #ifdef _POSIX
12351 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12352 #endif
12353
12354 #ifdef _WIN
12355 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12356 #endif
12357
12358 fclose (tmp_outfile_fp);
12359 }
12360
12361 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12362
12363 if (tmp_hashfile_fp)
12364 {
12365 #ifdef _POSIX
12366 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12367 #endif
12368
12369 #ifdef _WIN
12370 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12371 #endif
12372
12373 fclose (tmp_hashfile_fp);
12374 }
12375
12376 if (tmp_outfile_fp && tmp_outfile_fp)
12377 {
12378 tmpstat_outfile.st_mode = 0;
12379 tmpstat_outfile.st_nlink = 0;
12380 tmpstat_outfile.st_uid = 0;
12381 tmpstat_outfile.st_gid = 0;
12382 tmpstat_outfile.st_rdev = 0;
12383 tmpstat_outfile.st_atime = 0;
12384
12385 tmpstat_hashfile.st_mode = 0;
12386 tmpstat_hashfile.st_nlink = 0;
12387 tmpstat_hashfile.st_uid = 0;
12388 tmpstat_hashfile.st_gid = 0;
12389 tmpstat_hashfile.st_rdev = 0;
12390 tmpstat_hashfile.st_atime = 0;
12391
12392 #ifdef _POSIX
12393 tmpstat_outfile.st_blksize = 0;
12394 tmpstat_outfile.st_blocks = 0;
12395
12396 tmpstat_hashfile.st_blksize = 0;
12397 tmpstat_hashfile.st_blocks = 0;
12398 #endif
12399
12400 #ifdef _POSIX
12401 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12402 {
12403 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12404
12405 return (-1);
12406 }
12407 #endif
12408
12409 #ifdef _WIN
12410 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12411 {
12412 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12413
12414 return (-1);
12415 }
12416 #endif
12417 }
12418 }
12419 }
12420
12421 /**
12422 * Remove duplicates
12423 */
12424
12425 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12426
12427 if (isSalted)
12428 {
12429 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12430 }
12431 else
12432 {
12433 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12434 }
12435
12436 uint hashes_cnt_orig = hashes_cnt;
12437
12438 hashes_cnt = 1;
12439
12440 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12441 {
12442 if (isSalted)
12443 {
12444 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12445 {
12446 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12447 }
12448 }
12449 else
12450 {
12451 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12452 }
12453
12454 if (hashes_pos > hashes_cnt)
12455 {
12456 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12457 }
12458
12459 hashes_cnt++;
12460 }
12461
12462 /**
12463 * Potfile removes
12464 */
12465
12466 uint potfile_remove_cracks = 0;
12467
12468 if (potfile_disable == 0)
12469 {
12470 hash_t hash_buf;
12471
12472 hash_buf.digest = mymalloc (dgst_size);
12473 hash_buf.salt = NULL;
12474 hash_buf.esalt = NULL;
12475 hash_buf.hash_info = NULL;
12476 hash_buf.cracked = 0;
12477
12478 if (isSalted)
12479 {
12480 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12481 }
12482
12483 if (esalt_size)
12484 {
12485 hash_buf.esalt = mymalloc (esalt_size);
12486 }
12487
12488 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12489
12490 // no solution for these special hash types (for instane because they use hashfile in output etc)
12491 if ((hash_mode != 5200) &&
12492 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12493 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12494 (hash_mode != 9000))
12495 {
12496 FILE *fp = fopen (potfile, "rb");
12497
12498 if (fp != NULL)
12499 {
12500 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12501
12502 // to be safe work with a copy (because of line_len loop, i etc)
12503 // moved up here because it's easier to handle continue case
12504 // it's just 64kb
12505
12506 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12507
12508 while (!feof (fp))
12509 {
12510 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12511
12512 if (ptr == NULL) break;
12513
12514 int line_len = strlen (line_buf);
12515
12516 if (line_len == 0) continue;
12517
12518 int iter = MAX_CUT_TRIES;
12519
12520 for (int i = line_len - 1; i && iter; i--, line_len--)
12521 {
12522 if (line_buf[i] != ':') continue;
12523
12524 if (isSalted)
12525 {
12526 memset (hash_buf.salt, 0, sizeof (salt_t));
12527 }
12528
12529 hash_t *found = NULL;
12530
12531 if (hash_mode == 6800)
12532 {
12533 if (i < 64) // 64 = 16 * uint in salt_buf[]
12534 {
12535 // manipulate salt_buf
12536 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12537
12538 hash_buf.salt->salt_len = i;
12539
12540 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12541 }
12542 }
12543 else if (hash_mode == 2500)
12544 {
12545 if (i < 64) // 64 = 16 * uint in salt_buf[]
12546 {
12547 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12548 // manipulate salt_buf
12549
12550 memcpy (line_buf_cpy, line_buf, i);
12551
12552 char *mac2_pos = strrchr (line_buf_cpy, ':');
12553
12554 if (mac2_pos == NULL) continue;
12555
12556 mac2_pos[0] = 0;
12557 mac2_pos++;
12558
12559 if (strlen (mac2_pos) != 12) continue;
12560
12561 char *mac1_pos = strrchr (line_buf_cpy, ':');
12562
12563 if (mac1_pos == NULL) continue;
12564
12565 mac1_pos[0] = 0;
12566 mac1_pos++;
12567
12568 if (strlen (mac1_pos) != 12) continue;
12569
12570 uint essid_length = mac1_pos - line_buf_cpy - 1;
12571
12572 // here we need the ESSID
12573 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12574
12575 hash_buf.salt->salt_len = essid_length;
12576
12577 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12578
12579 if (found)
12580 {
12581 wpa_t *wpa = (wpa_t *) found->esalt;
12582
12583 // compare hex string(s) vs binary MAC address(es)
12584
12585 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12586 {
12587 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12588 {
12589 found = NULL;
12590
12591 break;
12592 }
12593 }
12594
12595 // early skip ;)
12596 if (!found) continue;
12597
12598 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12599 {
12600 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12601 {
12602 found = NULL;
12603
12604 break;
12605 }
12606 }
12607 }
12608 }
12609 }
12610 else
12611 {
12612 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12613
12614 if (parser_status == PARSER_OK)
12615 {
12616 if (isSalted)
12617 {
12618 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12619 }
12620 else
12621 {
12622 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12623 }
12624 }
12625 }
12626
12627 if (found == NULL) continue;
12628
12629 if (!found->cracked) potfile_remove_cracks++;
12630
12631 found->cracked = 1;
12632
12633 if (found) break;
12634
12635 iter--;
12636 }
12637 }
12638
12639 myfree (line_buf_cpy);
12640
12641 myfree (line_buf);
12642
12643 fclose (fp);
12644 }
12645 }
12646
12647 if (esalt_size)
12648 {
12649 local_free (hash_buf.esalt);
12650 }
12651
12652 if (isSalted)
12653 {
12654 local_free (hash_buf.salt);
12655 }
12656
12657 local_free (hash_buf.digest);
12658 }
12659
12660 /**
12661 * Now generate all the buffers required for later
12662 */
12663
12664 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12665
12666 salt_t *salts_buf_new = NULL;
12667 void *esalts_buf_new = NULL;
12668
12669 if (isSalted)
12670 {
12671 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12672
12673 if (esalt_size)
12674 {
12675 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12676 }
12677 }
12678 else
12679 {
12680 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12681 }
12682
12683 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12684
12685 uint digests_cnt = hashes_cnt;
12686 uint digests_done = 0;
12687
12688 size_t size_digests = digests_cnt * dgst_size;
12689 size_t size_shown = digests_cnt * sizeof (uint);
12690
12691 uint *digests_shown = (uint *) mymalloc (size_shown);
12692 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12693
12694 uint salts_cnt = 0;
12695 uint salts_done = 0;
12696
12697 hashinfo_t **hash_info = NULL;
12698
12699 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12700 {
12701 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12702
12703 if (username && (remove || show))
12704 {
12705 uint user_pos;
12706
12707 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12708 {
12709 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12710
12711 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12712 }
12713 }
12714 }
12715
12716 uint *salts_shown = (uint *) mymalloc (size_shown);
12717
12718 salt_t *salt_buf;
12719
12720 {
12721 // copied from inner loop
12722
12723 salt_buf = &salts_buf_new[salts_cnt];
12724
12725 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12726
12727 if (esalt_size)
12728 {
12729 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12730 }
12731
12732 salt_buf->digests_cnt = 0;
12733 salt_buf->digests_done = 0;
12734 salt_buf->digests_offset = 0;
12735
12736 salts_cnt++;
12737 }
12738
12739 if (hashes_buf[0].cracked == 1)
12740 {
12741 digests_shown[0] = 1;
12742
12743 digests_done++;
12744
12745 salt_buf->digests_done++;
12746 }
12747
12748 salt_buf->digests_cnt++;
12749
12750 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12751
12752 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12753 {
12754 hash_info[0] = hashes_buf[0].hash_info;
12755 }
12756
12757 // copy from inner loop
12758
12759 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12760 {
12761 if (isSalted)
12762 {
12763 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12764 {
12765 salt_buf = &salts_buf_new[salts_cnt];
12766
12767 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12768
12769 if (esalt_size)
12770 {
12771 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12772 }
12773
12774 salt_buf->digests_cnt = 0;
12775 salt_buf->digests_done = 0;
12776 salt_buf->digests_offset = hashes_pos;
12777
12778 salts_cnt++;
12779 }
12780 }
12781
12782 if (hashes_buf[hashes_pos].cracked == 1)
12783 {
12784 digests_shown[hashes_pos] = 1;
12785
12786 digests_done++;
12787
12788 salt_buf->digests_done++;
12789 }
12790
12791 salt_buf->digests_cnt++;
12792
12793 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12794
12795 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12796 {
12797 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12798 }
12799 }
12800
12801 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12802 {
12803 salt_t *salt_buf = &salts_buf_new[salt_pos];
12804
12805 if (salt_buf->digests_done == salt_buf->digests_cnt)
12806 {
12807 salts_shown[salt_pos] = 1;
12808
12809 salts_done++;
12810 }
12811
12812 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12813 }
12814
12815 local_free (digests_buf);
12816 local_free (salts_buf);
12817 local_free (esalts_buf);
12818
12819 digests_buf = digests_buf_new;
12820 salts_buf = salts_buf_new;
12821 esalts_buf = esalts_buf_new;
12822
12823 local_free (hashes_buf);
12824
12825 /**
12826 * special modification not set from parser
12827 */
12828
12829 switch (hash_mode)
12830 {
12831 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12832 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12833 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12834 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12835 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12836 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12837 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12838 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12839 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12840 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12841 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12842 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12843 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12844 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12845 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12846 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12847 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12848 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12849 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12850 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12851 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12852 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12853 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12854 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12855 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12856 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12857 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12858 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12859 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12860 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12861 }
12862
12863 if (truecrypt_keyfiles)
12864 {
12865 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12866
12867 char *keyfiles = strdup (truecrypt_keyfiles);
12868
12869 char *keyfile = strtok (keyfiles, ",");
12870
12871 do
12872 {
12873 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12874
12875 } while ((keyfile = strtok (NULL, ",")) != NULL);
12876
12877 free (keyfiles);
12878 }
12879
12880 if (veracrypt_keyfiles)
12881 {
12882 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12883
12884 char *keyfiles = strdup (veracrypt_keyfiles);
12885
12886 char *keyfile = strtok (keyfiles, ",");
12887
12888 do
12889 {
12890 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12891
12892 } while ((keyfile = strtok (NULL, ",")) != NULL);
12893
12894 free (keyfiles);
12895 }
12896
12897 data.digests_cnt = digests_cnt;
12898 data.digests_done = digests_done;
12899 data.digests_buf = digests_buf;
12900 data.digests_shown = digests_shown;
12901 data.digests_shown_tmp = digests_shown_tmp;
12902
12903 data.salts_cnt = salts_cnt;
12904 data.salts_done = salts_done;
12905 data.salts_buf = salts_buf;
12906 data.salts_shown = salts_shown;
12907
12908 data.esalts_buf = esalts_buf;
12909 data.hash_info = hash_info;
12910
12911 /**
12912 * Automatic Optimizers
12913 */
12914
12915 if (salts_cnt == 1)
12916 opti_type |= OPTI_TYPE_SINGLE_SALT;
12917
12918 if (digests_cnt == 1)
12919 opti_type |= OPTI_TYPE_SINGLE_HASH;
12920
12921 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12922 opti_type |= OPTI_TYPE_NOT_ITERATED;
12923
12924 if (attack_mode == ATTACK_MODE_BF)
12925 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12926
12927 data.opti_type = opti_type;
12928
12929 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12930 {
12931 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12932 {
12933 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12934 {
12935 if (opts_type & OPTS_TYPE_ST_ADD80)
12936 {
12937 opts_type &= ~OPTS_TYPE_ST_ADD80;
12938 opts_type |= OPTS_TYPE_PT_ADD80;
12939 }
12940
12941 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12942 {
12943 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12944 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12945 }
12946
12947 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12948 {
12949 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12950 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12951 }
12952 }
12953 }
12954 }
12955
12956 /**
12957 * Some algorithm, like descrypt, can benefit from JIT compilation
12958 */
12959
12960 int force_jit_compilation = -1;
12961
12962 if (hash_mode == 8900)
12963 {
12964 force_jit_compilation = 8900;
12965 }
12966 else if (hash_mode == 9300)
12967 {
12968 force_jit_compilation = 8900;
12969 }
12970 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12971 {
12972 force_jit_compilation = 1500;
12973 }
12974
12975 /**
12976 * generate bitmap tables
12977 */
12978
12979 const uint bitmap_shift1 = 5;
12980 const uint bitmap_shift2 = 13;
12981
12982 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12983
12984 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12985 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12986 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12987 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12988 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12989 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12990 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12991 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12992
12993 uint bitmap_bits;
12994 uint bitmap_nums;
12995 uint bitmap_mask;
12996 uint bitmap_size;
12997
12998 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12999 {
13000 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13001
13002 bitmap_nums = 1 << bitmap_bits;
13003
13004 bitmap_mask = bitmap_nums - 1;
13005
13006 bitmap_size = bitmap_nums * sizeof (uint);
13007
13008 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13009
13010 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;
13011 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;
13012
13013 break;
13014 }
13015
13016 bitmap_nums = 1 << bitmap_bits;
13017
13018 bitmap_mask = bitmap_nums - 1;
13019
13020 bitmap_size = bitmap_nums * sizeof (uint);
13021
13022 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);
13023 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);
13024
13025 /**
13026 * prepare quick rule
13027 */
13028
13029 data.rule_buf_l = rule_buf_l;
13030 data.rule_buf_r = rule_buf_r;
13031
13032 int rule_len_l = (int) strlen (rule_buf_l);
13033 int rule_len_r = (int) strlen (rule_buf_r);
13034
13035 data.rule_len_l = rule_len_l;
13036 data.rule_len_r = rule_len_r;
13037
13038 /**
13039 * load rules
13040 */
13041
13042 uint *all_kernel_rules_cnt = NULL;
13043
13044 kernel_rule_t **all_kernel_rules_buf = NULL;
13045
13046 if (rp_files_cnt)
13047 {
13048 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13049
13050 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13051 }
13052
13053 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13054
13055 int rule_len = 0;
13056
13057 for (uint i = 0; i < rp_files_cnt; i++)
13058 {
13059 uint kernel_rules_avail = 0;
13060
13061 uint kernel_rules_cnt = 0;
13062
13063 kernel_rule_t *kernel_rules_buf = NULL;
13064
13065 char *rp_file = rp_files[i];
13066
13067 char in[BLOCK_SIZE] = { 0 };
13068 char out[BLOCK_SIZE] = { 0 };
13069
13070 FILE *fp = NULL;
13071
13072 uint rule_line = 0;
13073
13074 if ((fp = fopen (rp_file, "rb")) == NULL)
13075 {
13076 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13077
13078 return (-1);
13079 }
13080
13081 while (!feof (fp))
13082 {
13083 memset (rule_buf, 0, HCBUFSIZ);
13084
13085 rule_len = fgetl (fp, rule_buf);
13086
13087 rule_line++;
13088
13089 if (rule_len == 0) continue;
13090
13091 if (rule_buf[0] == '#') continue;
13092
13093 if (kernel_rules_avail == kernel_rules_cnt)
13094 {
13095 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13096
13097 kernel_rules_avail += INCR_RULES;
13098 }
13099
13100 memset (in, 0, BLOCK_SIZE);
13101 memset (out, 0, BLOCK_SIZE);
13102
13103 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13104
13105 if (result == -1)
13106 {
13107 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13108
13109 continue;
13110 }
13111
13112 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13113 {
13114 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13115
13116 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13117
13118 continue;
13119 }
13120
13121 /* its so slow
13122 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13123 {
13124 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13125
13126 continue;
13127 }
13128 */
13129
13130 kernel_rules_cnt++;
13131 }
13132
13133 fclose (fp);
13134
13135 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13136
13137 all_kernel_rules_buf[i] = kernel_rules_buf;
13138 }
13139
13140 /**
13141 * merge rules or automatic rule generator
13142 */
13143
13144 uint kernel_rules_cnt = 0;
13145
13146 kernel_rule_t *kernel_rules_buf = NULL;
13147
13148 if (attack_mode == ATTACK_MODE_STRAIGHT)
13149 {
13150 if (rp_files_cnt)
13151 {
13152 kernel_rules_cnt = 1;
13153
13154 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13155
13156 repeats[0] = kernel_rules_cnt;
13157
13158 for (uint i = 0; i < rp_files_cnt; i++)
13159 {
13160 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13161
13162 repeats[i + 1] = kernel_rules_cnt;
13163 }
13164
13165 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13166
13167 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13168
13169 for (uint i = 0; i < kernel_rules_cnt; i++)
13170 {
13171 uint out_pos = 0;
13172
13173 kernel_rule_t *out = &kernel_rules_buf[i];
13174
13175 for (uint j = 0; j < rp_files_cnt; j++)
13176 {
13177 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13178 uint in_pos;
13179
13180 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13181
13182 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13183 {
13184 if (out_pos == RULES_MAX - 1)
13185 {
13186 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13187
13188 break;
13189 }
13190
13191 out->cmds[out_pos] = in->cmds[in_pos];
13192 }
13193 }
13194 }
13195
13196 local_free (repeats);
13197 }
13198 else if (rp_gen)
13199 {
13200 uint kernel_rules_avail = 0;
13201
13202 while (kernel_rules_cnt < rp_gen)
13203 {
13204 if (kernel_rules_avail == kernel_rules_cnt)
13205 {
13206 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13207
13208 kernel_rules_avail += INCR_RULES;
13209 }
13210
13211 memset (rule_buf, 0, HCBUFSIZ);
13212
13213 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13214
13215 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13216
13217 kernel_rules_cnt++;
13218 }
13219 }
13220 }
13221
13222 myfree (rule_buf);
13223
13224 /**
13225 * generate NOP rules
13226 */
13227
13228 if (kernel_rules_cnt == 0)
13229 {
13230 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13231
13232 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13233
13234 kernel_rules_cnt++;
13235 }
13236
13237 data.kernel_rules_cnt = kernel_rules_cnt;
13238 data.kernel_rules_buf = kernel_rules_buf;
13239
13240 /**
13241 * OpenCL platforms: detect
13242 */
13243
13244 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13245 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13246
13247 cl_uint platforms_cnt = 0;
13248 cl_uint platform_devices_cnt = 0;
13249
13250 if (keyspace == 0)
13251 {
13252 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13253
13254 if (platforms_cnt == 0)
13255 {
13256 log_info ("");
13257 log_info ("ATTENTION! No OpenCL compatible platform found");
13258 log_info ("");
13259 log_info ("You're probably missing the OpenCL runtime installation");
13260 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13261 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13262 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13263 log_info ("");
13264
13265 return (-1);
13266 }
13267
13268 if (opencl_platforms_filter != (uint) -1)
13269 {
13270 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13271
13272 if (opencl_platforms_filter > platform_cnt_mask)
13273 {
13274 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13275
13276 return (-1);
13277 }
13278 }
13279 }
13280
13281 /**
13282 * OpenCL device types:
13283 * 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.
13284 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13285 */
13286
13287 if (opencl_device_types == NULL)
13288 {
13289 cl_device_type device_types_all = 0;
13290
13291 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13292 {
13293 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13294
13295 cl_platform_id platform = platforms[platform_id];
13296
13297 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13298
13299 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13300 {
13301 cl_device_id device = platform_devices[platform_devices_id];
13302
13303 cl_device_type device_type;
13304
13305 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13306
13307 device_types_all |= device_type;
13308 }
13309 }
13310
13311 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13312 {
13313 device_types_filter |= CL_DEVICE_TYPE_CPU;
13314 }
13315 }
13316
13317 /**
13318 * OpenCL devices: simply push all devices from all platforms into the same device array
13319 */
13320
13321 int need_adl = 0;
13322 int need_nvml = 0;
13323
13324 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13325
13326 data.devices_param = devices_param;
13327
13328 uint devices_cnt = 0;
13329
13330 uint devices_active = 0;
13331
13332 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13333 {
13334 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13335
13336 cl_platform_id platform = platforms[platform_id];
13337
13338 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13339
13340 char platform_vendor[INFOSZ] = { 0 };
13341
13342 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13343
13344 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13345 // this causes trouble with vendor id based macros
13346 // we'll assign generic to those without special optimization available
13347
13348 cl_uint platform_vendor_id = 0;
13349
13350 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13351 {
13352 platform_vendor_id = VENDOR_ID_AMD;
13353 }
13354 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13355 {
13356 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13357 }
13358 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13359 {
13360 platform_vendor_id = VENDOR_ID_APPLE;
13361 }
13362 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13363 {
13364 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13365 }
13366 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13367 {
13368 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13369 }
13370 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13371 {
13372 platform_vendor_id = VENDOR_ID_MESA;
13373 }
13374 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13375 {
13376 platform_vendor_id = VENDOR_ID_NV;
13377 }
13378 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13379 {
13380 platform_vendor_id = VENDOR_ID_POCL;
13381 }
13382 else
13383 {
13384 platform_vendor_id = VENDOR_ID_GENERIC;
13385 }
13386
13387 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13388 {
13389 size_t param_value_size = 0;
13390
13391 const uint device_id = devices_cnt;
13392
13393 hc_device_param_t *device_param = &data.devices_param[device_id];
13394
13395 device_param->platform_vendor_id = platform_vendor_id;
13396
13397 device_param->device = platform_devices[platform_devices_id];
13398
13399 device_param->device_id = device_id;
13400
13401 device_param->platform_devices_id = platform_devices_id;
13402
13403 // device_type
13404
13405 cl_device_type device_type;
13406
13407 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13408
13409 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13410
13411 device_param->device_type = device_type;
13412
13413 // device_name
13414
13415 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13416
13417 char *device_name = (char *) mymalloc (param_value_size);
13418
13419 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13420
13421 device_param->device_name = device_name;
13422
13423 // device_vendor
13424
13425 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13426
13427 char *device_vendor = (char *) mymalloc (param_value_size);
13428
13429 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13430
13431 device_param->device_vendor = device_vendor;
13432
13433 cl_uint device_vendor_id = 0;
13434
13435 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13436 {
13437 device_vendor_id = VENDOR_ID_AMD;
13438 }
13439 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13440 {
13441 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13442 }
13443 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13444 {
13445 device_vendor_id = VENDOR_ID_APPLE;
13446 }
13447 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13448 {
13449 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13450 }
13451 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13452 {
13453 device_vendor_id = VENDOR_ID_INTEL_SDK;
13454 }
13455 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13456 {
13457 device_vendor_id = VENDOR_ID_MESA;
13458 }
13459 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13460 {
13461 device_vendor_id = VENDOR_ID_NV;
13462 }
13463 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13464 {
13465 device_vendor_id = VENDOR_ID_POCL;
13466 }
13467 else
13468 {
13469 device_vendor_id = VENDOR_ID_GENERIC;
13470 }
13471
13472 device_param->device_vendor_id = device_vendor_id;
13473
13474 // tuning db
13475
13476 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13477
13478 // device_version
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13481
13482 char *device_version = (char *) mymalloc (param_value_size);
13483
13484 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13485
13486 device_param->device_version = device_version;
13487
13488 // device_opencl_version
13489
13490 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13491
13492 char *device_opencl_version = (char *) mymalloc (param_value_size);
13493
13494 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13495
13496 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13497
13498 myfree (device_opencl_version);
13499
13500 // vector_width
13501
13502 cl_uint vector_width;
13503
13504 if (opencl_vector_width_chgd == 0)
13505 {
13506 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13507 {
13508 if (opti_type & OPTI_TYPE_USES_BITS_64)
13509 {
13510 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13511 }
13512 else
13513 {
13514 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13515 }
13516 }
13517 else
13518 {
13519 vector_width = (cl_uint) tuningdb_entry->vector_width;
13520 }
13521 }
13522 else
13523 {
13524 vector_width = opencl_vector_width;
13525 }
13526
13527 if (vector_width > 16) vector_width = 16;
13528
13529 device_param->vector_width = vector_width;
13530
13531 // max_compute_units
13532
13533 cl_uint device_processors;
13534
13535 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13536
13537 device_param->device_processors = device_processors;
13538
13539 // device_maxmem_alloc
13540 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13541
13542 cl_ulong device_maxmem_alloc;
13543
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13545
13546 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13547
13548 // device_global_mem
13549
13550 cl_ulong device_global_mem;
13551
13552 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13553
13554 device_param->device_global_mem = device_global_mem;
13555
13556 // max_work_group_size
13557
13558 size_t device_maxworkgroup_size;
13559
13560 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13561
13562 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13563
13564 // max_clock_frequency
13565
13566 cl_uint device_maxclock_frequency;
13567
13568 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13569
13570 device_param->device_maxclock_frequency = device_maxclock_frequency;
13571
13572 // device_endian_little
13573
13574 cl_bool device_endian_little;
13575
13576 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13577
13578 if (device_endian_little == CL_FALSE)
13579 {
13580 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13581
13582 device_param->skipped = 1;
13583 }
13584
13585 // device_available
13586
13587 cl_bool device_available;
13588
13589 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13590
13591 if (device_available == CL_FALSE)
13592 {
13593 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13594
13595 device_param->skipped = 1;
13596 }
13597
13598 // device_compiler_available
13599
13600 cl_bool device_compiler_available;
13601
13602 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13603
13604 if (device_compiler_available == CL_FALSE)
13605 {
13606 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13607
13608 device_param->skipped = 1;
13609 }
13610
13611 // device_execution_capabilities
13612
13613 cl_device_exec_capabilities device_execution_capabilities;
13614
13615 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13616
13617 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13618 {
13619 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13620
13621 device_param->skipped = 1;
13622 }
13623
13624 // device_extensions
13625
13626 size_t device_extensions_size;
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13629
13630 char *device_extensions = mymalloc (device_extensions_size + 1);
13631
13632 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13633
13634 if (strstr (device_extensions, "base_atomics") == 0)
13635 {
13636 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13637
13638 device_param->skipped = 1;
13639 }
13640
13641 if (strstr (device_extensions, "byte_addressable_store") == 0)
13642 {
13643 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13644
13645 device_param->skipped = 1;
13646 }
13647
13648 myfree (device_extensions);
13649
13650 // device_local_mem_size
13651
13652 cl_ulong device_local_mem_size;
13653
13654 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13655
13656 if (device_local_mem_size < 32768)
13657 {
13658 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13659
13660 device_param->skipped = 1;
13661 }
13662
13663 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13664 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13665 // This results in both utilizing it for 50%
13666 // However, Intel has much better SIMD control over their own hardware
13667 // It makes sense to give them full control over their own hardware
13668
13669 if (device_type & CL_DEVICE_TYPE_CPU)
13670 {
13671 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13672 {
13673 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13674
13675 device_param->skipped = 1;
13676 }
13677 }
13678
13679 // skipped
13680
13681 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13682 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13683
13684 // driver_version
13685
13686 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13687
13688 char *driver_version = (char *) mymalloc (param_value_size);
13689
13690 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13691
13692 device_param->driver_version = driver_version;
13693
13694 // device_name_chksum
13695
13696 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13697
13698 #if __x86_64__
13699 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);
13700 #else
13701 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);
13702 #endif
13703
13704 uint device_name_digest[4] = { 0 };
13705
13706 md5_64 ((uint *) device_name_chksum, device_name_digest);
13707
13708 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13709
13710 device_param->device_name_chksum = device_name_chksum;
13711
13712 // device_processor_cores
13713
13714 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13715 {
13716 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13717 {
13718 need_adl = 1;
13719 }
13720
13721 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13722 {
13723 need_nvml = 1;
13724 }
13725 }
13726
13727 // device_processor_cores
13728
13729 if (device_type & CL_DEVICE_TYPE_CPU)
13730 {
13731 cl_uint device_processor_cores = 1;
13732
13733 device_param->device_processor_cores = device_processor_cores;
13734 }
13735
13736 if (device_type & CL_DEVICE_TYPE_GPU)
13737 {
13738 if (device_vendor_id == VENDOR_ID_AMD)
13739 {
13740 cl_uint device_processor_cores = 0;
13741
13742 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13743
13744 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13745
13746 device_param->device_processor_cores = device_processor_cores;
13747 }
13748 else if (device_vendor_id == VENDOR_ID_NV)
13749 {
13750 cl_uint kernel_exec_timeout = 0;
13751
13752 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13753
13754 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13755
13756 device_param->kernel_exec_timeout = kernel_exec_timeout;
13757
13758 cl_uint device_processor_cores = 0;
13759
13760 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13761
13762 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13763
13764 device_param->device_processor_cores = device_processor_cores;
13765
13766 cl_uint sm_minor = 0;
13767 cl_uint sm_major = 0;
13768
13769 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13770 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13771
13772 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13773 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13774
13775 device_param->sm_minor = sm_minor;
13776 device_param->sm_major = sm_major;
13777 }
13778 else
13779 {
13780 cl_uint device_processor_cores = 1;
13781
13782 device_param->device_processor_cores = device_processor_cores;
13783 }
13784 }
13785
13786 // display results
13787
13788 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13789 {
13790 if (machine_readable == 0)
13791 {
13792 if (device_param->skipped == 0)
13793 {
13794 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13795 device_id + 1,
13796 device_name,
13797 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13798 (unsigned int) (device_global_mem / 1024 / 1024),
13799 (unsigned int) device_processors);
13800 }
13801 else
13802 {
13803 log_info ("Device #%u: %s, skipped",
13804 device_id + 1,
13805 device_name);
13806 }
13807 }
13808 }
13809
13810 // common driver check
13811
13812 if (device_param->skipped == 0)
13813 {
13814 if (device_type & CL_DEVICE_TYPE_GPU)
13815 {
13816 if (platform_vendor_id == VENDOR_ID_AMD)
13817 {
13818 int catalyst_check = (force == 1) ? 0 : 1;
13819
13820 int catalyst_warn = 0;
13821
13822 int catalyst_broken = 0;
13823
13824 if (catalyst_check == 1)
13825 {
13826 catalyst_warn = 1;
13827
13828 // v14.9 and higher
13829 if (atoi (device_param->driver_version) >= 1573)
13830 {
13831 catalyst_warn = 0;
13832 }
13833
13834 catalyst_check = 0;
13835 }
13836
13837 if (catalyst_broken == 1)
13838 {
13839 log_info ("");
13840 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13841 log_info ("It will pass over cracked hashes and does not report them as cracked");
13842 log_info ("You are STRONGLY encouraged not to use it");
13843 log_info ("You can use --force to override this but do not post error reports if you do so");
13844 log_info ("");
13845
13846 return (-1);
13847 }
13848
13849 if (catalyst_warn == 1)
13850 {
13851 log_info ("");
13852 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13853 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13854 log_info ("See hashcat's homepage for official supported catalyst drivers");
13855 #ifdef _WIN
13856 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13857 #endif
13858 log_info ("You can use --force to override this but do not post error reports if you do so");
13859 log_info ("");
13860
13861 return (-1);
13862 }
13863 }
13864 else if (platform_vendor_id == VENDOR_ID_NV)
13865 {
13866 if (device_param->kernel_exec_timeout != 0)
13867 {
13868 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);
13869 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13870 }
13871 }
13872 }
13873
13874 /* turns out pocl still creates segfaults (because of llvm)
13875 if (device_type & CL_DEVICE_TYPE_CPU)
13876 {
13877 if (platform_vendor_id == VENDOR_ID_AMD)
13878 {
13879 if (force == 0)
13880 {
13881 log_info ("");
13882 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13883 log_info ("You are STRONGLY encouraged not to use it");
13884 log_info ("You can use --force to override this but do not post error reports if you do so");
13885 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13886 log_info ("");
13887
13888 return (-1);
13889 }
13890 }
13891 }
13892 */
13893
13894 /**
13895 * kernel accel and loops tuning db adjustment
13896 */
13897
13898 device_param->kernel_accel_min = 1;
13899 device_param->kernel_accel_max = 1024;
13900
13901 device_param->kernel_loops_min = 1;
13902 device_param->kernel_loops_max = 1024;
13903
13904 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13905
13906 if (tuningdb_entry)
13907 {
13908 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13909 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13910
13911 if (_kernel_accel)
13912 {
13913 device_param->kernel_accel_min = _kernel_accel;
13914 device_param->kernel_accel_max = _kernel_accel;
13915 }
13916
13917 if (_kernel_loops)
13918 {
13919 if (workload_profile == 1)
13920 {
13921 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13922 }
13923 else if (workload_profile == 2)
13924 {
13925 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13926 }
13927
13928 device_param->kernel_loops_min = _kernel_loops;
13929 device_param->kernel_loops_max = _kernel_loops;
13930 }
13931 }
13932
13933 // commandline parameters overwrite tuningdb entries
13934
13935 if (kernel_accel)
13936 {
13937 device_param->kernel_accel_min = kernel_accel;
13938 device_param->kernel_accel_max = kernel_accel;
13939 }
13940
13941 if (kernel_loops)
13942 {
13943 device_param->kernel_loops_min = kernel_loops;
13944 device_param->kernel_loops_max = kernel_loops;
13945 }
13946
13947 /**
13948 * activate device
13949 */
13950
13951 devices_active++;
13952 }
13953
13954 // next please
13955
13956 devices_cnt++;
13957 }
13958 }
13959
13960 if (keyspace == 0 && devices_active == 0)
13961 {
13962 log_error ("ERROR: No devices found/left");
13963
13964 return (-1);
13965 }
13966
13967 // 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)
13968
13969 if (devices_filter != (uint) -1)
13970 {
13971 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13972
13973 if (devices_filter > devices_cnt_mask)
13974 {
13975 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13976
13977 return (-1);
13978 }
13979 }
13980
13981 data.devices_cnt = devices_cnt;
13982
13983 data.devices_active = devices_active;
13984
13985 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13986 {
13987 if (machine_readable == 0)
13988 {
13989 log_info ("");
13990 }
13991 }
13992
13993 /**
13994 * HM devices: init
13995 */
13996
13997 #ifdef HAVE_HWMON
13998 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
13999 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14000
14001 if (gpu_temp_disable == 0)
14002 {
14003 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14004 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14005
14006 data.hm_amd = NULL;
14007 data.hm_nv = NULL;
14008
14009 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14010 {
14011 data.hm_nv = nvml;
14012 }
14013
14014 if (data.hm_nv)
14015 {
14016 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14017 {
14018 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14019
14020 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14021
14022 int tmp_out = 0;
14023
14024 for (int i = 0; i < tmp_in; i++)
14025 {
14026 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14027 }
14028
14029 for (int i = 0; i < tmp_out; i++)
14030 {
14031 unsigned int speed;
14032
14033 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 0, hm_adapters_nv[i].adapter_index.nv, &speed) == NVML_SUCCESS) hm_adapters_nv[i].fan_get_supported = 1;
14034
14035 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14036
14037 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, NVML_GOM_ALL_ON);
14038 }
14039 }
14040 }
14041
14042 if ((need_adl == 1) && (adl_init (adl) == 0))
14043 {
14044 data.hm_amd = adl;
14045 }
14046
14047 if (data.hm_amd)
14048 {
14049 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14050 {
14051 // total number of adapters
14052
14053 int hm_adapters_num;
14054
14055 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14056
14057 // adapter info
14058
14059 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14060
14061 if (lpAdapterInfo == NULL) return (-1);
14062
14063 // get a list (of ids of) valid/usable adapters
14064
14065 int num_adl_adapters = 0;
14066
14067 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14068
14069 if (num_adl_adapters > 0)
14070 {
14071 hc_thread_mutex_lock (mux_adl);
14072
14073 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14074
14075 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14076
14077 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14078 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14079
14080 hc_thread_mutex_unlock (mux_adl);
14081 }
14082
14083 myfree (valid_adl_device_list);
14084 myfree (lpAdapterInfo);
14085 }
14086 }
14087
14088 if (data.hm_amd == NULL && data.hm_nv == NULL)
14089 {
14090 gpu_temp_disable = 1;
14091 }
14092 }
14093
14094 /**
14095 * OpenCL devices: allocate buffer for device specific information
14096 */
14097
14098 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14099 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14100
14101 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14102
14103 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14104
14105 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14106
14107 /**
14108 * User-defined GPU temp handling
14109 */
14110
14111 if (gpu_temp_disable == 1)
14112 {
14113 gpu_temp_abort = 0;
14114 gpu_temp_retain = 0;
14115 }
14116
14117 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14118 {
14119 if (gpu_temp_abort < gpu_temp_retain)
14120 {
14121 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14122
14123 return (-1);
14124 }
14125 }
14126
14127 data.gpu_temp_disable = gpu_temp_disable;
14128 data.gpu_temp_abort = gpu_temp_abort;
14129 data.gpu_temp_retain = gpu_temp_retain;
14130 #endif
14131
14132 /**
14133 * enable custom signal handler(s)
14134 */
14135
14136 if (benchmark == 0)
14137 {
14138 hc_signal (sigHandler_default);
14139 }
14140 else
14141 {
14142 hc_signal (sigHandler_benchmark);
14143 }
14144
14145 /**
14146 * inform the user
14147 */
14148
14149 if (data.quiet == 0)
14150 {
14151 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14152
14153 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);
14154
14155 if (attack_mode == ATTACK_MODE_STRAIGHT)
14156 {
14157 log_info ("Rules: %u", kernel_rules_cnt);
14158 }
14159
14160 if (opti_type)
14161 {
14162 log_info ("Applicable Optimizers:");
14163
14164 for (uint i = 0; i < 32; i++)
14165 {
14166 const uint opti_bit = 1u << i;
14167
14168 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14169 }
14170 }
14171
14172 /**
14173 * Watchdog and Temperature balance
14174 */
14175
14176 #ifdef HAVE_HWMON
14177 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14178 {
14179 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14180 }
14181
14182 if (gpu_temp_abort == 0)
14183 {
14184 log_info ("Watchdog: Temperature abort trigger disabled");
14185 }
14186 else
14187 {
14188 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14189 }
14190
14191 if (gpu_temp_retain == 0)
14192 {
14193 log_info ("Watchdog: Temperature retain trigger disabled");
14194 }
14195 else
14196 {
14197 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14198 }
14199
14200 if (data.quiet == 0) log_info ("");
14201 #endif
14202 }
14203
14204 #ifdef HAVE_HWMON
14205
14206 /**
14207 * HM devices: copy
14208 */
14209
14210 if (gpu_temp_disable == 0)
14211 {
14212 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14213 {
14214 hc_device_param_t *device_param = &data.devices_param[device_id];
14215
14216 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14217
14218 if (device_param->skipped) continue;
14219
14220 const uint platform_devices_id = device_param->platform_devices_id;
14221
14222 if (device_param->device_vendor_id == VENDOR_ID_NV)
14223 {
14224 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14225 }
14226
14227 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14228 {
14229 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14230 }
14231 }
14232 }
14233
14234 /**
14235 * powertune on user request
14236 */
14237
14238 if (powertune_enable == 1)
14239 {
14240 hc_thread_mutex_lock (mux_adl);
14241
14242 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14243 {
14244 hc_device_param_t *device_param = &data.devices_param[device_id];
14245
14246 if (device_param->skipped) continue;
14247
14248 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14249 {
14250 /**
14251 * Temporary fix:
14252 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14253 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14254 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14255 * Driver / ADL bug?
14256 */
14257
14258 if (data.hm_device[device_id].od_version == 6)
14259 {
14260 int ADL_rc;
14261
14262 // check powertune capabilities first, if not available then skip device
14263
14264 int powertune_supported = 0;
14265
14266 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14267 {
14268 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14269
14270 return (-1);
14271 }
14272
14273 // first backup current value, we will restore it later
14274
14275 if (powertune_supported != 0)
14276 {
14277 // powercontrol settings
14278
14279 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14280
14281 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
14282 {
14283 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
14284 }
14285
14286 if (ADL_rc != ADL_OK)
14287 {
14288 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14289
14290 return (-1);
14291 }
14292
14293 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14294 {
14295 log_error ("ERROR: Failed to set new ADL PowerControl values");
14296
14297 return (-1);
14298 }
14299
14300 // clocks
14301
14302 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14303
14304 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14305
14306 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14307 {
14308 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14309
14310 return (-1);
14311 }
14312
14313 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14314
14315 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14316
14317 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
14318 {
14319 log_error ("ERROR: Failed to get ADL device capabilities");
14320
14321 return (-1);
14322 }
14323
14324 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14325 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14326
14327 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14328 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14329
14330 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14331 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14332
14333 // warning if profile has too low max values
14334
14335 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14336 {
14337 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14338 }
14339
14340 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14341 {
14342 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14343 }
14344
14345 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14346
14347 performance_state->iNumberOfPerformanceLevels = 2;
14348
14349 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14350 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14351 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14352 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14353
14354 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14355 {
14356 log_info ("ERROR: Failed to set ADL performance state");
14357
14358 return (-1);
14359 }
14360
14361 local_free (performance_state);
14362 }
14363
14364 // set powertune value only
14365
14366 if (powertune_supported != 0)
14367 {
14368 // powertune set
14369 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14370
14371 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14372 {
14373 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14374
14375 return (-1);
14376 }
14377
14378 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14379 {
14380 log_error ("ERROR: Failed to set new ADL PowerControl values");
14381
14382 return (-1);
14383 }
14384 }
14385 }
14386 }
14387
14388 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14389 {
14390 // first backup current value, we will restore it later
14391
14392 unsigned int limit;
14393
14394 int powertune_supported = 0;
14395
14396 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &limit) == NVML_SUCCESS)
14397 {
14398 powertune_supported = 1;
14399 }
14400
14401 // if backup worked, activate the maximum allowed
14402
14403 if (powertune_supported != 0)
14404 {
14405 unsigned int minLimit;
14406 unsigned int maxLimit;
14407
14408 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, &minLimit, &maxLimit) == NVML_SUCCESS)
14409 {
14410 if (maxLimit > 0)
14411 {
14412 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, maxLimit) == NVML_SUCCESS)
14413 {
14414 // now we can be sure we need to reset later
14415
14416 nvml_power_limit[device_id] = limit;
14417 }
14418 }
14419 }
14420 }
14421 }
14422 }
14423
14424 hc_thread_mutex_unlock (mux_adl);
14425 }
14426
14427 #endif // HAVE_HWMON
14428
14429 #ifdef DEBUG
14430 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14431 #endif
14432
14433 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14434
14435 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14436 {
14437 /**
14438 * host buffer
14439 */
14440
14441 hc_device_param_t *device_param = &data.devices_param[device_id];
14442
14443 if (device_param->skipped) continue;
14444
14445 /**
14446 * device properties
14447 */
14448
14449 const char *device_name_chksum = device_param->device_name_chksum;
14450 const u32 device_processors = device_param->device_processors;
14451 const u32 device_processor_cores = device_param->device_processor_cores;
14452
14453 /**
14454 * create context for each device
14455 */
14456
14457 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14458
14459 /**
14460 * create command-queue
14461 */
14462
14463 // not supported with NV
14464 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14465
14466 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14467
14468 /**
14469 * kernel threads: some algorithms need a fixed kernel-threads count
14470 * because of shared memory usage or bitslice
14471 * there needs to be some upper limit, otherwise there's too much overhead
14472 */
14473
14474 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14475
14476 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14477 {
14478 kernel_threads = KERNEL_THREADS_MAX_CPU;
14479 }
14480
14481 if (hash_mode == 1500) kernel_threads = 64; // DES
14482 if (hash_mode == 3000) kernel_threads = 64; // DES
14483 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14484 if (hash_mode == 7500) kernel_threads = 64; // RC4
14485 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14486 if (hash_mode == 9700) kernel_threads = 64; // RC4
14487 if (hash_mode == 9710) kernel_threads = 64; // RC4
14488 if (hash_mode == 9800) kernel_threads = 64; // RC4
14489 if (hash_mode == 9810) kernel_threads = 64; // RC4
14490 if (hash_mode == 10400) kernel_threads = 64; // RC4
14491 if (hash_mode == 10410) kernel_threads = 64; // RC4
14492 if (hash_mode == 10500) kernel_threads = 64; // RC4
14493 if (hash_mode == 13100) kernel_threads = 64; // RC4
14494
14495 device_param->kernel_threads = kernel_threads;
14496
14497 /**
14498 * create input buffers on device : calculate size of fixed memory buffers
14499 */
14500
14501 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14502 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14503
14504 device_param->size_root_css = size_root_css;
14505 device_param->size_markov_css = size_markov_css;
14506
14507 size_t size_results = sizeof (uint);
14508
14509 device_param->size_results = size_results;
14510
14511 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14512 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14513
14514 size_t size_plains = digests_cnt * sizeof (plain_t);
14515 size_t size_salts = salts_cnt * sizeof (salt_t);
14516 size_t size_esalts = salts_cnt * esalt_size;
14517
14518 device_param->size_plains = size_plains;
14519 device_param->size_digests = size_digests;
14520 device_param->size_shown = size_shown;
14521 device_param->size_salts = size_salts;
14522
14523 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14524 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14525 size_t size_tm = 32 * sizeof (bs_word_t);
14526
14527 // scryptV stuff
14528
14529 size_t size_scryptV = 1;
14530
14531 if ((hash_mode == 8900) || (hash_mode == 9300))
14532 {
14533 uint tmto_start = 0;
14534 uint tmto_stop = 10;
14535
14536 if (scrypt_tmto)
14537 {
14538 tmto_start = scrypt_tmto;
14539 }
14540 else
14541 {
14542 // in case the user did not specify the tmto manually
14543 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14544 // but set the lower end only in case the user has a device with too less memory
14545
14546 if (hash_mode == 8900)
14547 {
14548 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14549 {
14550 tmto_start = 1;
14551 }
14552 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14553 {
14554 tmto_start = 2;
14555 }
14556 }
14557 else if (hash_mode == 9300)
14558 {
14559 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14560 {
14561 tmto_start = 2;
14562 }
14563 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14564 {
14565 tmto_start = 2;
14566 }
14567 }
14568 }
14569
14570 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14571 {
14572 // TODO: in theory the following calculation needs to be done per salt, not global
14573 // we assume all hashes have the same scrypt settings
14574
14575 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14576
14577 size_scryptV /= 1 << tmto;
14578
14579 size_scryptV *= device_processors * device_processor_cores;
14580
14581 if (size_scryptV > device_param->device_maxmem_alloc)
14582 {
14583 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14584
14585 continue;
14586 }
14587
14588 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14589 {
14590 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14591 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14592 }
14593
14594 break;
14595 }
14596
14597 if (data.salts_buf[0].scrypt_phy == 0)
14598 {
14599 log_error ("ERROR: can't allocate enough device memory");
14600
14601 return -1;
14602 }
14603
14604 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14605 }
14606
14607 /**
14608 * some algorithms need a fixed kernel-loops count
14609 */
14610
14611 if (hash_mode == 1500)
14612 {
14613 const u32 kernel_loops_fixed = 1024;
14614
14615 device_param->kernel_loops_min = kernel_loops_fixed;
14616 device_param->kernel_loops_max = kernel_loops_fixed;
14617 }
14618
14619 if (hash_mode == 3000)
14620 {
14621 const u32 kernel_loops_fixed = 1024;
14622
14623 device_param->kernel_loops_min = kernel_loops_fixed;
14624 device_param->kernel_loops_max = kernel_loops_fixed;
14625 }
14626
14627 if (hash_mode == 8900)
14628 {
14629 const u32 kernel_loops_fixed = 1;
14630
14631 device_param->kernel_loops_min = kernel_loops_fixed;
14632 device_param->kernel_loops_max = kernel_loops_fixed;
14633 }
14634
14635 if (hash_mode == 9300)
14636 {
14637 const u32 kernel_loops_fixed = 1;
14638
14639 device_param->kernel_loops_min = kernel_loops_fixed;
14640 device_param->kernel_loops_max = kernel_loops_fixed;
14641 }
14642
14643 if (hash_mode == 12500)
14644 {
14645 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14646
14647 device_param->kernel_loops_min = kernel_loops_fixed;
14648 device_param->kernel_loops_max = kernel_loops_fixed;
14649 }
14650
14651 /**
14652 * some algorithms have a maximum kernel-loops count
14653 */
14654
14655 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14656 {
14657 u32 innerloop_cnt = 0;
14658
14659 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14660 {
14661 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14662 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14663 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14664 }
14665 else
14666 {
14667 innerloop_cnt = data.salts_buf[0].salt_iter;
14668 }
14669
14670 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14671 (innerloop_cnt <= device_param->kernel_loops_max))
14672 {
14673 device_param->kernel_loops_max = innerloop_cnt;
14674 }
14675 }
14676
14677 u32 kernel_accel_min = device_param->kernel_accel_min;
14678 u32 kernel_accel_max = device_param->kernel_accel_max;
14679
14680 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14681
14682 size_t size_pws = 4;
14683 size_t size_tmps = 4;
14684 size_t size_hooks = 4;
14685
14686 while (kernel_accel_max >= kernel_accel_min)
14687 {
14688 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14689
14690 // size_pws
14691
14692 size_pws = kernel_power_max * sizeof (pw_t);
14693
14694 // size_tmps
14695
14696 switch (hash_mode)
14697 {
14698 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14699 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14700 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14701 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14702 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14703 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14704 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14705 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14706 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14707 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14708 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14709 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14710 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14711 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14712 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14713 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14714 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14715 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14716 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14717 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14718 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14719 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14720 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14721 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14722 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14723 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14724 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14725 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14726 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14727 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14728 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14729 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14730 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14731 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14732 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14733 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14734 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14735 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14736 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14737 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14738 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14739 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14740 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14741 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14742 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14743 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14744 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14745 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14746 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14747 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14748 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14749 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14750 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14751 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14752 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14753 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14754 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14755 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14756 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14757 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14758 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14759 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14760 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14761 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14762 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14763 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14764 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14765 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14766 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14767 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14768 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14769 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14770 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14771 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14772 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14773 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14774 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14775 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14776 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14777 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14778 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14779 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14780 };
14781
14782 // size_hooks
14783
14784 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14785 {
14786 // none yet
14787 }
14788
14789 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14790 // if not, decrease amplifier and try again
14791
14792 int skip = 0;
14793
14794 const u64 size_total
14795 = bitmap_size
14796 + bitmap_size
14797 + bitmap_size
14798 + bitmap_size
14799 + bitmap_size
14800 + bitmap_size
14801 + bitmap_size
14802 + bitmap_size
14803 + size_bfs
14804 + size_combs
14805 + size_digests
14806 + size_esalts
14807 + size_hooks
14808 + size_markov_css
14809 + size_plains
14810 + size_pws
14811 + size_pws // not a bug
14812 + size_results
14813 + size_root_css
14814 + size_rules
14815 + size_rules_c
14816 + size_salts
14817 + size_scryptV
14818 + size_shown
14819 + size_tm
14820 + size_tmps;
14821
14822 // Don't ask me, ask AMD!
14823
14824 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14825 if (size_total > device_param->device_global_mem) skip = 1;
14826
14827 if (skip == 1)
14828 {
14829 kernel_accel_max--;
14830
14831 continue;
14832 }
14833
14834 break;
14835 }
14836
14837 /*
14838 if (kernel_accel_max == 0)
14839 {
14840 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14841
14842 return -1;
14843 }
14844 */
14845
14846 device_param->kernel_accel_min = kernel_accel_min;
14847 device_param->kernel_accel_max = kernel_accel_max;
14848
14849 /*
14850 if (kernel_accel_max < kernel_accel)
14851 {
14852 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14853
14854 device_param->kernel_accel = kernel_accel_max;
14855 }
14856 */
14857
14858 device_param->size_bfs = size_bfs;
14859 device_param->size_combs = size_combs;
14860 device_param->size_rules = size_rules;
14861 device_param->size_rules_c = size_rules_c;
14862 device_param->size_pws = size_pws;
14863 device_param->size_tmps = size_tmps;
14864 device_param->size_hooks = size_hooks;
14865
14866 /**
14867 * default building options
14868 */
14869
14870 char build_opts[1024] = { 0 };
14871
14872 // we don't have sm_* on vendors not NV but it doesn't matter
14873
14874 #if _WIN
14875 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);
14876 #else
14877 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);
14878 #endif
14879
14880 char build_opts_new[1024] = { 0 };
14881
14882 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);
14883
14884 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14885
14886 /*
14887 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14888 {
14889 // we do vectorizing much better than the auto-vectorizer
14890
14891 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14892
14893 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14894 }
14895 */
14896
14897 #ifdef DEBUG
14898 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14899 #endif
14900
14901 /**
14902 * main kernel
14903 */
14904
14905 {
14906 /**
14907 * kernel source filename
14908 */
14909
14910 char source_file[256] = { 0 };
14911
14912 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14913
14914 struct stat sst;
14915
14916 if (stat (source_file, &sst) == -1)
14917 {
14918 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14919
14920 return -1;
14921 }
14922
14923 /**
14924 * kernel cached filename
14925 */
14926
14927 char cached_file[256] = { 0 };
14928
14929 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14930
14931 int cached = 1;
14932
14933 struct stat cst;
14934
14935 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14936 {
14937 cached = 0;
14938 }
14939
14940 /**
14941 * kernel compile or load
14942 */
14943
14944 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14945
14946 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14947
14948 if (force_jit_compilation == -1)
14949 {
14950 if (cached == 0)
14951 {
14952 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14953
14954 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14955
14956 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14957
14958 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14959
14960 #ifdef DEBUG
14961 size_t build_log_size = 0;
14962
14963 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14964
14965 if (build_log_size > 1)
14966 {
14967 char *build_log = (char *) malloc (build_log_size + 1);
14968
14969 memset (build_log, 0, build_log_size + 1);
14970
14971 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14972
14973 puts (build_log);
14974
14975 free (build_log);
14976 }
14977 #endif
14978
14979 if (rc != 0)
14980 {
14981 device_param->skipped = true;
14982
14983 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14984
14985 continue;
14986 }
14987
14988 size_t binary_size;
14989
14990 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14991
14992 u8 *binary = (u8 *) mymalloc (binary_size);
14993
14994 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14995
14996 writeProgramBin (cached_file, binary, binary_size);
14997
14998 local_free (binary);
14999 }
15000 else
15001 {
15002 #ifdef DEBUG
15003 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15004 #endif
15005
15006 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15007
15008 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15009
15010 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15011 }
15012 }
15013 else
15014 {
15015 #ifdef DEBUG
15016 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15017 #endif
15018
15019 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15020
15021 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15022
15023 char build_opts_update[1024] = { 0 };
15024
15025 if (force_jit_compilation == 1500)
15026 {
15027 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15028 }
15029 else if (force_jit_compilation == 8900)
15030 {
15031 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);
15032 }
15033 else
15034 {
15035 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15036 }
15037
15038 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15039
15040 #ifdef DEBUG
15041 size_t build_log_size = 0;
15042
15043 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15044
15045 if (build_log_size > 1)
15046 {
15047 char *build_log = (char *) malloc (build_log_size + 1);
15048
15049 memset (build_log, 0, build_log_size + 1);
15050
15051 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15052
15053 puts (build_log);
15054
15055 free (build_log);
15056 }
15057 #endif
15058
15059 if (rc != 0)
15060 {
15061 device_param->skipped = true;
15062
15063 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15064 }
15065 }
15066
15067 local_free (kernel_lengths);
15068 local_free (kernel_sources[0]);
15069 local_free (kernel_sources);
15070 }
15071
15072 /**
15073 * word generator kernel
15074 */
15075
15076 if (attack_mode != ATTACK_MODE_STRAIGHT)
15077 {
15078 /**
15079 * kernel mp source filename
15080 */
15081
15082 char source_file[256] = { 0 };
15083
15084 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15085
15086 struct stat sst;
15087
15088 if (stat (source_file, &sst) == -1)
15089 {
15090 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15091
15092 return -1;
15093 }
15094
15095 /**
15096 * kernel mp cached filename
15097 */
15098
15099 char cached_file[256] = { 0 };
15100
15101 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15102
15103 int cached = 1;
15104
15105 struct stat cst;
15106
15107 if (stat (cached_file, &cst) == -1)
15108 {
15109 cached = 0;
15110 }
15111
15112 /**
15113 * kernel compile or load
15114 */
15115
15116 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15117
15118 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15119
15120 if (cached == 0)
15121 {
15122 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15123 if (quiet == 0) log_info ("");
15124
15125 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15126
15127 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15128
15129 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15130
15131 if (rc != 0)
15132 {
15133 device_param->skipped = true;
15134
15135 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15136
15137 continue;
15138 }
15139
15140 size_t binary_size;
15141
15142 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15143
15144 u8 *binary = (u8 *) mymalloc (binary_size);
15145
15146 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15147
15148 writeProgramBin (cached_file, binary, binary_size);
15149
15150 local_free (binary);
15151 }
15152 else
15153 {
15154 #ifdef DEBUG
15155 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15156 #endif
15157
15158 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15159
15160 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15161
15162 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15163 }
15164
15165 local_free (kernel_lengths);
15166 local_free (kernel_sources[0]);
15167 local_free (kernel_sources);
15168 }
15169
15170 /**
15171 * amplifier kernel
15172 */
15173
15174 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15175 {
15176
15177 }
15178 else
15179 {
15180 /**
15181 * kernel amp source filename
15182 */
15183
15184 char source_file[256] = { 0 };
15185
15186 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15187
15188 struct stat sst;
15189
15190 if (stat (source_file, &sst) == -1)
15191 {
15192 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15193
15194 return -1;
15195 }
15196
15197 /**
15198 * kernel amp cached filename
15199 */
15200
15201 char cached_file[256] = { 0 };
15202
15203 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15204
15205 int cached = 1;
15206
15207 struct stat cst;
15208
15209 if (stat (cached_file, &cst) == -1)
15210 {
15211 cached = 0;
15212 }
15213
15214 /**
15215 * kernel compile or load
15216 */
15217
15218 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15219
15220 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15221
15222 if (cached == 0)
15223 {
15224 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15225 if (quiet == 0) log_info ("");
15226
15227 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15228
15229 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15230
15231 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15232
15233 if (rc != 0)
15234 {
15235 device_param->skipped = true;
15236
15237 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15238
15239 continue;
15240 }
15241
15242 size_t binary_size;
15243
15244 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15245
15246 u8 *binary = (u8 *) mymalloc (binary_size);
15247
15248 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15249
15250 writeProgramBin (cached_file, binary, binary_size);
15251
15252 local_free (binary);
15253 }
15254 else
15255 {
15256 #ifdef DEBUG
15257 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15258 #endif
15259
15260 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15261
15262 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15263
15264 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15265 }
15266
15267 local_free (kernel_lengths);
15268 local_free (kernel_sources[0]);
15269 local_free (kernel_sources);
15270 }
15271
15272 // some algorithm collide too fast, make that impossible
15273
15274 if (benchmark == 1)
15275 {
15276 ((uint *) digests_buf)[0] = -1;
15277 ((uint *) digests_buf)[1] = -1;
15278 ((uint *) digests_buf)[2] = -1;
15279 ((uint *) digests_buf)[3] = -1;
15280 }
15281
15282 /**
15283 * global buffers
15284 */
15285
15286 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15287 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15288 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15289 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15290 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15291 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15292 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15293 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15294 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15295 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15296 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15297 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15298 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15299 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15300 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15301 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15302 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15303 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15304
15305 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);
15306 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);
15307 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);
15308 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);
15309 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);
15310 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);
15311 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);
15312 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);
15313 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15314 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15315 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15316
15317 /**
15318 * special buffers
15319 */
15320
15321 if (attack_kern == ATTACK_KERN_STRAIGHT)
15322 {
15323 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15324 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15325
15326 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15327 }
15328 else if (attack_kern == ATTACK_KERN_COMBI)
15329 {
15330 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15331 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15332 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15333 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15334 }
15335 else if (attack_kern == ATTACK_KERN_BF)
15336 {
15337 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15338 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15339 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15340 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15341 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15342 }
15343
15344 if (size_esalts)
15345 {
15346 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15347
15348 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15349 }
15350
15351 /**
15352 * main host data
15353 */
15354
15355 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15356
15357 device_param->pws_buf = pws_buf;
15358
15359 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15360
15361 device_param->combs_buf = combs_buf;
15362
15363 void *hooks_buf = mymalloc (size_hooks);
15364
15365 device_param->hooks_buf = hooks_buf;
15366
15367 /**
15368 * kernel args
15369 */
15370
15371 device_param->kernel_params_buf32[21] = bitmap_mask;
15372 device_param->kernel_params_buf32[22] = bitmap_shift1;
15373 device_param->kernel_params_buf32[23] = bitmap_shift2;
15374 device_param->kernel_params_buf32[24] = 0; // salt_pos
15375 device_param->kernel_params_buf32[25] = 0; // loop_pos
15376 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15377 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15378 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15379 device_param->kernel_params_buf32[29] = 0; // digests_offset
15380 device_param->kernel_params_buf32[30] = 0; // combs_mode
15381 device_param->kernel_params_buf32[31] = 0; // gid_max
15382
15383 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15384 ? &device_param->d_pws_buf
15385 : &device_param->d_pws_amp_buf;
15386 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15387 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15388 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15389 device_param->kernel_params[ 4] = &device_param->d_tmps;
15390 device_param->kernel_params[ 5] = &device_param->d_hooks;
15391 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15392 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15393 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15394 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15395 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15396 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15397 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15398 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15399 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15400 device_param->kernel_params[15] = &device_param->d_digests_buf;
15401 device_param->kernel_params[16] = &device_param->d_digests_shown;
15402 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15403 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15404 device_param->kernel_params[19] = &device_param->d_result;
15405 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15406 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15407 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15408 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15409 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15410 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15411 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15412 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15413 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15414 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15415 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15416 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15417
15418 device_param->kernel_params_mp_buf64[3] = 0;
15419 device_param->kernel_params_mp_buf32[4] = 0;
15420 device_param->kernel_params_mp_buf32[5] = 0;
15421 device_param->kernel_params_mp_buf32[6] = 0;
15422 device_param->kernel_params_mp_buf32[7] = 0;
15423 device_param->kernel_params_mp_buf32[8] = 0;
15424
15425 device_param->kernel_params_mp[0] = NULL;
15426 device_param->kernel_params_mp[1] = NULL;
15427 device_param->kernel_params_mp[2] = NULL;
15428 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15429 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15430 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15431 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15432 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15433 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15434
15435 device_param->kernel_params_mp_l_buf64[3] = 0;
15436 device_param->kernel_params_mp_l_buf32[4] = 0;
15437 device_param->kernel_params_mp_l_buf32[5] = 0;
15438 device_param->kernel_params_mp_l_buf32[6] = 0;
15439 device_param->kernel_params_mp_l_buf32[7] = 0;
15440 device_param->kernel_params_mp_l_buf32[8] = 0;
15441 device_param->kernel_params_mp_l_buf32[9] = 0;
15442
15443 device_param->kernel_params_mp_l[0] = NULL;
15444 device_param->kernel_params_mp_l[1] = NULL;
15445 device_param->kernel_params_mp_l[2] = NULL;
15446 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15447 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15448 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15449 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15450 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15451 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15452 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15453
15454 device_param->kernel_params_mp_r_buf64[3] = 0;
15455 device_param->kernel_params_mp_r_buf32[4] = 0;
15456 device_param->kernel_params_mp_r_buf32[5] = 0;
15457 device_param->kernel_params_mp_r_buf32[6] = 0;
15458 device_param->kernel_params_mp_r_buf32[7] = 0;
15459 device_param->kernel_params_mp_r_buf32[8] = 0;
15460
15461 device_param->kernel_params_mp_r[0] = NULL;
15462 device_param->kernel_params_mp_r[1] = NULL;
15463 device_param->kernel_params_mp_r[2] = NULL;
15464 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15465 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15466 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15467 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15468 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15469 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15470
15471 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15472 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15473
15474 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15475 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15476 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15477 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15478 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15479 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15480 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15481
15482 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15483 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15484
15485 device_param->kernel_params_memset_buf32[1] = 0; // value
15486 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15487
15488 device_param->kernel_params_memset[0] = NULL;
15489 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15490 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15491
15492 /**
15493 * kernel name
15494 */
15495
15496 size_t kernel_wgs_tmp;
15497
15498 char kernel_name[64] = { 0 };
15499
15500 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15501 {
15502 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15503 {
15504 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15505
15506 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15507
15508 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15509
15510 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15511
15512 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15513
15514 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15515 }
15516 else
15517 {
15518 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15519
15520 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15521
15522 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15523
15524 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15525
15526 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15527
15528 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15529 }
15530
15531 if (data.attack_mode == ATTACK_MODE_BF)
15532 {
15533 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15534 {
15535 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15536
15537 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15538
15539 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);
15540 }
15541 }
15542 }
15543 else
15544 {
15545 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15546
15547 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15548
15549 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15550
15551 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15552
15553 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15554
15555 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15556
15557 if (opts_type & OPTS_TYPE_HOOK12)
15558 {
15559 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15560
15561 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15562
15563 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);
15564 }
15565
15566 if (opts_type & OPTS_TYPE_HOOK23)
15567 {
15568 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15569
15570 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15571
15572 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);
15573 }
15574 }
15575
15576 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);
15577 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);
15578 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);
15579
15580 for (uint i = 0; i <= 20; i++)
15581 {
15582 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15583 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15584 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15585
15586 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15587 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15588 }
15589
15590 for (uint i = 21; i <= 31; i++)
15591 {
15592 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15593 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15594 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15595
15596 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15597 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15598 }
15599
15600 // GPU memset
15601
15602 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15603
15604 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);
15605
15606 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15607 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15608 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15609
15610 // MP start
15611
15612 if (attack_mode == ATTACK_MODE_BF)
15613 {
15614 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15615 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15616
15617 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);
15618 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);
15619
15620 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15621 {
15622 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15623 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15624 }
15625 }
15626 else if (attack_mode == ATTACK_MODE_HYBRID1)
15627 {
15628 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15629
15630 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);
15631 }
15632 else if (attack_mode == ATTACK_MODE_HYBRID2)
15633 {
15634 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15635
15636 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);
15637 }
15638
15639 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15640 {
15641 // nothing to do
15642 }
15643 else
15644 {
15645 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15646
15647 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);
15648 }
15649
15650 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15651 {
15652 // nothing to do
15653 }
15654 else
15655 {
15656 for (uint i = 0; i < 5; i++)
15657 {
15658 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15659 }
15660
15661 for (uint i = 5; i < 7; i++)
15662 {
15663 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15664 }
15665 }
15666
15667 // maybe this has been updated by clGetKernelWorkGroupInfo()
15668 // value can only be decreased, so we don't need to reallocate buffers
15669
15670 device_param->kernel_threads = kernel_threads;
15671
15672 // zero some data buffers
15673
15674 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15675 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15676 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15677 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15678 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15679 run_kernel_bzero (device_param, device_param->d_result, size_results);
15680
15681 /**
15682 * special buffers
15683 */
15684
15685 if (attack_kern == ATTACK_KERN_STRAIGHT)
15686 {
15687 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15688 }
15689 else if (attack_kern == ATTACK_KERN_COMBI)
15690 {
15691 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15692 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15693 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15694 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15695 }
15696 else if (attack_kern == ATTACK_KERN_BF)
15697 {
15698 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15699 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15700 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15701 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15702 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15703 }
15704
15705 #if defined(HAVE_HWMON)
15706
15707 /**
15708 * Store thermal target temperature so we can send a notice to user
15709 */
15710
15711 if (gpu_temp_disable == 0)
15712 {
15713 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15714 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15715
15716 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15717 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15718
15719 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15720 }
15721
15722 /**
15723 * Store initial fanspeed if gpu_temp_retain is enabled
15724 */
15725
15726 if (gpu_temp_disable == 0)
15727 {
15728 if (gpu_temp_retain != 0)
15729 {
15730 hc_thread_mutex_lock (mux_adl);
15731
15732 if (data.hm_device[device_id].fan_get_supported == 1)
15733 {
15734 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15735 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15736
15737 temp_retain_fanspeed_value[device_id] = fanspeed;
15738 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15739
15740 // we also set it to tell the OS we take control over the fan and it's automatic controller
15741 // if it was set to automatic. we do not control user-defined fanspeeds.
15742
15743 if (fanpolicy == 1)
15744 {
15745 data.hm_device[device_id].fan_set_supported = 1;
15746
15747 int rc = -1;
15748
15749 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15750 {
15751 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 1);
15752 }
15753 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15754 {
15755
15756 }
15757
15758 if (rc == 0)
15759 {
15760 data.hm_device[device_id].fan_set_supported = 1;
15761 }
15762 else
15763 {
15764 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15765
15766 data.hm_device[device_id].fan_set_supported = 0;
15767 }
15768 }
15769 else
15770 {
15771 data.hm_device[device_id].fan_set_supported = 0;
15772 }
15773 }
15774
15775 hc_thread_mutex_unlock (mux_adl);
15776 }
15777 }
15778
15779 #endif // HAVE_HWMON
15780 }
15781
15782 if (data.quiet == 0) log_info_nn ("");
15783
15784 /**
15785 * In benchmark-mode, inform user which algorithm is checked
15786 */
15787
15788 if (benchmark == 1)
15789 {
15790 if (machine_readable == 0)
15791 {
15792 quiet = 0;
15793
15794 data.quiet = quiet;
15795
15796 char *hash_type = strhashtype (data.hash_mode); // not a bug
15797
15798 log_info ("Hashtype: %s", hash_type);
15799 log_info ("");
15800 }
15801 }
15802
15803 /**
15804 * keep track of the progress
15805 */
15806
15807 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15808 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15809 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15810
15811 /**
15812 * open filehandles
15813 */
15814
15815 #if _WIN
15816 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15817 {
15818 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15819
15820 return (-1);
15821 }
15822
15823 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15824 {
15825 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15826
15827 return (-1);
15828 }
15829
15830 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15831 {
15832 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15833
15834 return (-1);
15835 }
15836 #endif
15837
15838 /**
15839 * dictionary pad
15840 */
15841
15842 segment_size *= (1024 * 1024);
15843
15844 data.segment_size = segment_size;
15845
15846 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15847
15848 wl_data->buf = (char *) mymalloc (segment_size);
15849 wl_data->avail = segment_size;
15850 wl_data->incr = segment_size;
15851 wl_data->cnt = 0;
15852 wl_data->pos = 0;
15853
15854 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15855
15856 data.wordlist_mode = wordlist_mode;
15857
15858 cs_t *css_buf = NULL;
15859 uint css_cnt = 0;
15860 uint dictcnt = 0;
15861 uint maskcnt = 1;
15862 char **masks = NULL;
15863 char **dictfiles = NULL;
15864
15865 uint mask_from_file = 0;
15866
15867 if (attack_mode == ATTACK_MODE_STRAIGHT)
15868 {
15869 if (wordlist_mode == WL_MODE_FILE)
15870 {
15871 int wls_left = myargc - (optind + 1);
15872
15873 for (int i = 0; i < wls_left; i++)
15874 {
15875 char *l0_filename = myargv[optind + 1 + i];
15876
15877 struct stat l0_stat;
15878
15879 if (stat (l0_filename, &l0_stat) == -1)
15880 {
15881 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15882
15883 return (-1);
15884 }
15885
15886 uint is_dir = S_ISDIR (l0_stat.st_mode);
15887
15888 if (is_dir == 0)
15889 {
15890 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15891
15892 dictcnt++;
15893
15894 dictfiles[dictcnt - 1] = l0_filename;
15895 }
15896 else
15897 {
15898 // do not allow --keyspace w/ a directory
15899
15900 if (keyspace == 1)
15901 {
15902 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15903
15904 return (-1);
15905 }
15906
15907 char **dictionary_files = NULL;
15908
15909 dictionary_files = scan_directory (l0_filename);
15910
15911 if (dictionary_files != NULL)
15912 {
15913 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15914
15915 for (int d = 0; dictionary_files[d] != NULL; d++)
15916 {
15917 char *l1_filename = dictionary_files[d];
15918
15919 struct stat l1_stat;
15920
15921 if (stat (l1_filename, &l1_stat) == -1)
15922 {
15923 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15924
15925 return (-1);
15926 }
15927
15928 if (S_ISREG (l1_stat.st_mode))
15929 {
15930 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15931
15932 dictcnt++;
15933
15934 dictfiles[dictcnt - 1] = strdup (l1_filename);
15935 }
15936 }
15937 }
15938
15939 local_free (dictionary_files);
15940 }
15941 }
15942
15943 if (dictcnt < 1)
15944 {
15945 log_error ("ERROR: No usable dictionary file found.");
15946
15947 return (-1);
15948 }
15949 }
15950 else if (wordlist_mode == WL_MODE_STDIN)
15951 {
15952 dictcnt = 1;
15953 }
15954 }
15955 else if (attack_mode == ATTACK_MODE_COMBI)
15956 {
15957 // display
15958
15959 char *dictfile1 = myargv[optind + 1 + 0];
15960 char *dictfile2 = myargv[optind + 1 + 1];
15961
15962 // find the bigger dictionary and use as base
15963
15964 FILE *fp1 = NULL;
15965 FILE *fp2 = NULL;
15966
15967 struct stat tmp_stat;
15968
15969 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15970 {
15971 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15972
15973 return (-1);
15974 }
15975
15976 if (stat (dictfile1, &tmp_stat) == -1)
15977 {
15978 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15979
15980 fclose (fp1);
15981
15982 return (-1);
15983 }
15984
15985 if (S_ISDIR (tmp_stat.st_mode))
15986 {
15987 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15988
15989 fclose (fp1);
15990
15991 return (-1);
15992 }
15993
15994 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15995 {
15996 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15997
15998 fclose (fp1);
15999
16000 return (-1);
16001 }
16002
16003 if (stat (dictfile2, &tmp_stat) == -1)
16004 {
16005 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16006
16007 fclose (fp1);
16008 fclose (fp2);
16009
16010 return (-1);
16011 }
16012
16013 if (S_ISDIR (tmp_stat.st_mode))
16014 {
16015 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16016
16017 fclose (fp1);
16018 fclose (fp2);
16019
16020 return (-1);
16021 }
16022
16023 data.combs_cnt = 1;
16024
16025 data.quiet = 1;
16026
16027 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16028
16029 data.quiet = quiet;
16030
16031 if (words1_cnt == 0)
16032 {
16033 log_error ("ERROR: %s: empty file", dictfile1);
16034
16035 fclose (fp1);
16036 fclose (fp2);
16037
16038 return (-1);
16039 }
16040
16041 data.combs_cnt = 1;
16042
16043 data.quiet = 1;
16044
16045 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16046
16047 data.quiet = quiet;
16048
16049 if (words2_cnt == 0)
16050 {
16051 log_error ("ERROR: %s: empty file", dictfile2);
16052
16053 fclose (fp1);
16054 fclose (fp2);
16055
16056 return (-1);
16057 }
16058
16059 fclose (fp1);
16060 fclose (fp2);
16061
16062 data.dictfile = dictfile1;
16063 data.dictfile2 = dictfile2;
16064
16065 if (words1_cnt >= words2_cnt)
16066 {
16067 data.combs_cnt = words2_cnt;
16068 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16069
16070 dictfiles = &data.dictfile;
16071
16072 dictcnt = 1;
16073 }
16074 else
16075 {
16076 data.combs_cnt = words1_cnt;
16077 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16078
16079 dictfiles = &data.dictfile2;
16080
16081 dictcnt = 1;
16082
16083 // we also have to switch wordlist related rules!
16084
16085 char *tmpc = data.rule_buf_l;
16086
16087 data.rule_buf_l = data.rule_buf_r;
16088 data.rule_buf_r = tmpc;
16089
16090 int tmpi = data.rule_len_l;
16091
16092 data.rule_len_l = data.rule_len_r;
16093 data.rule_len_r = tmpi;
16094 }
16095 }
16096 else if (attack_mode == ATTACK_MODE_BF)
16097 {
16098 char *mask = NULL;
16099
16100 maskcnt = 0;
16101
16102 if (benchmark == 0)
16103 {
16104 mask = myargv[optind + 1];
16105
16106 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16107
16108 if ((optind + 2) <= myargc)
16109 {
16110 struct stat file_stat;
16111
16112 if (stat (mask, &file_stat) == -1)
16113 {
16114 maskcnt = 1;
16115
16116 masks[maskcnt - 1] = mystrdup (mask);
16117 }
16118 else
16119 {
16120 int wls_left = myargc - (optind + 1);
16121
16122 uint masks_avail = INCR_MASKS;
16123
16124 for (int i = 0; i < wls_left; i++)
16125 {
16126 if (i != 0)
16127 {
16128 mask = myargv[optind + 1 + i];
16129
16130 if (stat (mask, &file_stat) == -1)
16131 {
16132 log_error ("ERROR: %s: %s", mask, strerror (errno));
16133
16134 return (-1);
16135 }
16136 }
16137
16138 uint is_file = S_ISREG (file_stat.st_mode);
16139
16140 if (is_file == 1)
16141 {
16142 FILE *mask_fp;
16143
16144 if ((mask_fp = fopen (mask, "r")) == NULL)
16145 {
16146 log_error ("ERROR: %s: %s", mask, strerror (errno));
16147
16148 return (-1);
16149 }
16150
16151 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16152
16153 while (!feof (mask_fp))
16154 {
16155 memset (line_buf, 0, HCBUFSIZ);
16156
16157 int line_len = fgetl (mask_fp, line_buf);
16158
16159 if (line_len == 0) continue;
16160
16161 if (line_buf[0] == '#') continue;
16162
16163 if (masks_avail == maskcnt)
16164 {
16165 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16166
16167 masks_avail += INCR_MASKS;
16168 }
16169
16170 masks[maskcnt] = mystrdup (line_buf);
16171
16172 maskcnt++;
16173 }
16174
16175 myfree (line_buf);
16176
16177 fclose (mask_fp);
16178 }
16179 else
16180 {
16181 log_error ("ERROR: %s: unsupported file-type", mask);
16182
16183 return (-1);
16184 }
16185 }
16186
16187 mask_from_file = 1;
16188 }
16189 }
16190 else
16191 {
16192 custom_charset_1 = (char *) "?l?d?u";
16193 custom_charset_2 = (char *) "?l?d";
16194 custom_charset_3 = (char *) "?l?d*!$@_";
16195
16196 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16197 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16198 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16199
16200 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16201
16202 wordlist_mode = WL_MODE_MASK;
16203
16204 data.wordlist_mode = wordlist_mode;
16205
16206 increment = 1;
16207
16208 maskcnt = 1;
16209 }
16210 }
16211 else
16212 {
16213 /**
16214 * generate full masks and charsets
16215 */
16216
16217 masks = (char **) mymalloc (sizeof (char *));
16218
16219 switch (hash_mode)
16220 {
16221 case 1731: pw_min = 5;
16222 pw_max = 5;
16223 mask = mystrdup ("?b?b?b?b?b");
16224 break;
16225 case 12500: pw_min = 5;
16226 pw_max = 5;
16227 mask = mystrdup ("?b?b?b?b?b");
16228 break;
16229 default: pw_min = 7;
16230 pw_max = 7;
16231 mask = mystrdup ("?b?b?b?b?b?b?b");
16232 break;
16233 }
16234
16235 maskcnt = 1;
16236
16237 masks[maskcnt - 1] = mystrdup (mask);
16238
16239 wordlist_mode = WL_MODE_MASK;
16240
16241 data.wordlist_mode = wordlist_mode;
16242
16243 increment = 1;
16244 }
16245
16246 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16247
16248 if (increment)
16249 {
16250 if (increment_min > pw_min) pw_min = increment_min;
16251
16252 if (increment_max < pw_max) pw_max = increment_max;
16253 }
16254 }
16255 else if (attack_mode == ATTACK_MODE_HYBRID1)
16256 {
16257 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16258
16259 // display
16260
16261 char *mask = myargv[myargc - 1];
16262
16263 maskcnt = 0;
16264
16265 masks = (char **) mymalloc (1 * sizeof (char *));
16266
16267 // mod
16268
16269 struct stat file_stat;
16270
16271 if (stat (mask, &file_stat) == -1)
16272 {
16273 maskcnt = 1;
16274
16275 masks[maskcnt - 1] = mystrdup (mask);
16276 }
16277 else
16278 {
16279 uint is_file = S_ISREG (file_stat.st_mode);
16280
16281 if (is_file == 1)
16282 {
16283 FILE *mask_fp;
16284
16285 if ((mask_fp = fopen (mask, "r")) == NULL)
16286 {
16287 log_error ("ERROR: %s: %s", mask, strerror (errno));
16288
16289 return (-1);
16290 }
16291
16292 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16293
16294 uint masks_avail = 1;
16295
16296 while (!feof (mask_fp))
16297 {
16298 memset (line_buf, 0, HCBUFSIZ);
16299
16300 int line_len = fgetl (mask_fp, line_buf);
16301
16302 if (line_len == 0) continue;
16303
16304 if (line_buf[0] == '#') continue;
16305
16306 if (masks_avail == maskcnt)
16307 {
16308 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16309
16310 masks_avail += INCR_MASKS;
16311 }
16312
16313 masks[maskcnt] = mystrdup (line_buf);
16314
16315 maskcnt++;
16316 }
16317
16318 myfree (line_buf);
16319
16320 fclose (mask_fp);
16321
16322 mask_from_file = 1;
16323 }
16324 else
16325 {
16326 maskcnt = 1;
16327
16328 masks[maskcnt - 1] = mystrdup (mask);
16329 }
16330 }
16331
16332 // base
16333
16334 int wls_left = myargc - (optind + 2);
16335
16336 for (int i = 0; i < wls_left; i++)
16337 {
16338 char *filename = myargv[optind + 1 + i];
16339
16340 struct stat file_stat;
16341
16342 if (stat (filename, &file_stat) == -1)
16343 {
16344 log_error ("ERROR: %s: %s", filename, strerror (errno));
16345
16346 return (-1);
16347 }
16348
16349 uint is_dir = S_ISDIR (file_stat.st_mode);
16350
16351 if (is_dir == 0)
16352 {
16353 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16354
16355 dictcnt++;
16356
16357 dictfiles[dictcnt - 1] = filename;
16358 }
16359 else
16360 {
16361 // do not allow --keyspace w/ a directory
16362
16363 if (keyspace == 1)
16364 {
16365 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16366
16367 return (-1);
16368 }
16369
16370 char **dictionary_files = NULL;
16371
16372 dictionary_files = scan_directory (filename);
16373
16374 if (dictionary_files != NULL)
16375 {
16376 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16377
16378 for (int d = 0; dictionary_files[d] != NULL; d++)
16379 {
16380 char *l1_filename = dictionary_files[d];
16381
16382 struct stat l1_stat;
16383
16384 if (stat (l1_filename, &l1_stat) == -1)
16385 {
16386 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16387
16388 return (-1);
16389 }
16390
16391 if (S_ISREG (l1_stat.st_mode))
16392 {
16393 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16394
16395 dictcnt++;
16396
16397 dictfiles[dictcnt - 1] = strdup (l1_filename);
16398 }
16399 }
16400 }
16401
16402 local_free (dictionary_files);
16403 }
16404 }
16405
16406 if (dictcnt < 1)
16407 {
16408 log_error ("ERROR: No usable dictionary file found.");
16409
16410 return (-1);
16411 }
16412
16413 if (increment)
16414 {
16415 maskcnt = 0;
16416
16417 uint mask_min = increment_min; // we can't reject smaller masks here
16418 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16419
16420 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16421 {
16422 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16423
16424 if (cur_mask == NULL) break;
16425
16426 masks[maskcnt] = cur_mask;
16427
16428 maskcnt++;
16429
16430 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16431 }
16432 }
16433 }
16434 else if (attack_mode == ATTACK_MODE_HYBRID2)
16435 {
16436 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16437
16438 // display
16439
16440 char *mask = myargv[optind + 1 + 0];
16441
16442 maskcnt = 0;
16443
16444 masks = (char **) mymalloc (1 * sizeof (char *));
16445
16446 // mod
16447
16448 struct stat file_stat;
16449
16450 if (stat (mask, &file_stat) == -1)
16451 {
16452 maskcnt = 1;
16453
16454 masks[maskcnt - 1] = mystrdup (mask);
16455 }
16456 else
16457 {
16458 uint is_file = S_ISREG (file_stat.st_mode);
16459
16460 if (is_file == 1)
16461 {
16462 FILE *mask_fp;
16463
16464 if ((mask_fp = fopen (mask, "r")) == NULL)
16465 {
16466 log_error ("ERROR: %s: %s", mask, strerror (errno));
16467
16468 return (-1);
16469 }
16470
16471 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16472
16473 uint masks_avail = 1;
16474
16475 while (!feof (mask_fp))
16476 {
16477 memset (line_buf, 0, HCBUFSIZ);
16478
16479 int line_len = fgetl (mask_fp, line_buf);
16480
16481 if (line_len == 0) continue;
16482
16483 if (line_buf[0] == '#') continue;
16484
16485 if (masks_avail == maskcnt)
16486 {
16487 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16488
16489 masks_avail += INCR_MASKS;
16490 }
16491
16492 masks[maskcnt] = mystrdup (line_buf);
16493
16494 maskcnt++;
16495 }
16496
16497 myfree (line_buf);
16498
16499 fclose (mask_fp);
16500
16501 mask_from_file = 1;
16502 }
16503 else
16504 {
16505 maskcnt = 1;
16506
16507 masks[maskcnt - 1] = mystrdup (mask);
16508 }
16509 }
16510
16511 // base
16512
16513 int wls_left = myargc - (optind + 2);
16514
16515 for (int i = 0; i < wls_left; i++)
16516 {
16517 char *filename = myargv[optind + 2 + i];
16518
16519 struct stat file_stat;
16520
16521 if (stat (filename, &file_stat) == -1)
16522 {
16523 log_error ("ERROR: %s: %s", filename, strerror (errno));
16524
16525 return (-1);
16526 }
16527
16528 uint is_dir = S_ISDIR (file_stat.st_mode);
16529
16530 if (is_dir == 0)
16531 {
16532 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16533
16534 dictcnt++;
16535
16536 dictfiles[dictcnt - 1] = filename;
16537 }
16538 else
16539 {
16540 // do not allow --keyspace w/ a directory
16541
16542 if (keyspace == 1)
16543 {
16544 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16545
16546 return (-1);
16547 }
16548
16549 char **dictionary_files = NULL;
16550
16551 dictionary_files = scan_directory (filename);
16552
16553 if (dictionary_files != NULL)
16554 {
16555 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16556
16557 for (int d = 0; dictionary_files[d] != NULL; d++)
16558 {
16559 char *l1_filename = dictionary_files[d];
16560
16561 struct stat l1_stat;
16562
16563 if (stat (l1_filename, &l1_stat) == -1)
16564 {
16565 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16566
16567 return (-1);
16568 }
16569
16570 if (S_ISREG (l1_stat.st_mode))
16571 {
16572 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16573
16574 dictcnt++;
16575
16576 dictfiles[dictcnt - 1] = strdup (l1_filename);
16577 }
16578 }
16579 }
16580
16581 local_free (dictionary_files);
16582 }
16583 }
16584
16585 if (dictcnt < 1)
16586 {
16587 log_error ("ERROR: No usable dictionary file found.");
16588
16589 return (-1);
16590 }
16591
16592 if (increment)
16593 {
16594 maskcnt = 0;
16595
16596 uint mask_min = increment_min; // we can't reject smaller masks here
16597 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16598
16599 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16600 {
16601 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16602
16603 if (cur_mask == NULL) break;
16604
16605 masks[maskcnt] = cur_mask;
16606
16607 maskcnt++;
16608
16609 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16610 }
16611 }
16612 }
16613
16614 data.pw_min = pw_min;
16615 data.pw_max = pw_max;
16616
16617 /**
16618 * weak hash check
16619 */
16620
16621 if (weak_hash_threshold >= salts_cnt)
16622 {
16623 hc_device_param_t *device_param = NULL;
16624
16625 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16626 {
16627 device_param = &data.devices_param[device_id];
16628
16629 if (device_param->skipped) continue;
16630
16631 break;
16632 }
16633
16634 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16635
16636 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16637 {
16638 weak_hash_check (device_param, salt_pos);
16639 }
16640
16641 // Display hack, guarantee that there is at least one \r before real start
16642
16643 //if (data.quiet == 0) log_info ("");
16644 }
16645
16646 /**
16647 * status and monitor threads
16648 */
16649
16650 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16651
16652 hc_thread_t i_thread = 0;
16653
16654 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16655 {
16656 hc_thread_create (i_thread, thread_keypress, &benchmark);
16657 }
16658
16659 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16660
16661 uint ni_threads_cnt = 0;
16662
16663 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16664
16665 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16666
16667 ni_threads_cnt++;
16668
16669 /**
16670 * Outfile remove
16671 */
16672
16673 if (keyspace == 0)
16674 {
16675 if (outfile_check_timer != 0)
16676 {
16677 if (data.outfile_check_directory != NULL)
16678 {
16679 if ((hash_mode != 5200) &&
16680 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16681 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16682 (hash_mode != 9000))
16683 {
16684 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16685
16686 ni_threads_cnt++;
16687 }
16688 else
16689 {
16690 outfile_check_timer = 0;
16691 }
16692 }
16693 else
16694 {
16695 outfile_check_timer = 0;
16696 }
16697 }
16698 }
16699
16700 /**
16701 * Inform the user if we got some hashes remove because of the pot file remove feature
16702 */
16703
16704 if (data.quiet == 0)
16705 {
16706 if (potfile_remove_cracks > 0)
16707 {
16708 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16709 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16710 }
16711 }
16712
16713 data.outfile_check_timer = outfile_check_timer;
16714
16715 /**
16716 * main loop
16717 */
16718
16719 char **induction_dictionaries = NULL;
16720
16721 int induction_dictionaries_cnt = 0;
16722
16723 hcstat_table_t *root_table_buf = NULL;
16724 hcstat_table_t *markov_table_buf = NULL;
16725
16726 uint initial_restore_done = 0;
16727
16728 data.maskcnt = maskcnt;
16729
16730 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16731 {
16732 if (data.devices_status == STATUS_CRACKED) break;
16733
16734 data.devices_status = STATUS_INIT;
16735
16736 if (maskpos > rd->maskpos)
16737 {
16738 rd->dictpos = 0;
16739 }
16740
16741 rd->maskpos = maskpos;
16742 data.maskpos = maskpos;
16743
16744 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16745 {
16746 char *mask = masks[maskpos];
16747
16748 if (mask_from_file == 1)
16749 {
16750 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16751
16752 char *str_ptr;
16753 uint str_pos;
16754
16755 uint mask_offset = 0;
16756
16757 uint separator_cnt;
16758
16759 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16760 {
16761 str_ptr = strstr (mask + mask_offset, ",");
16762
16763 if (str_ptr == NULL) break;
16764
16765 str_pos = str_ptr - mask;
16766
16767 // escaped separator, i.e. "\,"
16768
16769 if (str_pos > 0)
16770 {
16771 if (mask[str_pos - 1] == '\\')
16772 {
16773 separator_cnt --;
16774
16775 mask_offset = str_pos + 1;
16776
16777 continue;
16778 }
16779 }
16780
16781 // reset the offset
16782
16783 mask_offset = 0;
16784
16785 mask[str_pos] = '\0';
16786
16787 switch (separator_cnt)
16788 {
16789 case 0:
16790 mp_reset_usr (mp_usr, 0);
16791
16792 custom_charset_1 = mask;
16793 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16794 break;
16795
16796 case 1:
16797 mp_reset_usr (mp_usr, 1);
16798
16799 custom_charset_2 = mask;
16800 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16801 break;
16802
16803 case 2:
16804 mp_reset_usr (mp_usr, 2);
16805
16806 custom_charset_3 = mask;
16807 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16808 break;
16809
16810 case 3:
16811 mp_reset_usr (mp_usr, 3);
16812
16813 custom_charset_4 = mask;
16814 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16815 break;
16816 }
16817
16818 mask = mask + str_pos + 1;
16819 }
16820 }
16821
16822 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16823 {
16824 if (maskpos > 0)
16825 {
16826 local_free (css_buf);
16827 local_free (data.root_css_buf);
16828 local_free (data.markov_css_buf);
16829
16830 local_free (masks[maskpos - 1]);
16831 }
16832
16833 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16834
16835 data.mask = mask;
16836 data.css_cnt = css_cnt;
16837 data.css_buf = css_buf;
16838
16839 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16840
16841 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16842
16843 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16844 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16845
16846 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16847
16848 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16849
16850 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16851 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16852
16853 data.root_css_buf = root_css_buf;
16854 data.markov_css_buf = markov_css_buf;
16855
16856 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16857
16858 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16859
16860 local_free (root_table_buf);
16861 local_free (markov_table_buf);
16862
16863 // args
16864
16865 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16866 {
16867 hc_device_param_t *device_param = &data.devices_param[device_id];
16868
16869 if (device_param->skipped) continue;
16870
16871 device_param->kernel_params_mp[0] = &device_param->d_combs;
16872 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16873 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16874
16875 device_param->kernel_params_mp_buf64[3] = 0;
16876 device_param->kernel_params_mp_buf32[4] = css_cnt;
16877 device_param->kernel_params_mp_buf32[5] = 0;
16878 device_param->kernel_params_mp_buf32[6] = 0;
16879 device_param->kernel_params_mp_buf32[7] = 0;
16880
16881 if (attack_mode == ATTACK_MODE_HYBRID1)
16882 {
16883 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16884 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16885 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16886 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16887 }
16888 else if (attack_mode == ATTACK_MODE_HYBRID2)
16889 {
16890 device_param->kernel_params_mp_buf32[5] = 0;
16891 device_param->kernel_params_mp_buf32[6] = 0;
16892 device_param->kernel_params_mp_buf32[7] = 0;
16893 }
16894
16895 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]);
16896 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]);
16897 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]);
16898
16899 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);
16900 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);
16901 }
16902 }
16903 else if (attack_mode == ATTACK_MODE_BF)
16904 {
16905 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16906
16907 if (increment)
16908 {
16909 for (uint i = 0; i < dictcnt; i++)
16910 {
16911 local_free (dictfiles[i]);
16912 }
16913
16914 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16915 {
16916 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16917
16918 if (l1_filename == NULL) break;
16919
16920 dictcnt++;
16921
16922 dictfiles[dictcnt - 1] = l1_filename;
16923 }
16924 }
16925 else
16926 {
16927 dictcnt++;
16928
16929 dictfiles[dictcnt - 1] = mask;
16930 }
16931
16932 if (dictcnt == 0)
16933 {
16934 log_error ("ERROR: Mask is too small");
16935
16936 return (-1);
16937 }
16938 }
16939 }
16940
16941 free (induction_dictionaries);
16942
16943 // induction_dictionaries_cnt = 0; // implied
16944
16945 if (attack_mode != ATTACK_MODE_BF)
16946 {
16947 if (keyspace == 0)
16948 {
16949 induction_dictionaries = scan_directory (induction_directory);
16950
16951 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16952 }
16953 }
16954
16955 if (induction_dictionaries_cnt)
16956 {
16957 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16958 }
16959
16960 /**
16961 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16962 */
16963 if (keyspace == 1)
16964 {
16965 if ((maskcnt > 1) || (dictcnt > 1))
16966 {
16967 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16968
16969 return (-1);
16970 }
16971 }
16972
16973 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16974 {
16975 char *subid = logfile_generate_subid ();
16976
16977 data.subid = subid;
16978
16979 logfile_sub_msg ("START");
16980
16981 data.devices_status = STATUS_INIT;
16982
16983 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16984 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16985 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16986
16987 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16988
16989 data.cpt_pos = 0;
16990
16991 data.cpt_start = time (NULL);
16992
16993 data.cpt_total = 0;
16994
16995 if (data.restore == 0)
16996 {
16997 rd->words_cur = skip;
16998
16999 skip = 0;
17000
17001 data.skip = 0;
17002 }
17003
17004 data.ms_paused = 0;
17005
17006 data.kernel_power_div = 0;
17007
17008 data.words_cur = rd->words_cur;
17009
17010 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17011 {
17012 hc_device_param_t *device_param = &data.devices_param[device_id];
17013
17014 if (device_param->skipped) continue;
17015
17016 device_param->speed_pos = 0;
17017
17018 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17019 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17020
17021 device_param->exec_pos = 0;
17022
17023 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17024
17025 device_param->outerloop_pos = 0;
17026 device_param->outerloop_left = 0;
17027 device_param->innerloop_pos = 0;
17028 device_param->innerloop_left = 0;
17029
17030 // some more resets:
17031
17032 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17033
17034 device_param->pws_cnt = 0;
17035
17036 device_param->words_off = 0;
17037 device_param->words_done = 0;
17038 }
17039
17040 // figure out some workload
17041
17042 if (attack_mode == ATTACK_MODE_STRAIGHT)
17043 {
17044 if (data.wordlist_mode == WL_MODE_FILE)
17045 {
17046 char *dictfile = NULL;
17047
17048 if (induction_dictionaries_cnt)
17049 {
17050 dictfile = induction_dictionaries[0];
17051 }
17052 else
17053 {
17054 dictfile = dictfiles[dictpos];
17055 }
17056
17057 data.dictfile = dictfile;
17058
17059 logfile_sub_string (dictfile);
17060
17061 for (uint i = 0; i < rp_files_cnt; i++)
17062 {
17063 logfile_sub_var_string ("rulefile", rp_files[i]);
17064 }
17065
17066 FILE *fd2 = fopen (dictfile, "rb");
17067
17068 if (fd2 == NULL)
17069 {
17070 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17071
17072 return (-1);
17073 }
17074
17075 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17076
17077 fclose (fd2);
17078
17079 if (data.words_cnt == 0)
17080 {
17081 if (data.devices_status == STATUS_CRACKED) break;
17082 if (data.devices_status == STATUS_ABORTED) break;
17083
17084 dictpos++;
17085
17086 continue;
17087 }
17088 }
17089 }
17090 else if (attack_mode == ATTACK_MODE_COMBI)
17091 {
17092 char *dictfile = data.dictfile;
17093 char *dictfile2 = data.dictfile2;
17094
17095 logfile_sub_string (dictfile);
17096 logfile_sub_string (dictfile2);
17097
17098 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17099 {
17100 FILE *fd2 = fopen (dictfile, "rb");
17101
17102 if (fd2 == NULL)
17103 {
17104 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17105
17106 return (-1);
17107 }
17108
17109 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17110
17111 fclose (fd2);
17112 }
17113 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17114 {
17115 FILE *fd2 = fopen (dictfile2, "rb");
17116
17117 if (fd2 == NULL)
17118 {
17119 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17120
17121 return (-1);
17122 }
17123
17124 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17125
17126 fclose (fd2);
17127 }
17128
17129 if (data.words_cnt == 0)
17130 {
17131 if (data.devices_status == STATUS_CRACKED) break;
17132 if (data.devices_status == STATUS_ABORTED) break;
17133
17134 dictpos++;
17135
17136 continue;
17137 }
17138 }
17139 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17140 {
17141 char *dictfile = NULL;
17142
17143 if (induction_dictionaries_cnt)
17144 {
17145 dictfile = induction_dictionaries[0];
17146 }
17147 else
17148 {
17149 dictfile = dictfiles[dictpos];
17150 }
17151
17152 data.dictfile = dictfile;
17153
17154 char *mask = data.mask;
17155
17156 logfile_sub_string (dictfile);
17157 logfile_sub_string (mask);
17158
17159 FILE *fd2 = fopen (dictfile, "rb");
17160
17161 if (fd2 == NULL)
17162 {
17163 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17164
17165 return (-1);
17166 }
17167
17168 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17169
17170 fclose (fd2);
17171
17172 if (data.words_cnt == 0)
17173 {
17174 if (data.devices_status == STATUS_CRACKED) break;
17175 if (data.devices_status == STATUS_ABORTED) break;
17176
17177 dictpos++;
17178
17179 continue;
17180 }
17181 }
17182 else if (attack_mode == ATTACK_MODE_BF)
17183 {
17184 local_free (css_buf);
17185 local_free (data.root_css_buf);
17186 local_free (data.markov_css_buf);
17187
17188 char *mask = dictfiles[dictpos];
17189
17190 logfile_sub_string (mask);
17191
17192 // base
17193
17194 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17195
17196 if (opts_type & OPTS_TYPE_PT_UNICODE)
17197 {
17198 uint css_cnt_unicode = css_cnt * 2;
17199
17200 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17201
17202 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17203 {
17204 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17205
17206 css_buf_unicode[j + 1].cs_buf[0] = 0;
17207 css_buf_unicode[j + 1].cs_len = 1;
17208 }
17209
17210 free (css_buf);
17211
17212 css_buf = css_buf_unicode;
17213 css_cnt = css_cnt_unicode;
17214 }
17215
17216 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17217
17218 uint mask_min = pw_min;
17219 uint mask_max = pw_max;
17220
17221 if (opts_type & OPTS_TYPE_PT_UNICODE)
17222 {
17223 mask_min *= 2;
17224 mask_max *= 2;
17225 }
17226
17227 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17228 {
17229 if (css_cnt < mask_min)
17230 {
17231 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17232 }
17233
17234 if (css_cnt > mask_max)
17235 {
17236 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17237 }
17238
17239 // skip to next mask
17240
17241 dictpos++;
17242
17243 rd->dictpos = dictpos;
17244
17245 logfile_sub_msg ("STOP");
17246
17247 continue;
17248 }
17249
17250 uint save_css_cnt = css_cnt;
17251
17252 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17253 {
17254 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17255 {
17256 uint salt_len = (uint) data.salts_buf[0].salt_len;
17257 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17258
17259 uint css_cnt_salt = css_cnt + salt_len;
17260
17261 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17262
17263 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17264
17265 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17266 {
17267 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17268 css_buf_salt[j].cs_len = 1;
17269 }
17270
17271 free (css_buf);
17272
17273 css_buf = css_buf_salt;
17274 css_cnt = css_cnt_salt;
17275 }
17276 }
17277
17278 data.mask = mask;
17279 data.css_cnt = css_cnt;
17280 data.css_buf = css_buf;
17281
17282 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17283
17284 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17285
17286 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17287
17288 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17289 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17290
17291 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17292
17293 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17294
17295 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17296 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17297
17298 data.root_css_buf = root_css_buf;
17299 data.markov_css_buf = markov_css_buf;
17300
17301 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17302
17303 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17304
17305 local_free (root_table_buf);
17306 local_free (markov_table_buf);
17307
17308 // copy + args
17309
17310 uint css_cnt_l = css_cnt;
17311 uint css_cnt_r;
17312
17313 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17314 {
17315 if (save_css_cnt < 6)
17316 {
17317 css_cnt_r = 1;
17318 }
17319 else if (save_css_cnt == 6)
17320 {
17321 css_cnt_r = 2;
17322 }
17323 else
17324 {
17325 if (opts_type & OPTS_TYPE_PT_UNICODE)
17326 {
17327 if (save_css_cnt == 8 || save_css_cnt == 10)
17328 {
17329 css_cnt_r = 2;
17330 }
17331 else
17332 {
17333 css_cnt_r = 4;
17334 }
17335 }
17336 else
17337 {
17338 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17339 {
17340 css_cnt_r = 3;
17341 }
17342 else
17343 {
17344 css_cnt_r = 4;
17345 }
17346 }
17347 }
17348 }
17349 else
17350 {
17351 css_cnt_r = 1;
17352
17353 /* unfinished code?
17354 int sum = css_buf[css_cnt_r - 1].cs_len;
17355
17356 for (uint i = 1; i < 4 && i < css_cnt; i++)
17357 {
17358 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17359
17360 css_cnt_r++;
17361
17362 sum *= css_buf[css_cnt_r - 1].cs_len;
17363 }
17364 */
17365 }
17366
17367 css_cnt_l -= css_cnt_r;
17368
17369 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17370
17371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17372 {
17373 hc_device_param_t *device_param = &data.devices_param[device_id];
17374
17375 if (device_param->skipped) continue;
17376
17377 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17378 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17379 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17380
17381 device_param->kernel_params_mp_l_buf64[3] = 0;
17382 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17383 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17384 device_param->kernel_params_mp_l_buf32[6] = 0;
17385 device_param->kernel_params_mp_l_buf32[7] = 0;
17386 device_param->kernel_params_mp_l_buf32[8] = 0;
17387
17388 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17389 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17390 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17391 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17392
17393 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17394 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17395 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17396
17397 device_param->kernel_params_mp_r_buf64[3] = 0;
17398 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17399 device_param->kernel_params_mp_r_buf32[5] = 0;
17400 device_param->kernel_params_mp_r_buf32[6] = 0;
17401 device_param->kernel_params_mp_r_buf32[7] = 0;
17402
17403 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]);
17404 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]);
17405 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]);
17406
17407 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]);
17408 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]);
17409 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]);
17410
17411 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);
17412 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);
17413 }
17414 }
17415
17416 u64 words_base = data.words_cnt;
17417
17418 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17419 {
17420 if (data.kernel_rules_cnt)
17421 {
17422 words_base /= data.kernel_rules_cnt;
17423 }
17424 }
17425 else if (data.attack_kern == ATTACK_KERN_COMBI)
17426 {
17427 if (data.combs_cnt)
17428 {
17429 words_base /= data.combs_cnt;
17430 }
17431 }
17432 else if (data.attack_kern == ATTACK_KERN_BF)
17433 {
17434 if (data.bfs_cnt)
17435 {
17436 words_base /= data.bfs_cnt;
17437 }
17438 }
17439
17440 data.words_base = words_base;
17441
17442 if (keyspace == 1)
17443 {
17444 log_info ("%llu", (unsigned long long int) words_base);
17445
17446 return (0);
17447 }
17448
17449 if (data.words_cur > data.words_base)
17450 {
17451 log_error ("ERROR: restore value greater keyspace");
17452
17453 return (-1);
17454 }
17455
17456 if (data.words_cur)
17457 {
17458 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17459 {
17460 for (uint i = 0; i < data.salts_cnt; i++)
17461 {
17462 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17463 }
17464 }
17465 else if (data.attack_kern == ATTACK_KERN_COMBI)
17466 {
17467 for (uint i = 0; i < data.salts_cnt; i++)
17468 {
17469 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17470 }
17471 }
17472 else if (data.attack_kern == ATTACK_KERN_BF)
17473 {
17474 for (uint i = 0; i < data.salts_cnt; i++)
17475 {
17476 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17477 }
17478 }
17479 }
17480
17481 /*
17482 * Update loopback file
17483 */
17484
17485 if (loopback == 1)
17486 {
17487 time_t now;
17488
17489 time (&now);
17490
17491 uint random_num = get_random_num (0, 9999);
17492
17493 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17494
17495 data.loopback_file = loopback_file;
17496 }
17497
17498 /*
17499 * Update dictionary statistic
17500 */
17501
17502 if (keyspace == 0)
17503 {
17504 dictstat_fp = fopen (dictstat, "wb");
17505
17506 if (dictstat_fp)
17507 {
17508 lock_file (dictstat_fp);
17509
17510 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17511
17512 fclose (dictstat_fp);
17513 }
17514 }
17515
17516 data.devices_status = STATUS_RUNNING;
17517
17518 if (initial_restore_done == 0)
17519 {
17520 if (data.restore_disable == 0) cycle_restore ();
17521
17522 initial_restore_done = 1;
17523 }
17524
17525 hc_timer_set (&data.timer_running);
17526
17527 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17528 {
17529 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17530 {
17531 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17532 if (quiet == 0) fflush (stdout);
17533 }
17534 }
17535 else if (wordlist_mode == WL_MODE_STDIN)
17536 {
17537 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17538 if (data.quiet == 0) log_info ("");
17539 }
17540
17541 /**
17542 * create autotune threads
17543 */
17544
17545 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17546
17547 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17548 {
17549 hc_device_param_t *device_param = &devices_param[device_id];
17550
17551 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17552 }
17553
17554 hc_thread_wait (data.devices_cnt, c_threads);
17555
17556 /*
17557 * Inform user about possible slow speeds
17558 */
17559
17560 uint kernel_power_all = 0;
17561
17562 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17563 {
17564 hc_device_param_t *device_param = &devices_param[device_id];
17565
17566 kernel_power_all += device_param->kernel_power;
17567 }
17568
17569 data.kernel_power_all = kernel_power_all;
17570
17571 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17572 {
17573 if (data.words_base < kernel_power_all)
17574 {
17575 if (quiet == 0)
17576 {
17577 log_info ("ATTENTION!");
17578 log_info (" The wordlist or mask you are using is too small.");
17579 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17580 log_info (" The cracking speed will drop.");
17581 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17582 log_info ("");
17583 }
17584 }
17585 }
17586
17587 /**
17588 * create cracker threads
17589 */
17590
17591 time_t runtime_start;
17592
17593 time (&runtime_start);
17594
17595 data.runtime_start = runtime_start;
17596
17597 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17598 {
17599 hc_device_param_t *device_param = &devices_param[device_id];
17600
17601 if (wordlist_mode == WL_MODE_STDIN)
17602 {
17603 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17604 }
17605 else
17606 {
17607 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17608 }
17609 }
17610
17611 hc_thread_wait (data.devices_cnt, c_threads);
17612
17613 local_free (c_threads);
17614
17615 data.restore = 0;
17616
17617 // finalize task
17618
17619 logfile_sub_var_uint ("status-after-work", data.devices_status);
17620
17621 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17622
17623 if (data.devices_status == STATUS_CRACKED) break;
17624 if (data.devices_status == STATUS_ABORTED) break;
17625
17626 if (data.devices_status == STATUS_BYPASS)
17627 {
17628 data.devices_status = STATUS_RUNNING;
17629 }
17630
17631 if (induction_dictionaries_cnt)
17632 {
17633 unlink (induction_dictionaries[0]);
17634 }
17635
17636 free (induction_dictionaries);
17637
17638 if (attack_mode != ATTACK_MODE_BF)
17639 {
17640 induction_dictionaries = scan_directory (induction_directory);
17641
17642 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17643 }
17644
17645 if (benchmark == 0)
17646 {
17647 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17648 {
17649 if (quiet == 0) clear_prompt ();
17650
17651 if (quiet == 0) log_info ("");
17652
17653 if (status == 1)
17654 {
17655 status_display ();
17656 }
17657 else
17658 {
17659 if (quiet == 0) status_display ();
17660 }
17661
17662 if (quiet == 0) log_info ("");
17663 }
17664 }
17665
17666 if (attack_mode == ATTACK_MODE_BF)
17667 {
17668 dictpos++;
17669
17670 rd->dictpos = dictpos;
17671 }
17672 else
17673 {
17674 if (induction_dictionaries_cnt)
17675 {
17676 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17677 }
17678 else
17679 {
17680 dictpos++;
17681
17682 rd->dictpos = dictpos;
17683 }
17684 }
17685
17686 time_t runtime_stop;
17687
17688 time (&runtime_stop);
17689
17690 data.runtime_stop = runtime_stop;
17691
17692 logfile_sub_uint (runtime_start);
17693 logfile_sub_uint (runtime_stop);
17694
17695 logfile_sub_msg ("STOP");
17696
17697 global_free (subid);
17698 }
17699
17700 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17701
17702 if (data.devices_status == STATUS_CRACKED) break;
17703 if (data.devices_status == STATUS_ABORTED) break;
17704 if (data.devices_status == STATUS_QUIT) break;
17705
17706 if (data.devices_status == STATUS_BYPASS)
17707 {
17708 data.devices_status = STATUS_RUNNING;
17709 }
17710 }
17711
17712 // 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
17713
17714 if (attack_mode == ATTACK_MODE_STRAIGHT)
17715 {
17716 if (data.wordlist_mode == WL_MODE_FILE)
17717 {
17718 if (data.dictfile == NULL)
17719 {
17720 if (dictfiles != NULL)
17721 {
17722 data.dictfile = dictfiles[0];
17723
17724 hc_timer_set (&data.timer_running);
17725 }
17726 }
17727 }
17728 }
17729 // NOTE: combi is okay because it is already set beforehand
17730 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17731 {
17732 if (data.dictfile == NULL)
17733 {
17734 if (dictfiles != NULL)
17735 {
17736 hc_timer_set (&data.timer_running);
17737
17738 data.dictfile = dictfiles[0];
17739 }
17740 }
17741 }
17742 else if (attack_mode == ATTACK_MODE_BF)
17743 {
17744 if (data.mask == NULL)
17745 {
17746 hc_timer_set (&data.timer_running);
17747
17748 data.mask = masks[0];
17749 }
17750 }
17751
17752 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17753 {
17754 data.devices_status = STATUS_EXHAUSTED;
17755 }
17756
17757 // if cracked / aborted remove last induction dictionary
17758
17759 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17760 {
17761 struct stat induct_stat;
17762
17763 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17764 {
17765 unlink (induction_dictionaries[file_pos]);
17766 }
17767 }
17768
17769 // wait for non-interactive threads
17770
17771 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17772 {
17773 hc_thread_wait (1, &ni_threads[thread_idx]);
17774 }
17775
17776 local_free (ni_threads);
17777
17778 // wait for interactive threads
17779
17780 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17781 {
17782 hc_thread_wait (1, &i_thread);
17783 }
17784
17785 // we dont need restore file anymore
17786 if (data.restore_disable == 0)
17787 {
17788 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17789 {
17790 unlink (eff_restore_file);
17791 unlink (new_restore_file);
17792 }
17793 else
17794 {
17795 cycle_restore ();
17796 }
17797 }
17798
17799 // finally save left hashes
17800
17801 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17802 {
17803 save_hash ();
17804 }
17805
17806 /**
17807 * Clean up
17808 */
17809
17810 if (benchmark == 1)
17811 {
17812 status_benchmark ();
17813
17814 if (machine_readable == 0)
17815 {
17816 log_info ("");
17817 }
17818 }
17819 else
17820 {
17821 if (quiet == 0) clear_prompt ();
17822
17823 if (quiet == 0) log_info ("");
17824
17825 if (status == 1)
17826 {
17827 status_display ();
17828 }
17829 else
17830 {
17831 if (quiet == 0) status_display ();
17832 }
17833
17834 if (quiet == 0) log_info ("");
17835 }
17836
17837 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17838 {
17839 hc_device_param_t *device_param = &data.devices_param[device_id];
17840
17841 if (device_param->skipped) continue;
17842
17843 local_free (device_param->combs_buf);
17844
17845 local_free (device_param->hooks_buf);
17846
17847 local_free (device_param->device_name);
17848
17849 local_free (device_param->device_name_chksum);
17850
17851 local_free (device_param->device_version);
17852
17853 local_free (device_param->driver_version);
17854
17855 if (device_param->pws_buf) myfree (device_param->pws_buf);
17856 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17857 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17858 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17859 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17860 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17861 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17862 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17863 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17864 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17865 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17866 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17867 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17868 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17869 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17870 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17871 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17872 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17873 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17874 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17875 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17876 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17877 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17878 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17879 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17880 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17881 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17882 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17883 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17884
17885 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17886 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17887 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17888 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17889 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17890 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17891 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17892 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17893 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17894 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17895 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17896
17897 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17898 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17899 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17900
17901 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17902 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17903 }
17904
17905 // reset default fan speed
17906
17907 #ifdef HAVE_HWMON
17908 if (gpu_temp_disable == 0)
17909 {
17910 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17911 {
17912 hc_thread_mutex_lock (mux_adl);
17913
17914 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17915 {
17916 hc_device_param_t *device_param = &data.devices_param[device_id];
17917
17918 if (device_param->skipped) continue;
17919
17920 if (data.hm_device[device_id].fan_set_supported == 1)
17921 {
17922 int fanspeed = temp_retain_fanspeed_value[device_id];
17923 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17924
17925 if (fanpolicy == 1)
17926 {
17927 int rc = -1;
17928
17929 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17930 {
17931 rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed, 0);
17932 }
17933 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17934 {
17935
17936 }
17937
17938 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17939 }
17940 }
17941 }
17942
17943 hc_thread_mutex_unlock (mux_adl);
17944 }
17945 }
17946
17947 // reset power tuning
17948
17949 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17950 {
17951 hc_thread_mutex_lock (mux_adl);
17952
17953 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17954 {
17955 hc_device_param_t *device_param = &data.devices_param[device_id];
17956
17957 if (device_param->skipped) continue;
17958
17959 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17960 {
17961 if (data.hm_device[device_id].od_version == 6)
17962 {
17963 // check powertune capabilities first, if not available then skip device
17964
17965 int powertune_supported = 0;
17966
17967 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17968 {
17969 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17970
17971 return (-1);
17972 }
17973
17974 if (powertune_supported != 0)
17975 {
17976 // powercontrol settings
17977
17978 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17979 {
17980 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17981
17982 return (-1);
17983 }
17984
17985 // clocks
17986
17987 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17988
17989 performance_state->iNumberOfPerformanceLevels = 2;
17990
17991 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17992 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17993 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17994 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17995
17996 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17997 {
17998 log_info ("ERROR: Failed to restore ADL performance state");
17999
18000 return (-1);
18001 }
18002
18003 local_free (performance_state);
18004 }
18005 }
18006 }
18007
18008 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18009 {
18010 unsigned int limit = nvml_power_limit[device_id];
18011
18012 if (limit > 0)
18013 {
18014 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nv, 0, data.hm_device[device_id].adapter_index.nv, limit);
18015 }
18016 }
18017 }
18018
18019 hc_thread_mutex_unlock (mux_adl);
18020 }
18021
18022 if (gpu_temp_disable == 0)
18023 {
18024 if (data.hm_nv)
18025 {
18026 hm_NVML_nvmlShutdown (data.hm_nv);
18027
18028 nvml_close (data.hm_nv);
18029
18030 data.hm_nv = NULL;
18031 }
18032
18033 if (data.hm_amd)
18034 {
18035 hm_ADL_Main_Control_Destroy (data.hm_amd);
18036
18037 adl_close (data.hm_amd);
18038
18039 data.hm_amd = NULL;
18040 }
18041 }
18042 #endif // HAVE_HWMON
18043
18044 // free memory
18045
18046 local_free (masks);
18047
18048 local_free (dictstat_base);
18049
18050 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18051 {
18052 pot_t *pot_ptr = &pot[pot_pos];
18053
18054 hash_t *hash = &pot_ptr->hash;
18055
18056 local_free (hash->digest);
18057
18058 if (isSalted)
18059 {
18060 local_free (hash->salt);
18061 }
18062 }
18063
18064 local_free (pot);
18065
18066 local_free (all_kernel_rules_cnt);
18067 local_free (all_kernel_rules_buf);
18068
18069 local_free (wl_data->buf);
18070 local_free (wl_data);
18071
18072 local_free (bitmap_s1_a);
18073 local_free (bitmap_s1_b);
18074 local_free (bitmap_s1_c);
18075 local_free (bitmap_s1_d);
18076 local_free (bitmap_s2_a);
18077 local_free (bitmap_s2_b);
18078 local_free (bitmap_s2_c);
18079 local_free (bitmap_s2_d);
18080
18081 #ifdef HAVE_HWMON
18082 local_free (temp_retain_fanspeed_value);
18083 local_free (od_clock_mem_status);
18084 local_free (od_power_control_status);
18085 local_free (nvml_power_limit);
18086 #endif
18087
18088 global_free (devices_param);
18089
18090 global_free (kernel_rules_buf);
18091
18092 global_free (root_css_buf);
18093 global_free (markov_css_buf);
18094
18095 global_free (digests_buf);
18096 global_free (digests_shown);
18097 global_free (digests_shown_tmp);
18098
18099 global_free (salts_buf);
18100 global_free (salts_shown);
18101
18102 global_free (esalts_buf);
18103
18104 global_free (words_progress_done);
18105 global_free (words_progress_rejected);
18106 global_free (words_progress_restored);
18107
18108 if (pot_fp) fclose (pot_fp);
18109
18110 if (data.devices_status == STATUS_QUIT) break;
18111 }
18112
18113 // destroy others mutex
18114
18115 hc_thread_mutex_delete (mux_dispatcher);
18116 hc_thread_mutex_delete (mux_counter);
18117 hc_thread_mutex_delete (mux_display);
18118 hc_thread_mutex_delete (mux_adl);
18119
18120 // free memory
18121
18122 local_free (eff_restore_file);
18123 local_free (new_restore_file);
18124
18125 local_free (rd);
18126
18127 // tuning db
18128
18129 tuning_db_destroy (tuning_db);
18130
18131 // loopback
18132
18133 local_free (loopback_file);
18134
18135 if (loopback == 1) unlink (loopback_file);
18136
18137 // induction directory
18138
18139 if (induction_dir == NULL)
18140 {
18141 if (attack_mode != ATTACK_MODE_BF)
18142 {
18143 if (rmdir (induction_directory) == -1)
18144 {
18145 if (errno == ENOENT)
18146 {
18147 // good, we can ignore
18148 }
18149 else if (errno == ENOTEMPTY)
18150 {
18151 // good, we can ignore
18152 }
18153 else
18154 {
18155 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18156
18157 return (-1);
18158 }
18159 }
18160
18161 local_free (induction_directory);
18162 }
18163 }
18164
18165 // outfile-check directory
18166
18167 if (outfile_check_dir == NULL)
18168 {
18169 if (rmdir (outfile_check_directory) == -1)
18170 {
18171 if (errno == ENOENT)
18172 {
18173 // good, we can ignore
18174 }
18175 else if (errno == ENOTEMPTY)
18176 {
18177 // good, we can ignore
18178 }
18179 else
18180 {
18181 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18182
18183 return (-1);
18184 }
18185 }
18186
18187 local_free (outfile_check_directory);
18188 }
18189
18190 time_t proc_stop;
18191
18192 time (&proc_stop);
18193
18194 logfile_top_uint (proc_start);
18195 logfile_top_uint (proc_stop);
18196
18197 logfile_top_msg ("STOP");
18198
18199 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18200 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18201
18202 if (data.ocl) ocl_close (data.ocl);
18203
18204 if (data.devices_status == STATUS_ABORTED) return 2;
18205 if (data.devices_status == STATUS_QUIT) return 2;
18206 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18207 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18208 if (data.devices_status == STATUS_CRACKED) return 0;
18209
18210 return -1;
18211 }
Hashcat additions to support pwdhash