projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
More nvapi preparations and display skip reason in benchmark
[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_adl (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_nvapi = 0;
13323 int need_nvml = 0;
13324
13325 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13326
13327 data.devices_param = devices_param;
13328
13329 uint devices_cnt = 0;
13330
13331 uint devices_active = 0;
13332
13333 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13334 {
13335 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13336
13337 cl_platform_id platform = platforms[platform_id];
13338
13339 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13340
13341 char platform_vendor[INFOSZ] = { 0 };
13342
13343 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13344
13345 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13346 // this causes trouble with vendor id based macros
13347 // we'll assign generic to those without special optimization available
13348
13349 cl_uint platform_vendor_id = 0;
13350
13351 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13352 {
13353 platform_vendor_id = VENDOR_ID_AMD;
13354 }
13355 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13356 {
13357 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13358 }
13359 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13360 {
13361 platform_vendor_id = VENDOR_ID_APPLE;
13362 }
13363 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13364 {
13365 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13366 }
13367 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13368 {
13369 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13370 }
13371 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13372 {
13373 platform_vendor_id = VENDOR_ID_MESA;
13374 }
13375 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13376 {
13377 platform_vendor_id = VENDOR_ID_NV;
13378 }
13379 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13380 {
13381 platform_vendor_id = VENDOR_ID_POCL;
13382 }
13383 else
13384 {
13385 platform_vendor_id = VENDOR_ID_GENERIC;
13386 }
13387
13388 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13389 {
13390 size_t param_value_size = 0;
13391
13392 const uint device_id = devices_cnt;
13393
13394 hc_device_param_t *device_param = &data.devices_param[device_id];
13395
13396 device_param->platform_vendor_id = platform_vendor_id;
13397
13398 device_param->device = platform_devices[platform_devices_id];
13399
13400 device_param->device_id = device_id;
13401
13402 device_param->platform_devices_id = platform_devices_id;
13403
13404 // device_type
13405
13406 cl_device_type device_type;
13407
13408 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13409
13410 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13411
13412 device_param->device_type = device_type;
13413
13414 // device_name
13415
13416 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13417
13418 char *device_name = (char *) mymalloc (param_value_size);
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13421
13422 device_param->device_name = device_name;
13423
13424 // device_vendor
13425
13426 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13427
13428 char *device_vendor = (char *) mymalloc (param_value_size);
13429
13430 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13431
13432 device_param->device_vendor = device_vendor;
13433
13434 cl_uint device_vendor_id = 0;
13435
13436 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13437 {
13438 device_vendor_id = VENDOR_ID_AMD;
13439 }
13440 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13441 {
13442 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13443 }
13444 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13445 {
13446 device_vendor_id = VENDOR_ID_APPLE;
13447 }
13448 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13449 {
13450 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13451 }
13452 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13453 {
13454 device_vendor_id = VENDOR_ID_INTEL_SDK;
13455 }
13456 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13457 {
13458 device_vendor_id = VENDOR_ID_MESA;
13459 }
13460 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13461 {
13462 device_vendor_id = VENDOR_ID_NV;
13463 }
13464 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13465 {
13466 device_vendor_id = VENDOR_ID_POCL;
13467 }
13468 else
13469 {
13470 device_vendor_id = VENDOR_ID_GENERIC;
13471 }
13472
13473 device_param->device_vendor_id = device_vendor_id;
13474
13475 // tuning db
13476
13477 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13478
13479 // device_version
13480
13481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13482
13483 char *device_version = (char *) mymalloc (param_value_size);
13484
13485 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13486
13487 device_param->device_version = device_version;
13488
13489 // device_opencl_version
13490
13491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13492
13493 char *device_opencl_version = (char *) mymalloc (param_value_size);
13494
13495 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13496
13497 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13498
13499 myfree (device_opencl_version);
13500
13501 // vector_width
13502
13503 cl_uint vector_width;
13504
13505 if (opencl_vector_width_chgd == 0)
13506 {
13507 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13508 {
13509 if (opti_type & OPTI_TYPE_USES_BITS_64)
13510 {
13511 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13512 }
13513 else
13514 {
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13516 }
13517 }
13518 else
13519 {
13520 vector_width = (cl_uint) tuningdb_entry->vector_width;
13521 }
13522 }
13523 else
13524 {
13525 vector_width = opencl_vector_width;
13526 }
13527
13528 if (vector_width > 16) vector_width = 16;
13529
13530 device_param->vector_width = vector_width;
13531
13532 // max_compute_units
13533
13534 cl_uint device_processors;
13535
13536 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13537
13538 device_param->device_processors = device_processors;
13539
13540 // device_maxmem_alloc
13541 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13542
13543 cl_ulong device_maxmem_alloc;
13544
13545 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13546
13547 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13548
13549 // device_global_mem
13550
13551 cl_ulong device_global_mem;
13552
13553 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13554
13555 device_param->device_global_mem = device_global_mem;
13556
13557 // max_work_group_size
13558
13559 size_t device_maxworkgroup_size;
13560
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13562
13563 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13564
13565 // max_clock_frequency
13566
13567 cl_uint device_maxclock_frequency;
13568
13569 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13570
13571 device_param->device_maxclock_frequency = device_maxclock_frequency;
13572
13573 // device_endian_little
13574
13575 cl_bool device_endian_little;
13576
13577 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13578
13579 if (device_endian_little == CL_FALSE)
13580 {
13581 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13582
13583 device_param->skipped = 1;
13584 }
13585
13586 // device_available
13587
13588 cl_bool device_available;
13589
13590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13591
13592 if (device_available == CL_FALSE)
13593 {
13594 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13595
13596 device_param->skipped = 1;
13597 }
13598
13599 // device_compiler_available
13600
13601 cl_bool device_compiler_available;
13602
13603 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13604
13605 if (device_compiler_available == CL_FALSE)
13606 {
13607 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13608
13609 device_param->skipped = 1;
13610 }
13611
13612 // device_execution_capabilities
13613
13614 cl_device_exec_capabilities device_execution_capabilities;
13615
13616 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13617
13618 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13619 {
13620 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13621
13622 device_param->skipped = 1;
13623 }
13624
13625 // device_extensions
13626
13627 size_t device_extensions_size;
13628
13629 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13630
13631 char *device_extensions = mymalloc (device_extensions_size + 1);
13632
13633 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13634
13635 if (strstr (device_extensions, "base_atomics") == 0)
13636 {
13637 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13638
13639 device_param->skipped = 1;
13640 }
13641
13642 if (strstr (device_extensions, "byte_addressable_store") == 0)
13643 {
13644 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13645
13646 device_param->skipped = 1;
13647 }
13648
13649 myfree (device_extensions);
13650
13651 // device_local_mem_size
13652
13653 cl_ulong device_local_mem_size;
13654
13655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13656
13657 if (device_local_mem_size < 32768)
13658 {
13659 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13660
13661 device_param->skipped = 1;
13662 }
13663
13664 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13665 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13666 // This results in both utilizing it for 50%
13667 // However, Intel has much better SIMD control over their own hardware
13668 // It makes sense to give them full control over their own hardware
13669
13670 if (device_type & CL_DEVICE_TYPE_CPU)
13671 {
13672 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13673 {
13674 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13675 log_info (" You can use --force to override this but do not post error reports if you do so");
13676
13677 if (data.force == 0) device_param->skipped = 1;
13678 }
13679 }
13680
13681 // skipped
13682
13683 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13684 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13685
13686 // driver_version
13687
13688 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13689
13690 char *driver_version = (char *) mymalloc (param_value_size);
13691
13692 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13693
13694 device_param->driver_version = driver_version;
13695
13696 // device_name_chksum
13697
13698 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13699
13700 #if __x86_64__
13701 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);
13702 #else
13703 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);
13704 #endif
13705
13706 uint device_name_digest[4] = { 0 };
13707
13708 md5_64 ((uint *) device_name_chksum, device_name_digest);
13709
13710 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13711
13712 device_param->device_name_chksum = device_name_chksum;
13713
13714 // device_processor_cores
13715
13716 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
13717 {
13718 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
13719 {
13720 need_adl = 1;
13721 }
13722
13723 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
13724 {
13725 need_nvml = 1;
13726
13727 #ifdef _WIN
13728 need_nvapi = 1;
13729 #endif
13730 }
13731 }
13732
13733 // device_processor_cores
13734
13735 if (device_type & CL_DEVICE_TYPE_CPU)
13736 {
13737 cl_uint device_processor_cores = 1;
13738
13739 device_param->device_processor_cores = device_processor_cores;
13740 }
13741
13742 if (device_type & CL_DEVICE_TYPE_GPU)
13743 {
13744 if (device_vendor_id == VENDOR_ID_AMD)
13745 {
13746 cl_uint device_processor_cores = 0;
13747
13748 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13749
13750 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13751
13752 device_param->device_processor_cores = device_processor_cores;
13753 }
13754 else if (device_vendor_id == VENDOR_ID_NV)
13755 {
13756 cl_uint kernel_exec_timeout = 0;
13757
13758 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13759
13760 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13761
13762 device_param->kernel_exec_timeout = kernel_exec_timeout;
13763
13764 cl_uint device_processor_cores = 0;
13765
13766 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13767
13768 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13769
13770 device_param->device_processor_cores = device_processor_cores;
13771
13772 cl_uint sm_minor = 0;
13773 cl_uint sm_major = 0;
13774
13775 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13776 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13777
13778 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13779 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13780
13781 device_param->sm_minor = sm_minor;
13782 device_param->sm_major = sm_major;
13783 }
13784 else
13785 {
13786 cl_uint device_processor_cores = 1;
13787
13788 device_param->device_processor_cores = device_processor_cores;
13789 }
13790 }
13791
13792 // display results
13793
13794 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13795 {
13796 if (machine_readable == 0)
13797 {
13798 if (device_param->skipped == 0)
13799 {
13800 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13801 device_id + 1,
13802 device_name,
13803 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13804 (unsigned int) (device_global_mem / 1024 / 1024),
13805 (unsigned int) device_processors);
13806 }
13807 else
13808 {
13809 log_info ("Device #%u: %s, skipped",
13810 device_id + 1,
13811 device_name);
13812 }
13813 }
13814 }
13815
13816 // common driver check
13817
13818 if (device_param->skipped == 0)
13819 {
13820 if (device_type & CL_DEVICE_TYPE_GPU)
13821 {
13822 if (platform_vendor_id == VENDOR_ID_AMD)
13823 {
13824 int catalyst_check = (force == 1) ? 0 : 1;
13825
13826 int catalyst_warn = 0;
13827
13828 int catalyst_broken = 0;
13829
13830 if (catalyst_check == 1)
13831 {
13832 catalyst_warn = 1;
13833
13834 // v14.9 and higher
13835 if (atoi (device_param->driver_version) >= 1573)
13836 {
13837 catalyst_warn = 0;
13838 }
13839
13840 catalyst_check = 0;
13841 }
13842
13843 if (catalyst_broken == 1)
13844 {
13845 log_info ("");
13846 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13847 log_info ("It will pass over cracked hashes and does not report them as cracked");
13848 log_info ("You are STRONGLY encouraged not to use it");
13849 log_info ("You can use --force to override this but do not post error reports if you do so");
13850 log_info ("");
13851
13852 return (-1);
13853 }
13854
13855 if (catalyst_warn == 1)
13856 {
13857 log_info ("");
13858 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13859 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13860 log_info ("See hashcat's homepage for official supported catalyst drivers");
13861 #ifdef _WIN
13862 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13863 #endif
13864 log_info ("You can use --force to override this but do not post error reports if you do so");
13865 log_info ("");
13866
13867 return (-1);
13868 }
13869 }
13870 else if (platform_vendor_id == VENDOR_ID_NV)
13871 {
13872 if (device_param->kernel_exec_timeout != 0)
13873 {
13874 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);
13875 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13876 }
13877 }
13878 }
13879
13880 /* turns out pocl still creates segfaults (because of llvm)
13881 if (device_type & CL_DEVICE_TYPE_CPU)
13882 {
13883 if (platform_vendor_id == VENDOR_ID_AMD)
13884 {
13885 if (force == 0)
13886 {
13887 log_info ("");
13888 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13889 log_info ("You are STRONGLY encouraged not to use it");
13890 log_info ("You can use --force to override this but do not post error reports if you do so");
13891 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13892 log_info ("");
13893
13894 return (-1);
13895 }
13896 }
13897 }
13898 */
13899
13900 /**
13901 * kernel accel and loops tuning db adjustment
13902 */
13903
13904 device_param->kernel_accel_min = 1;
13905 device_param->kernel_accel_max = 1024;
13906
13907 device_param->kernel_loops_min = 1;
13908 device_param->kernel_loops_max = 1024;
13909
13910 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13911
13912 if (tuningdb_entry)
13913 {
13914 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13915 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13916
13917 if (_kernel_accel)
13918 {
13919 device_param->kernel_accel_min = _kernel_accel;
13920 device_param->kernel_accel_max = _kernel_accel;
13921 }
13922
13923 if (_kernel_loops)
13924 {
13925 if (workload_profile == 1)
13926 {
13927 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13928 }
13929 else if (workload_profile == 2)
13930 {
13931 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13932 }
13933
13934 device_param->kernel_loops_min = _kernel_loops;
13935 device_param->kernel_loops_max = _kernel_loops;
13936 }
13937 }
13938
13939 // commandline parameters overwrite tuningdb entries
13940
13941 if (kernel_accel)
13942 {
13943 device_param->kernel_accel_min = kernel_accel;
13944 device_param->kernel_accel_max = kernel_accel;
13945 }
13946
13947 if (kernel_loops)
13948 {
13949 device_param->kernel_loops_min = kernel_loops;
13950 device_param->kernel_loops_max = kernel_loops;
13951 }
13952
13953 /**
13954 * activate device
13955 */
13956
13957 devices_active++;
13958 }
13959
13960 // next please
13961
13962 devices_cnt++;
13963 }
13964 }
13965
13966 if (keyspace == 0 && devices_active == 0)
13967 {
13968 log_error ("ERROR: No devices found/left");
13969
13970 return (-1);
13971 }
13972
13973 // 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)
13974
13975 if (devices_filter != (uint) -1)
13976 {
13977 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13978
13979 if (devices_filter > devices_cnt_mask)
13980 {
13981 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13982
13983 return (-1);
13984 }
13985 }
13986
13987 data.devices_cnt = devices_cnt;
13988
13989 data.devices_active = devices_active;
13990
13991 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13992 {
13993 if (machine_readable == 0)
13994 {
13995 log_info ("");
13996 }
13997 }
13998
13999 /**
14000 * HM devices: init
14001 */
14002
14003 #ifdef HAVE_HWMON
14004 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14005 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14006 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0, 0 } };
14007
14008 if (gpu_temp_disable == 0)
14009 {
14010 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14011 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14012 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14013
14014 data.hm_adl = NULL;
14015 data.hm_nvapi = NULL;
14016 data.hm_nvml = NULL;
14017
14018 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14019 {
14020 data.hm_nvml = nvml;
14021 }
14022
14023 if (data.hm_nvml)
14024 {
14025 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14026 {
14027 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14028
14029 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14030
14031 int tmp_out = 0;
14032
14033 for (int i = 0; i < tmp_in; i++)
14034 {
14035 hm_adapters_nvml[tmp_out++].adapter_index.nvml = nvmlGPUHandle[i];
14036 }
14037
14038 for (int i = 0; i < tmp_out; i++)
14039 {
14040 unsigned int speed;
14041
14042 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].adapter_index.nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14043
14044 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].adapter_index.nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14045
14046 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].adapter_index.nvml, NVML_GOM_ALL_ON);
14047 }
14048 }
14049 }
14050
14051 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14052 {
14053 data.hm_nvapi = nvapi;
14054 }
14055
14056 if (data.hm_nvapi)
14057 {
14058 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14059 {
14060 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14061
14062 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14063
14064 int tmp_out = 0;
14065
14066 for (int i = 0; i < tmp_in; i++)
14067 {
14068 hm_adapters_nvapi[tmp_out++].adapter_index.nvapi = nvGPUHandle[i];
14069 }
14070 }
14071 }
14072
14073 if ((need_adl == 1) && (adl_init (adl) == 0))
14074 {
14075 data.hm_adl = adl;
14076 }
14077
14078 if (data.hm_adl)
14079 {
14080 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14081 {
14082 // total number of adapters
14083
14084 int hm_adapters_num;
14085
14086 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14087
14088 // adapter info
14089
14090 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14091
14092 if (lpAdapterInfo == NULL) return (-1);
14093
14094 // get a list (of ids of) valid/usable adapters
14095
14096 int num_adl_adapters = 0;
14097
14098 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14099
14100 if (num_adl_adapters > 0)
14101 {
14102 hc_thread_mutex_lock (mux_adl);
14103
14104 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14105
14106 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14107
14108 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14109 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14110
14111 hc_thread_mutex_unlock (mux_adl);
14112 }
14113
14114 myfree (valid_adl_device_list);
14115 myfree (lpAdapterInfo);
14116 }
14117 }
14118
14119 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14120 {
14121 gpu_temp_disable = 1;
14122 }
14123 }
14124
14125 /**
14126 * OpenCL devices: allocate buffer for device specific information
14127 */
14128
14129 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14130 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14131
14132 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14133
14134 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14135
14136 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14137
14138 /**
14139 * User-defined GPU temp handling
14140 */
14141
14142 if (gpu_temp_disable == 1)
14143 {
14144 gpu_temp_abort = 0;
14145 gpu_temp_retain = 0;
14146 }
14147
14148 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14149 {
14150 if (gpu_temp_abort < gpu_temp_retain)
14151 {
14152 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14153
14154 return (-1);
14155 }
14156 }
14157
14158 data.gpu_temp_disable = gpu_temp_disable;
14159 data.gpu_temp_abort = gpu_temp_abort;
14160 data.gpu_temp_retain = gpu_temp_retain;
14161 #endif
14162
14163 /**
14164 * enable custom signal handler(s)
14165 */
14166
14167 if (benchmark == 0)
14168 {
14169 hc_signal (sigHandler_default);
14170 }
14171 else
14172 {
14173 hc_signal (sigHandler_benchmark);
14174 }
14175
14176 /**
14177 * inform the user
14178 */
14179
14180 if (data.quiet == 0)
14181 {
14182 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14183
14184 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);
14185
14186 if (attack_mode == ATTACK_MODE_STRAIGHT)
14187 {
14188 log_info ("Rules: %u", kernel_rules_cnt);
14189 }
14190
14191 if (opti_type)
14192 {
14193 log_info ("Applicable Optimizers:");
14194
14195 for (uint i = 0; i < 32; i++)
14196 {
14197 const uint opti_bit = 1u << i;
14198
14199 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14200 }
14201 }
14202
14203 /**
14204 * Watchdog and Temperature balance
14205 */
14206
14207 #ifdef HAVE_HWMON
14208 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14209 {
14210 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14211 }
14212
14213 if (gpu_temp_abort == 0)
14214 {
14215 log_info ("Watchdog: Temperature abort trigger disabled");
14216 }
14217 else
14218 {
14219 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14220 }
14221
14222 if (gpu_temp_retain == 0)
14223 {
14224 log_info ("Watchdog: Temperature retain trigger disabled");
14225 }
14226 else
14227 {
14228 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14229 }
14230
14231 if (data.quiet == 0) log_info ("");
14232 #endif
14233 }
14234
14235 #ifdef HAVE_HWMON
14236
14237 /**
14238 * HM devices: copy
14239 */
14240
14241 if (gpu_temp_disable == 0)
14242 {
14243 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14244 {
14245 hc_device_param_t *device_param = &data.devices_param[device_id];
14246
14247 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14248
14249 if (device_param->skipped) continue;
14250
14251 const uint platform_devices_id = device_param->platform_devices_id;
14252
14253 if (device_param->device_vendor_id == VENDOR_ID_NV)
14254 {
14255 memcpy (&data.hm_device[device_id], &hm_adapters_nvml[platform_devices_id], sizeof (hm_attrs_t));
14256 }
14257
14258 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14259 {
14260 memcpy (&data.hm_device[device_id], &hm_adapters_adl[platform_devices_id], sizeof (hm_attrs_t));
14261 }
14262 }
14263 }
14264
14265 /**
14266 * powertune on user request
14267 */
14268
14269 if (powertune_enable == 1)
14270 {
14271 hc_thread_mutex_lock (mux_adl);
14272
14273 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14274 {
14275 hc_device_param_t *device_param = &data.devices_param[device_id];
14276
14277 if (device_param->skipped) continue;
14278
14279 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14280 {
14281 /**
14282 * Temporary fix:
14283 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14284 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14285 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14286 * Driver / ADL bug?
14287 */
14288
14289 if (data.hm_device[device_id].od_version == 6)
14290 {
14291 int ADL_rc;
14292
14293 // check powertune capabilities first, if not available then skip device
14294
14295 int powertune_supported = 0;
14296
14297 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK)
14298 {
14299 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14300
14301 return (-1);
14302 }
14303
14304 // first backup current value, we will restore it later
14305
14306 if (powertune_supported != 0)
14307 {
14308 // powercontrol settings
14309
14310 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14311
14312 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune)) == ADL_OK)
14313 {
14314 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &od_power_control_status[device_id]);
14315 }
14316
14317 if (ADL_rc != ADL_OK)
14318 {
14319 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14320
14321 return (-1);
14322 }
14323
14324 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, powertune.iMaxValue)) != ADL_OK)
14325 {
14326 log_error ("ERROR: Failed to set new ADL PowerControl values");
14327
14328 return (-1);
14329 }
14330
14331 // clocks
14332
14333 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14334
14335 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14336
14337 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14338 {
14339 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14340
14341 return (-1);
14342 }
14343
14344 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14345
14346 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14347
14348 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &caps)) != ADL_OK)
14349 {
14350 log_error ("ERROR: Failed to get ADL device capabilities");
14351
14352 return (-1);
14353 }
14354
14355 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14356 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14357
14358 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14359 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14360
14361 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14362 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14363
14364 // warning if profile has too low max values
14365
14366 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14367 {
14368 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14369 }
14370
14371 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14372 {
14373 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14374 }
14375
14376 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14377
14378 performance_state->iNumberOfPerformanceLevels = 2;
14379
14380 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14381 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14382 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14383 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14384
14385 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14386 {
14387 log_info ("ERROR: Failed to set ADL performance state");
14388
14389 return (-1);
14390 }
14391
14392 local_free (performance_state);
14393 }
14394
14395 // set powertune value only
14396
14397 if (powertune_supported != 0)
14398 {
14399 // powertune set
14400 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14401
14402 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune)) != ADL_OK)
14403 {
14404 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14405
14406 return (-1);
14407 }
14408
14409 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, powertune.iMaxValue)) != ADL_OK)
14410 {
14411 log_error ("ERROR: Failed to set new ADL PowerControl values");
14412
14413 return (-1);
14414 }
14415 }
14416 }
14417 }
14418
14419 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14420 {
14421 // first backup current value, we will restore it later
14422
14423 unsigned int limit;
14424
14425 int powertune_supported = 0;
14426
14427 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &limit) == NVML_SUCCESS)
14428 {
14429 powertune_supported = 1;
14430 }
14431
14432 // if backup worked, activate the maximum allowed
14433
14434 if (powertune_supported != 0)
14435 {
14436 unsigned int minLimit;
14437 unsigned int maxLimit;
14438
14439 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14440 {
14441 if (maxLimit > 0)
14442 {
14443 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, maxLimit) == NVML_SUCCESS)
14444 {
14445 // now we can be sure we need to reset later
14446
14447 nvml_power_limit[device_id] = limit;
14448 }
14449 }
14450 }
14451 }
14452 }
14453 }
14454
14455 hc_thread_mutex_unlock (mux_adl);
14456 }
14457
14458 #endif // HAVE_HWMON
14459
14460 #ifdef DEBUG
14461 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14462 #endif
14463
14464 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14465
14466 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14467 {
14468 /**
14469 * host buffer
14470 */
14471
14472 hc_device_param_t *device_param = &data.devices_param[device_id];
14473
14474 if (device_param->skipped) continue;
14475
14476 /**
14477 * device properties
14478 */
14479
14480 const char *device_name_chksum = device_param->device_name_chksum;
14481 const u32 device_processors = device_param->device_processors;
14482 const u32 device_processor_cores = device_param->device_processor_cores;
14483
14484 /**
14485 * create context for each device
14486 */
14487
14488 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14489
14490 /**
14491 * create command-queue
14492 */
14493
14494 // not supported with NV
14495 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14496
14497 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14498
14499 /**
14500 * kernel threads: some algorithms need a fixed kernel-threads count
14501 * because of shared memory usage or bitslice
14502 * there needs to be some upper limit, otherwise there's too much overhead
14503 */
14504
14505 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14506
14507 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14508 {
14509 kernel_threads = KERNEL_THREADS_MAX_CPU;
14510 }
14511
14512 if (hash_mode == 1500) kernel_threads = 64; // DES
14513 if (hash_mode == 3000) kernel_threads = 64; // DES
14514 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14515 if (hash_mode == 7500) kernel_threads = 64; // RC4
14516 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14517 if (hash_mode == 9700) kernel_threads = 64; // RC4
14518 if (hash_mode == 9710) kernel_threads = 64; // RC4
14519 if (hash_mode == 9800) kernel_threads = 64; // RC4
14520 if (hash_mode == 9810) kernel_threads = 64; // RC4
14521 if (hash_mode == 10400) kernel_threads = 64; // RC4
14522 if (hash_mode == 10410) kernel_threads = 64; // RC4
14523 if (hash_mode == 10500) kernel_threads = 64; // RC4
14524 if (hash_mode == 13100) kernel_threads = 64; // RC4
14525
14526 device_param->kernel_threads = kernel_threads;
14527
14528 /**
14529 * create input buffers on device : calculate size of fixed memory buffers
14530 */
14531
14532 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14533 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14534
14535 device_param->size_root_css = size_root_css;
14536 device_param->size_markov_css = size_markov_css;
14537
14538 size_t size_results = sizeof (uint);
14539
14540 device_param->size_results = size_results;
14541
14542 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14543 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14544
14545 size_t size_plains = digests_cnt * sizeof (plain_t);
14546 size_t size_salts = salts_cnt * sizeof (salt_t);
14547 size_t size_esalts = salts_cnt * esalt_size;
14548
14549 device_param->size_plains = size_plains;
14550 device_param->size_digests = size_digests;
14551 device_param->size_shown = size_shown;
14552 device_param->size_salts = size_salts;
14553
14554 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14555 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14556 size_t size_tm = 32 * sizeof (bs_word_t);
14557
14558 // scryptV stuff
14559
14560 size_t size_scryptV = 1;
14561
14562 if ((hash_mode == 8900) || (hash_mode == 9300))
14563 {
14564 uint tmto_start = 0;
14565 uint tmto_stop = 10;
14566
14567 if (scrypt_tmto)
14568 {
14569 tmto_start = scrypt_tmto;
14570 }
14571 else
14572 {
14573 // in case the user did not specify the tmto manually
14574 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14575 // but set the lower end only in case the user has a device with too less memory
14576
14577 if (hash_mode == 8900)
14578 {
14579 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14580 {
14581 tmto_start = 1;
14582 }
14583 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14584 {
14585 tmto_start = 2;
14586 }
14587 }
14588 else if (hash_mode == 9300)
14589 {
14590 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14591 {
14592 tmto_start = 2;
14593 }
14594 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14595 {
14596 tmto_start = 2;
14597 }
14598 }
14599 }
14600
14601 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14602 {
14603 // TODO: in theory the following calculation needs to be done per salt, not global
14604 // we assume all hashes have the same scrypt settings
14605
14606 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14607
14608 size_scryptV /= 1 << tmto;
14609
14610 size_scryptV *= device_processors * device_processor_cores;
14611
14612 if (size_scryptV > device_param->device_maxmem_alloc)
14613 {
14614 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14615
14616 continue;
14617 }
14618
14619 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14620 {
14621 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14622 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14623 }
14624
14625 break;
14626 }
14627
14628 if (data.salts_buf[0].scrypt_phy == 0)
14629 {
14630 log_error ("ERROR: can't allocate enough device memory");
14631
14632 return -1;
14633 }
14634
14635 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14636 }
14637
14638 /**
14639 * some algorithms need a fixed kernel-loops count
14640 */
14641
14642 if (hash_mode == 1500)
14643 {
14644 const u32 kernel_loops_fixed = 1024;
14645
14646 device_param->kernel_loops_min = kernel_loops_fixed;
14647 device_param->kernel_loops_max = kernel_loops_fixed;
14648 }
14649
14650 if (hash_mode == 3000)
14651 {
14652 const u32 kernel_loops_fixed = 1024;
14653
14654 device_param->kernel_loops_min = kernel_loops_fixed;
14655 device_param->kernel_loops_max = kernel_loops_fixed;
14656 }
14657
14658 if (hash_mode == 8900)
14659 {
14660 const u32 kernel_loops_fixed = 1;
14661
14662 device_param->kernel_loops_min = kernel_loops_fixed;
14663 device_param->kernel_loops_max = kernel_loops_fixed;
14664 }
14665
14666 if (hash_mode == 9300)
14667 {
14668 const u32 kernel_loops_fixed = 1;
14669
14670 device_param->kernel_loops_min = kernel_loops_fixed;
14671 device_param->kernel_loops_max = kernel_loops_fixed;
14672 }
14673
14674 if (hash_mode == 12500)
14675 {
14676 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14677
14678 device_param->kernel_loops_min = kernel_loops_fixed;
14679 device_param->kernel_loops_max = kernel_loops_fixed;
14680 }
14681
14682 /**
14683 * some algorithms have a maximum kernel-loops count
14684 */
14685
14686 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14687 {
14688 u32 innerloop_cnt = 0;
14689
14690 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14691 {
14692 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14693 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14694 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14695 }
14696 else
14697 {
14698 innerloop_cnt = data.salts_buf[0].salt_iter;
14699 }
14700
14701 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14702 (innerloop_cnt <= device_param->kernel_loops_max))
14703 {
14704 device_param->kernel_loops_max = innerloop_cnt;
14705 }
14706 }
14707
14708 u32 kernel_accel_min = device_param->kernel_accel_min;
14709 u32 kernel_accel_max = device_param->kernel_accel_max;
14710
14711 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14712
14713 size_t size_pws = 4;
14714 size_t size_tmps = 4;
14715 size_t size_hooks = 4;
14716
14717 while (kernel_accel_max >= kernel_accel_min)
14718 {
14719 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14720
14721 // size_pws
14722
14723 size_pws = kernel_power_max * sizeof (pw_t);
14724
14725 // size_tmps
14726
14727 switch (hash_mode)
14728 {
14729 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14730 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14731 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14732 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14733 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14734 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14735 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14736 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14737 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14738 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14739 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14740 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14741 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14742 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14743 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14744 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14745 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14746 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14747 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14748 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14749 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14750 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14751 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14752 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14753 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14754 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14755 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14756 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14757 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14758 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14759 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14760 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14761 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14762 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14763 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14764 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14765 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14766 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14767 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14768 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14769 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14770 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14771 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14772 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14773 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14774 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14775 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14776 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14777 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14778 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14779 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14780 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14781 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14782 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14783 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14784 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14785 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14786 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14787 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14788 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14789 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14790 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14791 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14792 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14793 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14794 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14795 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14796 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14797 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14798 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14799 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14800 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14801 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14802 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14803 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14804 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14805 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14806 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14807 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14808 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14809 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14810 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14811 };
14812
14813 // size_hooks
14814
14815 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14816 {
14817 // none yet
14818 }
14819
14820 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14821 // if not, decrease amplifier and try again
14822
14823 int skip = 0;
14824
14825 const u64 size_total
14826 = bitmap_size
14827 + bitmap_size
14828 + bitmap_size
14829 + bitmap_size
14830 + bitmap_size
14831 + bitmap_size
14832 + bitmap_size
14833 + bitmap_size
14834 + size_bfs
14835 + size_combs
14836 + size_digests
14837 + size_esalts
14838 + size_hooks
14839 + size_markov_css
14840 + size_plains
14841 + size_pws
14842 + size_pws // not a bug
14843 + size_results
14844 + size_root_css
14845 + size_rules
14846 + size_rules_c
14847 + size_salts
14848 + size_scryptV
14849 + size_shown
14850 + size_tm
14851 + size_tmps;
14852
14853 // Don't ask me, ask AMD!
14854
14855 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14856 if (size_total > device_param->device_global_mem) skip = 1;
14857
14858 if (skip == 1)
14859 {
14860 kernel_accel_max--;
14861
14862 continue;
14863 }
14864
14865 break;
14866 }
14867
14868 /*
14869 if (kernel_accel_max == 0)
14870 {
14871 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14872
14873 return -1;
14874 }
14875 */
14876
14877 device_param->kernel_accel_min = kernel_accel_min;
14878 device_param->kernel_accel_max = kernel_accel_max;
14879
14880 /*
14881 if (kernel_accel_max < kernel_accel)
14882 {
14883 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14884
14885 device_param->kernel_accel = kernel_accel_max;
14886 }
14887 */
14888
14889 device_param->size_bfs = size_bfs;
14890 device_param->size_combs = size_combs;
14891 device_param->size_rules = size_rules;
14892 device_param->size_rules_c = size_rules_c;
14893 device_param->size_pws = size_pws;
14894 device_param->size_tmps = size_tmps;
14895 device_param->size_hooks = size_hooks;
14896
14897 /**
14898 * default building options
14899 */
14900
14901 char build_opts[1024] = { 0 };
14902
14903 // we don't have sm_* on vendors not NV but it doesn't matter
14904
14905 #if _WIN
14906 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);
14907 #else
14908 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);
14909 #endif
14910
14911 char build_opts_new[1024] = { 0 };
14912
14913 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);
14914
14915 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14916
14917 /*
14918 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14919 {
14920 // we do vectorizing much better than the auto-vectorizer
14921
14922 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14923
14924 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14925 }
14926 */
14927
14928 #ifdef DEBUG
14929 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14930 #endif
14931
14932 /**
14933 * main kernel
14934 */
14935
14936 {
14937 /**
14938 * kernel source filename
14939 */
14940
14941 char source_file[256] = { 0 };
14942
14943 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14944
14945 struct stat sst;
14946
14947 if (stat (source_file, &sst) == -1)
14948 {
14949 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14950
14951 return -1;
14952 }
14953
14954 /**
14955 * kernel cached filename
14956 */
14957
14958 char cached_file[256] = { 0 };
14959
14960 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14961
14962 int cached = 1;
14963
14964 struct stat cst;
14965
14966 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14967 {
14968 cached = 0;
14969 }
14970
14971 /**
14972 * kernel compile or load
14973 */
14974
14975 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14976
14977 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14978
14979 if (force_jit_compilation == -1)
14980 {
14981 if (cached == 0)
14982 {
14983 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14984
14985 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14986
14987 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14988
14989 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14990
14991 #ifdef DEBUG
14992 size_t build_log_size = 0;
14993
14994 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14995
14996 if (build_log_size > 1)
14997 {
14998 char *build_log = (char *) malloc (build_log_size + 1);
14999
15000 memset (build_log, 0, build_log_size + 1);
15001
15002 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15003
15004 puts (build_log);
15005
15006 free (build_log);
15007 }
15008 #endif
15009
15010 if (rc != 0)
15011 {
15012 device_param->skipped = true;
15013
15014 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15015
15016 continue;
15017 }
15018
15019 size_t binary_size;
15020
15021 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15022
15023 u8 *binary = (u8 *) mymalloc (binary_size);
15024
15025 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15026
15027 writeProgramBin (cached_file, binary, binary_size);
15028
15029 local_free (binary);
15030 }
15031 else
15032 {
15033 #ifdef DEBUG
15034 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15035 #endif
15036
15037 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15038
15039 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15040
15041 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15042 }
15043 }
15044 else
15045 {
15046 #ifdef DEBUG
15047 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15048 #endif
15049
15050 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15051
15052 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15053
15054 char build_opts_update[1024] = { 0 };
15055
15056 if (force_jit_compilation == 1500)
15057 {
15058 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15059 }
15060 else if (force_jit_compilation == 8900)
15061 {
15062 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);
15063 }
15064 else
15065 {
15066 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15067 }
15068
15069 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15070
15071 #ifdef DEBUG
15072 size_t build_log_size = 0;
15073
15074 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15075
15076 if (build_log_size > 1)
15077 {
15078 char *build_log = (char *) malloc (build_log_size + 1);
15079
15080 memset (build_log, 0, build_log_size + 1);
15081
15082 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15083
15084 puts (build_log);
15085
15086 free (build_log);
15087 }
15088 #endif
15089
15090 if (rc != 0)
15091 {
15092 device_param->skipped = true;
15093
15094 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15095 }
15096 }
15097
15098 local_free (kernel_lengths);
15099 local_free (kernel_sources[0]);
15100 local_free (kernel_sources);
15101 }
15102
15103 /**
15104 * word generator kernel
15105 */
15106
15107 if (attack_mode != ATTACK_MODE_STRAIGHT)
15108 {
15109 /**
15110 * kernel mp source filename
15111 */
15112
15113 char source_file[256] = { 0 };
15114
15115 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15116
15117 struct stat sst;
15118
15119 if (stat (source_file, &sst) == -1)
15120 {
15121 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15122
15123 return -1;
15124 }
15125
15126 /**
15127 * kernel mp cached filename
15128 */
15129
15130 char cached_file[256] = { 0 };
15131
15132 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15133
15134 int cached = 1;
15135
15136 struct stat cst;
15137
15138 if (stat (cached_file, &cst) == -1)
15139 {
15140 cached = 0;
15141 }
15142
15143 /**
15144 * kernel compile or load
15145 */
15146
15147 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15148
15149 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15150
15151 if (cached == 0)
15152 {
15153 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15154 if (quiet == 0) log_info ("");
15155
15156 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15157
15158 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15159
15160 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15161
15162 if (rc != 0)
15163 {
15164 device_param->skipped = true;
15165
15166 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15167
15168 continue;
15169 }
15170
15171 size_t binary_size;
15172
15173 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15174
15175 u8 *binary = (u8 *) mymalloc (binary_size);
15176
15177 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15178
15179 writeProgramBin (cached_file, binary, binary_size);
15180
15181 local_free (binary);
15182 }
15183 else
15184 {
15185 #ifdef DEBUG
15186 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15187 #endif
15188
15189 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15190
15191 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15192
15193 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15194 }
15195
15196 local_free (kernel_lengths);
15197 local_free (kernel_sources[0]);
15198 local_free (kernel_sources);
15199 }
15200
15201 /**
15202 * amplifier kernel
15203 */
15204
15205 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15206 {
15207
15208 }
15209 else
15210 {
15211 /**
15212 * kernel amp source filename
15213 */
15214
15215 char source_file[256] = { 0 };
15216
15217 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15218
15219 struct stat sst;
15220
15221 if (stat (source_file, &sst) == -1)
15222 {
15223 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15224
15225 return -1;
15226 }
15227
15228 /**
15229 * kernel amp cached filename
15230 */
15231
15232 char cached_file[256] = { 0 };
15233
15234 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15235
15236 int cached = 1;
15237
15238 struct stat cst;
15239
15240 if (stat (cached_file, &cst) == -1)
15241 {
15242 cached = 0;
15243 }
15244
15245 /**
15246 * kernel compile or load
15247 */
15248
15249 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15250
15251 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15252
15253 if (cached == 0)
15254 {
15255 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15256 if (quiet == 0) log_info ("");
15257
15258 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15259
15260 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15261
15262 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15263
15264 if (rc != 0)
15265 {
15266 device_param->skipped = true;
15267
15268 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15269
15270 continue;
15271 }
15272
15273 size_t binary_size;
15274
15275 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15276
15277 u8 *binary = (u8 *) mymalloc (binary_size);
15278
15279 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15280
15281 writeProgramBin (cached_file, binary, binary_size);
15282
15283 local_free (binary);
15284 }
15285 else
15286 {
15287 #ifdef DEBUG
15288 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15289 #endif
15290
15291 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15292
15293 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15294
15295 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15296 }
15297
15298 local_free (kernel_lengths);
15299 local_free (kernel_sources[0]);
15300 local_free (kernel_sources);
15301 }
15302
15303 // some algorithm collide too fast, make that impossible
15304
15305 if (benchmark == 1)
15306 {
15307 ((uint *) digests_buf)[0] = -1;
15308 ((uint *) digests_buf)[1] = -1;
15309 ((uint *) digests_buf)[2] = -1;
15310 ((uint *) digests_buf)[3] = -1;
15311 }
15312
15313 /**
15314 * global buffers
15315 */
15316
15317 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15318 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15319 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15320 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15321 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15322 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15323 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15324 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15325 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15326 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15327 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15328 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15329 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15330 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15331 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15332 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15333 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15334 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15335
15336 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);
15337 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);
15338 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);
15339 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);
15340 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);
15341 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);
15342 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);
15343 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);
15344 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15345 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15346 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15347
15348 /**
15349 * special buffers
15350 */
15351
15352 if (attack_kern == ATTACK_KERN_STRAIGHT)
15353 {
15354 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15355 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15356
15357 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15358 }
15359 else if (attack_kern == ATTACK_KERN_COMBI)
15360 {
15361 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15362 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15363 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15364 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15365 }
15366 else if (attack_kern == ATTACK_KERN_BF)
15367 {
15368 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15369 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15370 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15371 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15372 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15373 }
15374
15375 if (size_esalts)
15376 {
15377 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15378
15379 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15380 }
15381
15382 /**
15383 * main host data
15384 */
15385
15386 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15387
15388 device_param->pws_buf = pws_buf;
15389
15390 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15391
15392 device_param->combs_buf = combs_buf;
15393
15394 void *hooks_buf = mymalloc (size_hooks);
15395
15396 device_param->hooks_buf = hooks_buf;
15397
15398 /**
15399 * kernel args
15400 */
15401
15402 device_param->kernel_params_buf32[21] = bitmap_mask;
15403 device_param->kernel_params_buf32[22] = bitmap_shift1;
15404 device_param->kernel_params_buf32[23] = bitmap_shift2;
15405 device_param->kernel_params_buf32[24] = 0; // salt_pos
15406 device_param->kernel_params_buf32[25] = 0; // loop_pos
15407 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15408 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15409 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15410 device_param->kernel_params_buf32[29] = 0; // digests_offset
15411 device_param->kernel_params_buf32[30] = 0; // combs_mode
15412 device_param->kernel_params_buf32[31] = 0; // gid_max
15413
15414 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15415 ? &device_param->d_pws_buf
15416 : &device_param->d_pws_amp_buf;
15417 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15418 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15419 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15420 device_param->kernel_params[ 4] = &device_param->d_tmps;
15421 device_param->kernel_params[ 5] = &device_param->d_hooks;
15422 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15423 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15424 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15425 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15426 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15427 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15428 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15429 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15430 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15431 device_param->kernel_params[15] = &device_param->d_digests_buf;
15432 device_param->kernel_params[16] = &device_param->d_digests_shown;
15433 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15434 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15435 device_param->kernel_params[19] = &device_param->d_result;
15436 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15437 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15438 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15439 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15440 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15441 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15442 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15443 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15444 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15445 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15446 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15447 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15448
15449 device_param->kernel_params_mp_buf64[3] = 0;
15450 device_param->kernel_params_mp_buf32[4] = 0;
15451 device_param->kernel_params_mp_buf32[5] = 0;
15452 device_param->kernel_params_mp_buf32[6] = 0;
15453 device_param->kernel_params_mp_buf32[7] = 0;
15454 device_param->kernel_params_mp_buf32[8] = 0;
15455
15456 device_param->kernel_params_mp[0] = NULL;
15457 device_param->kernel_params_mp[1] = NULL;
15458 device_param->kernel_params_mp[2] = NULL;
15459 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15460 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15461 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15462 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15463 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15464 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15465
15466 device_param->kernel_params_mp_l_buf64[3] = 0;
15467 device_param->kernel_params_mp_l_buf32[4] = 0;
15468 device_param->kernel_params_mp_l_buf32[5] = 0;
15469 device_param->kernel_params_mp_l_buf32[6] = 0;
15470 device_param->kernel_params_mp_l_buf32[7] = 0;
15471 device_param->kernel_params_mp_l_buf32[8] = 0;
15472 device_param->kernel_params_mp_l_buf32[9] = 0;
15473
15474 device_param->kernel_params_mp_l[0] = NULL;
15475 device_param->kernel_params_mp_l[1] = NULL;
15476 device_param->kernel_params_mp_l[2] = NULL;
15477 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15478 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15479 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15480 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15481 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15482 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15483 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15484
15485 device_param->kernel_params_mp_r_buf64[3] = 0;
15486 device_param->kernel_params_mp_r_buf32[4] = 0;
15487 device_param->kernel_params_mp_r_buf32[5] = 0;
15488 device_param->kernel_params_mp_r_buf32[6] = 0;
15489 device_param->kernel_params_mp_r_buf32[7] = 0;
15490 device_param->kernel_params_mp_r_buf32[8] = 0;
15491
15492 device_param->kernel_params_mp_r[0] = NULL;
15493 device_param->kernel_params_mp_r[1] = NULL;
15494 device_param->kernel_params_mp_r[2] = NULL;
15495 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15496 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15497 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15498 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15499 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15500 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15501
15502 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15503 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15504
15505 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15506 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15507 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15508 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15509 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15510 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15511 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15512
15513 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15514 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15515
15516 device_param->kernel_params_memset_buf32[1] = 0; // value
15517 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15518
15519 device_param->kernel_params_memset[0] = NULL;
15520 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15521 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15522
15523 /**
15524 * kernel name
15525 */
15526
15527 size_t kernel_wgs_tmp;
15528
15529 char kernel_name[64] = { 0 };
15530
15531 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15532 {
15533 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15534 {
15535 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15536
15537 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15538
15539 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15540
15541 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15542
15543 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15544
15545 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15546 }
15547 else
15548 {
15549 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15550
15551 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15552
15553 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15554
15555 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15556
15557 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15558
15559 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15560 }
15561
15562 if (data.attack_mode == ATTACK_MODE_BF)
15563 {
15564 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15565 {
15566 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15567
15568 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15569
15570 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);
15571 }
15572 }
15573 }
15574 else
15575 {
15576 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15577
15578 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15579
15580 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15581
15582 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15583
15584 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15585
15586 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15587
15588 if (opts_type & OPTS_TYPE_HOOK12)
15589 {
15590 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15591
15592 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15593
15594 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);
15595 }
15596
15597 if (opts_type & OPTS_TYPE_HOOK23)
15598 {
15599 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15600
15601 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15602
15603 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);
15604 }
15605 }
15606
15607 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);
15608 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);
15609 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);
15610
15611 for (uint i = 0; i <= 20; i++)
15612 {
15613 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15614 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15615 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15616
15617 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15618 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15619 }
15620
15621 for (uint i = 21; i <= 31; i++)
15622 {
15623 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15624 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15625 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15626
15627 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15628 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15629 }
15630
15631 // GPU memset
15632
15633 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15634
15635 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);
15636
15637 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15638 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15639 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15640
15641 // MP start
15642
15643 if (attack_mode == ATTACK_MODE_BF)
15644 {
15645 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15646 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15647
15648 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);
15649 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);
15650
15651 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15652 {
15653 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15654 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15655 }
15656 }
15657 else if (attack_mode == ATTACK_MODE_HYBRID1)
15658 {
15659 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15660
15661 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);
15662 }
15663 else if (attack_mode == ATTACK_MODE_HYBRID2)
15664 {
15665 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15666
15667 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);
15668 }
15669
15670 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15671 {
15672 // nothing to do
15673 }
15674 else
15675 {
15676 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15677
15678 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);
15679 }
15680
15681 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15682 {
15683 // nothing to do
15684 }
15685 else
15686 {
15687 for (uint i = 0; i < 5; i++)
15688 {
15689 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15690 }
15691
15692 for (uint i = 5; i < 7; i++)
15693 {
15694 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15695 }
15696 }
15697
15698 // maybe this has been updated by clGetKernelWorkGroupInfo()
15699 // value can only be decreased, so we don't need to reallocate buffers
15700
15701 device_param->kernel_threads = kernel_threads;
15702
15703 // zero some data buffers
15704
15705 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15706 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15707 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15708 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15709 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15710 run_kernel_bzero (device_param, device_param->d_result, size_results);
15711
15712 /**
15713 * special buffers
15714 */
15715
15716 if (attack_kern == ATTACK_KERN_STRAIGHT)
15717 {
15718 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15719 }
15720 else if (attack_kern == ATTACK_KERN_COMBI)
15721 {
15722 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15723 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15724 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15725 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15726 }
15727 else if (attack_kern == ATTACK_KERN_BF)
15728 {
15729 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15730 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15731 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15732 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15733 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15734 }
15735
15736 #if defined(HAVE_HWMON)
15737
15738 /**
15739 * Store thermal target temperature so we can send a notice to user
15740 */
15741
15742 if (gpu_temp_disable == 0)
15743 {
15744 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15745 const int gpu_temp_threshold_shutdown = hm_get_threshold_slowdown_with_device_id (device_id);
15746
15747 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown > 0) ? gpu_temp_threshold_slowdown : 10000;
15748 data.hm_device[device_id].gpu_temp_threshold_shutdown = (gpu_temp_threshold_shutdown > 0) ? gpu_temp_threshold_shutdown : 10000;
15749
15750 // we could use those numbers for gpu_temp_retain and gpu_temp_abort, too
15751 }
15752
15753 /**
15754 * Store initial fanspeed if gpu_temp_retain is enabled
15755 */
15756
15757 if (gpu_temp_disable == 0)
15758 {
15759 if (gpu_temp_retain != 0)
15760 {
15761 hc_thread_mutex_lock (mux_adl);
15762
15763 if (data.hm_device[device_id].fan_get_supported == 1)
15764 {
15765 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
15766 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
15767
15768 temp_retain_fanspeed_value[device_id] = fanspeed;
15769 temp_retain_fanpolicy_value[device_id] = fanpolicy;
15770
15771 // we also set it to tell the OS we take control over the fan and it's automatic controller
15772 // if it was set to automatic. we do not control user-defined fanspeeds.
15773
15774 if (fanpolicy == 1)
15775 {
15776 data.hm_device[device_id].fan_set_supported = 1;
15777
15778 int rc = -1;
15779
15780 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15781 {
15782 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
15783 }
15784 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15785 {
15786
15787 }
15788
15789 if (rc == 0)
15790 {
15791 data.hm_device[device_id].fan_set_supported = 1;
15792 }
15793 else
15794 {
15795 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
15796
15797 data.hm_device[device_id].fan_set_supported = 0;
15798 }
15799 }
15800 else
15801 {
15802 data.hm_device[device_id].fan_set_supported = 0;
15803 }
15804 }
15805
15806 hc_thread_mutex_unlock (mux_adl);
15807 }
15808 }
15809
15810 #endif // HAVE_HWMON
15811 }
15812
15813 if (data.quiet == 0) log_info_nn ("");
15814
15815 /**
15816 * In benchmark-mode, inform user which algorithm is checked
15817 */
15818
15819 if (benchmark == 1)
15820 {
15821 if (machine_readable == 0)
15822 {
15823 quiet = 0;
15824
15825 data.quiet = quiet;
15826
15827 char *hash_type = strhashtype (data.hash_mode); // not a bug
15828
15829 log_info ("Hashtype: %s", hash_type);
15830 log_info ("");
15831 }
15832 }
15833
15834 /**
15835 * keep track of the progress
15836 */
15837
15838 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15839 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15840 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15841
15842 /**
15843 * open filehandles
15844 */
15845
15846 #if _WIN
15847 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15848 {
15849 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15850
15851 return (-1);
15852 }
15853
15854 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15855 {
15856 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15857
15858 return (-1);
15859 }
15860
15861 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15862 {
15863 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15864
15865 return (-1);
15866 }
15867 #endif
15868
15869 /**
15870 * dictionary pad
15871 */
15872
15873 segment_size *= (1024 * 1024);
15874
15875 data.segment_size = segment_size;
15876
15877 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15878
15879 wl_data->buf = (char *) mymalloc (segment_size);
15880 wl_data->avail = segment_size;
15881 wl_data->incr = segment_size;
15882 wl_data->cnt = 0;
15883 wl_data->pos = 0;
15884
15885 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15886
15887 data.wordlist_mode = wordlist_mode;
15888
15889 cs_t *css_buf = NULL;
15890 uint css_cnt = 0;
15891 uint dictcnt = 0;
15892 uint maskcnt = 1;
15893 char **masks = NULL;
15894 char **dictfiles = NULL;
15895
15896 uint mask_from_file = 0;
15897
15898 if (attack_mode == ATTACK_MODE_STRAIGHT)
15899 {
15900 if (wordlist_mode == WL_MODE_FILE)
15901 {
15902 int wls_left = myargc - (optind + 1);
15903
15904 for (int i = 0; i < wls_left; i++)
15905 {
15906 char *l0_filename = myargv[optind + 1 + i];
15907
15908 struct stat l0_stat;
15909
15910 if (stat (l0_filename, &l0_stat) == -1)
15911 {
15912 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15913
15914 return (-1);
15915 }
15916
15917 uint is_dir = S_ISDIR (l0_stat.st_mode);
15918
15919 if (is_dir == 0)
15920 {
15921 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15922
15923 dictcnt++;
15924
15925 dictfiles[dictcnt - 1] = l0_filename;
15926 }
15927 else
15928 {
15929 // do not allow --keyspace w/ a directory
15930
15931 if (keyspace == 1)
15932 {
15933 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15934
15935 return (-1);
15936 }
15937
15938 char **dictionary_files = NULL;
15939
15940 dictionary_files = scan_directory (l0_filename);
15941
15942 if (dictionary_files != NULL)
15943 {
15944 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15945
15946 for (int d = 0; dictionary_files[d] != NULL; d++)
15947 {
15948 char *l1_filename = dictionary_files[d];
15949
15950 struct stat l1_stat;
15951
15952 if (stat (l1_filename, &l1_stat) == -1)
15953 {
15954 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15955
15956 return (-1);
15957 }
15958
15959 if (S_ISREG (l1_stat.st_mode))
15960 {
15961 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15962
15963 dictcnt++;
15964
15965 dictfiles[dictcnt - 1] = strdup (l1_filename);
15966 }
15967 }
15968 }
15969
15970 local_free (dictionary_files);
15971 }
15972 }
15973
15974 if (dictcnt < 1)
15975 {
15976 log_error ("ERROR: No usable dictionary file found.");
15977
15978 return (-1);
15979 }
15980 }
15981 else if (wordlist_mode == WL_MODE_STDIN)
15982 {
15983 dictcnt = 1;
15984 }
15985 }
15986 else if (attack_mode == ATTACK_MODE_COMBI)
15987 {
15988 // display
15989
15990 char *dictfile1 = myargv[optind + 1 + 0];
15991 char *dictfile2 = myargv[optind + 1 + 1];
15992
15993 // find the bigger dictionary and use as base
15994
15995 FILE *fp1 = NULL;
15996 FILE *fp2 = NULL;
15997
15998 struct stat tmp_stat;
15999
16000 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16001 {
16002 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16003
16004 return (-1);
16005 }
16006
16007 if (stat (dictfile1, &tmp_stat) == -1)
16008 {
16009 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16010
16011 fclose (fp1);
16012
16013 return (-1);
16014 }
16015
16016 if (S_ISDIR (tmp_stat.st_mode))
16017 {
16018 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16019
16020 fclose (fp1);
16021
16022 return (-1);
16023 }
16024
16025 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16026 {
16027 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16028
16029 fclose (fp1);
16030
16031 return (-1);
16032 }
16033
16034 if (stat (dictfile2, &tmp_stat) == -1)
16035 {
16036 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16037
16038 fclose (fp1);
16039 fclose (fp2);
16040
16041 return (-1);
16042 }
16043
16044 if (S_ISDIR (tmp_stat.st_mode))
16045 {
16046 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16047
16048 fclose (fp1);
16049 fclose (fp2);
16050
16051 return (-1);
16052 }
16053
16054 data.combs_cnt = 1;
16055
16056 data.quiet = 1;
16057
16058 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16059
16060 data.quiet = quiet;
16061
16062 if (words1_cnt == 0)
16063 {
16064 log_error ("ERROR: %s: empty file", dictfile1);
16065
16066 fclose (fp1);
16067 fclose (fp2);
16068
16069 return (-1);
16070 }
16071
16072 data.combs_cnt = 1;
16073
16074 data.quiet = 1;
16075
16076 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16077
16078 data.quiet = quiet;
16079
16080 if (words2_cnt == 0)
16081 {
16082 log_error ("ERROR: %s: empty file", dictfile2);
16083
16084 fclose (fp1);
16085 fclose (fp2);
16086
16087 return (-1);
16088 }
16089
16090 fclose (fp1);
16091 fclose (fp2);
16092
16093 data.dictfile = dictfile1;
16094 data.dictfile2 = dictfile2;
16095
16096 if (words1_cnt >= words2_cnt)
16097 {
16098 data.combs_cnt = words2_cnt;
16099 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16100
16101 dictfiles = &data.dictfile;
16102
16103 dictcnt = 1;
16104 }
16105 else
16106 {
16107 data.combs_cnt = words1_cnt;
16108 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16109
16110 dictfiles = &data.dictfile2;
16111
16112 dictcnt = 1;
16113
16114 // we also have to switch wordlist related rules!
16115
16116 char *tmpc = data.rule_buf_l;
16117
16118 data.rule_buf_l = data.rule_buf_r;
16119 data.rule_buf_r = tmpc;
16120
16121 int tmpi = data.rule_len_l;
16122
16123 data.rule_len_l = data.rule_len_r;
16124 data.rule_len_r = tmpi;
16125 }
16126 }
16127 else if (attack_mode == ATTACK_MODE_BF)
16128 {
16129 char *mask = NULL;
16130
16131 maskcnt = 0;
16132
16133 if (benchmark == 0)
16134 {
16135 mask = myargv[optind + 1];
16136
16137 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16138
16139 if ((optind + 2) <= myargc)
16140 {
16141 struct stat file_stat;
16142
16143 if (stat (mask, &file_stat) == -1)
16144 {
16145 maskcnt = 1;
16146
16147 masks[maskcnt - 1] = mystrdup (mask);
16148 }
16149 else
16150 {
16151 int wls_left = myargc - (optind + 1);
16152
16153 uint masks_avail = INCR_MASKS;
16154
16155 for (int i = 0; i < wls_left; i++)
16156 {
16157 if (i != 0)
16158 {
16159 mask = myargv[optind + 1 + i];
16160
16161 if (stat (mask, &file_stat) == -1)
16162 {
16163 log_error ("ERROR: %s: %s", mask, strerror (errno));
16164
16165 return (-1);
16166 }
16167 }
16168
16169 uint is_file = S_ISREG (file_stat.st_mode);
16170
16171 if (is_file == 1)
16172 {
16173 FILE *mask_fp;
16174
16175 if ((mask_fp = fopen (mask, "r")) == NULL)
16176 {
16177 log_error ("ERROR: %s: %s", mask, strerror (errno));
16178
16179 return (-1);
16180 }
16181
16182 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16183
16184 while (!feof (mask_fp))
16185 {
16186 memset (line_buf, 0, HCBUFSIZ);
16187
16188 int line_len = fgetl (mask_fp, line_buf);
16189
16190 if (line_len == 0) continue;
16191
16192 if (line_buf[0] == '#') continue;
16193
16194 if (masks_avail == maskcnt)
16195 {
16196 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16197
16198 masks_avail += INCR_MASKS;
16199 }
16200
16201 masks[maskcnt] = mystrdup (line_buf);
16202
16203 maskcnt++;
16204 }
16205
16206 myfree (line_buf);
16207
16208 fclose (mask_fp);
16209 }
16210 else
16211 {
16212 log_error ("ERROR: %s: unsupported file-type", mask);
16213
16214 return (-1);
16215 }
16216 }
16217
16218 mask_from_file = 1;
16219 }
16220 }
16221 else
16222 {
16223 custom_charset_1 = (char *) "?l?d?u";
16224 custom_charset_2 = (char *) "?l?d";
16225 custom_charset_3 = (char *) "?l?d*!$@_";
16226
16227 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16228 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16229 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16230
16231 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16232
16233 wordlist_mode = WL_MODE_MASK;
16234
16235 data.wordlist_mode = wordlist_mode;
16236
16237 increment = 1;
16238
16239 maskcnt = 1;
16240 }
16241 }
16242 else
16243 {
16244 /**
16245 * generate full masks and charsets
16246 */
16247
16248 masks = (char **) mymalloc (sizeof (char *));
16249
16250 switch (hash_mode)
16251 {
16252 case 1731: pw_min = 5;
16253 pw_max = 5;
16254 mask = mystrdup ("?b?b?b?b?b");
16255 break;
16256 case 12500: pw_min = 5;
16257 pw_max = 5;
16258 mask = mystrdup ("?b?b?b?b?b");
16259 break;
16260 default: pw_min = 7;
16261 pw_max = 7;
16262 mask = mystrdup ("?b?b?b?b?b?b?b");
16263 break;
16264 }
16265
16266 maskcnt = 1;
16267
16268 masks[maskcnt - 1] = mystrdup (mask);
16269
16270 wordlist_mode = WL_MODE_MASK;
16271
16272 data.wordlist_mode = wordlist_mode;
16273
16274 increment = 1;
16275 }
16276
16277 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16278
16279 if (increment)
16280 {
16281 if (increment_min > pw_min) pw_min = increment_min;
16282
16283 if (increment_max < pw_max) pw_max = increment_max;
16284 }
16285 }
16286 else if (attack_mode == ATTACK_MODE_HYBRID1)
16287 {
16288 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16289
16290 // display
16291
16292 char *mask = myargv[myargc - 1];
16293
16294 maskcnt = 0;
16295
16296 masks = (char **) mymalloc (1 * sizeof (char *));
16297
16298 // mod
16299
16300 struct stat file_stat;
16301
16302 if (stat (mask, &file_stat) == -1)
16303 {
16304 maskcnt = 1;
16305
16306 masks[maskcnt - 1] = mystrdup (mask);
16307 }
16308 else
16309 {
16310 uint is_file = S_ISREG (file_stat.st_mode);
16311
16312 if (is_file == 1)
16313 {
16314 FILE *mask_fp;
16315
16316 if ((mask_fp = fopen (mask, "r")) == NULL)
16317 {
16318 log_error ("ERROR: %s: %s", mask, strerror (errno));
16319
16320 return (-1);
16321 }
16322
16323 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16324
16325 uint masks_avail = 1;
16326
16327 while (!feof (mask_fp))
16328 {
16329 memset (line_buf, 0, HCBUFSIZ);
16330
16331 int line_len = fgetl (mask_fp, line_buf);
16332
16333 if (line_len == 0) continue;
16334
16335 if (line_buf[0] == '#') continue;
16336
16337 if (masks_avail == maskcnt)
16338 {
16339 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16340
16341 masks_avail += INCR_MASKS;
16342 }
16343
16344 masks[maskcnt] = mystrdup (line_buf);
16345
16346 maskcnt++;
16347 }
16348
16349 myfree (line_buf);
16350
16351 fclose (mask_fp);
16352
16353 mask_from_file = 1;
16354 }
16355 else
16356 {
16357 maskcnt = 1;
16358
16359 masks[maskcnt - 1] = mystrdup (mask);
16360 }
16361 }
16362
16363 // base
16364
16365 int wls_left = myargc - (optind + 2);
16366
16367 for (int i = 0; i < wls_left; i++)
16368 {
16369 char *filename = myargv[optind + 1 + i];
16370
16371 struct stat file_stat;
16372
16373 if (stat (filename, &file_stat) == -1)
16374 {
16375 log_error ("ERROR: %s: %s", filename, strerror (errno));
16376
16377 return (-1);
16378 }
16379
16380 uint is_dir = S_ISDIR (file_stat.st_mode);
16381
16382 if (is_dir == 0)
16383 {
16384 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16385
16386 dictcnt++;
16387
16388 dictfiles[dictcnt - 1] = filename;
16389 }
16390 else
16391 {
16392 // do not allow --keyspace w/ a directory
16393
16394 if (keyspace == 1)
16395 {
16396 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16397
16398 return (-1);
16399 }
16400
16401 char **dictionary_files = NULL;
16402
16403 dictionary_files = scan_directory (filename);
16404
16405 if (dictionary_files != NULL)
16406 {
16407 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16408
16409 for (int d = 0; dictionary_files[d] != NULL; d++)
16410 {
16411 char *l1_filename = dictionary_files[d];
16412
16413 struct stat l1_stat;
16414
16415 if (stat (l1_filename, &l1_stat) == -1)
16416 {
16417 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16418
16419 return (-1);
16420 }
16421
16422 if (S_ISREG (l1_stat.st_mode))
16423 {
16424 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16425
16426 dictcnt++;
16427
16428 dictfiles[dictcnt - 1] = strdup (l1_filename);
16429 }
16430 }
16431 }
16432
16433 local_free (dictionary_files);
16434 }
16435 }
16436
16437 if (dictcnt < 1)
16438 {
16439 log_error ("ERROR: No usable dictionary file found.");
16440
16441 return (-1);
16442 }
16443
16444 if (increment)
16445 {
16446 maskcnt = 0;
16447
16448 uint mask_min = increment_min; // we can't reject smaller masks here
16449 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16450
16451 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16452 {
16453 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16454
16455 if (cur_mask == NULL) break;
16456
16457 masks[maskcnt] = cur_mask;
16458
16459 maskcnt++;
16460
16461 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16462 }
16463 }
16464 }
16465 else if (attack_mode == ATTACK_MODE_HYBRID2)
16466 {
16467 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16468
16469 // display
16470
16471 char *mask = myargv[optind + 1 + 0];
16472
16473 maskcnt = 0;
16474
16475 masks = (char **) mymalloc (1 * sizeof (char *));
16476
16477 // mod
16478
16479 struct stat file_stat;
16480
16481 if (stat (mask, &file_stat) == -1)
16482 {
16483 maskcnt = 1;
16484
16485 masks[maskcnt - 1] = mystrdup (mask);
16486 }
16487 else
16488 {
16489 uint is_file = S_ISREG (file_stat.st_mode);
16490
16491 if (is_file == 1)
16492 {
16493 FILE *mask_fp;
16494
16495 if ((mask_fp = fopen (mask, "r")) == NULL)
16496 {
16497 log_error ("ERROR: %s: %s", mask, strerror (errno));
16498
16499 return (-1);
16500 }
16501
16502 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16503
16504 uint masks_avail = 1;
16505
16506 while (!feof (mask_fp))
16507 {
16508 memset (line_buf, 0, HCBUFSIZ);
16509
16510 int line_len = fgetl (mask_fp, line_buf);
16511
16512 if (line_len == 0) continue;
16513
16514 if (line_buf[0] == '#') continue;
16515
16516 if (masks_avail == maskcnt)
16517 {
16518 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16519
16520 masks_avail += INCR_MASKS;
16521 }
16522
16523 masks[maskcnt] = mystrdup (line_buf);
16524
16525 maskcnt++;
16526 }
16527
16528 myfree (line_buf);
16529
16530 fclose (mask_fp);
16531
16532 mask_from_file = 1;
16533 }
16534 else
16535 {
16536 maskcnt = 1;
16537
16538 masks[maskcnt - 1] = mystrdup (mask);
16539 }
16540 }
16541
16542 // base
16543
16544 int wls_left = myargc - (optind + 2);
16545
16546 for (int i = 0; i < wls_left; i++)
16547 {
16548 char *filename = myargv[optind + 2 + i];
16549
16550 struct stat file_stat;
16551
16552 if (stat (filename, &file_stat) == -1)
16553 {
16554 log_error ("ERROR: %s: %s", filename, strerror (errno));
16555
16556 return (-1);
16557 }
16558
16559 uint is_dir = S_ISDIR (file_stat.st_mode);
16560
16561 if (is_dir == 0)
16562 {
16563 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16564
16565 dictcnt++;
16566
16567 dictfiles[dictcnt - 1] = filename;
16568 }
16569 else
16570 {
16571 // do not allow --keyspace w/ a directory
16572
16573 if (keyspace == 1)
16574 {
16575 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16576
16577 return (-1);
16578 }
16579
16580 char **dictionary_files = NULL;
16581
16582 dictionary_files = scan_directory (filename);
16583
16584 if (dictionary_files != NULL)
16585 {
16586 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16587
16588 for (int d = 0; dictionary_files[d] != NULL; d++)
16589 {
16590 char *l1_filename = dictionary_files[d];
16591
16592 struct stat l1_stat;
16593
16594 if (stat (l1_filename, &l1_stat) == -1)
16595 {
16596 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16597
16598 return (-1);
16599 }
16600
16601 if (S_ISREG (l1_stat.st_mode))
16602 {
16603 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16604
16605 dictcnt++;
16606
16607 dictfiles[dictcnt - 1] = strdup (l1_filename);
16608 }
16609 }
16610 }
16611
16612 local_free (dictionary_files);
16613 }
16614 }
16615
16616 if (dictcnt < 1)
16617 {
16618 log_error ("ERROR: No usable dictionary file found.");
16619
16620 return (-1);
16621 }
16622
16623 if (increment)
16624 {
16625 maskcnt = 0;
16626
16627 uint mask_min = increment_min; // we can't reject smaller masks here
16628 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16629
16630 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16631 {
16632 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16633
16634 if (cur_mask == NULL) break;
16635
16636 masks[maskcnt] = cur_mask;
16637
16638 maskcnt++;
16639
16640 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16641 }
16642 }
16643 }
16644
16645 data.pw_min = pw_min;
16646 data.pw_max = pw_max;
16647
16648 /**
16649 * weak hash check
16650 */
16651
16652 if (weak_hash_threshold >= salts_cnt)
16653 {
16654 hc_device_param_t *device_param = NULL;
16655
16656 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16657 {
16658 device_param = &data.devices_param[device_id];
16659
16660 if (device_param->skipped) continue;
16661
16662 break;
16663 }
16664
16665 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16666
16667 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16668 {
16669 weak_hash_check (device_param, salt_pos);
16670 }
16671
16672 // Display hack, guarantee that there is at least one \r before real start
16673
16674 //if (data.quiet == 0) log_info ("");
16675 }
16676
16677 /**
16678 * status and monitor threads
16679 */
16680
16681 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16682
16683 hc_thread_t i_thread = 0;
16684
16685 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16686 {
16687 hc_thread_create (i_thread, thread_keypress, &benchmark);
16688 }
16689
16690 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16691
16692 uint ni_threads_cnt = 0;
16693
16694 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16695
16696 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16697
16698 ni_threads_cnt++;
16699
16700 /**
16701 * Outfile remove
16702 */
16703
16704 if (keyspace == 0)
16705 {
16706 if (outfile_check_timer != 0)
16707 {
16708 if (data.outfile_check_directory != NULL)
16709 {
16710 if ((hash_mode != 5200) &&
16711 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16712 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16713 (hash_mode != 9000))
16714 {
16715 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16716
16717 ni_threads_cnt++;
16718 }
16719 else
16720 {
16721 outfile_check_timer = 0;
16722 }
16723 }
16724 else
16725 {
16726 outfile_check_timer = 0;
16727 }
16728 }
16729 }
16730
16731 /**
16732 * Inform the user if we got some hashes remove because of the pot file remove feature
16733 */
16734
16735 if (data.quiet == 0)
16736 {
16737 if (potfile_remove_cracks > 0)
16738 {
16739 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16740 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16741 }
16742 }
16743
16744 data.outfile_check_timer = outfile_check_timer;
16745
16746 /**
16747 * main loop
16748 */
16749
16750 char **induction_dictionaries = NULL;
16751
16752 int induction_dictionaries_cnt = 0;
16753
16754 hcstat_table_t *root_table_buf = NULL;
16755 hcstat_table_t *markov_table_buf = NULL;
16756
16757 uint initial_restore_done = 0;
16758
16759 data.maskcnt = maskcnt;
16760
16761 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16762 {
16763 if (data.devices_status == STATUS_CRACKED) break;
16764
16765 data.devices_status = STATUS_INIT;
16766
16767 if (maskpos > rd->maskpos)
16768 {
16769 rd->dictpos = 0;
16770 }
16771
16772 rd->maskpos = maskpos;
16773 data.maskpos = maskpos;
16774
16775 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16776 {
16777 char *mask = masks[maskpos];
16778
16779 if (mask_from_file == 1)
16780 {
16781 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16782
16783 char *str_ptr;
16784 uint str_pos;
16785
16786 uint mask_offset = 0;
16787
16788 uint separator_cnt;
16789
16790 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16791 {
16792 str_ptr = strstr (mask + mask_offset, ",");
16793
16794 if (str_ptr == NULL) break;
16795
16796 str_pos = str_ptr - mask;
16797
16798 // escaped separator, i.e. "\,"
16799
16800 if (str_pos > 0)
16801 {
16802 if (mask[str_pos - 1] == '\\')
16803 {
16804 separator_cnt --;
16805
16806 mask_offset = str_pos + 1;
16807
16808 continue;
16809 }
16810 }
16811
16812 // reset the offset
16813
16814 mask_offset = 0;
16815
16816 mask[str_pos] = '\0';
16817
16818 switch (separator_cnt)
16819 {
16820 case 0:
16821 mp_reset_usr (mp_usr, 0);
16822
16823 custom_charset_1 = mask;
16824 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16825 break;
16826
16827 case 1:
16828 mp_reset_usr (mp_usr, 1);
16829
16830 custom_charset_2 = mask;
16831 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16832 break;
16833
16834 case 2:
16835 mp_reset_usr (mp_usr, 2);
16836
16837 custom_charset_3 = mask;
16838 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16839 break;
16840
16841 case 3:
16842 mp_reset_usr (mp_usr, 3);
16843
16844 custom_charset_4 = mask;
16845 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16846 break;
16847 }
16848
16849 mask = mask + str_pos + 1;
16850 }
16851 }
16852
16853 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16854 {
16855 if (maskpos > 0)
16856 {
16857 local_free (css_buf);
16858 local_free (data.root_css_buf);
16859 local_free (data.markov_css_buf);
16860
16861 local_free (masks[maskpos - 1]);
16862 }
16863
16864 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16865
16866 data.mask = mask;
16867 data.css_cnt = css_cnt;
16868 data.css_buf = css_buf;
16869
16870 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16871
16872 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16873
16874 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16875 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16876
16877 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16878
16879 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16880
16881 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16882 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16883
16884 data.root_css_buf = root_css_buf;
16885 data.markov_css_buf = markov_css_buf;
16886
16887 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16888
16889 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16890
16891 local_free (root_table_buf);
16892 local_free (markov_table_buf);
16893
16894 // args
16895
16896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16897 {
16898 hc_device_param_t *device_param = &data.devices_param[device_id];
16899
16900 if (device_param->skipped) continue;
16901
16902 device_param->kernel_params_mp[0] = &device_param->d_combs;
16903 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16904 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16905
16906 device_param->kernel_params_mp_buf64[3] = 0;
16907 device_param->kernel_params_mp_buf32[4] = css_cnt;
16908 device_param->kernel_params_mp_buf32[5] = 0;
16909 device_param->kernel_params_mp_buf32[6] = 0;
16910 device_param->kernel_params_mp_buf32[7] = 0;
16911
16912 if (attack_mode == ATTACK_MODE_HYBRID1)
16913 {
16914 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16915 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16916 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16917 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16918 }
16919 else if (attack_mode == ATTACK_MODE_HYBRID2)
16920 {
16921 device_param->kernel_params_mp_buf32[5] = 0;
16922 device_param->kernel_params_mp_buf32[6] = 0;
16923 device_param->kernel_params_mp_buf32[7] = 0;
16924 }
16925
16926 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]);
16927 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]);
16928 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]);
16929
16930 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);
16931 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);
16932 }
16933 }
16934 else if (attack_mode == ATTACK_MODE_BF)
16935 {
16936 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16937
16938 if (increment)
16939 {
16940 for (uint i = 0; i < dictcnt; i++)
16941 {
16942 local_free (dictfiles[i]);
16943 }
16944
16945 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16946 {
16947 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16948
16949 if (l1_filename == NULL) break;
16950
16951 dictcnt++;
16952
16953 dictfiles[dictcnt - 1] = l1_filename;
16954 }
16955 }
16956 else
16957 {
16958 dictcnt++;
16959
16960 dictfiles[dictcnt - 1] = mask;
16961 }
16962
16963 if (dictcnt == 0)
16964 {
16965 log_error ("ERROR: Mask is too small");
16966
16967 return (-1);
16968 }
16969 }
16970 }
16971
16972 free (induction_dictionaries);
16973
16974 // induction_dictionaries_cnt = 0; // implied
16975
16976 if (attack_mode != ATTACK_MODE_BF)
16977 {
16978 if (keyspace == 0)
16979 {
16980 induction_dictionaries = scan_directory (induction_directory);
16981
16982 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16983 }
16984 }
16985
16986 if (induction_dictionaries_cnt)
16987 {
16988 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16989 }
16990
16991 /**
16992 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16993 */
16994 if (keyspace == 1)
16995 {
16996 if ((maskcnt > 1) || (dictcnt > 1))
16997 {
16998 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16999
17000 return (-1);
17001 }
17002 }
17003
17004 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17005 {
17006 char *subid = logfile_generate_subid ();
17007
17008 data.subid = subid;
17009
17010 logfile_sub_msg ("START");
17011
17012 data.devices_status = STATUS_INIT;
17013
17014 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17015 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17016 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17017
17018 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17019
17020 data.cpt_pos = 0;
17021
17022 data.cpt_start = time (NULL);
17023
17024 data.cpt_total = 0;
17025
17026 if (data.restore == 0)
17027 {
17028 rd->words_cur = skip;
17029
17030 skip = 0;
17031
17032 data.skip = 0;
17033 }
17034
17035 data.ms_paused = 0;
17036
17037 data.kernel_power_div = 0;
17038
17039 data.words_cur = rd->words_cur;
17040
17041 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17042 {
17043 hc_device_param_t *device_param = &data.devices_param[device_id];
17044
17045 if (device_param->skipped) continue;
17046
17047 device_param->speed_pos = 0;
17048
17049 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17050 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17051
17052 device_param->exec_pos = 0;
17053
17054 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17055
17056 device_param->outerloop_pos = 0;
17057 device_param->outerloop_left = 0;
17058 device_param->innerloop_pos = 0;
17059 device_param->innerloop_left = 0;
17060
17061 // some more resets:
17062
17063 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17064
17065 device_param->pws_cnt = 0;
17066
17067 device_param->words_off = 0;
17068 device_param->words_done = 0;
17069 }
17070
17071 // figure out some workload
17072
17073 if (attack_mode == ATTACK_MODE_STRAIGHT)
17074 {
17075 if (data.wordlist_mode == WL_MODE_FILE)
17076 {
17077 char *dictfile = NULL;
17078
17079 if (induction_dictionaries_cnt)
17080 {
17081 dictfile = induction_dictionaries[0];
17082 }
17083 else
17084 {
17085 dictfile = dictfiles[dictpos];
17086 }
17087
17088 data.dictfile = dictfile;
17089
17090 logfile_sub_string (dictfile);
17091
17092 for (uint i = 0; i < rp_files_cnt; i++)
17093 {
17094 logfile_sub_var_string ("rulefile", rp_files[i]);
17095 }
17096
17097 FILE *fd2 = fopen (dictfile, "rb");
17098
17099 if (fd2 == NULL)
17100 {
17101 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17102
17103 return (-1);
17104 }
17105
17106 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17107
17108 fclose (fd2);
17109
17110 if (data.words_cnt == 0)
17111 {
17112 if (data.devices_status == STATUS_CRACKED) break;
17113 if (data.devices_status == STATUS_ABORTED) break;
17114
17115 dictpos++;
17116
17117 continue;
17118 }
17119 }
17120 }
17121 else if (attack_mode == ATTACK_MODE_COMBI)
17122 {
17123 char *dictfile = data.dictfile;
17124 char *dictfile2 = data.dictfile2;
17125
17126 logfile_sub_string (dictfile);
17127 logfile_sub_string (dictfile2);
17128
17129 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17130 {
17131 FILE *fd2 = fopen (dictfile, "rb");
17132
17133 if (fd2 == NULL)
17134 {
17135 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17136
17137 return (-1);
17138 }
17139
17140 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17141
17142 fclose (fd2);
17143 }
17144 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17145 {
17146 FILE *fd2 = fopen (dictfile2, "rb");
17147
17148 if (fd2 == NULL)
17149 {
17150 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17151
17152 return (-1);
17153 }
17154
17155 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17156
17157 fclose (fd2);
17158 }
17159
17160 if (data.words_cnt == 0)
17161 {
17162 if (data.devices_status == STATUS_CRACKED) break;
17163 if (data.devices_status == STATUS_ABORTED) break;
17164
17165 dictpos++;
17166
17167 continue;
17168 }
17169 }
17170 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17171 {
17172 char *dictfile = NULL;
17173
17174 if (induction_dictionaries_cnt)
17175 {
17176 dictfile = induction_dictionaries[0];
17177 }
17178 else
17179 {
17180 dictfile = dictfiles[dictpos];
17181 }
17182
17183 data.dictfile = dictfile;
17184
17185 char *mask = data.mask;
17186
17187 logfile_sub_string (dictfile);
17188 logfile_sub_string (mask);
17189
17190 FILE *fd2 = fopen (dictfile, "rb");
17191
17192 if (fd2 == NULL)
17193 {
17194 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17195
17196 return (-1);
17197 }
17198
17199 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17200
17201 fclose (fd2);
17202
17203 if (data.words_cnt == 0)
17204 {
17205 if (data.devices_status == STATUS_CRACKED) break;
17206 if (data.devices_status == STATUS_ABORTED) break;
17207
17208 dictpos++;
17209
17210 continue;
17211 }
17212 }
17213 else if (attack_mode == ATTACK_MODE_BF)
17214 {
17215 local_free (css_buf);
17216 local_free (data.root_css_buf);
17217 local_free (data.markov_css_buf);
17218
17219 char *mask = dictfiles[dictpos];
17220
17221 logfile_sub_string (mask);
17222
17223 // base
17224
17225 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17226
17227 if (opts_type & OPTS_TYPE_PT_UNICODE)
17228 {
17229 uint css_cnt_unicode = css_cnt * 2;
17230
17231 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17232
17233 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17234 {
17235 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17236
17237 css_buf_unicode[j + 1].cs_buf[0] = 0;
17238 css_buf_unicode[j + 1].cs_len = 1;
17239 }
17240
17241 free (css_buf);
17242
17243 css_buf = css_buf_unicode;
17244 css_cnt = css_cnt_unicode;
17245 }
17246
17247 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17248
17249 uint mask_min = pw_min;
17250 uint mask_max = pw_max;
17251
17252 if (opts_type & OPTS_TYPE_PT_UNICODE)
17253 {
17254 mask_min *= 2;
17255 mask_max *= 2;
17256 }
17257
17258 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17259 {
17260 if (css_cnt < mask_min)
17261 {
17262 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17263 }
17264
17265 if (css_cnt > mask_max)
17266 {
17267 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17268 }
17269
17270 // skip to next mask
17271
17272 dictpos++;
17273
17274 rd->dictpos = dictpos;
17275
17276 logfile_sub_msg ("STOP");
17277
17278 continue;
17279 }
17280
17281 uint save_css_cnt = css_cnt;
17282
17283 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17284 {
17285 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17286 {
17287 uint salt_len = (uint) data.salts_buf[0].salt_len;
17288 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17289
17290 uint css_cnt_salt = css_cnt + salt_len;
17291
17292 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17293
17294 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17295
17296 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17297 {
17298 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17299 css_buf_salt[j].cs_len = 1;
17300 }
17301
17302 free (css_buf);
17303
17304 css_buf = css_buf_salt;
17305 css_cnt = css_cnt_salt;
17306 }
17307 }
17308
17309 data.mask = mask;
17310 data.css_cnt = css_cnt;
17311 data.css_buf = css_buf;
17312
17313 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17314
17315 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17316
17317 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17318
17319 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17320 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17321
17322 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17323
17324 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17325
17326 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17327 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17328
17329 data.root_css_buf = root_css_buf;
17330 data.markov_css_buf = markov_css_buf;
17331
17332 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17333
17334 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17335
17336 local_free (root_table_buf);
17337 local_free (markov_table_buf);
17338
17339 // copy + args
17340
17341 uint css_cnt_l = css_cnt;
17342 uint css_cnt_r;
17343
17344 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17345 {
17346 if (save_css_cnt < 6)
17347 {
17348 css_cnt_r = 1;
17349 }
17350 else if (save_css_cnt == 6)
17351 {
17352 css_cnt_r = 2;
17353 }
17354 else
17355 {
17356 if (opts_type & OPTS_TYPE_PT_UNICODE)
17357 {
17358 if (save_css_cnt == 8 || save_css_cnt == 10)
17359 {
17360 css_cnt_r = 2;
17361 }
17362 else
17363 {
17364 css_cnt_r = 4;
17365 }
17366 }
17367 else
17368 {
17369 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17370 {
17371 css_cnt_r = 3;
17372 }
17373 else
17374 {
17375 css_cnt_r = 4;
17376 }
17377 }
17378 }
17379 }
17380 else
17381 {
17382 css_cnt_r = 1;
17383
17384 /* unfinished code?
17385 int sum = css_buf[css_cnt_r - 1].cs_len;
17386
17387 for (uint i = 1; i < 4 && i < css_cnt; i++)
17388 {
17389 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17390
17391 css_cnt_r++;
17392
17393 sum *= css_buf[css_cnt_r - 1].cs_len;
17394 }
17395 */
17396 }
17397
17398 css_cnt_l -= css_cnt_r;
17399
17400 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17401
17402 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17403 {
17404 hc_device_param_t *device_param = &data.devices_param[device_id];
17405
17406 if (device_param->skipped) continue;
17407
17408 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17409 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17410 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17411
17412 device_param->kernel_params_mp_l_buf64[3] = 0;
17413 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17414 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17415 device_param->kernel_params_mp_l_buf32[6] = 0;
17416 device_param->kernel_params_mp_l_buf32[7] = 0;
17417 device_param->kernel_params_mp_l_buf32[8] = 0;
17418
17419 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17420 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17421 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17422 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17423
17424 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17425 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17426 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17427
17428 device_param->kernel_params_mp_r_buf64[3] = 0;
17429 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17430 device_param->kernel_params_mp_r_buf32[5] = 0;
17431 device_param->kernel_params_mp_r_buf32[6] = 0;
17432 device_param->kernel_params_mp_r_buf32[7] = 0;
17433
17434 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]);
17435 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]);
17436 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]);
17437
17438 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]);
17439 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]);
17440 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]);
17441
17442 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);
17443 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);
17444 }
17445 }
17446
17447 u64 words_base = data.words_cnt;
17448
17449 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17450 {
17451 if (data.kernel_rules_cnt)
17452 {
17453 words_base /= data.kernel_rules_cnt;
17454 }
17455 }
17456 else if (data.attack_kern == ATTACK_KERN_COMBI)
17457 {
17458 if (data.combs_cnt)
17459 {
17460 words_base /= data.combs_cnt;
17461 }
17462 }
17463 else if (data.attack_kern == ATTACK_KERN_BF)
17464 {
17465 if (data.bfs_cnt)
17466 {
17467 words_base /= data.bfs_cnt;
17468 }
17469 }
17470
17471 data.words_base = words_base;
17472
17473 if (keyspace == 1)
17474 {
17475 log_info ("%llu", (unsigned long long int) words_base);
17476
17477 return (0);
17478 }
17479
17480 if (data.words_cur > data.words_base)
17481 {
17482 log_error ("ERROR: restore value greater keyspace");
17483
17484 return (-1);
17485 }
17486
17487 if (data.words_cur)
17488 {
17489 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17490 {
17491 for (uint i = 0; i < data.salts_cnt; i++)
17492 {
17493 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17494 }
17495 }
17496 else if (data.attack_kern == ATTACK_KERN_COMBI)
17497 {
17498 for (uint i = 0; i < data.salts_cnt; i++)
17499 {
17500 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17501 }
17502 }
17503 else if (data.attack_kern == ATTACK_KERN_BF)
17504 {
17505 for (uint i = 0; i < data.salts_cnt; i++)
17506 {
17507 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17508 }
17509 }
17510 }
17511
17512 /*
17513 * Update loopback file
17514 */
17515
17516 if (loopback == 1)
17517 {
17518 time_t now;
17519
17520 time (&now);
17521
17522 uint random_num = get_random_num (0, 9999);
17523
17524 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17525
17526 data.loopback_file = loopback_file;
17527 }
17528
17529 /*
17530 * Update dictionary statistic
17531 */
17532
17533 if (keyspace == 0)
17534 {
17535 dictstat_fp = fopen (dictstat, "wb");
17536
17537 if (dictstat_fp)
17538 {
17539 lock_file (dictstat_fp);
17540
17541 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17542
17543 fclose (dictstat_fp);
17544 }
17545 }
17546
17547 data.devices_status = STATUS_RUNNING;
17548
17549 if (initial_restore_done == 0)
17550 {
17551 if (data.restore_disable == 0) cycle_restore ();
17552
17553 initial_restore_done = 1;
17554 }
17555
17556 hc_timer_set (&data.timer_running);
17557
17558 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17559 {
17560 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17561 {
17562 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17563 if (quiet == 0) fflush (stdout);
17564 }
17565 }
17566 else if (wordlist_mode == WL_MODE_STDIN)
17567 {
17568 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17569 if (data.quiet == 0) log_info ("");
17570 }
17571
17572 /**
17573 * create autotune threads
17574 */
17575
17576 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17577
17578 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17579 {
17580 hc_device_param_t *device_param = &devices_param[device_id];
17581
17582 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17583 }
17584
17585 hc_thread_wait (data.devices_cnt, c_threads);
17586
17587 /*
17588 * Inform user about possible slow speeds
17589 */
17590
17591 uint kernel_power_all = 0;
17592
17593 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17594 {
17595 hc_device_param_t *device_param = &devices_param[device_id];
17596
17597 kernel_power_all += device_param->kernel_power;
17598 }
17599
17600 data.kernel_power_all = kernel_power_all;
17601
17602 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17603 {
17604 if (data.words_base < kernel_power_all)
17605 {
17606 if (quiet == 0)
17607 {
17608 log_info ("ATTENTION!");
17609 log_info (" The wordlist or mask you are using is too small.");
17610 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17611 log_info (" The cracking speed will drop.");
17612 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17613 log_info ("");
17614 }
17615 }
17616 }
17617
17618 /**
17619 * create cracker threads
17620 */
17621
17622 time_t runtime_start;
17623
17624 time (&runtime_start);
17625
17626 data.runtime_start = runtime_start;
17627
17628 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17629 {
17630 hc_device_param_t *device_param = &devices_param[device_id];
17631
17632 if (wordlist_mode == WL_MODE_STDIN)
17633 {
17634 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17635 }
17636 else
17637 {
17638 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17639 }
17640 }
17641
17642 hc_thread_wait (data.devices_cnt, c_threads);
17643
17644 local_free (c_threads);
17645
17646 data.restore = 0;
17647
17648 // finalize task
17649
17650 logfile_sub_var_uint ("status-after-work", data.devices_status);
17651
17652 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17653
17654 if (data.devices_status == STATUS_CRACKED) break;
17655 if (data.devices_status == STATUS_ABORTED) break;
17656
17657 if (data.devices_status == STATUS_BYPASS)
17658 {
17659 data.devices_status = STATUS_RUNNING;
17660 }
17661
17662 if (induction_dictionaries_cnt)
17663 {
17664 unlink (induction_dictionaries[0]);
17665 }
17666
17667 free (induction_dictionaries);
17668
17669 if (attack_mode != ATTACK_MODE_BF)
17670 {
17671 induction_dictionaries = scan_directory (induction_directory);
17672
17673 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17674 }
17675
17676 if (benchmark == 0)
17677 {
17678 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17679 {
17680 if (quiet == 0) clear_prompt ();
17681
17682 if (quiet == 0) log_info ("");
17683
17684 if (status == 1)
17685 {
17686 status_display ();
17687 }
17688 else
17689 {
17690 if (quiet == 0) status_display ();
17691 }
17692
17693 if (quiet == 0) log_info ("");
17694 }
17695 }
17696
17697 if (attack_mode == ATTACK_MODE_BF)
17698 {
17699 dictpos++;
17700
17701 rd->dictpos = dictpos;
17702 }
17703 else
17704 {
17705 if (induction_dictionaries_cnt)
17706 {
17707 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17708 }
17709 else
17710 {
17711 dictpos++;
17712
17713 rd->dictpos = dictpos;
17714 }
17715 }
17716
17717 time_t runtime_stop;
17718
17719 time (&runtime_stop);
17720
17721 data.runtime_stop = runtime_stop;
17722
17723 logfile_sub_uint (runtime_start);
17724 logfile_sub_uint (runtime_stop);
17725
17726 logfile_sub_msg ("STOP");
17727
17728 global_free (subid);
17729 }
17730
17731 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17732
17733 if (data.devices_status == STATUS_CRACKED) break;
17734 if (data.devices_status == STATUS_ABORTED) break;
17735 if (data.devices_status == STATUS_QUIT) break;
17736
17737 if (data.devices_status == STATUS_BYPASS)
17738 {
17739 data.devices_status = STATUS_RUNNING;
17740 }
17741 }
17742
17743 // 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
17744
17745 if (attack_mode == ATTACK_MODE_STRAIGHT)
17746 {
17747 if (data.wordlist_mode == WL_MODE_FILE)
17748 {
17749 if (data.dictfile == NULL)
17750 {
17751 if (dictfiles != NULL)
17752 {
17753 data.dictfile = dictfiles[0];
17754
17755 hc_timer_set (&data.timer_running);
17756 }
17757 }
17758 }
17759 }
17760 // NOTE: combi is okay because it is already set beforehand
17761 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17762 {
17763 if (data.dictfile == NULL)
17764 {
17765 if (dictfiles != NULL)
17766 {
17767 hc_timer_set (&data.timer_running);
17768
17769 data.dictfile = dictfiles[0];
17770 }
17771 }
17772 }
17773 else if (attack_mode == ATTACK_MODE_BF)
17774 {
17775 if (data.mask == NULL)
17776 {
17777 hc_timer_set (&data.timer_running);
17778
17779 data.mask = masks[0];
17780 }
17781 }
17782
17783 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17784 {
17785 data.devices_status = STATUS_EXHAUSTED;
17786 }
17787
17788 // if cracked / aborted remove last induction dictionary
17789
17790 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17791 {
17792 struct stat induct_stat;
17793
17794 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17795 {
17796 unlink (induction_dictionaries[file_pos]);
17797 }
17798 }
17799
17800 // wait for non-interactive threads
17801
17802 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17803 {
17804 hc_thread_wait (1, &ni_threads[thread_idx]);
17805 }
17806
17807 local_free (ni_threads);
17808
17809 // wait for interactive threads
17810
17811 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17812 {
17813 hc_thread_wait (1, &i_thread);
17814 }
17815
17816 // we dont need restore file anymore
17817 if (data.restore_disable == 0)
17818 {
17819 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17820 {
17821 unlink (eff_restore_file);
17822 unlink (new_restore_file);
17823 }
17824 else
17825 {
17826 cycle_restore ();
17827 }
17828 }
17829
17830 // finally save left hashes
17831
17832 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17833 {
17834 save_hash ();
17835 }
17836
17837 /**
17838 * Clean up
17839 */
17840
17841 if (benchmark == 1)
17842 {
17843 status_benchmark ();
17844
17845 if (machine_readable == 0)
17846 {
17847 log_info ("");
17848 }
17849 }
17850 else
17851 {
17852 if (quiet == 0) clear_prompt ();
17853
17854 if (quiet == 0) log_info ("");
17855
17856 if (status == 1)
17857 {
17858 status_display ();
17859 }
17860 else
17861 {
17862 if (quiet == 0) status_display ();
17863 }
17864
17865 if (quiet == 0) log_info ("");
17866 }
17867
17868 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17869 {
17870 hc_device_param_t *device_param = &data.devices_param[device_id];
17871
17872 if (device_param->skipped) continue;
17873
17874 local_free (device_param->combs_buf);
17875
17876 local_free (device_param->hooks_buf);
17877
17878 local_free (device_param->device_name);
17879
17880 local_free (device_param->device_name_chksum);
17881
17882 local_free (device_param->device_version);
17883
17884 local_free (device_param->driver_version);
17885
17886 if (device_param->pws_buf) myfree (device_param->pws_buf);
17887 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17888 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17889 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17890 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17891 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17892 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17893 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17894 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17895 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17896 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17897 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17898 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17899 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17900 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17901 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17902 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17903 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17904 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17905 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17906 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17907 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17908 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17909 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17910 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17911 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17912 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17913 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17914 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17915
17916 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17917 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17918 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17919 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17920 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17921 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17922 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17923 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17924 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17925 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17926 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17927
17928 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17929 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17930 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17931
17932 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17933 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17934 }
17935
17936 // reset default fan speed
17937
17938 #ifdef HAVE_HWMON
17939 if (gpu_temp_disable == 0)
17940 {
17941 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17942 {
17943 hc_thread_mutex_lock (mux_adl);
17944
17945 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17946 {
17947 hc_device_param_t *device_param = &data.devices_param[device_id];
17948
17949 if (device_param->skipped) continue;
17950
17951 if (data.hm_device[device_id].fan_set_supported == 1)
17952 {
17953 int fanspeed = temp_retain_fanspeed_value[device_id];
17954 int fanpolicy = temp_retain_fanpolicy_value[device_id];
17955
17956 if (fanpolicy == 1)
17957 {
17958 int rc = -1;
17959
17960 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17961 {
17962 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
17963 }
17964 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17965 {
17966
17967 }
17968
17969 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
17970 }
17971 }
17972 }
17973
17974 hc_thread_mutex_unlock (mux_adl);
17975 }
17976 }
17977
17978 // reset power tuning
17979
17980 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17981 {
17982 hc_thread_mutex_lock (mux_adl);
17983
17984 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17985 {
17986 hc_device_param_t *device_param = &data.devices_param[device_id];
17987
17988 if (device_param->skipped) continue;
17989
17990 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
17991 {
17992 if (data.hm_device[device_id].od_version == 6)
17993 {
17994 // check powertune capabilities first, if not available then skip device
17995
17996 int powertune_supported = 0;
17997
17998 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adapter_index.adl, &powertune_supported)) != ADL_OK)
17999 {
18000 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18001
18002 return (-1);
18003 }
18004
18005 if (powertune_supported != 0)
18006 {
18007 // powercontrol settings
18008
18009 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, od_power_control_status[device_id])) != ADL_OK)
18010 {
18011 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18012
18013 return (-1);
18014 }
18015
18016 // clocks
18017
18018 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18019
18020 performance_state->iNumberOfPerformanceLevels = 2;
18021
18022 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18023 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18024 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18025 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18026
18027 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adapter_index.adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18028 {
18029 log_info ("ERROR: Failed to restore ADL performance state");
18030
18031 return (-1);
18032 }
18033
18034 local_free (performance_state);
18035 }
18036 }
18037 }
18038
18039 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18040 {
18041 unsigned int limit = nvml_power_limit[device_id];
18042
18043 if (limit > 0)
18044 {
18045 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].adapter_index.nvml, limit);
18046 }
18047 }
18048 }
18049
18050 hc_thread_mutex_unlock (mux_adl);
18051 }
18052
18053 if (gpu_temp_disable == 0)
18054 {
18055 if (data.hm_nvml)
18056 {
18057 hm_NVML_nvmlShutdown (data.hm_nvml);
18058
18059 nvml_close (data.hm_nvml);
18060
18061 data.hm_nvml = NULL;
18062 }
18063
18064 if (data.hm_adl)
18065 {
18066 hm_ADL_Main_Control_Destroy (data.hm_adl);
18067
18068 adl_close (data.hm_adl);
18069
18070 data.hm_adl = NULL;
18071 }
18072 }
18073 #endif // HAVE_HWMON
18074
18075 // free memory
18076
18077 local_free (masks);
18078
18079 local_free (dictstat_base);
18080
18081 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18082 {
18083 pot_t *pot_ptr = &pot[pot_pos];
18084
18085 hash_t *hash = &pot_ptr->hash;
18086
18087 local_free (hash->digest);
18088
18089 if (isSalted)
18090 {
18091 local_free (hash->salt);
18092 }
18093 }
18094
18095 local_free (pot);
18096
18097 local_free (all_kernel_rules_cnt);
18098 local_free (all_kernel_rules_buf);
18099
18100 local_free (wl_data->buf);
18101 local_free (wl_data);
18102
18103 local_free (bitmap_s1_a);
18104 local_free (bitmap_s1_b);
18105 local_free (bitmap_s1_c);
18106 local_free (bitmap_s1_d);
18107 local_free (bitmap_s2_a);
18108 local_free (bitmap_s2_b);
18109 local_free (bitmap_s2_c);
18110 local_free (bitmap_s2_d);
18111
18112 #ifdef HAVE_HWMON
18113 local_free (temp_retain_fanspeed_value);
18114 local_free (od_clock_mem_status);
18115 local_free (od_power_control_status);
18116 local_free (nvml_power_limit);
18117 #endif
18118
18119 global_free (devices_param);
18120
18121 global_free (kernel_rules_buf);
18122
18123 global_free (root_css_buf);
18124 global_free (markov_css_buf);
18125
18126 global_free (digests_buf);
18127 global_free (digests_shown);
18128 global_free (digests_shown_tmp);
18129
18130 global_free (salts_buf);
18131 global_free (salts_shown);
18132
18133 global_free (esalts_buf);
18134
18135 global_free (words_progress_done);
18136 global_free (words_progress_rejected);
18137 global_free (words_progress_restored);
18138
18139 if (pot_fp) fclose (pot_fp);
18140
18141 if (data.devices_status == STATUS_QUIT) break;
18142 }
18143
18144 // destroy others mutex
18145
18146 hc_thread_mutex_delete (mux_dispatcher);
18147 hc_thread_mutex_delete (mux_counter);
18148 hc_thread_mutex_delete (mux_display);
18149 hc_thread_mutex_delete (mux_adl);
18150
18151 // free memory
18152
18153 local_free (eff_restore_file);
18154 local_free (new_restore_file);
18155
18156 local_free (rd);
18157
18158 // tuning db
18159
18160 tuning_db_destroy (tuning_db);
18161
18162 // loopback
18163
18164 local_free (loopback_file);
18165
18166 if (loopback == 1) unlink (loopback_file);
18167
18168 // induction directory
18169
18170 if (induction_dir == NULL)
18171 {
18172 if (attack_mode != ATTACK_MODE_BF)
18173 {
18174 if (rmdir (induction_directory) == -1)
18175 {
18176 if (errno == ENOENT)
18177 {
18178 // good, we can ignore
18179 }
18180 else if (errno == ENOTEMPTY)
18181 {
18182 // good, we can ignore
18183 }
18184 else
18185 {
18186 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18187
18188 return (-1);
18189 }
18190 }
18191
18192 local_free (induction_directory);
18193 }
18194 }
18195
18196 // outfile-check directory
18197
18198 if (outfile_check_dir == NULL)
18199 {
18200 if (rmdir (outfile_check_directory) == -1)
18201 {
18202 if (errno == ENOENT)
18203 {
18204 // good, we can ignore
18205 }
18206 else if (errno == ENOTEMPTY)
18207 {
18208 // good, we can ignore
18209 }
18210 else
18211 {
18212 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18213
18214 return (-1);
18215 }
18216 }
18217
18218 local_free (outfile_check_directory);
18219 }
18220
18221 time_t proc_stop;
18222
18223 time (&proc_stop);
18224
18225 logfile_top_uint (proc_start);
18226 logfile_top_uint (proc_stop);
18227
18228 logfile_top_msg ("STOP");
18229
18230 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18231 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18232
18233 if (data.ocl) ocl_close (data.ocl);
18234
18235 if (data.devices_status == STATUS_ABORTED) return 2;
18236 if (data.devices_status == STATUS_QUIT) return 2;
18237 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18238 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18239 if (data.devices_status == STATUS_CRACKED) return 0;
18240
18241 return -1;
18242 }
Hashcat additions to support pwdhash