projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix osx compilation
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 70
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ======+==================================================+======================================",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ===+========",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ===+========",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ===+======",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ===+=========",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ===+=============",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ===+=============+=========+===================+=================",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_machine_readable ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.machine_readable == 1)
918 {
919 status_display_machine_readable ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 #define HM_STR_BUF_SIZE 255
1547
1548 if (data.hm_device[device_id].fan_supported == 1)
1549 {
1550 char utilization[HM_STR_BUF_SIZE] = { 0 };
1551 char temperature[HM_STR_BUF_SIZE] = { 0 };
1552 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1553 char corespeed[HM_STR_BUF_SIZE] = { 0 };
1554 char memoryspeed[HM_STR_BUF_SIZE] = { 0 };
1555
1556 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1557 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1558 hm_device_val_to_str ((char *) corespeed, HM_STR_BUF_SIZE, "Mhz", hm_get_corespeed_with_device_id (device_id));
1559 hm_device_val_to_str ((char *) memoryspeed, HM_STR_BUF_SIZE, "Mhz", hm_get_memoryspeed_with_device_id (device_id));
1560
1561 if (device_param->device_vendor_id == VENDOR_ID_AMD)
1562 {
1563 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1564 }
1565 else if (device_param->device_vendor_id == VENDOR_ID_NV)
1566 {
1567 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1568 }
1569
1570 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan, %s Core, %s Mem", device_id + 1, utilization, temperature, fanspeed, corespeed, memoryspeed);
1571 }
1572 else
1573 {
1574 char utilization[HM_STR_BUF_SIZE] = { 0 };
1575 char temperature[HM_STR_BUF_SIZE] = { 0 };
1576
1577 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1578 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1579
1580 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1581 }
1582 }
1583
1584 hc_thread_mutex_unlock (mux_adl);
1585 }
1586 #endif // HAVE_HWMON
1587 }
1588
1589 static void status_benchmark_automate ()
1590 {
1591 u64 speed_cnt[DEVICES_MAX] = { 0 };
1592 double speed_ms[DEVICES_MAX] = { 0 };
1593
1594 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1595 {
1596 hc_device_param_t *device_param = &data.devices_param[device_id];
1597
1598 if (device_param->skipped) continue;
1599
1600 speed_cnt[device_id] = device_param->speed_cnt[0];
1601 speed_ms[device_id] = device_param->speed_ms[0];
1602 }
1603
1604 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 hashes_dev_ms[device_id] = 0;
1613
1614 if (speed_ms[device_id])
1615 {
1616 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1617 }
1618 }
1619
1620 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1621 {
1622 hc_device_param_t *device_param = &data.devices_param[device_id];
1623
1624 if (device_param->skipped) continue;
1625
1626 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1627 }
1628 }
1629
1630 static void status_benchmark ()
1631 {
1632 if (data.devices_status == STATUS_INIT) return;
1633 if (data.devices_status == STATUS_STARTING) return;
1634 if (data.devices_status == STATUS_BYPASS) return;
1635
1636 if (data.machine_readable == 1)
1637 {
1638 status_benchmark_automate ();
1639
1640 return;
1641 }
1642
1643 u64 speed_cnt[DEVICES_MAX] = { 0 };
1644 double speed_ms[DEVICES_MAX] = { 0 };
1645
1646 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1647 {
1648 hc_device_param_t *device_param = &data.devices_param[device_id];
1649
1650 if (device_param->skipped) continue;
1651
1652 speed_cnt[device_id] = device_param->speed_cnt[0];
1653 speed_ms[device_id] = device_param->speed_ms[0];
1654 }
1655
1656 double hashes_all_ms = 0;
1657
1658 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1659
1660 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1661 {
1662 hc_device_param_t *device_param = &data.devices_param[device_id];
1663
1664 if (device_param->skipped) continue;
1665
1666 hashes_dev_ms[device_id] = 0;
1667
1668 if (speed_ms[device_id])
1669 {
1670 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1671
1672 hashes_all_ms += hashes_dev_ms[device_id];
1673 }
1674 }
1675
1676 /**
1677 * exec time
1678 */
1679
1680 double exec_all_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1689
1690 exec_all_ms[device_id] = exec_ms_avg;
1691 }
1692
1693 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1694 {
1695 hc_device_param_t *device_param = &data.devices_param[device_id];
1696
1697 if (device_param->skipped) continue;
1698
1699 char display_dev_cur[16] = { 0 };
1700
1701 strncpy (display_dev_cur, "0.00", 4);
1702
1703 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1704
1705 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1706 }
1707
1708 char display_all_cur[16] = { 0 };
1709
1710 strncpy (display_all_cur, "0.00", 4);
1711
1712 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1713
1714 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1715 }
1716
1717 /**
1718 * hashcat -only- functions
1719 */
1720
1721 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1722 {
1723 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1724 {
1725 if (attack_kern == ATTACK_KERN_STRAIGHT)
1726 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1727 else if (attack_kern == ATTACK_KERN_COMBI)
1728 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1729 else if (attack_kern == ATTACK_KERN_BF)
1730 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1731 }
1732 else
1733 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1734 }
1735
1736 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)
1737 {
1738 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1739 {
1740 if (attack_kern == ATTACK_KERN_STRAIGHT)
1741 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1742 else if (attack_kern == ATTACK_KERN_COMBI)
1743 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1744 else if (attack_kern == ATTACK_KERN_BF)
1745 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1746 }
1747 else
1748 {
1749 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1750 }
1751 }
1752
1753 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1754 {
1755 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1756 {
1757 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1758 }
1759 else
1760 {
1761 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1762 }
1763 }
1764
1765 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)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1770 }
1771 else
1772 {
1773 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1774 }
1775 }
1776
1777 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1778 {
1779 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1780 }
1781
1782 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1783 {
1784 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1785 }
1786
1787 static uint convert_from_hex (char *line_buf, const uint line_len)
1788 {
1789 if (line_len & 1) return (line_len); // not in hex
1790
1791 if (data.hex_wordlist == 1)
1792 {
1793 uint i;
1794 uint j;
1795
1796 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1797 {
1798 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1799 }
1800
1801 memset (line_buf + i, 0, line_len - i);
1802
1803 return (i);
1804 }
1805 else if (line_len >= 6) // $HEX[] = 6
1806 {
1807 if (line_buf[0] != '$') return (line_len);
1808 if (line_buf[1] != 'H') return (line_len);
1809 if (line_buf[2] != 'E') return (line_len);
1810 if (line_buf[3] != 'X') return (line_len);
1811 if (line_buf[4] != '[') return (line_len);
1812 if (line_buf[line_len - 1] != ']') return (line_len);
1813
1814 uint i;
1815 uint j;
1816
1817 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1818 {
1819 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1820 }
1821
1822 memset (line_buf + i, 0, line_len - i);
1823
1824 return (i);
1825 }
1826
1827 return (line_len);
1828 }
1829
1830 static void clear_prompt ()
1831 {
1832 fputc ('\r', stdout);
1833
1834 for (size_t i = 0; i < strlen (PROMPT); i++)
1835 {
1836 fputc (' ', stdout);
1837 }
1838
1839 fputc ('\r', stdout);
1840
1841 fflush (stdout);
1842 }
1843
1844 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1845 {
1846 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);
1847 }
1848
1849 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1850 {
1851 char *outfile = data.outfile;
1852 uint quiet = data.quiet;
1853 FILE *pot_fp = data.pot_fp;
1854 uint loopback = data.loopback;
1855 uint debug_mode = data.debug_mode;
1856 char *debug_file = data.debug_file;
1857
1858 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1859 int debug_rule_len = 0; // -1 error
1860 uint debug_plain_len = 0;
1861
1862 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1863
1864 // hash
1865
1866 char out_buf[HCBUFSIZ] = { 0 };
1867
1868 const u32 salt_pos = plain->salt_pos;
1869 const u32 digest_pos = plain->digest_pos; // relative
1870 const u32 gidvid = plain->gidvid;
1871 const u32 il_pos = plain->il_pos;
1872
1873 ascii_digest (out_buf, salt_pos, digest_pos);
1874
1875 // plain
1876
1877 u64 crackpos = device_param->words_off;
1878
1879 uint plain_buf[16] = { 0 };
1880
1881 u8 *plain_ptr = (u8 *) plain_buf;
1882
1883 unsigned int plain_len = 0;
1884
1885 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1886 {
1887 pw_t pw;
1888
1889 gidd_to_pw_t (device_param, gidvid, &pw);
1890
1891 for (int i = 0; i < 16; i++)
1892 {
1893 plain_buf[i] = pw.i[i];
1894 }
1895
1896 plain_len = pw.pw_len;
1897
1898 const uint off = device_param->innerloop_pos + il_pos;
1899
1900 if (debug_mode > 0)
1901 {
1902 debug_rule_len = 0;
1903
1904 // save rule
1905 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1906 {
1907 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1908
1909 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1910 }
1911
1912 // save plain
1913 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1914 {
1915 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1916
1917 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1918
1919 debug_plain_len = plain_len;
1920 }
1921 }
1922
1923 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1924
1925 crackpos += gidvid;
1926 crackpos *= data.kernel_rules_cnt;
1927 crackpos += device_param->innerloop_pos + il_pos;
1928
1929 if (plain_len > data.pw_max) plain_len = data.pw_max;
1930 }
1931 else if (data.attack_mode == ATTACK_MODE_COMBI)
1932 {
1933 pw_t pw;
1934
1935 gidd_to_pw_t (device_param, gidvid, &pw);
1936
1937 for (int i = 0; i < 16; i++)
1938 {
1939 plain_buf[i] = pw.i[i];
1940 }
1941
1942 plain_len = pw.pw_len;
1943
1944 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1945 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1946
1947 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1948 {
1949 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1950 }
1951 else
1952 {
1953 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1954
1955 memcpy (plain_ptr, comb_buf, comb_len);
1956 }
1957
1958 plain_len += comb_len;
1959
1960 crackpos += gidvid;
1961 crackpos *= data.combs_cnt;
1962 crackpos += device_param->innerloop_pos + il_pos;
1963
1964 if (data.pw_max != PW_DICTMAX1)
1965 {
1966 if (plain_len > data.pw_max) plain_len = data.pw_max;
1967 }
1968 }
1969 else if (data.attack_mode == ATTACK_MODE_BF)
1970 {
1971 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1972 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1973
1974 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1975 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1976
1977 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1978 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1979
1980 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1981 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1982
1983 plain_len = data.css_cnt;
1984
1985 crackpos += gidvid;
1986 crackpos *= data.bfs_cnt;
1987 crackpos += device_param->innerloop_pos + il_pos;
1988 }
1989 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1990 {
1991 pw_t pw;
1992
1993 gidd_to_pw_t (device_param, gidvid, &pw);
1994
1995 for (int i = 0; i < 16; i++)
1996 {
1997 plain_buf[i] = pw.i[i];
1998 }
1999
2000 plain_len = pw.pw_len;
2001
2002 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2003
2004 uint start = 0;
2005 uint stop = device_param->kernel_params_mp_buf32[4];
2006
2007 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2008
2009 plain_len += start + stop;
2010
2011 crackpos += gidvid;
2012 crackpos *= data.combs_cnt;
2013 crackpos += device_param->innerloop_pos + il_pos;
2014
2015 if (data.pw_max != PW_DICTMAX1)
2016 {
2017 if (plain_len > data.pw_max) plain_len = data.pw_max;
2018 }
2019 }
2020 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
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 memmove (plain_ptr + stop, plain_ptr, plain_len);
2039
2040 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2041
2042 plain_len += start + stop;
2043
2044 crackpos += gidvid;
2045 crackpos *= data.combs_cnt;
2046 crackpos += device_param->innerloop_pos + il_pos;
2047
2048 if (data.pw_max != PW_DICTMAX1)
2049 {
2050 if (plain_len > data.pw_max) plain_len = data.pw_max;
2051 }
2052 }
2053
2054 if (data.attack_mode == ATTACK_MODE_BF)
2055 {
2056 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2057 {
2058 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2059 {
2060 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2061 {
2062 plain_len = plain_len - data.salts_buf[0].salt_len;
2063 }
2064 }
2065
2066 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2067 {
2068 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2069 {
2070 plain_ptr[j] = plain_ptr[i];
2071 }
2072
2073 plain_len = plain_len / 2;
2074 }
2075 }
2076 }
2077
2078 // if enabled, update also the potfile
2079
2080 if (pot_fp)
2081 {
2082 lock_file (pot_fp);
2083
2084 fprintf (pot_fp, "%s:", out_buf);
2085
2086 format_plain (pot_fp, plain_ptr, plain_len, 1);
2087
2088 fputc ('\n', pot_fp);
2089
2090 fflush (pot_fp);
2091
2092 unlock_file (pot_fp);
2093 }
2094
2095 // outfile
2096
2097 FILE *out_fp = NULL;
2098
2099 if (outfile != NULL)
2100 {
2101 if ((out_fp = fopen (outfile, "ab")) == NULL)
2102 {
2103 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2104
2105 out_fp = stdout;
2106 }
2107 lock_file (out_fp);
2108 }
2109 else
2110 {
2111 out_fp = stdout;
2112
2113 if (quiet == 0) clear_prompt ();
2114 }
2115
2116 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2117
2118 if (outfile != NULL)
2119 {
2120 if (out_fp != stdout)
2121 {
2122 fclose (out_fp);
2123 }
2124 }
2125 else
2126 {
2127 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2128 {
2129 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2130 {
2131 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2132 if (quiet == 0) fflush (stdout);
2133 }
2134 }
2135 }
2136
2137 // loopback
2138
2139 if (loopback)
2140 {
2141 char *loopback_file = data.loopback_file;
2142
2143 FILE *fb_fp = NULL;
2144
2145 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2146 {
2147 lock_file (fb_fp);
2148
2149 format_plain (fb_fp, plain_ptr, plain_len, 1);
2150
2151 fputc ('\n', fb_fp);
2152
2153 fclose (fb_fp);
2154 }
2155 }
2156
2157 // (rule) debug mode
2158
2159 // the next check implies that:
2160 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2161 // - debug_mode > 0
2162
2163 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2164 {
2165 if (debug_rule_len < 0) debug_rule_len = 0;
2166
2167 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2168
2169 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2170
2171 if ((quiet == 0) && (debug_file == NULL))
2172 {
2173 fprintf (stdout, "%s", PROMPT);
2174
2175 fflush (stdout);
2176 }
2177 }
2178 }
2179
2180 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2181 {
2182 salt_t *salt_buf = &data.salts_buf[salt_pos];
2183
2184 u32 num_cracked;
2185
2186 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2187
2188 if (num_cracked)
2189 {
2190 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2191
2192 log_info_nn ("");
2193
2194 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2195
2196 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);
2197
2198 uint cpt_cracked = 0;
2199
2200 for (uint i = 0; i < num_cracked; i++)
2201 {
2202 const uint hash_pos = cracked[i].hash_pos;
2203
2204 if (data.digests_shown[hash_pos] == 1) continue;
2205
2206 hc_thread_mutex_lock (mux_display);
2207
2208 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2209 {
2210 data.digests_shown[hash_pos] = 1;
2211
2212 data.digests_done++;
2213
2214 cpt_cracked++;
2215
2216 salt_buf->digests_done++;
2217
2218 if (salt_buf->digests_done == salt_buf->digests_cnt)
2219 {
2220 data.salts_shown[salt_pos] = 1;
2221
2222 data.salts_done++;
2223 }
2224 }
2225
2226 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2227
2228 hc_thread_mutex_unlock (mux_display);
2229
2230 check_hash (device_param, &cracked[i]);
2231 }
2232
2233 myfree (cracked);
2234
2235 if (cpt_cracked > 0)
2236 {
2237 hc_thread_mutex_lock (mux_display);
2238
2239 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2240 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2241
2242 data.cpt_pos++;
2243
2244 data.cpt_total += cpt_cracked;
2245
2246 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2247
2248 hc_thread_mutex_unlock (mux_display);
2249 }
2250
2251 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2252 {
2253 // we need to reset cracked state on the device
2254 // otherwise host thinks again and again the hash was cracked
2255 // and returns invalid password each time
2256
2257 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2258
2259 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);
2260 }
2261
2262 num_cracked = 0;
2263
2264 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2265 }
2266 }
2267
2268 static void save_hash ()
2269 {
2270 char *hashfile = data.hashfile;
2271
2272 char new_hashfile[256] = { 0 };
2273 char old_hashfile[256] = { 0 };
2274
2275 snprintf (new_hashfile, 255, "%s.new", hashfile);
2276 snprintf (old_hashfile, 255, "%s.old", hashfile);
2277
2278 unlink (new_hashfile);
2279
2280 char separator = data.separator;
2281
2282 FILE *fp = fopen (new_hashfile, "wb");
2283
2284 if (fp == NULL)
2285 {
2286 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2287
2288 exit (-1);
2289 }
2290
2291 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2292 {
2293 if (data.salts_shown[salt_pos] == 1) continue;
2294
2295 salt_t *salt_buf = &data.salts_buf[salt_pos];
2296
2297 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2298 {
2299 uint idx = salt_buf->digests_offset + digest_pos;
2300
2301 if (data.digests_shown[idx] == 1) continue;
2302
2303 if (data.hash_mode != 2500)
2304 {
2305 char out_buf[HCBUFSIZ] = { 0 };
2306
2307 if (data.username == 1)
2308 {
2309 user_t *user = data.hash_info[idx]->user;
2310
2311 uint i;
2312
2313 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2314
2315 fputc (separator, fp);
2316 }
2317
2318 ascii_digest (out_buf, salt_pos, digest_pos);
2319
2320 fputs (out_buf, fp);
2321
2322 log_out (fp, "");
2323 }
2324 else
2325 {
2326 hccap_t hccap;
2327
2328 to_hccap_t (&hccap, salt_pos, digest_pos);
2329
2330 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2331 }
2332 }
2333 }
2334
2335 fflush (fp);
2336
2337 fclose (fp);
2338
2339 unlink (old_hashfile);
2340
2341 if (rename (hashfile, old_hashfile) != 0)
2342 {
2343 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2344
2345 exit (-1);
2346 }
2347
2348 unlink (hashfile);
2349
2350 if (rename (new_hashfile, hashfile) != 0)
2351 {
2352 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2353
2354 exit (-1);
2355 }
2356
2357 unlink (old_hashfile);
2358 }
2359
2360 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2361 {
2362 // function called only in case kernel_power_all > words_left
2363
2364 float kernel_power_div = (float) (total_left) / kernel_power_all;
2365
2366 kernel_power_div += kernel_power_div / 100;
2367
2368 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2369
2370 while (kernel_power_new < total_left)
2371 {
2372 kernel_power_div += kernel_power_div / 100;
2373
2374 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2375 }
2376
2377 if (data.quiet == 0)
2378 {
2379 clear_prompt ();
2380
2381 //log_info ("");
2382
2383 log_info ("INFO: approaching final keyspace, workload adjusted");
2384 log_info ("");
2385
2386 fprintf (stdout, "%s", PROMPT);
2387
2388 fflush (stdout);
2389 }
2390
2391 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2392
2393 return kernel_power_div;
2394 }
2395
2396 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2397 {
2398 uint num_elements = num;
2399
2400 device_param->kernel_params_buf32[30] = data.combs_mode;
2401 device_param->kernel_params_buf32[31] = num;
2402
2403 uint kernel_threads = device_param->kernel_threads;
2404
2405 while (num_elements % kernel_threads) num_elements++;
2406
2407 cl_kernel kernel = NULL;
2408
2409 switch (kern_run)
2410 {
2411 case KERN_RUN_1: kernel = device_param->kernel1; break;
2412 case KERN_RUN_12: kernel = device_param->kernel12; break;
2413 case KERN_RUN_2: kernel = device_param->kernel2; break;
2414 case KERN_RUN_23: kernel = device_param->kernel23; break;
2415 case KERN_RUN_3: kernel = device_param->kernel3; break;
2416 }
2417
2418 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2419 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2420 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2421 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2422 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2423 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2424 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2425 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2426 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2427 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2428 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2429
2430 cl_event event;
2431
2432 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2433 {
2434 const size_t global_work_size[3] = { num_elements, 32, 1 };
2435 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2436
2437 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2438 }
2439 else
2440 {
2441 if (kern_run == KERN_RUN_2)
2442 {
2443 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2444 {
2445 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2446 }
2447 }
2448
2449 while (num_elements % kernel_threads) num_elements++;
2450
2451 const size_t global_work_size[3] = { num_elements, 1, 1 };
2452 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2453
2454 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2455 }
2456
2457 hc_clFlush (data.ocl, device_param->command_queue);
2458
2459 hc_clWaitForEvents (data.ocl, 1, &event);
2460
2461 if (event_update)
2462 {
2463 cl_ulong time_start;
2464 cl_ulong time_end;
2465
2466 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2467 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2468
2469 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2470
2471 uint exec_pos = device_param->exec_pos;
2472
2473 device_param->exec_ms[exec_pos] = exec_time;
2474
2475 exec_pos++;
2476
2477 if (exec_pos == EXEC_CACHE)
2478 {
2479 exec_pos = 0;
2480 }
2481
2482 device_param->exec_pos = exec_pos;
2483 }
2484
2485 hc_clReleaseEvent (data.ocl, event);
2486
2487 hc_clFinish (data.ocl, device_param->command_queue);
2488 }
2489
2490 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2491 {
2492 uint num_elements = num;
2493
2494 switch (kern_run)
2495 {
2496 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2497 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2498 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2499 }
2500
2501 // causes problems with special threads like in bcrypt
2502 // const uint kernel_threads = device_param->kernel_threads;
2503
2504 uint kernel_threads = device_param->kernel_threads;
2505
2506 while (num_elements % kernel_threads) num_elements++;
2507
2508 cl_kernel kernel = NULL;
2509
2510 switch (kern_run)
2511 {
2512 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2513 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2514 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2515 }
2516
2517 switch (kern_run)
2518 {
2519 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2520 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2521 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2522 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2523 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2524 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2525 break;
2526 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2527 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2528 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2529 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2530 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2531 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2532 break;
2533 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2534 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2535 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2536 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2537 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2538 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2539 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2540 break;
2541 }
2542
2543 const size_t global_work_size[3] = { num_elements, 1, 1 };
2544 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2545
2546 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2547
2548 hc_clFlush (data.ocl, device_param->command_queue);
2549
2550 hc_clFinish (data.ocl, device_param->command_queue);
2551 }
2552
2553 static void run_kernel_tm (hc_device_param_t *device_param)
2554 {
2555 const uint num_elements = 1024; // fixed
2556
2557 uint kernel_threads = 32;
2558
2559 cl_kernel kernel = device_param->kernel_tm;
2560
2561 const size_t global_work_size[3] = { num_elements, 1, 1 };
2562 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2563
2564 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2565
2566 hc_clFlush (data.ocl, device_param->command_queue);
2567
2568 hc_clFinish (data.ocl, device_param->command_queue);
2569 }
2570
2571 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2572 {
2573 uint num_elements = num;
2574
2575 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2576 device_param->kernel_params_amp_buf32[6] = num_elements;
2577
2578 // causes problems with special threads like in bcrypt
2579 // const uint kernel_threads = device_param->kernel_threads;
2580
2581 uint kernel_threads = device_param->kernel_threads;
2582
2583 while (num_elements % kernel_threads) num_elements++;
2584
2585 cl_kernel kernel = device_param->kernel_amp;
2586
2587 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2588 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2589
2590 const size_t global_work_size[3] = { num_elements, 1, 1 };
2591 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2592
2593 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2594
2595 hc_clFlush (data.ocl, device_param->command_queue);
2596
2597 hc_clFinish (data.ocl, device_param->command_queue);
2598 }
2599
2600 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2601 {
2602 const u32 num16d = num / 16;
2603 const u32 num16m = num % 16;
2604
2605 if (num16d)
2606 {
2607 device_param->kernel_params_memset_buf32[1] = value;
2608 device_param->kernel_params_memset_buf32[2] = num16d;
2609
2610 uint kernel_threads = device_param->kernel_threads;
2611
2612 uint num_elements = num16d;
2613
2614 while (num_elements % kernel_threads) num_elements++;
2615
2616 cl_kernel kernel = device_param->kernel_memset;
2617
2618 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2619 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2620 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
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 if (num16m)
2633 {
2634 u32 tmp[4];
2635
2636 tmp[0] = value;
2637 tmp[1] = value;
2638 tmp[2] = value;
2639 tmp[3] = value;
2640
2641 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2642 }
2643 }
2644
2645 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2646 {
2647 run_kernel_memset (device_param, buf, 0, size);
2648
2649 /*
2650 int rc = -1;
2651
2652 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2653 {
2654 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2655
2656 const cl_uchar zero = 0;
2657
2658 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2659 }
2660
2661 if (rc != 0)
2662 {
2663 // NOTE: clEnqueueFillBuffer () always fails with -59
2664 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2665 // How's that possible, OpenCL 1.2 support is advertised??
2666 // We need to workaround...
2667
2668 #define FILLSZ 0x100000
2669
2670 char *tmp = (char *) mymalloc (FILLSZ);
2671
2672 for (size_t i = 0; i < size; i += FILLSZ)
2673 {
2674 const size_t left = size - i;
2675
2676 const size_t fillsz = MIN (FILLSZ, left);
2677
2678 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2679 }
2680
2681 myfree (tmp);
2682 }
2683 */
2684 }
2685
2686 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)
2687 {
2688 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2689 {
2690 if (attack_mode == ATTACK_MODE_BF)
2691 {
2692 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2693 {
2694 const uint size_tm = 32 * sizeof (bs_word_t);
2695
2696 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2697
2698 run_kernel_tm (device_param);
2699
2700 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);
2701 }
2702 }
2703
2704 if (highest_pw_len < 16)
2705 {
2706 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2707 }
2708 else if (highest_pw_len < 32)
2709 {
2710 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2711 }
2712 else
2713 {
2714 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2715 }
2716 }
2717 else
2718 {
2719 run_kernel_amp (device_param, pws_cnt);
2720
2721 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2722
2723 if (opts_type & OPTS_TYPE_HOOK12)
2724 {
2725 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2726 }
2727
2728 uint iter = salt_buf->salt_iter;
2729
2730 uint loop_step = device_param->kernel_loops;
2731
2732 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2733 {
2734 uint loop_left = iter - loop_pos;
2735
2736 loop_left = MIN (loop_left, loop_step);
2737
2738 device_param->kernel_params_buf32[25] = loop_pos;
2739 device_param->kernel_params_buf32[26] = loop_left;
2740
2741 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2742
2743 if (data.devices_status == STATUS_CRACKED) break;
2744 if (data.devices_status == STATUS_ABORTED) break;
2745 if (data.devices_status == STATUS_QUIT) break;
2746
2747 /**
2748 * speed
2749 */
2750
2751 const float iter_part = (float) (loop_pos + loop_left) / iter;
2752
2753 const u64 perf_sum_all = pws_cnt * iter_part;
2754
2755 double speed_ms;
2756
2757 hc_timer_get (device_param->timer_speed, speed_ms);
2758
2759 const u32 speed_pos = device_param->speed_pos;
2760
2761 device_param->speed_cnt[speed_pos] = perf_sum_all;
2762
2763 device_param->speed_ms[speed_pos] = speed_ms;
2764
2765 if (data.benchmark == 1)
2766 {
2767 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2768 }
2769 }
2770
2771 if (opts_type & OPTS_TYPE_HOOK23)
2772 {
2773 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2774
2775 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);
2776
2777 // do something with data
2778
2779 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);
2780 }
2781
2782 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2783 }
2784 }
2785
2786 static int run_rule_engine (const int rule_len, const char *rule_buf)
2787 {
2788 if (rule_len == 0)
2789 {
2790 return 0;
2791 }
2792 else if (rule_len == 1)
2793 {
2794 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2795 }
2796
2797 return 1;
2798 }
2799
2800 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2801 {
2802 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2803 {
2804 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);
2805 }
2806 else if (data.attack_kern == ATTACK_KERN_COMBI)
2807 {
2808 if (data.attack_mode == ATTACK_MODE_COMBI)
2809 {
2810 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2811 {
2812 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x01;
2821 }
2822 }
2823 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2824 {
2825 for (u32 i = 0; i < pws_cnt; i++)
2826 {
2827 const u32 pw_len = device_param->pws_buf[i].pw_len;
2828
2829 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2830
2831 ptr[pw_len] = 0x80;
2832 }
2833 }
2834 }
2835 }
2836 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2837 {
2838 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2839 {
2840 for (u32 i = 0; i < pws_cnt; i++)
2841 {
2842 const u32 pw_len = device_param->pws_buf[i].pw_len;
2843
2844 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2845
2846 ptr[pw_len] = 0x01;
2847 }
2848 }
2849 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2850 {
2851 for (u32 i = 0; i < pws_cnt; i++)
2852 {
2853 const u32 pw_len = device_param->pws_buf[i].pw_len;
2854
2855 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2856
2857 ptr[pw_len] = 0x80;
2858 }
2859 }
2860 }
2861
2862 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);
2863 }
2864 else if (data.attack_kern == ATTACK_KERN_BF)
2865 {
2866 const u64 off = device_param->words_off;
2867
2868 device_param->kernel_params_mp_l_buf64[3] = off;
2869
2870 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2871 }
2872 }
2873
2874 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2875 {
2876 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2877
2878 device_param->kernel_params_buf32[25] = 0;
2879 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2880 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2881
2882 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2883 {
2884 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2885 }
2886 else
2887 {
2888 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2889 }
2890
2891 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2892
2893 return exec_ms_prev;
2894 }
2895
2896 static void autotune (hc_device_param_t *device_param)
2897 {
2898 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2899
2900 const u32 kernel_accel_min = device_param->kernel_accel_min;
2901 const u32 kernel_accel_max = device_param->kernel_accel_max;
2902
2903 const u32 kernel_loops_min = device_param->kernel_loops_min;
2904 const u32 kernel_loops_max = device_param->kernel_loops_max;
2905
2906 u32 kernel_accel = kernel_accel_min;
2907 u32 kernel_loops = kernel_loops_min;
2908
2909 // in this case the user specified a fixed -u and -n on the commandline
2910 // no way to tune anything
2911 // but we need to run a few caching rounds
2912
2913 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2914 {
2915 try_run (device_param, kernel_accel, kernel_loops);
2916 try_run (device_param, kernel_accel, kernel_loops);
2917 try_run (device_param, kernel_accel, kernel_loops);
2918 try_run (device_param, kernel_accel, kernel_loops);
2919
2920 device_param->kernel_accel = kernel_accel;
2921 device_param->kernel_loops = kernel_loops;
2922
2923 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2924
2925 device_param->kernel_power = kernel_power;
2926
2927 return;
2928 }
2929
2930 // from here it's clear we are allowed to autotune
2931 // so let's init some fake words
2932
2933 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2934
2935 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2936
2937 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2938 {
2939 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2940 }
2941
2942 /*
2943 for (u32 i = 0; i < kernel_power_max; i++)
2944 {
2945 device_param->pws_buf[i].i[0] = i;
2946 device_param->pws_buf[i].i[1] = 0x01234567;
2947 device_param->pws_buf[i].pw_len = 7;
2948 }
2949
2950 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);
2951
2952 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2953 {
2954 run_kernel_amp (device_param, kernel_power_max);
2955 }
2956 */
2957
2958 #define VERIFIER_CNT 1
2959
2960 // first find out highest kernel-loops that stays below target_ms
2961
2962 if (kernel_loops_min < kernel_loops_max)
2963 {
2964 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2965 {
2966 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2967
2968 for (int i = 0; i < VERIFIER_CNT; i++)
2969 {
2970 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2971
2972 exec_ms = MIN (exec_ms, exec_ms_v);
2973 }
2974
2975 if (exec_ms < target_ms) break;
2976 }
2977 }
2978
2979 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2980
2981 #define STEPS_CNT 10
2982
2983 if (kernel_accel_min < kernel_accel_max)
2984 {
2985 for (int i = 0; i < STEPS_CNT; i++)
2986 {
2987 const u32 kernel_accel_try = 1 << i;
2988
2989 if (kernel_accel_try < kernel_accel_min) continue;
2990 if (kernel_accel_try > kernel_accel_max) break;
2991
2992 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2993
2994 for (int i = 0; i < VERIFIER_CNT; i++)
2995 {
2996 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2997
2998 exec_ms = MIN (exec_ms, exec_ms_v);
2999 }
3000
3001 if (exec_ms > target_ms) break;
3002
3003 kernel_accel = kernel_accel_try;
3004 }
3005 }
3006
3007 // at this point we want to know the actual runtime for the following reason:
3008 // we need a reference for the balancing loop following up, and this
3009 // the balancing loop can have an effect that the creates a new opportunity, for example:
3010 // if the target is 95 ms and the current runtime is 48ms the above loop
3011 // stopped the execution because the previous exec_ms was > 95ms
3012 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3013 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3014
3015 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3016
3017 for (int i = 0; i < VERIFIER_CNT; i++)
3018 {
3019 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3020
3021 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3022 }
3023
3024 u32 diff = kernel_loops - kernel_accel;
3025
3026 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3027 {
3028 u32 kernel_accel_orig = kernel_accel;
3029 u32 kernel_loops_orig = kernel_loops;
3030
3031 for (u32 f = 1; f < 1024; f++)
3032 {
3033 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3034 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3035
3036 if (kernel_accel_try > kernel_accel_max) break;
3037 if (kernel_loops_try < kernel_loops_min) break;
3038
3039 u32 diff_new = kernel_loops_try - kernel_accel_try;
3040
3041 if (diff_new > diff) break;
3042
3043 diff_new = diff;
3044
3045 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3046
3047 for (int i = 0; i < VERIFIER_CNT; i++)
3048 {
3049 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3050
3051 exec_ms = MIN (exec_ms, exec_ms_v);
3052 }
3053
3054 if (exec_ms < exec_ms_pre_final)
3055 {
3056 exec_ms_pre_final = exec_ms;
3057
3058 kernel_accel = kernel_accel_try;
3059 kernel_loops = kernel_loops_try;
3060 }
3061 }
3062 }
3063
3064 const double exec_left = target_ms / exec_ms_pre_final;
3065
3066 const double accel_left = kernel_accel_max / kernel_accel;
3067
3068 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3069
3070 if (exec_accel_min >= 1.0)
3071 {
3072 // this is safe to not overflow kernel_accel_max because of accel_left
3073
3074 kernel_accel = (double) kernel_accel * exec_accel_min;
3075 }
3076
3077 // reset them fake words
3078
3079 /*
3080 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3081
3082 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);
3083 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);
3084 */
3085
3086 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3087
3088 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3089 {
3090 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3091 }
3092
3093 // reset timer
3094
3095 device_param->exec_pos = 0;
3096
3097 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3098
3099 // store
3100
3101 device_param->kernel_accel = kernel_accel;
3102 device_param->kernel_loops = kernel_loops;
3103
3104 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3105
3106 device_param->kernel_power = kernel_power;
3107
3108 #ifdef DEBUG
3109
3110 if (data.quiet == 0)
3111 {
3112 clear_prompt ();
3113
3114 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3115 "Device #%u: autotuned kernel-loops to %u\n",
3116 device_param->device_id + 1, kernel_accel,
3117 device_param->device_id + 1, kernel_loops);
3118
3119 fprintf (stdout, "%s", PROMPT);
3120
3121 fflush (stdout);
3122 }
3123
3124 #endif
3125 }
3126
3127 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3128 {
3129 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3130
3131 // init speed timer
3132
3133 uint speed_pos = device_param->speed_pos;
3134
3135 #ifdef _POSIX
3136 if (device_param->timer_speed.tv_sec == 0)
3137 {
3138 hc_timer_set (&device_param->timer_speed);
3139 }
3140 #endif
3141
3142 #ifdef _WIN
3143 if (device_param->timer_speed.QuadPart == 0)
3144 {
3145 hc_timer_set (&device_param->timer_speed);
3146 }
3147 #endif
3148
3149 // find higest password length, this is for optimization stuff
3150
3151 uint highest_pw_len = 0;
3152
3153 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3154 {
3155 }
3156 else if (data.attack_kern == ATTACK_KERN_COMBI)
3157 {
3158 }
3159 else if (data.attack_kern == ATTACK_KERN_BF)
3160 {
3161 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3162 + device_param->kernel_params_mp_l_buf32[5];
3163 }
3164
3165 // iteration type
3166
3167 uint innerloop_step = 0;
3168 uint innerloop_cnt = 0;
3169
3170 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3171 else innerloop_step = 1;
3172
3173 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3174 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3175 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3176
3177 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3178
3179 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3180 {
3181 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3182
3183 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3184
3185 if (data.devices_status == STATUS_CRACKED) break;
3186 if (data.devices_status == STATUS_ABORTED) break;
3187 if (data.devices_status == STATUS_QUIT) break;
3188 if (data.devices_status == STATUS_BYPASS) break;
3189
3190 salt_t *salt_buf = &data.salts_buf[salt_pos];
3191
3192 device_param->kernel_params_buf32[24] = salt_pos;
3193 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3194 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3195
3196 FILE *combs_fp = device_param->combs_fp;
3197
3198 if (data.attack_mode == ATTACK_MODE_COMBI)
3199 {
3200 rewind (combs_fp);
3201 }
3202
3203 // innerloops
3204
3205 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3206 {
3207 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3208
3209 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3210
3211 if (data.devices_status == STATUS_CRACKED) break;
3212 if (data.devices_status == STATUS_ABORTED) break;
3213 if (data.devices_status == STATUS_QUIT) break;
3214 if (data.devices_status == STATUS_BYPASS) break;
3215
3216 uint innerloop_left = innerloop_cnt - innerloop_pos;
3217
3218 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3219
3220 device_param->innerloop_pos = innerloop_pos;
3221 device_param->innerloop_left = innerloop_left;
3222
3223 device_param->kernel_params_buf32[27] = innerloop_left;
3224
3225 // i think we can get rid of this
3226 if (innerloop_left == 0)
3227 {
3228 puts ("bug, how should this happen????\n");
3229
3230 continue;
3231 }
3232
3233 if (data.salts_shown[salt_pos] == 1)
3234 {
3235 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3236
3237 continue;
3238 }
3239
3240 // initialize amplifiers
3241
3242 if (data.attack_mode == ATTACK_MODE_COMBI)
3243 {
3244 uint i = 0;
3245
3246 while (i < innerloop_left)
3247 {
3248 if (feof (combs_fp)) break;
3249
3250 int line_len = fgetl (combs_fp, line_buf);
3251
3252 if (line_len >= PW_MAX1) continue;
3253
3254 line_len = convert_from_hex (line_buf, line_len);
3255
3256 char *line_buf_new = line_buf;
3257
3258 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3259 {
3260 char rule_buf_out[BLOCK_SIZE] = { 0 };
3261
3262 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3263
3264 if (rule_len_out < 0)
3265 {
3266 data.words_progress_rejected[salt_pos] += pws_cnt;
3267
3268 continue;
3269 }
3270
3271 line_len = rule_len_out;
3272
3273 line_buf_new = rule_buf_out;
3274 }
3275
3276 line_len = MIN (line_len, PW_DICTMAX);
3277
3278 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3279
3280 memcpy (ptr, line_buf_new, line_len);
3281
3282 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3283
3284 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3285 {
3286 uppercase (ptr, line_len);
3287 }
3288
3289 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3290 {
3291 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3292 {
3293 ptr[line_len] = 0x80;
3294 }
3295
3296 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3297 {
3298 ptr[line_len] = 0x01;
3299 }
3300 }
3301
3302 device_param->combs_buf[i].pw_len = line_len;
3303
3304 i++;
3305 }
3306
3307 for (uint j = i; j < innerloop_left; j++)
3308 {
3309 device_param->combs_buf[j].i[0] = 0;
3310 device_param->combs_buf[j].i[1] = 0;
3311 device_param->combs_buf[j].i[2] = 0;
3312 device_param->combs_buf[j].i[3] = 0;
3313 device_param->combs_buf[j].i[4] = 0;
3314 device_param->combs_buf[j].i[5] = 0;
3315 device_param->combs_buf[j].i[6] = 0;
3316 device_param->combs_buf[j].i[7] = 0;
3317
3318 device_param->combs_buf[j].pw_len = 0;
3319 }
3320
3321 innerloop_left = i;
3322 }
3323 else if (data.attack_mode == ATTACK_MODE_BF)
3324 {
3325 u64 off = innerloop_pos;
3326
3327 device_param->kernel_params_mp_r_buf64[3] = off;
3328
3329 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3330 }
3331 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3332 {
3333 u64 off = innerloop_pos;
3334
3335 device_param->kernel_params_mp_buf64[3] = off;
3336
3337 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3338 }
3339 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3340 {
3341 u64 off = innerloop_pos;
3342
3343 device_param->kernel_params_mp_buf64[3] = off;
3344
3345 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3346 }
3347
3348 // copy amplifiers
3349
3350 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3351 {
3352 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);
3353 }
3354 else if (data.attack_mode == ATTACK_MODE_COMBI)
3355 {
3356 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);
3357 }
3358 else if (data.attack_mode == ATTACK_MODE_BF)
3359 {
3360 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);
3361 }
3362 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3363 {
3364 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);
3365 }
3366 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3367 {
3368 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);
3369 }
3370
3371 if (data.benchmark == 1)
3372 {
3373 hc_timer_set (&device_param->timer_speed);
3374 }
3375
3376 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3377
3378 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3379
3380 if (data.devices_status == STATUS_CRACKED) break;
3381 if (data.devices_status == STATUS_ABORTED) break;
3382 if (data.devices_status == STATUS_QUIT) break;
3383
3384 /**
3385 * result
3386 */
3387
3388 check_cracked (device_param, salt_pos);
3389
3390 /**
3391 * progress
3392 */
3393
3394 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3395
3396 hc_thread_mutex_lock (mux_counter);
3397
3398 data.words_progress_done[salt_pos] += perf_sum_all;
3399
3400 hc_thread_mutex_unlock (mux_counter);
3401
3402 /**
3403 * speed
3404 */
3405
3406 double speed_ms;
3407
3408 hc_timer_get (device_param->timer_speed, speed_ms);
3409
3410 hc_timer_set (&device_param->timer_speed);
3411
3412 // current speed
3413
3414 //hc_thread_mutex_lock (mux_display);
3415
3416 device_param->speed_cnt[speed_pos] = perf_sum_all;
3417
3418 device_param->speed_ms[speed_pos] = speed_ms;
3419
3420 //hc_thread_mutex_unlock (mux_display);
3421
3422 speed_pos++;
3423
3424 if (speed_pos == SPEED_CACHE)
3425 {
3426 speed_pos = 0;
3427 }
3428
3429 /**
3430 * benchmark
3431 */
3432
3433 if (data.benchmark == 1) break;
3434 }
3435 }
3436
3437 device_param->speed_pos = speed_pos;
3438
3439 myfree (line_buf);
3440 }
3441
3442 static void load_segment (wl_data_t *wl_data, FILE *fd)
3443 {
3444 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3445
3446 wl_data->pos = 0;
3447
3448 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3449
3450 wl_data->buf[wl_data->cnt] = 0;
3451
3452 if (wl_data->cnt == 0) return;
3453
3454 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3455
3456 while (!feof (fd))
3457 {
3458 if (wl_data->cnt == wl_data->avail)
3459 {
3460 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3461
3462 wl_data->avail += wl_data->incr;
3463 }
3464
3465 const int c = fgetc (fd);
3466
3467 if (c == EOF) break;
3468
3469 wl_data->buf[wl_data->cnt] = (char) c;
3470
3471 wl_data->cnt++;
3472
3473 if (c == '\n') break;
3474 }
3475
3476 // ensure stream ends with a newline
3477
3478 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3479 {
3480 wl_data->cnt++;
3481
3482 wl_data->buf[wl_data->cnt - 1] = '\n';
3483 }
3484
3485 return;
3486 }
3487
3488 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3489 {
3490 char *ptr = buf;
3491
3492 for (u32 i = 0; i < sz; i++, ptr++)
3493 {
3494 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3495
3496 if (i == 7)
3497 {
3498 *off = i;
3499 *len = i;
3500
3501 return;
3502 }
3503
3504 if (*ptr != '\n') continue;
3505
3506 *off = i + 1;
3507
3508 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3509
3510 *len = i;
3511
3512 return;
3513 }
3514
3515 *off = sz;
3516 *len = sz;
3517 }
3518
3519 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3520 {
3521 char *ptr = buf;
3522
3523 for (u32 i = 0; i < sz; i++, ptr++)
3524 {
3525 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3526
3527 if (*ptr != '\n') continue;
3528
3529 *off = i + 1;
3530
3531 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3532
3533 *len = i;
3534
3535 return;
3536 }
3537
3538 *off = sz;
3539 *len = sz;
3540 }
3541
3542 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3543 {
3544 char *ptr = buf;
3545
3546 for (u32 i = 0; i < sz; i++, ptr++)
3547 {
3548 if (*ptr != '\n') continue;
3549
3550 *off = i + 1;
3551
3552 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3553
3554 *len = i;
3555
3556 return;
3557 }
3558
3559 *off = sz;
3560 *len = sz;
3561 }
3562
3563 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3564 {
3565 while (wl_data->pos < wl_data->cnt)
3566 {
3567 uint off;
3568 uint len;
3569
3570 char *ptr = wl_data->buf + wl_data->pos;
3571
3572 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3573
3574 wl_data->pos += off;
3575
3576 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3577 {
3578 char rule_buf_out[BLOCK_SIZE] = { 0 };
3579
3580 int rule_len_out = -1;
3581
3582 if (len < BLOCK_SIZE)
3583 {
3584 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3585 }
3586
3587 if (rule_len_out < 0)
3588 {
3589 continue;
3590 }
3591
3592 if (rule_len_out > PW_MAX)
3593 {
3594 continue;
3595 }
3596 }
3597 else
3598 {
3599 if (len > PW_MAX)
3600 {
3601 continue;
3602 }
3603 }
3604
3605 *out_buf = ptr;
3606 *out_len = len;
3607
3608 return;
3609 }
3610
3611 if (feof (fd))
3612 {
3613 fprintf (stderr, "BUG feof()!!\n");
3614
3615 return;
3616 }
3617
3618 load_segment (wl_data, fd);
3619
3620 get_next_word (wl_data, fd, out_buf, out_len);
3621 }
3622
3623 #ifdef _POSIX
3624 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3625 #endif
3626
3627 #ifdef _WIN
3628 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3629 #endif
3630 {
3631 hc_signal (NULL);
3632
3633 dictstat_t d;
3634
3635 d.cnt = 0;
3636
3637 #ifdef _POSIX
3638 fstat (fileno (fd), &d.stat);
3639 #endif
3640
3641 #ifdef _WIN
3642 _fstat64 (fileno (fd), &d.stat);
3643 #endif
3644
3645 d.stat.st_mode = 0;
3646 d.stat.st_nlink = 0;
3647 d.stat.st_uid = 0;
3648 d.stat.st_gid = 0;
3649 d.stat.st_rdev = 0;
3650 d.stat.st_atime = 0;
3651
3652 #ifdef _POSIX
3653 d.stat.st_blksize = 0;
3654 d.stat.st_blocks = 0;
3655 #endif
3656
3657 if (d.stat.st_size == 0) return 0;
3658
3659 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3660
3661 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3662 {
3663 if (d_cache)
3664 {
3665 u64 cnt = d_cache->cnt;
3666
3667 u64 keyspace = cnt;
3668
3669 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3670 {
3671 keyspace *= data.kernel_rules_cnt;
3672 }
3673 else if (data.attack_kern == ATTACK_KERN_COMBI)
3674 {
3675 keyspace *= data.combs_cnt;
3676 }
3677
3678 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);
3679 if (data.quiet == 0) log_info ("");
3680
3681 hc_signal (sigHandler_default);
3682
3683 return (keyspace);
3684 }
3685 }
3686
3687 time_t now = 0;
3688 time_t prev = 0;
3689
3690 u64 comp = 0;
3691 u64 cnt = 0;
3692 u64 cnt2 = 0;
3693
3694 while (!feof (fd))
3695 {
3696 load_segment (wl_data, fd);
3697
3698 comp += wl_data->cnt;
3699
3700 u32 i = 0;
3701
3702 while (i < wl_data->cnt)
3703 {
3704 u32 len;
3705 u32 off;
3706
3707 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3708
3709 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3710 {
3711 char rule_buf_out[BLOCK_SIZE] = { 0 };
3712
3713 int rule_len_out = -1;
3714
3715 if (len < BLOCK_SIZE)
3716 {
3717 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3718 }
3719
3720 if (rule_len_out < 0)
3721 {
3722 len = PW_MAX1;
3723 }
3724 else
3725 {
3726 len = rule_len_out;
3727 }
3728 }
3729
3730 if (len < PW_MAX1)
3731 {
3732 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3733 {
3734 cnt += data.kernel_rules_cnt;
3735 }
3736 else if (data.attack_kern == ATTACK_KERN_COMBI)
3737 {
3738 cnt += data.combs_cnt;
3739 }
3740
3741 d.cnt++;
3742 }
3743
3744 i += off;
3745
3746 cnt2++;
3747 }
3748
3749 time (&now);
3750
3751 if ((now - prev) == 0) continue;
3752
3753 float percent = (float) comp / (float) d.stat.st_size;
3754
3755 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);
3756
3757 time (&prev);
3758 }
3759
3760 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);
3761 if (data.quiet == 0) log_info ("");
3762
3763 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3764
3765 hc_signal (sigHandler_default);
3766
3767 return (cnt);
3768 }
3769
3770 static void *thread_monitor (void *p)
3771 {
3772 uint runtime_check = 0;
3773 uint remove_check = 0;
3774 uint status_check = 0;
3775 uint restore_check = 0;
3776
3777 uint restore_left = data.restore_timer;
3778 uint remove_left = data.remove_timer;
3779 uint status_left = data.status_timer;
3780
3781 #ifdef HAVE_HWMON
3782 uint hwmon_check = 0;
3783
3784 // these variables are mainly used for fan control (AMD only)
3785
3786 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3787
3788 // temperature controller "loopback" values
3789
3790 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3791 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3792
3793 #ifdef HAVE_ADL
3794 int temp_threshold = 1; // degrees celcius
3795
3796 int fan_speed_min = 15; // in percentage
3797 int fan_speed_max = 100;
3798 #endif // HAVE_ADL
3799
3800 time_t last_temp_check_time;
3801 #endif // HAVE_HWMON
3802
3803 uint sleep_time = 1;
3804
3805 if (data.runtime)
3806 {
3807 runtime_check = 1;
3808 }
3809
3810 if (data.restore_timer)
3811 {
3812 restore_check = 1;
3813 }
3814
3815 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3816 {
3817 remove_check = 1;
3818 }
3819
3820 if (data.status == 1)
3821 {
3822 status_check = 1;
3823 }
3824
3825 #ifdef HAVE_HWMON
3826 if (data.gpu_temp_disable == 0)
3827 {
3828 time (&last_temp_check_time);
3829
3830 hwmon_check = 1;
3831 }
3832 #endif
3833
3834 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3835 {
3836 #ifdef HAVE_HWMON
3837 if (hwmon_check == 0)
3838 #endif
3839 return (p);
3840 }
3841
3842 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3843 {
3844 hc_sleep (sleep_time);
3845
3846 if (data.devices_status != STATUS_RUNNING) continue;
3847
3848
3849 #ifdef HAVE_HWMON
3850 if (hwmon_check == 1)
3851 {
3852 hc_thread_mutex_lock (mux_adl);
3853
3854 time_t temp_check_time;
3855
3856 time (&temp_check_time);
3857
3858 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3859
3860 if (Ta == 0) Ta = 1;
3861
3862 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3863 {
3864 hc_device_param_t *device_param = &data.devices_param[device_id];
3865
3866 if (device_param->skipped) continue;
3867
3868 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3869
3870 const int temperature = hm_get_temperature_with_device_id (device_id);
3871
3872 if (temperature > (int) data.gpu_temp_abort)
3873 {
3874 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3875
3876 if (data.devices_status != STATUS_QUIT) myabort ();
3877
3878 break;
3879 }
3880
3881 #ifdef HAVE_ADL
3882 const int gpu_temp_retain = data.gpu_temp_retain;
3883
3884 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3885 {
3886 if (data.hm_device[device_id].fan_supported == 1)
3887 {
3888 int temp_cur = temperature;
3889
3890 int temp_diff_new = gpu_temp_retain - temp_cur;
3891
3892 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3893
3894 // calculate Ta value (time difference in seconds between the last check and this check)
3895
3896 last_temp_check_time = temp_check_time;
3897
3898 float Kp = 1.8;
3899 float Ki = 0.005;
3900 float Kd = 6;
3901
3902 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3903
3904 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);
3905
3906 if (abs (fan_diff_required) >= temp_threshold)
3907 {
3908 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3909
3910 int fan_speed_level = fan_speed_cur;
3911
3912 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3913
3914 int fan_speed_new = fan_speed_level - fan_diff_required;
3915
3916 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3917 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3918
3919 if (fan_speed_new != fan_speed_cur)
3920 {
3921 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3922 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3923
3924 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3925 {
3926 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3927
3928 fan_speed_chgd[device_id] = 1;
3929 }
3930
3931 temp_diff_old[device_id] = temp_diff_new;
3932 }
3933 }
3934 }
3935 }
3936 #endif // HAVE_ADL
3937 }
3938
3939 hc_thread_mutex_unlock (mux_adl);
3940 }
3941 #endif // HAVE_HWMON
3942
3943 if (restore_check == 1)
3944 {
3945 restore_left--;
3946
3947 if (restore_left == 0)
3948 {
3949 if (data.restore_disable == 0) cycle_restore ();
3950
3951 restore_left = data.restore_timer;
3952 }
3953 }
3954
3955 if ((runtime_check == 1) && (data.runtime_start > 0))
3956 {
3957 time_t runtime_cur;
3958
3959 time (&runtime_cur);
3960
3961 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3962
3963 if (runtime_left <= 0)
3964 {
3965 if (data.benchmark == 0)
3966 {
3967 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3968 }
3969
3970 if (data.devices_status != STATUS_QUIT) myabort ();
3971 }
3972 }
3973
3974 if (remove_check == 1)
3975 {
3976 remove_left--;
3977
3978 if (remove_left == 0)
3979 {
3980 if (data.digests_saved != data.digests_done)
3981 {
3982 data.digests_saved = data.digests_done;
3983
3984 save_hash ();
3985 }
3986
3987 remove_left = data.remove_timer;
3988 }
3989 }
3990
3991 if (status_check == 1)
3992 {
3993 status_left--;
3994
3995 if (status_left == 0)
3996 {
3997 //hc_thread_mutex_lock (mux_display);
3998
3999 if (data.quiet == 0) clear_prompt ();
4000
4001 if (data.quiet == 0) log_info ("");
4002
4003 status_display ();
4004
4005 if (data.quiet == 0) log_info ("");
4006
4007 //hc_thread_mutex_unlock (mux_display);
4008
4009 status_left = data.status_timer;
4010 }
4011 }
4012 }
4013
4014 #ifdef HAVE_HWMON
4015 myfree (fan_speed_chgd);
4016
4017 myfree (temp_diff_old);
4018 myfree (temp_diff_sum);
4019 #endif
4020
4021 p = NULL;
4022
4023 return (p);
4024 }
4025
4026 static void *thread_outfile_remove (void *p)
4027 {
4028 // some hash-dependent constants
4029 char *outfile_dir = data.outfile_check_directory;
4030 uint dgst_size = data.dgst_size;
4031 uint isSalted = data.isSalted;
4032 uint esalt_size = data.esalt_size;
4033 uint hash_mode = data.hash_mode;
4034
4035 uint outfile_check_timer = data.outfile_check_timer;
4036
4037 char separator = data.separator;
4038
4039 // some hash-dependent functions
4040 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4041 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4042
4043 // buffers
4044 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4045
4046 hash_buf.digest = mymalloc (dgst_size);
4047
4048 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4049
4050 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4051
4052 uint digest_buf[64] = { 0 };
4053
4054 outfile_data_t *out_info = NULL;
4055
4056 char **out_files = NULL;
4057
4058 time_t folder_mtime = 0;
4059
4060 int out_cnt = 0;
4061
4062 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4063
4064 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4065 {
4066 hc_sleep (1);
4067
4068 if (data.devices_status != STATUS_RUNNING) continue;
4069
4070 check_left--;
4071
4072 if (check_left == 0)
4073 {
4074 struct stat outfile_check_stat;
4075
4076 if (stat (outfile_dir, &outfile_check_stat) == 0)
4077 {
4078 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4079
4080 if (is_dir == 1)
4081 {
4082 if (outfile_check_stat.st_mtime > folder_mtime)
4083 {
4084 char **out_files_new = scan_directory (outfile_dir);
4085
4086 int out_cnt_new = count_dictionaries (out_files_new);
4087
4088 outfile_data_t *out_info_new = NULL;
4089
4090 if (out_cnt_new > 0)
4091 {
4092 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4093
4094 for (int i = 0; i < out_cnt_new; i++)
4095 {
4096 out_info_new[i].file_name = out_files_new[i];
4097
4098 // check if there are files that we have seen/checked before (and not changed)
4099
4100 for (int j = 0; j < out_cnt; j++)
4101 {
4102 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4103 {
4104 struct stat outfile_stat;
4105
4106 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4107 {
4108 if (outfile_stat.st_ctime == out_info[j].ctime)
4109 {
4110 out_info_new[i].ctime = out_info[j].ctime;
4111 out_info_new[i].seek = out_info[j].seek;
4112 }
4113 }
4114 }
4115 }
4116 }
4117 }
4118
4119 local_free (out_info);
4120 local_free (out_files);
4121
4122 out_files = out_files_new;
4123 out_cnt = out_cnt_new;
4124 out_info = out_info_new;
4125
4126 folder_mtime = outfile_check_stat.st_mtime;
4127 }
4128
4129 for (int j = 0; j < out_cnt; j++)
4130 {
4131 FILE *fp = fopen (out_info[j].file_name, "rb");
4132
4133 if (fp != NULL)
4134 {
4135 //hc_thread_mutex_lock (mux_display);
4136
4137 #ifdef _POSIX
4138 struct stat outfile_stat;
4139
4140 fstat (fileno (fp), &outfile_stat);
4141 #endif
4142
4143 #ifdef _WIN
4144 struct stat64 outfile_stat;
4145
4146 _fstat64 (fileno (fp), &outfile_stat);
4147 #endif
4148
4149 if (outfile_stat.st_ctime > out_info[j].ctime)
4150 {
4151 out_info[j].ctime = outfile_stat.st_ctime;
4152 out_info[j].seek = 0;
4153 }
4154
4155 fseek (fp, out_info[j].seek, SEEK_SET);
4156
4157 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4158
4159 while (!feof (fp))
4160 {
4161 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4162
4163 if (ptr == NULL) break;
4164
4165 int line_len = strlen (line_buf);
4166
4167 if (line_len <= 0) continue;
4168
4169 int iter = MAX_CUT_TRIES;
4170
4171 for (uint i = line_len - 1; i && iter; i--, line_len--)
4172 {
4173 if (line_buf[i] != separator) continue;
4174
4175 int parser_status = PARSER_OK;
4176
4177 if ((hash_mode != 2500) && (hash_mode != 6800))
4178 {
4179 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4180 }
4181
4182 uint found = 0;
4183
4184 if (parser_status == PARSER_OK)
4185 {
4186 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4187 {
4188 if (data.salts_shown[salt_pos] == 1) continue;
4189
4190 salt_t *salt_buf = &data.salts_buf[salt_pos];
4191
4192 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4193 {
4194 uint idx = salt_buf->digests_offset + digest_pos;
4195
4196 if (data.digests_shown[idx] == 1) continue;
4197
4198 uint cracked = 0;
4199
4200 if (hash_mode == 6800)
4201 {
4202 if (i == salt_buf->salt_len)
4203 {
4204 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4205 }
4206 }
4207 else if (hash_mode == 2500)
4208 {
4209 // BSSID : MAC1 : MAC2 (:plain)
4210 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4211 {
4212 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4213
4214 if (!cracked) continue;
4215
4216 // now compare MAC1 and MAC2 too, since we have this additional info
4217 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4218 char *mac2_pos = mac1_pos + 12 + 1;
4219
4220 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4221 wpa_t *wpa = &wpas[salt_pos];
4222
4223 // compare hex string(s) vs binary MAC address(es)
4224
4225 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4226 {
4227 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4228 {
4229 cracked = 0;
4230
4231 break;
4232 }
4233 }
4234
4235 // early skip ;)
4236 if (!cracked) continue;
4237
4238 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4239 {
4240 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4241 {
4242 cracked = 0;
4243
4244 break;
4245 }
4246 }
4247 }
4248 }
4249 else
4250 {
4251 char *digests_buf_ptr = (char *) data.digests_buf;
4252
4253 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4254
4255 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4256 }
4257
4258 if (cracked == 1)
4259 {
4260 found = 1;
4261
4262 data.digests_shown[idx] = 1;
4263
4264 data.digests_done++;
4265
4266 salt_buf->digests_done++;
4267
4268 if (salt_buf->digests_done == salt_buf->digests_cnt)
4269 {
4270 data.salts_shown[salt_pos] = 1;
4271
4272 data.salts_done++;
4273
4274 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4275 }
4276 }
4277 }
4278
4279 if (data.devices_status == STATUS_CRACKED) break;
4280 }
4281 }
4282
4283 if (found) break;
4284
4285 if (data.devices_status == STATUS_CRACKED) break;
4286
4287 iter--;
4288 }
4289
4290 if (data.devices_status == STATUS_CRACKED) break;
4291 }
4292
4293 myfree (line_buf);
4294
4295 out_info[j].seek = ftell (fp);
4296
4297 //hc_thread_mutex_unlock (mux_display);
4298
4299 fclose (fp);
4300 }
4301 }
4302 }
4303 }
4304
4305 check_left = outfile_check_timer;
4306 }
4307 }
4308
4309 if (esalt_size) local_free (hash_buf.esalt);
4310
4311 if (isSalted) local_free (hash_buf.salt);
4312
4313 local_free (hash_buf.digest);
4314
4315 local_free (out_info);
4316
4317 local_free (out_files);
4318
4319 p = NULL;
4320
4321 return (p);
4322 }
4323
4324 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4325 {
4326 if (device_param->pws_cnt < device_param->kernel_power)
4327 {
4328 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4329
4330 u8 *ptr = (u8 *) pw->i;
4331
4332 memcpy (ptr, pw_buf, pw_len);
4333
4334 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4335
4336 pw->pw_len = pw_len;
4337
4338 device_param->pws_cnt++;
4339 }
4340 else
4341 {
4342 fprintf (stderr, "BUG pw_add()!!\n");
4343
4344 return;
4345 }
4346 }
4347
4348 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4349 {
4350 hc_thread_mutex_lock (mux_dispatcher);
4351
4352 const u64 words_cur = data.words_cur;
4353 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4354
4355 device_param->words_off = words_cur;
4356
4357 const u64 words_left = words_base - words_cur;
4358
4359 if (allow_div)
4360 {
4361 if (data.kernel_power_all > words_left)
4362 {
4363 if (data.kernel_power_div == 0)
4364 {
4365 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4366 }
4367 }
4368
4369 if (data.kernel_power_div)
4370 {
4371 if (device_param->kernel_power == device_param->kernel_power_user)
4372 {
4373 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4374
4375 if (kernel_power_new < device_param->kernel_power)
4376 {
4377 device_param->kernel_power = kernel_power_new;
4378 }
4379 }
4380 }
4381 }
4382
4383 const uint kernel_power = device_param->kernel_power;
4384
4385 uint work = MIN (words_left, kernel_power);
4386
4387 work = MIN (work, max);
4388
4389 data.words_cur += work;
4390
4391 hc_thread_mutex_unlock (mux_dispatcher);
4392
4393 return work;
4394 }
4395
4396 static void *thread_calc_stdin (void *p)
4397 {
4398 hc_device_param_t *device_param = (hc_device_param_t *) p;
4399
4400 if (device_param->skipped) return NULL;
4401
4402 autotune (device_param);
4403
4404 char *buf = (char *) mymalloc (HCBUFSIZ);
4405
4406 const uint attack_kern = data.attack_kern;
4407
4408 const uint kernel_power = device_param->kernel_power;
4409
4410 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4411 {
4412 hc_thread_mutex_lock (mux_dispatcher);
4413
4414 if (feof (stdin) != 0)
4415 {
4416 hc_thread_mutex_unlock (mux_dispatcher);
4417
4418 break;
4419 }
4420
4421 uint words_cur = 0;
4422
4423 while (words_cur < kernel_power)
4424 {
4425 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4426
4427 if (line_buf == NULL) break;
4428
4429 uint line_len = in_superchop (line_buf);
4430
4431 line_len = convert_from_hex (line_buf, line_len);
4432
4433 // post-process rule engine
4434
4435 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4436 {
4437 char rule_buf_out[BLOCK_SIZE] = { 0 };
4438
4439 int rule_len_out = -1;
4440
4441 if (line_len < BLOCK_SIZE)
4442 {
4443 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4444 }
4445
4446 if (rule_len_out < 0) continue;
4447
4448 line_buf = rule_buf_out;
4449 line_len = rule_len_out;
4450 }
4451
4452 if (line_len > PW_MAX)
4453 {
4454 continue;
4455 }
4456
4457 if (attack_kern == ATTACK_KERN_STRAIGHT)
4458 {
4459 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4460 {
4461 hc_thread_mutex_lock (mux_counter);
4462
4463 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4464 {
4465 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4466 }
4467
4468 hc_thread_mutex_unlock (mux_counter);
4469
4470 continue;
4471 }
4472 }
4473 else if (attack_kern == ATTACK_KERN_COMBI)
4474 {
4475 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4476 // since we still need to combine the plains
4477
4478 if (line_len > data.pw_max)
4479 {
4480 hc_thread_mutex_lock (mux_counter);
4481
4482 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4483 {
4484 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4485 }
4486
4487 hc_thread_mutex_unlock (mux_counter);
4488
4489 continue;
4490 }
4491 }
4492
4493 pw_add (device_param, (u8 *) line_buf, line_len);
4494
4495 words_cur++;
4496
4497 if (data.devices_status == STATUS_CRACKED) break;
4498 if (data.devices_status == STATUS_ABORTED) break;
4499 if (data.devices_status == STATUS_QUIT) break;
4500 if (data.devices_status == STATUS_BYPASS) break;
4501 }
4502
4503 hc_thread_mutex_unlock (mux_dispatcher);
4504
4505 if (data.devices_status == STATUS_CRACKED) break;
4506 if (data.devices_status == STATUS_ABORTED) break;
4507 if (data.devices_status == STATUS_QUIT) break;
4508 if (data.devices_status == STATUS_BYPASS) break;
4509
4510 // flush
4511
4512 const uint pws_cnt = device_param->pws_cnt;
4513
4514 if (pws_cnt)
4515 {
4516 run_copy (device_param, pws_cnt);
4517
4518 run_cracker (device_param, pws_cnt);
4519
4520 device_param->pws_cnt = 0;
4521
4522 /*
4523 still required?
4524 if (attack_kern == ATTACK_KERN_STRAIGHT)
4525 {
4526 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4527 }
4528 else if (attack_kern == ATTACK_KERN_COMBI)
4529 {
4530 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4531 }
4532 */
4533 }
4534 }
4535
4536 device_param->kernel_accel = 0;
4537 device_param->kernel_loops = 0;
4538
4539 myfree (buf);
4540
4541 return NULL;
4542 }
4543
4544 static void *thread_calc (void *p)
4545 {
4546 hc_device_param_t *device_param = (hc_device_param_t *) p;
4547
4548 if (device_param->skipped) return NULL;
4549
4550 autotune (device_param);
4551
4552 const uint attack_mode = data.attack_mode;
4553 const uint attack_kern = data.attack_kern;
4554
4555 if (attack_mode == ATTACK_MODE_BF)
4556 {
4557 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4558 {
4559 const uint work = get_work (device_param, -1, true);
4560
4561 if (work == 0) break;
4562
4563 const u64 words_off = device_param->words_off;
4564 const u64 words_fin = words_off + work;
4565
4566 const uint pws_cnt = work;
4567
4568 device_param->pws_cnt = pws_cnt;
4569
4570 if (pws_cnt)
4571 {
4572 run_copy (device_param, pws_cnt);
4573
4574 run_cracker (device_param, pws_cnt);
4575
4576 device_param->pws_cnt = 0;
4577
4578 /*
4579 still required?
4580 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4581 */
4582 }
4583
4584 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4585
4586 if (data.devices_status == STATUS_CRACKED) break;
4587 if (data.devices_status == STATUS_ABORTED) break;
4588 if (data.devices_status == STATUS_QUIT) break;
4589 if (data.devices_status == STATUS_BYPASS) break;
4590
4591 if (data.benchmark == 1) break;
4592
4593 device_param->words_done = words_fin;
4594 }
4595 }
4596 else
4597 {
4598 const uint segment_size = data.segment_size;
4599
4600 char *dictfile = data.dictfile;
4601
4602 if (attack_mode == ATTACK_MODE_COMBI)
4603 {
4604 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4605 {
4606 dictfile = data.dictfile2;
4607 }
4608 }
4609
4610 FILE *fd = fopen (dictfile, "rb");
4611
4612 if (fd == NULL)
4613 {
4614 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4615
4616 return NULL;
4617 }
4618
4619 if (attack_mode == ATTACK_MODE_COMBI)
4620 {
4621 const uint combs_mode = data.combs_mode;
4622
4623 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4624 {
4625 const char *dictfilec = data.dictfile2;
4626
4627 FILE *combs_fp = fopen (dictfilec, "rb");
4628
4629 if (combs_fp == NULL)
4630 {
4631 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4632
4633 fclose (fd);
4634
4635 return NULL;
4636 }
4637
4638 device_param->combs_fp = combs_fp;
4639 }
4640 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4641 {
4642 const char *dictfilec = data.dictfile;
4643
4644 FILE *combs_fp = fopen (dictfilec, "rb");
4645
4646 if (combs_fp == NULL)
4647 {
4648 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4649
4650 fclose (fd);
4651
4652 return NULL;
4653 }
4654
4655 device_param->combs_fp = combs_fp;
4656 }
4657 }
4658
4659 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4660
4661 wl_data->buf = (char *) mymalloc (segment_size);
4662 wl_data->avail = segment_size;
4663 wl_data->incr = segment_size;
4664 wl_data->cnt = 0;
4665 wl_data->pos = 0;
4666
4667 u64 words_cur = 0;
4668
4669 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4670 {
4671 u64 words_off = 0;
4672 u64 words_fin = 0;
4673
4674 bool allow_div = true;
4675
4676 u64 max = -1;
4677
4678 while (max)
4679 {
4680 const uint work = get_work (device_param, max, allow_div);
4681
4682 allow_div = false;
4683
4684 if (work == 0) break;
4685
4686 words_off = device_param->words_off;
4687 words_fin = words_off + work;
4688
4689 char *line_buf;
4690 uint line_len;
4691
4692 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4693
4694 max = 0;
4695
4696 for ( ; words_cur < words_fin; words_cur++)
4697 {
4698 get_next_word (wl_data, fd, &line_buf, &line_len);
4699
4700 line_len = convert_from_hex (line_buf, line_len);
4701
4702 // post-process rule engine
4703
4704 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4705 {
4706 char rule_buf_out[BLOCK_SIZE] = { 0 };
4707
4708 int rule_len_out = -1;
4709
4710 if (line_len < BLOCK_SIZE)
4711 {
4712 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4713 }
4714
4715 if (rule_len_out < 0) continue;
4716
4717 line_buf = rule_buf_out;
4718 line_len = rule_len_out;
4719 }
4720
4721 if (attack_kern == ATTACK_KERN_STRAIGHT)
4722 {
4723 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4724 {
4725 max++;
4726
4727 hc_thread_mutex_lock (mux_counter);
4728
4729 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4730 {
4731 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4732 }
4733
4734 hc_thread_mutex_unlock (mux_counter);
4735
4736 continue;
4737 }
4738 }
4739 else if (attack_kern == ATTACK_KERN_COMBI)
4740 {
4741 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4742 // since we still need to combine the plains
4743
4744 if (line_len > data.pw_max)
4745 {
4746 max++;
4747
4748 hc_thread_mutex_lock (mux_counter);
4749
4750 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4751 {
4752 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4753 }
4754
4755 hc_thread_mutex_unlock (mux_counter);
4756
4757 continue;
4758 }
4759 }
4760
4761 pw_add (device_param, (u8 *) line_buf, line_len);
4762
4763 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4764
4765 if (data.devices_status == STATUS_CRACKED) break;
4766 if (data.devices_status == STATUS_ABORTED) break;
4767 if (data.devices_status == STATUS_QUIT) break;
4768 if (data.devices_status == STATUS_BYPASS) break;
4769 }
4770
4771 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4772
4773 if (data.devices_status == STATUS_CRACKED) break;
4774 if (data.devices_status == STATUS_ABORTED) break;
4775 if (data.devices_status == STATUS_QUIT) break;
4776 if (data.devices_status == STATUS_BYPASS) break;
4777 }
4778
4779 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4780
4781 if (data.devices_status == STATUS_CRACKED) break;
4782 if (data.devices_status == STATUS_ABORTED) break;
4783 if (data.devices_status == STATUS_QUIT) break;
4784 if (data.devices_status == STATUS_BYPASS) break;
4785
4786 //
4787 // flush
4788 //
4789
4790 const uint pws_cnt = device_param->pws_cnt;
4791
4792 if (pws_cnt)
4793 {
4794 run_copy (device_param, pws_cnt);
4795
4796 run_cracker (device_param, pws_cnt);
4797
4798 device_param->pws_cnt = 0;
4799
4800 /*
4801 still required?
4802 if (attack_kern == ATTACK_KERN_STRAIGHT)
4803 {
4804 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4805 }
4806 else if (attack_kern == ATTACK_KERN_COMBI)
4807 {
4808 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4809 }
4810 */
4811 }
4812
4813 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4814
4815 if (data.devices_status == STATUS_CRACKED) break;
4816 if (data.devices_status == STATUS_ABORTED) break;
4817 if (data.devices_status == STATUS_QUIT) break;
4818 if (data.devices_status == STATUS_BYPASS) break;
4819
4820 if (words_fin == 0) break;
4821
4822 device_param->words_done = words_fin;
4823 }
4824
4825 if (attack_mode == ATTACK_MODE_COMBI)
4826 {
4827 fclose (device_param->combs_fp);
4828 }
4829
4830 free (wl_data->buf);
4831 free (wl_data);
4832
4833 fclose (fd);
4834 }
4835
4836 device_param->kernel_accel = 0;
4837 device_param->kernel_loops = 0;
4838
4839 return NULL;
4840 }
4841
4842 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4843 {
4844 if (!device_param)
4845 {
4846 log_error ("ERROR: %s : Invalid argument", __func__);
4847
4848 exit (-1);
4849 }
4850
4851 salt_t *salt_buf = &data.salts_buf[salt_pos];
4852
4853 device_param->kernel_params_buf32[24] = salt_pos;
4854 device_param->kernel_params_buf32[27] = 1;
4855 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4856 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4857 device_param->kernel_params_buf32[30] = 0;
4858 device_param->kernel_params_buf32[31] = 1;
4859
4860 char *dictfile_old = data.dictfile;
4861
4862 const char *weak_hash_check = "weak-hash-check";
4863
4864 data.dictfile = (char *) weak_hash_check;
4865
4866 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4867
4868 data.kernel_rules_buf[0].cmds[0] = 0;
4869
4870 /**
4871 * run the kernel
4872 */
4873
4874 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4875 {
4876 run_kernel (KERN_RUN_1, device_param, 1, false);
4877 }
4878 else
4879 {
4880 run_kernel (KERN_RUN_1, device_param, 1, false);
4881
4882 uint loop_step = 16;
4883
4884 const uint iter = salt_buf->salt_iter;
4885
4886 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4887 {
4888 uint loop_left = iter - loop_pos;
4889
4890 loop_left = MIN (loop_left, loop_step);
4891
4892 device_param->kernel_params_buf32[25] = loop_pos;
4893 device_param->kernel_params_buf32[26] = loop_left;
4894
4895 run_kernel (KERN_RUN_2, device_param, 1, false);
4896 }
4897
4898 run_kernel (KERN_RUN_3, device_param, 1, false);
4899 }
4900
4901 /**
4902 * result
4903 */
4904
4905 check_cracked (device_param, salt_pos);
4906
4907 /**
4908 * cleanup
4909 */
4910
4911 device_param->kernel_params_buf32[24] = 0;
4912 device_param->kernel_params_buf32[25] = 0;
4913 device_param->kernel_params_buf32[26] = 0;
4914 device_param->kernel_params_buf32[27] = 0;
4915 device_param->kernel_params_buf32[28] = 0;
4916 device_param->kernel_params_buf32[29] = 0;
4917 device_param->kernel_params_buf32[30] = 0;
4918 device_param->kernel_params_buf32[31] = 0;
4919
4920 data.dictfile = dictfile_old;
4921
4922 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4923 }
4924
4925 // hlfmt hashcat
4926
4927 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4928 {
4929 if (data.username == 0)
4930 {
4931 *hashbuf_pos = line_buf;
4932 *hashbuf_len = line_len;
4933 }
4934 else
4935 {
4936 char *pos = line_buf;
4937 int len = line_len;
4938
4939 for (int i = 0; i < line_len; i++, pos++, len--)
4940 {
4941 if (line_buf[i] == data.separator)
4942 {
4943 pos++;
4944
4945 len--;
4946
4947 break;
4948 }
4949 }
4950
4951 *hashbuf_pos = pos;
4952 *hashbuf_len = len;
4953 }
4954 }
4955
4956 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4957 {
4958 char *pos = NULL;
4959 int len = 0;
4960
4961 int sep_cnt = 0;
4962
4963 for (int i = 0; i < line_len; i++)
4964 {
4965 if (line_buf[i] == data.separator)
4966 {
4967 sep_cnt++;
4968
4969 continue;
4970 }
4971
4972 if (sep_cnt == 0)
4973 {
4974 if (pos == NULL) pos = line_buf + i;
4975
4976 len++;
4977 }
4978 }
4979
4980 *userbuf_pos = pos;
4981 *userbuf_len = len;
4982 }
4983
4984 // hlfmt pwdump
4985
4986 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4987 {
4988 int sep_cnt = 0;
4989
4990 int sep2_len = 0;
4991 int sep3_len = 0;
4992
4993 for (int i = 0; i < line_len; i++)
4994 {
4995 if (line_buf[i] == ':')
4996 {
4997 sep_cnt++;
4998
4999 continue;
5000 }
5001
5002 if (sep_cnt == 2) sep2_len++;
5003 if (sep_cnt == 3) sep3_len++;
5004 }
5005
5006 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5007
5008 return 0;
5009 }
5010
5011 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5012 {
5013 char *pos = NULL;
5014 int len = 0;
5015
5016 int sep_cnt = 0;
5017
5018 for (int i = 0; i < line_len; i++)
5019 {
5020 if (line_buf[i] == ':')
5021 {
5022 sep_cnt++;
5023
5024 continue;
5025 }
5026
5027 if (data.hash_mode == 1000)
5028 {
5029 if (sep_cnt == 3)
5030 {
5031 if (pos == NULL) pos = line_buf + i;
5032
5033 len++;
5034 }
5035 }
5036 else if (data.hash_mode == 3000)
5037 {
5038 if (sep_cnt == 2)
5039 {
5040 if (pos == NULL) pos = line_buf + i;
5041
5042 len++;
5043 }
5044 }
5045 }
5046
5047 *hashbuf_pos = pos;
5048 *hashbuf_len = len;
5049 }
5050
5051 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5052 {
5053 char *pos = NULL;
5054 int len = 0;
5055
5056 int sep_cnt = 0;
5057
5058 for (int i = 0; i < line_len; i++)
5059 {
5060 if (line_buf[i] == ':')
5061 {
5062 sep_cnt++;
5063
5064 continue;
5065 }
5066
5067 if (sep_cnt == 0)
5068 {
5069 if (pos == NULL) pos = line_buf + i;
5070
5071 len++;
5072 }
5073 }
5074
5075 *userbuf_pos = pos;
5076 *userbuf_len = len;
5077 }
5078
5079 // hlfmt passwd
5080
5081 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5082 {
5083 int sep_cnt = 0;
5084
5085 char sep5_first = 0;
5086 char sep6_first = 0;
5087
5088 for (int i = 0; i < line_len; i++)
5089 {
5090 if (line_buf[i] == ':')
5091 {
5092 sep_cnt++;
5093
5094 continue;
5095 }
5096
5097 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5098 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5099 }
5100
5101 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5102
5103 return 0;
5104 }
5105
5106 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5107 {
5108 char *pos = NULL;
5109 int len = 0;
5110
5111 int sep_cnt = 0;
5112
5113 for (int i = 0; i < line_len; i++)
5114 {
5115 if (line_buf[i] == ':')
5116 {
5117 sep_cnt++;
5118
5119 continue;
5120 }
5121
5122 if (sep_cnt == 1)
5123 {
5124 if (pos == NULL) pos = line_buf + i;
5125
5126 len++;
5127 }
5128 }
5129
5130 *hashbuf_pos = pos;
5131 *hashbuf_len = len;
5132 }
5133
5134 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5135 {
5136 char *pos = NULL;
5137 int len = 0;
5138
5139 int sep_cnt = 0;
5140
5141 for (int i = 0; i < line_len; i++)
5142 {
5143 if (line_buf[i] == ':')
5144 {
5145 sep_cnt++;
5146
5147 continue;
5148 }
5149
5150 if (sep_cnt == 0)
5151 {
5152 if (pos == NULL) pos = line_buf + i;
5153
5154 len++;
5155 }
5156 }
5157
5158 *userbuf_pos = pos;
5159 *userbuf_len = len;
5160 }
5161
5162 // hlfmt shadow
5163
5164 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5165 {
5166 int sep_cnt = 0;
5167
5168 for (int i = 0; i < line_len; i++)
5169 {
5170 if (line_buf[i] == ':') sep_cnt++;
5171 }
5172
5173 if (sep_cnt == 8) return 1;
5174
5175 return 0;
5176 }
5177
5178 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5179 {
5180 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5181 }
5182
5183 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5184 {
5185 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5186 }
5187
5188 // hlfmt main
5189
5190 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5191 {
5192 switch (hashfile_format)
5193 {
5194 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5195 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5196 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5197 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5198 }
5199 }
5200
5201 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5202 {
5203 switch (hashfile_format)
5204 {
5205 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5206 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5207 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5208 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5209 }
5210 }
5211
5212 char *strhlfmt (const uint hashfile_format)
5213 {
5214 switch (hashfile_format)
5215 {
5216 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5217 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5218 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5219 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5220 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5221 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5222 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5223 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5224 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5225 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5226 }
5227
5228 return ((char *) "Unknown");
5229 }
5230
5231 static uint hlfmt_detect (FILE *fp, uint max_check)
5232 {
5233 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5234
5235 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5236 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5237
5238 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5239
5240 uint num_check = 0;
5241
5242 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5243
5244 while (!feof (fp))
5245 {
5246 int line_len = fgetl (fp, line_buf);
5247
5248 if (line_len == 0) continue;
5249
5250 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5251 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5252 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5253
5254 if (num_check == max_check) break;
5255
5256 num_check++;
5257 }
5258
5259 myfree (line_buf);
5260
5261 uint hashlist_format = HLFMT_HASHCAT;
5262
5263 for (int i = 1; i < HLFMTS_CNT; i++)
5264 {
5265 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5266
5267 hashlist_format = i;
5268 }
5269
5270 free (formats_cnt);
5271
5272 return hashlist_format;
5273 }
5274
5275 /**
5276 * some further helper function
5277 */
5278
5279 // wrapper around mymalloc for ADL
5280
5281 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5282 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5283 {
5284 return mymalloc (iSize);
5285 }
5286 #endif
5287
5288 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)
5289 {
5290 u64 collisions = 0;
5291
5292 const uint dgst_pos0 = data.dgst_pos0;
5293 const uint dgst_pos1 = data.dgst_pos1;
5294 const uint dgst_pos2 = data.dgst_pos2;
5295 const uint dgst_pos3 = data.dgst_pos3;
5296
5297 memset (bitmap_a, 0, bitmap_size);
5298 memset (bitmap_b, 0, bitmap_size);
5299 memset (bitmap_c, 0, bitmap_size);
5300 memset (bitmap_d, 0, bitmap_size);
5301
5302 for (uint i = 0; i < digests_cnt; i++)
5303 {
5304 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5305
5306 uint *digest_ptr = (uint *) digests_buf_ptr;
5307
5308 digests_buf_ptr += dgst_size;
5309
5310 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5311 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5312 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5313 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5314
5315 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5316 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5317 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5318 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5319
5320 if (bitmap_a[idx0] & val0) collisions++;
5321 if (bitmap_b[idx1] & val1) collisions++;
5322 if (bitmap_c[idx2] & val2) collisions++;
5323 if (bitmap_d[idx3] & val3) collisions++;
5324
5325 bitmap_a[idx0] |= val0;
5326 bitmap_b[idx1] |= val1;
5327 bitmap_c[idx2] |= val2;
5328 bitmap_d[idx3] |= val3;
5329
5330 if (collisions >= collisions_max) return 0x7fffffff;
5331 }
5332
5333 return collisions;
5334 }
5335
5336 /**
5337 * main
5338 */
5339
5340 #ifdef _WIN
5341 void SetConsoleWindowSize (const int x)
5342 {
5343 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5344
5345 if (h == INVALID_HANDLE_VALUE) return;
5346
5347 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5348
5349 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5350
5351 SMALL_RECT *sr = &bufferInfo.srWindow;
5352
5353 sr->Right = MAX (sr->Right, x - 1);
5354
5355 COORD co;
5356
5357 co.X = sr->Right + 1;
5358 co.Y = sr->Bottom + 1;
5359
5360 if (!SetConsoleScreenBufferSize (h, co)) return;
5361
5362 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5363 }
5364 #endif
5365
5366 int main (int argc, char **argv)
5367 {
5368 #ifdef _WIN
5369 SetConsoleWindowSize (132);
5370 #endif
5371
5372 /**
5373 * To help users a bit
5374 */
5375
5376 char *compute = getenv ("COMPUTE");
5377
5378 if (compute)
5379 {
5380 static char display[100];
5381
5382 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5383
5384 putenv (display);
5385 }
5386 else
5387 {
5388 if (getenv ("DISPLAY") == NULL)
5389 putenv ((char *) "DISPLAY=:0");
5390 }
5391
5392 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5393 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5394
5395 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5396 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5397
5398 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5399 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5400
5401 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5402 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5403
5404 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5405 putenv ((char *) "POCL_KERNEL_CACHE=0");
5406
5407 umask (077);
5408
5409 /**
5410 * Real init
5411 */
5412
5413 memset (&data, 0, sizeof (hc_global_data_t));
5414
5415 time_t proc_start;
5416
5417 time (&proc_start);
5418
5419 data.proc_start = proc_start;
5420
5421 int myargc = argc;
5422 char **myargv = argv;
5423
5424 hc_thread_mutex_init (mux_dispatcher);
5425 hc_thread_mutex_init (mux_counter);
5426 hc_thread_mutex_init (mux_display);
5427 hc_thread_mutex_init (mux_adl);
5428
5429 /**
5430 * commandline parameters
5431 */
5432
5433 uint usage = USAGE;
5434 uint version = VERSION;
5435 uint quiet = QUIET;
5436 uint benchmark = BENCHMARK;
5437 uint show = SHOW;
5438 uint left = LEFT;
5439 uint username = USERNAME;
5440 uint remove = REMOVE;
5441 uint remove_timer = REMOVE_TIMER;
5442 u64 skip = SKIP;
5443 u64 limit = LIMIT;
5444 uint keyspace = KEYSPACE;
5445 uint potfile_disable = POTFILE_DISABLE;
5446 char *potfile_path = NULL;
5447 uint debug_mode = DEBUG_MODE;
5448 char *debug_file = NULL;
5449 char *induction_dir = NULL;
5450 char *outfile_check_dir = NULL;
5451 uint force = FORCE;
5452 uint runtime = RUNTIME;
5453 uint hash_mode = HASH_MODE;
5454 uint attack_mode = ATTACK_MODE;
5455 uint markov_disable = MARKOV_DISABLE;
5456 uint markov_classic = MARKOV_CLASSIC;
5457 uint markov_threshold = MARKOV_THRESHOLD;
5458 char *markov_hcstat = NULL;
5459 char *outfile = NULL;
5460 uint outfile_format = OUTFILE_FORMAT;
5461 uint outfile_autohex = OUTFILE_AUTOHEX;
5462 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5463 uint restore = RESTORE;
5464 uint restore_timer = RESTORE_TIMER;
5465 uint restore_disable = RESTORE_DISABLE;
5466 uint status = STATUS;
5467 uint status_timer = STATUS_TIMER;
5468 uint machine_readable = MACHINE_READABLE;
5469 uint loopback = LOOPBACK;
5470 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5471 char *session = NULL;
5472 uint hex_charset = HEX_CHARSET;
5473 uint hex_salt = HEX_SALT;
5474 uint hex_wordlist = HEX_WORDLIST;
5475 uint rp_gen = RP_GEN;
5476 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5477 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5478 uint rp_gen_seed = RP_GEN_SEED;
5479 char *rule_buf_l = (char *) RULE_BUF_L;
5480 char *rule_buf_r = (char *) RULE_BUF_R;
5481 uint increment = INCREMENT;
5482 uint increment_min = INCREMENT_MIN;
5483 uint increment_max = INCREMENT_MAX;
5484 char *cpu_affinity = NULL;
5485 OCL_PTR *ocl = NULL;
5486 char *opencl_devices = NULL;
5487 char *opencl_platforms = NULL;
5488 char *opencl_device_types = NULL;
5489 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5490 char *truecrypt_keyfiles = NULL;
5491 char *veracrypt_keyfiles = NULL;
5492 uint veracrypt_pim = 0;
5493 uint workload_profile = WORKLOAD_PROFILE;
5494 uint kernel_accel = KERNEL_ACCEL;
5495 uint kernel_loops = KERNEL_LOOPS;
5496 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5497 #ifdef HAVE_HWMON
5498 uint gpu_temp_abort = GPU_TEMP_ABORT;
5499 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5500 #ifdef HAVE_ADL
5501 uint powertune_enable = POWERTUNE_ENABLE;
5502 #endif
5503 #endif
5504 uint logfile_disable = LOGFILE_DISABLE;
5505 uint segment_size = SEGMENT_SIZE;
5506 uint scrypt_tmto = SCRYPT_TMTO;
5507 char separator = SEPARATOR;
5508 uint bitmap_min = BITMAP_MIN;
5509 uint bitmap_max = BITMAP_MAX;
5510 char *custom_charset_1 = NULL;
5511 char *custom_charset_2 = NULL;
5512 char *custom_charset_3 = NULL;
5513 char *custom_charset_4 = NULL;
5514
5515 #define IDX_HELP 'h'
5516 #define IDX_VERSION 'V'
5517 #define IDX_VERSION_LOWER 'v'
5518 #define IDX_QUIET 0xff02
5519 #define IDX_SHOW 0xff03
5520 #define IDX_LEFT 0xff04
5521 #define IDX_REMOVE 0xff05
5522 #define IDX_REMOVE_TIMER 0xff37
5523 #define IDX_SKIP 's'
5524 #define IDX_LIMIT 'l'
5525 #define IDX_KEYSPACE 0xff35
5526 #define IDX_POTFILE_DISABLE 0xff06
5527 #define IDX_POTFILE_PATH 0xffe0
5528 #define IDX_DEBUG_MODE 0xff43
5529 #define IDX_DEBUG_FILE 0xff44
5530 #define IDX_INDUCTION_DIR 0xff46
5531 #define IDX_OUTFILE_CHECK_DIR 0xff47
5532 #define IDX_USERNAME 0xff07
5533 #define IDX_FORCE 0xff08
5534 #define IDX_RUNTIME 0xff09
5535 #define IDX_BENCHMARK 'b'
5536 #define IDX_HASH_MODE 'm'
5537 #define IDX_ATTACK_MODE 'a'
5538 #define IDX_RP_FILE 'r'
5539 #define IDX_RP_GEN 'g'
5540 #define IDX_RP_GEN_FUNC_MIN 0xff10
5541 #define IDX_RP_GEN_FUNC_MAX 0xff11
5542 #define IDX_RP_GEN_SEED 0xff34
5543 #define IDX_RULE_BUF_L 'j'
5544 #define IDX_RULE_BUF_R 'k'
5545 #define IDX_INCREMENT 'i'
5546 #define IDX_INCREMENT_MIN 0xff12
5547 #define IDX_INCREMENT_MAX 0xff13
5548 #define IDX_OUTFILE 'o'
5549 #define IDX_OUTFILE_FORMAT 0xff14
5550 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5551 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5552 #define IDX_RESTORE 0xff15
5553 #define IDX_RESTORE_DISABLE 0xff27
5554 #define IDX_STATUS 0xff17
5555 #define IDX_STATUS_TIMER 0xff18
5556 #define IDX_MACHINE_READABLE 0xff50
5557 #define IDX_LOOPBACK 0xff38
5558 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5559 #define IDX_SESSION 0xff19
5560 #define IDX_HEX_CHARSET 0xff20
5561 #define IDX_HEX_SALT 0xff21
5562 #define IDX_HEX_WORDLIST 0xff40
5563 #define IDX_MARKOV_DISABLE 0xff22
5564 #define IDX_MARKOV_CLASSIC 0xff23
5565 #define IDX_MARKOV_THRESHOLD 't'
5566 #define IDX_MARKOV_HCSTAT 0xff24
5567 #define IDX_CPU_AFFINITY 0xff25
5568 #define IDX_OPENCL_DEVICES 'd'
5569 #define IDX_OPENCL_PLATFORMS 0xff72
5570 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5571 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5572 #define IDX_WORKLOAD_PROFILE 'w'
5573 #define IDX_KERNEL_ACCEL 'n'
5574 #define IDX_KERNEL_LOOPS 'u'
5575 #define IDX_GPU_TEMP_DISABLE 0xff29
5576 #define IDX_GPU_TEMP_ABORT 0xff30
5577 #define IDX_GPU_TEMP_RETAIN 0xff31
5578 #define IDX_POWERTUNE_ENABLE 0xff41
5579 #define IDX_LOGFILE_DISABLE 0xff51
5580 #define IDX_TRUECRYPT_KEYFILES 0xff52
5581 #define IDX_VERACRYPT_KEYFILES 0xff53
5582 #define IDX_VERACRYPT_PIM 0xff54
5583 #define IDX_SCRYPT_TMTO 0xff61
5584 #define IDX_SEGMENT_SIZE 'c'
5585 #define IDX_SEPARATOR 'p'
5586 #define IDX_BITMAP_MIN 0xff70
5587 #define IDX_BITMAP_MAX 0xff71
5588 #define IDX_CUSTOM_CHARSET_1 '1'
5589 #define IDX_CUSTOM_CHARSET_2 '2'
5590 #define IDX_CUSTOM_CHARSET_3 '3'
5591 #define IDX_CUSTOM_CHARSET_4 '4'
5592
5593 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5594
5595 struct option long_options[] =
5596 {
5597 {"help", no_argument, 0, IDX_HELP},
5598 {"version", no_argument, 0, IDX_VERSION},
5599 {"quiet", no_argument, 0, IDX_QUIET},
5600 {"show", no_argument, 0, IDX_SHOW},
5601 {"left", no_argument, 0, IDX_LEFT},
5602 {"username", no_argument, 0, IDX_USERNAME},
5603 {"remove", no_argument, 0, IDX_REMOVE},
5604 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5605 {"skip", required_argument, 0, IDX_SKIP},
5606 {"limit", required_argument, 0, IDX_LIMIT},
5607 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5608 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5609 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5610 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5611 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5612 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5613 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5614 {"force", no_argument, 0, IDX_FORCE},
5615 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5616 {"restore", no_argument, 0, IDX_RESTORE},
5617 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5618 {"status", no_argument, 0, IDX_STATUS},
5619 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5620 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5621 {"loopback", no_argument, 0, IDX_LOOPBACK},
5622 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5623 {"session", required_argument, 0, IDX_SESSION},
5624 {"runtime", required_argument, 0, IDX_RUNTIME},
5625 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5626 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5627 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5628 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5629 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5630 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5631 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5632 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5633 {"rules-file", required_argument, 0, IDX_RP_FILE},
5634 {"outfile", required_argument, 0, IDX_OUTFILE},
5635 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5636 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5637 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5638 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5639 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5640 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5641 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5642 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5643 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5644 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5645 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5646 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5647 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5648 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5649 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5650 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5651 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5652 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5653 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5654 #ifdef HAVE_HWMON
5655 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5656 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5657 #ifdef HAVE_ADL
5658 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5659 #endif
5660 #endif // HAVE_HWMON
5661 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5662 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5663 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5664 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5665 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5666 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5667 {"seperator", required_argument, 0, IDX_SEPARATOR},
5668 {"separator", required_argument, 0, IDX_SEPARATOR},
5669 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5670 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5671 {"increment", no_argument, 0, IDX_INCREMENT},
5672 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5673 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5674 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5675 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5676 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5677 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5678 {0, 0, 0, 0}
5679 };
5680
5681 uint rp_files_cnt = 0;
5682
5683 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5684
5685 int option_index = 0;
5686 int c = -1;
5687
5688 optind = 1;
5689 optopt = 0;
5690
5691 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5692 {
5693 switch (c)
5694 {
5695 case IDX_HELP: usage = 1; break;
5696 case IDX_VERSION:
5697 case IDX_VERSION_LOWER: version = 1; break;
5698 case IDX_RESTORE: restore = 1; break;
5699 case IDX_SESSION: session = optarg; break;
5700 case IDX_SHOW: show = 1; break;
5701 case IDX_LEFT: left = 1; break;
5702 case '?': return (-1);
5703 }
5704 }
5705
5706 if (optopt != 0)
5707 {
5708 log_error ("ERROR: Invalid argument specified");
5709
5710 return (-1);
5711 }
5712
5713 /**
5714 * exit functions
5715 */
5716
5717 if (version)
5718 {
5719 log_info ("%s", VERSION_TAG);
5720
5721 return (0);
5722 }
5723
5724 if (usage)
5725 {
5726 usage_big_print (PROGNAME);
5727
5728 return (0);
5729 }
5730
5731 /**
5732 * session needs to be set, always!
5733 */
5734
5735 if (session == NULL) session = (char *) PROGNAME;
5736
5737 /**
5738 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5739 */
5740
5741 char *exec_path = get_exec_path ();
5742
5743 #ifdef LINUX
5744
5745 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5746 char *resolved_exec_path = realpath (exec_path, NULL);
5747
5748 char *install_dir = get_install_dir (resolved_exec_path);
5749 char *profile_dir = NULL;
5750 char *session_dir = NULL;
5751 char *shared_dir = NULL;
5752
5753 if (strcmp (install_dir, resolved_install_folder) == 0)
5754 {
5755 struct passwd *pw = getpwuid (getuid ());
5756
5757 const char *homedir = pw->pw_dir;
5758
5759 profile_dir = get_profile_dir (homedir);
5760 session_dir = get_session_dir (profile_dir);
5761 shared_dir = strdup (SHARED_FOLDER);
5762
5763 mkdir (profile_dir, 0700);
5764 mkdir (session_dir, 0700);
5765 }
5766 else
5767 {
5768 profile_dir = install_dir;
5769 session_dir = install_dir;
5770 shared_dir = install_dir;
5771 }
5772
5773 myfree (resolved_install_folder);
5774 myfree (resolved_exec_path);
5775
5776 #else
5777
5778 char *install_dir = get_install_dir (exec_path);
5779 char *profile_dir = install_dir;
5780 char *session_dir = install_dir;
5781 char *shared_dir = install_dir;
5782
5783 #endif
5784
5785 data.install_dir = install_dir;
5786 data.profile_dir = profile_dir;
5787 data.session_dir = session_dir;
5788 data.shared_dir = shared_dir;
5789
5790 myfree (exec_path);
5791
5792 /**
5793 * kernel cache, we need to make sure folder exist
5794 */
5795
5796 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5797
5798 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5799
5800 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5801
5802 mkdir (kernels_folder, 0700);
5803
5804 myfree (kernels_folder);
5805
5806 /**
5807 * session
5808 */
5809
5810 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5811
5812 data.session = session;
5813
5814 char *eff_restore_file = (char *) mymalloc (session_size);
5815 char *new_restore_file = (char *) mymalloc (session_size);
5816
5817 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5818 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5819
5820 data.eff_restore_file = eff_restore_file;
5821 data.new_restore_file = new_restore_file;
5822
5823 if (((show == 1) || (left == 1)) && (restore == 1))
5824 {
5825 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5826 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5827
5828 return (-1);
5829 }
5830
5831 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5832 if ((show == 1) || (left == 1))
5833 {
5834 restore_disable = 1;
5835
5836 restore = 0;
5837 }
5838
5839 data.restore_disable = restore_disable;
5840
5841 restore_data_t *rd = init_restore (argc, argv);
5842
5843 data.rd = rd;
5844
5845 /**
5846 * restore file
5847 */
5848
5849 if (restore == 1)
5850 {
5851 read_restore (eff_restore_file, rd);
5852
5853 if (rd->version_bin < RESTORE_MIN)
5854 {
5855 log_error ("ERROR: Incompatible restore-file version");
5856
5857 return (-1);
5858 }
5859
5860 myargc = rd->argc;
5861 myargv = rd->argv;
5862
5863 #ifdef _POSIX
5864 rd->pid = getpid ();
5865 #elif _WIN
5866 rd->pid = GetCurrentProcessId ();
5867 #endif
5868 }
5869
5870 uint hash_mode_chgd = 0;
5871 uint runtime_chgd = 0;
5872 uint kernel_loops_chgd = 0;
5873 uint kernel_accel_chgd = 0;
5874 uint attack_mode_chgd = 0;
5875 uint outfile_format_chgd = 0;
5876 uint rp_gen_seed_chgd = 0;
5877 uint remove_timer_chgd = 0;
5878 uint increment_min_chgd = 0;
5879 uint increment_max_chgd = 0;
5880 uint workload_profile_chgd = 0;
5881 uint opencl_vector_width_chgd = 0;
5882
5883 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5884 uint gpu_temp_retain_chgd = 0;
5885 uint gpu_temp_abort_chgd = 0;
5886 #endif
5887
5888 optind = 1;
5889 optopt = 0;
5890 option_index = 0;
5891
5892 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5893 {
5894 switch (c)
5895 {
5896 //case IDX_HELP: usage = 1; break;
5897 //case IDX_VERSION: version = 1; break;
5898 //case IDX_RESTORE: restore = 1; break;
5899 case IDX_QUIET: quiet = 1; break;
5900 //case IDX_SHOW: show = 1; break;
5901 case IDX_SHOW: break;
5902 //case IDX_LEFT: left = 1; break;
5903 case IDX_LEFT: break;
5904 case IDX_USERNAME: username = 1; break;
5905 case IDX_REMOVE: remove = 1; break;
5906 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5907 remove_timer_chgd = 1; break;
5908 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5909 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5910 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5911 case IDX_DEBUG_FILE: debug_file = optarg; break;
5912 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5913 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5914 case IDX_FORCE: force = 1; break;
5915 case IDX_SKIP: skip = atoll (optarg); break;
5916 case IDX_LIMIT: limit = atoll (optarg); break;
5917 case IDX_KEYSPACE: keyspace = 1; break;
5918 case IDX_BENCHMARK: benchmark = 1; break;
5919 case IDX_RESTORE: break;
5920 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5921 case IDX_STATUS: status = 1; break;
5922 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5923 case IDX_MACHINE_READABLE: machine_readable = 1; break;
5924 case IDX_LOOPBACK: loopback = 1; break;
5925 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5926 //case IDX_SESSION: session = optarg; break;
5927 case IDX_SESSION: break;
5928 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5929 hash_mode_chgd = 1; break;
5930 case IDX_RUNTIME: runtime = atoi (optarg);
5931 runtime_chgd = 1; break;
5932 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5933 attack_mode_chgd = 1; break;
5934 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5935 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5936 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5937 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5938 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5939 rp_gen_seed_chgd = 1; break;
5940 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5941 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5942 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5943 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5944 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5945 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5946 case IDX_OUTFILE: outfile = optarg; break;
5947 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5948 outfile_format_chgd = 1; break;
5949 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5950 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5951 case IDX_HEX_CHARSET: hex_charset = 1; break;
5952 case IDX_HEX_SALT: hex_salt = 1; break;
5953 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5954 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5955 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5956 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5957 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5958 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5959 opencl_vector_width_chgd = 1; break;
5960 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5961 workload_profile_chgd = 1; break;
5962 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5963 kernel_accel_chgd = 1; break;
5964 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5965 kernel_loops_chgd = 1; break;
5966 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5967 #ifdef HAVE_HWMON
5968 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5969 #ifdef HAVE_ADL
5970 gpu_temp_abort_chgd = 1;
5971 #endif
5972 break;
5973 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5974 #ifdef HAVE_ADL
5975 gpu_temp_retain_chgd = 1;
5976 #endif
5977 break;
5978 #ifdef HAVE_ADL
5979 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5980 #endif
5981 #endif // HAVE_HWMON
5982 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5983 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5984 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5985 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5986 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5987 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5988 case IDX_SEPARATOR: separator = optarg[0]; break;
5989 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5990 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5991 case IDX_INCREMENT: increment = 1; break;
5992 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5993 increment_min_chgd = 1; break;
5994 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5995 increment_max_chgd = 1; break;
5996 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5997 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5998 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5999 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6000
6001 default:
6002 log_error ("ERROR: Invalid argument specified");
6003 return (-1);
6004 }
6005 }
6006
6007 if (optopt != 0)
6008 {
6009 log_error ("ERROR: Invalid argument specified");
6010
6011 return (-1);
6012 }
6013
6014 /**
6015 * Inform user things getting started,
6016 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6017 * - we do not need to check algorithm_pos
6018 */
6019
6020 if (quiet == 0)
6021 {
6022 if (benchmark == 1)
6023 {
6024 if (machine_readable == 0)
6025 {
6026 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6027 log_info ("");
6028 }
6029 else
6030 {
6031 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6032 }
6033 }
6034 else if (restore == 1)
6035 {
6036 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6037 log_info ("");
6038 }
6039 else
6040 {
6041 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6042 log_info ("");
6043 }
6044 }
6045
6046 /**
6047 * sanity check
6048 */
6049
6050 if (attack_mode > 7)
6051 {
6052 log_error ("ERROR: Invalid attack-mode specified");
6053
6054 return (-1);
6055 }
6056
6057 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6058 {
6059 log_error ("ERROR: Invalid runtime specified");
6060
6061 return (-1);
6062 }
6063
6064 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6065 {
6066 log_error ("ERROR: Invalid hash-type specified");
6067
6068 return (-1);
6069 }
6070
6071 // renamed hash modes
6072
6073 if (hash_mode_chgd)
6074 {
6075 int n = -1;
6076
6077 switch (hash_mode)
6078 {
6079 case 123: n = 124;
6080 break;
6081 }
6082
6083 if (n >= 0)
6084 {
6085 log_error ("Old -m specified, use -m %d instead", n);
6086
6087 return (-1);
6088 }
6089 }
6090
6091 if (username == 1)
6092 {
6093 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6094 {
6095 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6096
6097 return (-1);
6098 }
6099 }
6100
6101 if (outfile_format > 16)
6102 {
6103 log_error ("ERROR: Invalid outfile-format specified");
6104
6105 return (-1);
6106 }
6107
6108 if (left == 1)
6109 {
6110 if (outfile_format_chgd == 1)
6111 {
6112 if (outfile_format > 1)
6113 {
6114 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6115
6116 return (-1);
6117 }
6118 }
6119 else
6120 {
6121 outfile_format = OUTFILE_FMT_HASH;
6122 }
6123 }
6124
6125 if (show == 1)
6126 {
6127 if (outfile_format_chgd == 1)
6128 {
6129 if ((outfile_format > 7) && (outfile_format < 16))
6130 {
6131 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6132
6133 return (-1);
6134 }
6135 }
6136 }
6137
6138 if (increment_min < INCREMENT_MIN)
6139 {
6140 log_error ("ERROR: Invalid increment-min specified");
6141
6142 return (-1);
6143 }
6144
6145 if (increment_max > INCREMENT_MAX)
6146 {
6147 log_error ("ERROR: Invalid increment-max specified");
6148
6149 return (-1);
6150 }
6151
6152 if (increment_min > increment_max)
6153 {
6154 log_error ("ERROR: Invalid increment-min specified");
6155
6156 return (-1);
6157 }
6158
6159 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6160 {
6161 log_error ("ERROR: increment is not allowed in attack-mode 0");
6162
6163 return (-1);
6164 }
6165
6166 if ((increment == 0) && (increment_min_chgd == 1))
6167 {
6168 log_error ("ERROR: increment-min is only supported together with increment switch");
6169
6170 return (-1);
6171 }
6172
6173 if ((increment == 0) && (increment_max_chgd == 1))
6174 {
6175 log_error ("ERROR: increment-max is only supported together with increment switch");
6176
6177 return (-1);
6178 }
6179
6180 if (rp_files_cnt && rp_gen)
6181 {
6182 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6183
6184 return (-1);
6185 }
6186
6187 if (rp_files_cnt || rp_gen)
6188 {
6189 if (attack_mode != ATTACK_MODE_STRAIGHT)
6190 {
6191 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6192
6193 return (-1);
6194 }
6195 }
6196
6197 if (rp_gen_func_min > rp_gen_func_max)
6198 {
6199 log_error ("ERROR: Invalid rp-gen-func-min specified");
6200
6201 return (-1);
6202 }
6203
6204 if (kernel_accel_chgd == 1)
6205 {
6206 if (force == 0)
6207 {
6208 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6209 log_info ("Please consider using the option -w instead");
6210 log_info ("You can use --force to override this but do not post error reports if you do so");
6211 log_info ("");
6212
6213 return (-1);
6214 }
6215
6216 if (kernel_accel < 1)
6217 {
6218 log_error ("ERROR: Invalid kernel-accel specified");
6219
6220 return (-1);
6221 }
6222
6223 if (kernel_accel > 1024)
6224 {
6225 log_error ("ERROR: Invalid kernel-accel specified");
6226
6227 return (-1);
6228 }
6229 }
6230
6231 if (kernel_loops_chgd == 1)
6232 {
6233 if (force == 0)
6234 {
6235 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6236 log_info ("Please consider using the option -w instead");
6237 log_info ("You can use --force to override this but do not post error reports if you do so");
6238 log_info ("");
6239
6240 return (-1);
6241 }
6242
6243 if (kernel_loops < 1)
6244 {
6245 log_error ("ERROR: Invalid kernel-loops specified");
6246
6247 return (-1);
6248 }
6249
6250 if (kernel_loops > 1024)
6251 {
6252 log_error ("ERROR: Invalid kernel-loops specified");
6253
6254 return (-1);
6255 }
6256 }
6257
6258 if ((workload_profile < 1) || (workload_profile > 4))
6259 {
6260 log_error ("ERROR: workload-profile %i not available", workload_profile);
6261
6262 return (-1);
6263 }
6264
6265 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6266 {
6267 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6268
6269 return (-1);
6270 }
6271
6272 if (show == 1 || left == 1)
6273 {
6274 attack_mode = ATTACK_MODE_NONE;
6275
6276 if (remove == 1)
6277 {
6278 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6279
6280 return (-1);
6281 }
6282
6283 if (potfile_disable == 1)
6284 {
6285 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6286
6287 return (-1);
6288 }
6289 }
6290
6291 uint attack_kern = ATTACK_KERN_NONE;
6292
6293 switch (attack_mode)
6294 {
6295 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6296 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6297 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6298 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6299 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6300 }
6301
6302 if (benchmark == 0)
6303 {
6304 if (keyspace == 1)
6305 {
6306 int num_additional_params = 1;
6307
6308 if (attack_kern == ATTACK_KERN_COMBI)
6309 {
6310 num_additional_params = 2;
6311 }
6312
6313 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6314
6315 if (keyspace_wordlist_specified == 0) optind--;
6316 }
6317
6318 if (attack_kern == ATTACK_KERN_NONE)
6319 {
6320 if ((optind + 1) != myargc)
6321 {
6322 usage_mini_print (myargv[0]);
6323
6324 return (-1);
6325 }
6326 }
6327 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6328 {
6329 if ((optind + 1) > myargc)
6330 {
6331 usage_mini_print (myargv[0]);
6332
6333 return (-1);
6334 }
6335 }
6336 else if (attack_kern == ATTACK_KERN_COMBI)
6337 {
6338 if ((optind + 3) != myargc)
6339 {
6340 usage_mini_print (myargv[0]);
6341
6342 return (-1);
6343 }
6344 }
6345 else if (attack_kern == ATTACK_KERN_BF)
6346 {
6347 if ((optind + 1) > myargc)
6348 {
6349 usage_mini_print (myargv[0]);
6350
6351 return (-1);
6352 }
6353 }
6354 else
6355 {
6356 usage_mini_print (myargv[0]);
6357
6358 return (-1);
6359 }
6360 }
6361 else
6362 {
6363 if (myargv[optind] != 0)
6364 {
6365 log_error ("ERROR: Invalid argument for benchmark mode specified");
6366
6367 return (-1);
6368 }
6369
6370 if (attack_mode_chgd == 1)
6371 {
6372 if (attack_mode != ATTACK_MODE_BF)
6373 {
6374 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6375
6376 return (-1);
6377 }
6378 }
6379 }
6380
6381 if (skip != 0 && limit != 0)
6382 {
6383 limit += skip;
6384 }
6385
6386 if (keyspace == 1)
6387 {
6388 if (show == 1)
6389 {
6390 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6391
6392 return (-1);
6393 }
6394 else if (left == 1)
6395 {
6396 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6397
6398 return (-1);
6399 }
6400
6401 potfile_disable = 1;
6402
6403 restore_disable = 1;
6404
6405 restore = 0;
6406
6407 weak_hash_threshold = 0;
6408
6409 quiet = 1;
6410 }
6411
6412 if (remove_timer_chgd == 1)
6413 {
6414 if (remove == 0)
6415 {
6416 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6417
6418 return (-1);
6419 }
6420
6421 if (remove_timer < 1)
6422 {
6423 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6424
6425 return (-1);
6426 }
6427 }
6428
6429 if (loopback == 1)
6430 {
6431 if (attack_mode == ATTACK_MODE_STRAIGHT)
6432 {
6433 if ((rp_files_cnt == 0) && (rp_gen == 0))
6434 {
6435 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6436
6437 return (-1);
6438 }
6439 }
6440 else
6441 {
6442 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6443
6444 return (-1);
6445 }
6446 }
6447
6448 if (debug_mode > 0)
6449 {
6450 if (attack_mode != ATTACK_MODE_STRAIGHT)
6451 {
6452 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6453
6454 return (-1);
6455 }
6456
6457 if ((rp_files_cnt == 0) && (rp_gen == 0))
6458 {
6459 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6460
6461 return (-1);
6462 }
6463 }
6464
6465 if (debug_mode > 4)
6466 {
6467 log_error ("ERROR: Invalid debug-mode specified");
6468
6469 return (-1);
6470 }
6471
6472 if (debug_file != NULL)
6473 {
6474 if (debug_mode < 1)
6475 {
6476 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6477
6478 return (-1);
6479 }
6480 }
6481
6482 if (induction_dir != NULL)
6483 {
6484 if (attack_mode == ATTACK_MODE_BF)
6485 {
6486 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6487
6488 return (-1);
6489 }
6490 }
6491
6492 if (attack_mode != ATTACK_MODE_STRAIGHT)
6493 {
6494 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6495 {
6496 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6497
6498 return (-1);
6499 }
6500
6501 weak_hash_threshold = 0;
6502 }
6503
6504 /**
6505 * induction directory
6506 */
6507
6508 char *induction_directory = NULL;
6509
6510 if (attack_mode != ATTACK_MODE_BF)
6511 {
6512 if (induction_dir == NULL)
6513 {
6514 induction_directory = (char *) mymalloc (session_size);
6515
6516 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6517
6518 // create induction folder if it does not already exist
6519
6520 if (keyspace == 0)
6521 {
6522 if (rmdir (induction_directory) == -1)
6523 {
6524 if (errno == ENOENT)
6525 {
6526 // good, we can ignore
6527 }
6528 else if (errno == ENOTEMPTY)
6529 {
6530 char *induction_directory_mv = (char *) mymalloc (session_size);
6531
6532 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6533
6534 if (rename (induction_directory, induction_directory_mv) != 0)
6535 {
6536 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6537
6538 return (-1);
6539 }
6540 }
6541 else
6542 {
6543 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6544
6545 return (-1);
6546 }
6547 }
6548
6549 if (mkdir (induction_directory, 0700) == -1)
6550 {
6551 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6552
6553 return (-1);
6554 }
6555 }
6556 }
6557 else
6558 {
6559 induction_directory = induction_dir;
6560 }
6561 }
6562
6563 data.induction_directory = induction_directory;
6564
6565 /**
6566 * loopback
6567 */
6568
6569 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6570
6571 char *loopback_file = (char *) mymalloc (loopback_size);
6572
6573 /**
6574 * tuning db
6575 */
6576
6577 char tuning_db_file[256] = { 0 };
6578
6579 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6580
6581 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6582
6583 /**
6584 * outfile-check directory
6585 */
6586
6587 char *outfile_check_directory = NULL;
6588
6589 if (outfile_check_dir == NULL)
6590 {
6591 outfile_check_directory = (char *) mymalloc (session_size);
6592
6593 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6594 }
6595 else
6596 {
6597 outfile_check_directory = outfile_check_dir;
6598 }
6599
6600 data.outfile_check_directory = outfile_check_directory;
6601
6602 if (keyspace == 0)
6603 {
6604 struct stat outfile_check_stat;
6605
6606 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6607 {
6608 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6609
6610 if (is_dir == 0)
6611 {
6612 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6613
6614 return (-1);
6615 }
6616 }
6617 else if (outfile_check_dir == NULL)
6618 {
6619 if (mkdir (outfile_check_directory, 0700) == -1)
6620 {
6621 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6622
6623 return (-1);
6624 }
6625 }
6626 }
6627
6628 /**
6629 * special other stuff
6630 */
6631
6632 if (hash_mode == 9710)
6633 {
6634 outfile_format = 5;
6635 outfile_format_chgd = 1;
6636 }
6637
6638 if (hash_mode == 9810)
6639 {
6640 outfile_format = 5;
6641 outfile_format_chgd = 1;
6642 }
6643
6644 if (hash_mode == 10410)
6645 {
6646 outfile_format = 5;
6647 outfile_format_chgd = 1;
6648 }
6649
6650 /**
6651 * store stuff
6652 */
6653
6654 data.hash_mode = hash_mode;
6655 data.restore = restore;
6656 data.restore_timer = restore_timer;
6657 data.restore_disable = restore_disable;
6658 data.status = status;
6659 data.status_timer = status_timer;
6660 data.machine_readable = machine_readable;
6661 data.loopback = loopback;
6662 data.runtime = runtime;
6663 data.remove = remove;
6664 data.remove_timer = remove_timer;
6665 data.debug_mode = debug_mode;
6666 data.debug_file = debug_file;
6667 data.username = username;
6668 data.quiet = quiet;
6669 data.outfile = outfile;
6670 data.outfile_format = outfile_format;
6671 data.outfile_autohex = outfile_autohex;
6672 data.hex_charset = hex_charset;
6673 data.hex_salt = hex_salt;
6674 data.hex_wordlist = hex_wordlist;
6675 data.separator = separator;
6676 data.rp_files = rp_files;
6677 data.rp_files_cnt = rp_files_cnt;
6678 data.rp_gen = rp_gen;
6679 data.rp_gen_seed = rp_gen_seed;
6680 data.force = force;
6681 data.benchmark = benchmark;
6682 data.skip = skip;
6683 data.limit = limit;
6684 #ifdef HAVE_HWMON
6685 #ifdef HAVE_ADL
6686 data.powertune_enable = powertune_enable;
6687 #endif
6688 #endif
6689 data.logfile_disable = logfile_disable;
6690 data.truecrypt_keyfiles = truecrypt_keyfiles;
6691 data.veracrypt_keyfiles = veracrypt_keyfiles;
6692 data.veracrypt_pim = veracrypt_pim;
6693 data.scrypt_tmto = scrypt_tmto;
6694 data.workload_profile = workload_profile;
6695
6696 /**
6697 * cpu affinity
6698 */
6699
6700 if (cpu_affinity)
6701 {
6702 set_cpu_affinity (cpu_affinity);
6703 }
6704
6705 if (rp_gen_seed_chgd == 0)
6706 {
6707 srand (proc_start);
6708 }
6709 else
6710 {
6711 srand (rp_gen_seed);
6712 }
6713
6714 /**
6715 * logfile init
6716 */
6717
6718 if (logfile_disable == 0)
6719 {
6720 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6721
6722 char *logfile = (char *) mymalloc (logfile_size);
6723
6724 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6725
6726 data.logfile = logfile;
6727
6728 char *topid = logfile_generate_topid ();
6729
6730 data.topid = topid;
6731 }
6732
6733 // logfile_append() checks for logfile_disable internally to make it easier from here
6734
6735 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6736 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6737 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6738 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6739 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6740 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6741 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6742 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6743 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6744 #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));
6745
6746 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6747 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6748 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6749 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6750 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6751 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6752 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6753 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6754
6755 logfile_top_msg ("START");
6756
6757 logfile_top_uint (attack_mode);
6758 logfile_top_uint (attack_kern);
6759 logfile_top_uint (benchmark);
6760 logfile_top_uint (bitmap_min);
6761 logfile_top_uint (bitmap_max);
6762 logfile_top_uint (debug_mode);
6763 logfile_top_uint (force);
6764 logfile_top_uint (kernel_accel);
6765 logfile_top_uint (kernel_loops);
6766 logfile_top_uint (gpu_temp_disable);
6767 #ifdef HAVE_HWMON
6768 logfile_top_uint (gpu_temp_abort);
6769 logfile_top_uint (gpu_temp_retain);
6770 #endif
6771 logfile_top_uint (hash_mode);
6772 logfile_top_uint (hex_charset);
6773 logfile_top_uint (hex_salt);
6774 logfile_top_uint (hex_wordlist);
6775 logfile_top_uint (increment);
6776 logfile_top_uint (increment_max);
6777 logfile_top_uint (increment_min);
6778 logfile_top_uint (keyspace);
6779 logfile_top_uint (left);
6780 logfile_top_uint (logfile_disable);
6781 logfile_top_uint (loopback);
6782 logfile_top_uint (markov_classic);
6783 logfile_top_uint (markov_disable);
6784 logfile_top_uint (markov_threshold);
6785 logfile_top_uint (outfile_autohex);
6786 logfile_top_uint (outfile_check_timer);
6787 logfile_top_uint (outfile_format);
6788 logfile_top_uint (potfile_disable);
6789 logfile_top_string (potfile_path);
6790 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6791 logfile_top_uint (powertune_enable);
6792 #endif
6793 logfile_top_uint (scrypt_tmto);
6794 logfile_top_uint (quiet);
6795 logfile_top_uint (remove);
6796 logfile_top_uint (remove_timer);
6797 logfile_top_uint (restore);
6798 logfile_top_uint (restore_disable);
6799 logfile_top_uint (restore_timer);
6800 logfile_top_uint (rp_gen);
6801 logfile_top_uint (rp_gen_func_max);
6802 logfile_top_uint (rp_gen_func_min);
6803 logfile_top_uint (rp_gen_seed);
6804 logfile_top_uint (runtime);
6805 logfile_top_uint (segment_size);
6806 logfile_top_uint (show);
6807 logfile_top_uint (status);
6808 logfile_top_uint (machine_readable);
6809 logfile_top_uint (status_timer);
6810 logfile_top_uint (usage);
6811 logfile_top_uint (username);
6812 logfile_top_uint (version);
6813 logfile_top_uint (weak_hash_threshold);
6814 logfile_top_uint (workload_profile);
6815 logfile_top_uint64 (limit);
6816 logfile_top_uint64 (skip);
6817 logfile_top_char (separator);
6818 logfile_top_string (cpu_affinity);
6819 logfile_top_string (custom_charset_1);
6820 logfile_top_string (custom_charset_2);
6821 logfile_top_string (custom_charset_3);
6822 logfile_top_string (custom_charset_4);
6823 logfile_top_string (debug_file);
6824 logfile_top_string (opencl_devices);
6825 logfile_top_string (opencl_platforms);
6826 logfile_top_string (opencl_device_types);
6827 logfile_top_uint (opencl_vector_width);
6828 logfile_top_string (induction_dir);
6829 logfile_top_string (markov_hcstat);
6830 logfile_top_string (outfile);
6831 logfile_top_string (outfile_check_dir);
6832 logfile_top_string (rule_buf_l);
6833 logfile_top_string (rule_buf_r);
6834 logfile_top_string (session);
6835 logfile_top_string (truecrypt_keyfiles);
6836 logfile_top_string (veracrypt_keyfiles);
6837 logfile_top_uint (veracrypt_pim);
6838
6839 /**
6840 * Init OpenCL library loader
6841 */
6842
6843 if (keyspace == 0)
6844 {
6845 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6846
6847 ocl_init (ocl);
6848
6849 data.ocl = ocl;
6850 }
6851
6852 /**
6853 * OpenCL platform selection
6854 */
6855
6856 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6857
6858 /**
6859 * OpenCL device selection
6860 */
6861
6862 u32 devices_filter = setup_devices_filter (opencl_devices);
6863
6864 /**
6865 * OpenCL device type selection
6866 */
6867
6868 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6869
6870 /**
6871 * benchmark
6872 */
6873
6874 if (benchmark == 1)
6875 {
6876 /**
6877 * disable useless stuff for benchmark
6878 */
6879
6880 status_timer = 0;
6881 restore_timer = 0;
6882 restore_disable = 1;
6883 potfile_disable = 1;
6884 weak_hash_threshold = 0;
6885 gpu_temp_disable = 1;
6886
6887 #ifdef HAVE_HWMON
6888 #ifdef HAVE_ADL
6889 powertune_enable = 1;
6890 #endif
6891 #endif
6892
6893 data.status_timer = status_timer;
6894 data.restore_timer = restore_timer;
6895 data.restore_disable = restore_disable;
6896
6897 /**
6898 * force attack mode to be bruteforce
6899 */
6900
6901 attack_mode = ATTACK_MODE_BF;
6902 attack_kern = ATTACK_KERN_BF;
6903
6904 if (workload_profile_chgd == 0)
6905 {
6906 workload_profile = 3;
6907
6908 data.workload_profile = workload_profile;
6909 }
6910 }
6911
6912 /**
6913 * config
6914 */
6915
6916 uint hash_type = 0;
6917 uint salt_type = 0;
6918 uint attack_exec = 0;
6919 uint opts_type = 0;
6920 uint kern_type = 0;
6921 uint dgst_size = 0;
6922 uint esalt_size = 0;
6923 uint opti_type = 0;
6924 uint dgst_pos0 = -1;
6925 uint dgst_pos1 = -1;
6926 uint dgst_pos2 = -1;
6927 uint dgst_pos3 = -1;
6928
6929 int (*parse_func) (char *, uint, hash_t *);
6930 int (*sort_by_digest) (const void *, const void *);
6931
6932 uint algorithm_pos = 0;
6933 uint algorithm_max = 1;
6934
6935 uint *algorithms = default_benchmark_algorithms;
6936
6937 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6938
6939 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6940 {
6941 /*
6942 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6943 * the following algos are skipped entirely
6944 */
6945
6946 if (algorithm_pos > 0)
6947 {
6948 local_free (rd);
6949
6950 rd = init_restore (argc, argv);
6951
6952 data.rd = rd;
6953 }
6954
6955 /**
6956 * update hash_mode in case of multihash benchmark
6957 */
6958
6959 if (benchmark == 1)
6960 {
6961 if (hash_mode_chgd == 0)
6962 {
6963 hash_mode = algorithms[algorithm_pos];
6964
6965 data.hash_mode = hash_mode;
6966 }
6967
6968 quiet = 1;
6969
6970 data.quiet = quiet;
6971 }
6972
6973 switch (hash_mode)
6974 {
6975 case 0: hash_type = HASH_TYPE_MD5;
6976 salt_type = SALT_TYPE_NONE;
6977 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6978 opts_type = OPTS_TYPE_PT_GENERATE_LE
6979 | OPTS_TYPE_PT_ADD80
6980 | OPTS_TYPE_PT_ADDBITS14;
6981 kern_type = KERN_TYPE_MD5;
6982 dgst_size = DGST_SIZE_4_4;
6983 parse_func = md5_parse_hash;
6984 sort_by_digest = sort_by_digest_4_4;
6985 opti_type = OPTI_TYPE_ZERO_BYTE
6986 | OPTI_TYPE_PRECOMPUTE_INIT
6987 | OPTI_TYPE_PRECOMPUTE_MERKLE
6988 | OPTI_TYPE_MEET_IN_MIDDLE
6989 | OPTI_TYPE_EARLY_SKIP
6990 | OPTI_TYPE_NOT_ITERATED
6991 | OPTI_TYPE_NOT_SALTED
6992 | OPTI_TYPE_RAW_HASH;
6993 dgst_pos0 = 0;
6994 dgst_pos1 = 3;
6995 dgst_pos2 = 2;
6996 dgst_pos3 = 1;
6997 break;
6998
6999 case 10: hash_type = HASH_TYPE_MD5;
7000 salt_type = SALT_TYPE_INTERN;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_LE
7003 | OPTS_TYPE_ST_ADD80
7004 | OPTS_TYPE_ST_ADDBITS14;
7005 kern_type = KERN_TYPE_MD5_PWSLT;
7006 dgst_size = DGST_SIZE_4_4;
7007 parse_func = md5s_parse_hash;
7008 sort_by_digest = sort_by_digest_4_4;
7009 opti_type = OPTI_TYPE_ZERO_BYTE
7010 | OPTI_TYPE_PRECOMPUTE_INIT
7011 | OPTI_TYPE_PRECOMPUTE_MERKLE
7012 | OPTI_TYPE_MEET_IN_MIDDLE
7013 | OPTI_TYPE_EARLY_SKIP
7014 | OPTI_TYPE_NOT_ITERATED
7015 | OPTI_TYPE_APPENDED_SALT
7016 | OPTI_TYPE_RAW_HASH;
7017 dgst_pos0 = 0;
7018 dgst_pos1 = 3;
7019 dgst_pos2 = 2;
7020 dgst_pos3 = 1;
7021 break;
7022
7023 case 11: hash_type = HASH_TYPE_MD5;
7024 salt_type = SALT_TYPE_INTERN;
7025 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7026 opts_type = OPTS_TYPE_PT_GENERATE_LE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS14;
7029 kern_type = KERN_TYPE_MD5_PWSLT;
7030 dgst_size = DGST_SIZE_4_4;
7031 parse_func = joomla_parse_hash;
7032 sort_by_digest = sort_by_digest_4_4;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_PRECOMPUTE_INIT
7035 | OPTI_TYPE_PRECOMPUTE_MERKLE
7036 | OPTI_TYPE_MEET_IN_MIDDLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_APPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 0;
7042 dgst_pos1 = 3;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 12: hash_type = HASH_TYPE_MD5;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_LE
7051 | OPTS_TYPE_ST_ADD80
7052 | OPTS_TYPE_ST_ADDBITS14;
7053 kern_type = KERN_TYPE_MD5_PWSLT;
7054 dgst_size = DGST_SIZE_4_4;
7055 parse_func = postgresql_parse_hash;
7056 sort_by_digest = sort_by_digest_4_4;
7057 opti_type = OPTI_TYPE_ZERO_BYTE
7058 | OPTI_TYPE_PRECOMPUTE_INIT
7059 | OPTI_TYPE_PRECOMPUTE_MERKLE
7060 | OPTI_TYPE_MEET_IN_MIDDLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_APPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 20: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_PT_ADD80
7076 | OPTS_TYPE_PT_ADDBITS14;
7077 kern_type = KERN_TYPE_MD5_SLTPW;
7078 dgst_size = DGST_SIZE_4_4;
7079 parse_func = md5s_parse_hash;
7080 sort_by_digest = sort_by_digest_4_4;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_PRECOMPUTE_INIT
7083 | OPTI_TYPE_PRECOMPUTE_MERKLE
7084 | OPTI_TYPE_EARLY_SKIP
7085 | OPTI_TYPE_NOT_ITERATED
7086 | OPTI_TYPE_PREPENDED_SALT
7087 | OPTI_TYPE_RAW_HASH;
7088 dgst_pos0 = 0;
7089 dgst_pos1 = 3;
7090 dgst_pos2 = 2;
7091 dgst_pos3 = 1;
7092 break;
7093
7094 case 21: hash_type = HASH_TYPE_MD5;
7095 salt_type = SALT_TYPE_INTERN;
7096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7097 opts_type = OPTS_TYPE_PT_GENERATE_LE
7098 | OPTS_TYPE_PT_ADD80
7099 | OPTS_TYPE_PT_ADDBITS14;
7100 kern_type = KERN_TYPE_MD5_SLTPW;
7101 dgst_size = DGST_SIZE_4_4;
7102 parse_func = osc_parse_hash;
7103 sort_by_digest = sort_by_digest_4_4;
7104 opti_type = OPTI_TYPE_ZERO_BYTE
7105 | OPTI_TYPE_PRECOMPUTE_INIT
7106 | OPTI_TYPE_PRECOMPUTE_MERKLE
7107 | OPTI_TYPE_EARLY_SKIP
7108 | OPTI_TYPE_NOT_ITERATED
7109 | OPTI_TYPE_PREPENDED_SALT
7110 | OPTI_TYPE_RAW_HASH;
7111 dgst_pos0 = 0;
7112 dgst_pos1 = 3;
7113 dgst_pos2 = 2;
7114 dgst_pos3 = 1;
7115 break;
7116
7117 case 22: hash_type = HASH_TYPE_MD5;
7118 salt_type = SALT_TYPE_EMBEDDED;
7119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7120 opts_type = OPTS_TYPE_PT_GENERATE_LE
7121 | OPTS_TYPE_PT_ADD80
7122 | OPTS_TYPE_PT_ADDBITS14;
7123 kern_type = KERN_TYPE_MD5_SLTPW;
7124 dgst_size = DGST_SIZE_4_4;
7125 parse_func = netscreen_parse_hash;
7126 sort_by_digest = sort_by_digest_4_4;
7127 opti_type = OPTI_TYPE_ZERO_BYTE
7128 | OPTI_TYPE_PRECOMPUTE_INIT
7129 | OPTI_TYPE_PRECOMPUTE_MERKLE
7130 | OPTI_TYPE_EARLY_SKIP
7131 | OPTI_TYPE_NOT_ITERATED
7132 | OPTI_TYPE_PREPENDED_SALT
7133 | OPTI_TYPE_RAW_HASH;
7134 dgst_pos0 = 0;
7135 dgst_pos1 = 3;
7136 dgst_pos2 = 2;
7137 dgst_pos3 = 1;
7138 break;
7139
7140 case 23: hash_type = HASH_TYPE_MD5;
7141 salt_type = SALT_TYPE_EMBEDDED;
7142 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7143 opts_type = OPTS_TYPE_PT_GENERATE_LE
7144 | OPTS_TYPE_PT_ADD80
7145 | OPTS_TYPE_PT_ADDBITS14;
7146 kern_type = KERN_TYPE_MD5_SLTPW;
7147 dgst_size = DGST_SIZE_4_4;
7148 parse_func = skype_parse_hash;
7149 sort_by_digest = sort_by_digest_4_4;
7150 opti_type = OPTI_TYPE_ZERO_BYTE
7151 | OPTI_TYPE_PRECOMPUTE_INIT
7152 | OPTI_TYPE_PRECOMPUTE_MERKLE
7153 | OPTI_TYPE_EARLY_SKIP
7154 | OPTI_TYPE_NOT_ITERATED
7155 | OPTI_TYPE_PREPENDED_SALT
7156 | OPTI_TYPE_RAW_HASH;
7157 dgst_pos0 = 0;
7158 dgst_pos1 = 3;
7159 dgst_pos2 = 2;
7160 dgst_pos3 = 1;
7161 break;
7162
7163 case 30: hash_type = HASH_TYPE_MD5;
7164 salt_type = SALT_TYPE_INTERN;
7165 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7166 opts_type = OPTS_TYPE_PT_GENERATE_LE
7167 | OPTS_TYPE_PT_UNICODE
7168 | OPTS_TYPE_ST_ADD80
7169 | OPTS_TYPE_ST_ADDBITS14;
7170 kern_type = KERN_TYPE_MD5_PWUSLT;
7171 dgst_size = DGST_SIZE_4_4;
7172 parse_func = md5s_parse_hash;
7173 sort_by_digest = sort_by_digest_4_4;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_MEET_IN_MIDDLE
7178 | OPTI_TYPE_EARLY_SKIP
7179 | OPTI_TYPE_NOT_ITERATED
7180 | OPTI_TYPE_APPENDED_SALT
7181 | OPTI_TYPE_RAW_HASH;
7182 dgst_pos0 = 0;
7183 dgst_pos1 = 3;
7184 dgst_pos2 = 2;
7185 dgst_pos3 = 1;
7186 break;
7187
7188 case 40: hash_type = HASH_TYPE_MD5;
7189 salt_type = SALT_TYPE_INTERN;
7190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7191 opts_type = OPTS_TYPE_PT_GENERATE_LE
7192 | OPTS_TYPE_PT_ADD80
7193 | OPTS_TYPE_PT_ADDBITS14
7194 | OPTS_TYPE_PT_UNICODE;
7195 kern_type = KERN_TYPE_MD5_SLTPWU;
7196 dgst_size = DGST_SIZE_4_4;
7197 parse_func = md5s_parse_hash;
7198 sort_by_digest = sort_by_digest_4_4;
7199 opti_type = OPTI_TYPE_ZERO_BYTE
7200 | OPTI_TYPE_PRECOMPUTE_INIT
7201 | OPTI_TYPE_PRECOMPUTE_MERKLE
7202 | OPTI_TYPE_EARLY_SKIP
7203 | OPTI_TYPE_NOT_ITERATED
7204 | OPTI_TYPE_PREPENDED_SALT
7205 | OPTI_TYPE_RAW_HASH;
7206 dgst_pos0 = 0;
7207 dgst_pos1 = 3;
7208 dgst_pos2 = 2;
7209 dgst_pos3 = 1;
7210 break;
7211
7212 case 50: hash_type = HASH_TYPE_MD5;
7213 salt_type = SALT_TYPE_INTERN;
7214 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7215 opts_type = OPTS_TYPE_PT_GENERATE_LE
7216 | OPTS_TYPE_ST_ADD80
7217 | OPTS_TYPE_ST_ADDBITS14;
7218 kern_type = KERN_TYPE_HMACMD5_PW;
7219 dgst_size = DGST_SIZE_4_4;
7220 parse_func = hmacmd5_parse_hash;
7221 sort_by_digest = sort_by_digest_4_4;
7222 opti_type = OPTI_TYPE_ZERO_BYTE
7223 | OPTI_TYPE_NOT_ITERATED;
7224 dgst_pos0 = 0;
7225 dgst_pos1 = 3;
7226 dgst_pos2 = 2;
7227 dgst_pos3 = 1;
7228 break;
7229
7230 case 60: hash_type = HASH_TYPE_MD5;
7231 salt_type = SALT_TYPE_INTERN;
7232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7233 opts_type = OPTS_TYPE_PT_GENERATE_LE
7234 | OPTS_TYPE_PT_ADD80
7235 | OPTS_TYPE_PT_ADDBITS14;
7236 kern_type = KERN_TYPE_HMACMD5_SLT;
7237 dgst_size = DGST_SIZE_4_4;
7238 parse_func = hmacmd5_parse_hash;
7239 sort_by_digest = sort_by_digest_4_4;
7240 opti_type = OPTI_TYPE_ZERO_BYTE
7241 | OPTI_TYPE_NOT_ITERATED;
7242 dgst_pos0 = 0;
7243 dgst_pos1 = 3;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 100: hash_type = HASH_TYPE_SHA1;
7249 salt_type = SALT_TYPE_NONE;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_BE
7252 | OPTS_TYPE_PT_ADD80
7253 | OPTS_TYPE_PT_ADDBITS15;
7254 kern_type = KERN_TYPE_SHA1;
7255 dgst_size = DGST_SIZE_4_5;
7256 parse_func = sha1_parse_hash;
7257 sort_by_digest = sort_by_digest_4_5;
7258 opti_type = OPTI_TYPE_ZERO_BYTE
7259 | OPTI_TYPE_PRECOMPUTE_INIT
7260 | OPTI_TYPE_PRECOMPUTE_MERKLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_NOT_SALTED
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 3;
7266 dgst_pos1 = 4;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 101: hash_type = HASH_TYPE_SHA1;
7272 salt_type = SALT_TYPE_NONE;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_BE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS15;
7277 kern_type = KERN_TYPE_SHA1;
7278 dgst_size = DGST_SIZE_4_5;
7279 parse_func = sha1b64_parse_hash;
7280 sort_by_digest = sort_by_digest_4_5;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_EARLY_SKIP
7285 | OPTI_TYPE_NOT_ITERATED
7286 | OPTI_TYPE_NOT_SALTED
7287 | OPTI_TYPE_RAW_HASH;
7288 dgst_pos0 = 3;
7289 dgst_pos1 = 4;
7290 dgst_pos2 = 2;
7291 dgst_pos3 = 1;
7292 break;
7293
7294 case 110: hash_type = HASH_TYPE_SHA1;
7295 salt_type = SALT_TYPE_INTERN;
7296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7297 opts_type = OPTS_TYPE_PT_GENERATE_BE
7298 | OPTS_TYPE_ST_ADD80
7299 | OPTS_TYPE_ST_ADDBITS15;
7300 kern_type = KERN_TYPE_SHA1_PWSLT;
7301 dgst_size = DGST_SIZE_4_5;
7302 parse_func = sha1s_parse_hash;
7303 sort_by_digest = sort_by_digest_4_5;
7304 opti_type = OPTI_TYPE_ZERO_BYTE
7305 | OPTI_TYPE_PRECOMPUTE_INIT
7306 | OPTI_TYPE_PRECOMPUTE_MERKLE
7307 | OPTI_TYPE_EARLY_SKIP
7308 | OPTI_TYPE_NOT_ITERATED
7309 | OPTI_TYPE_APPENDED_SALT
7310 | OPTI_TYPE_RAW_HASH;
7311 dgst_pos0 = 3;
7312 dgst_pos1 = 4;
7313 dgst_pos2 = 2;
7314 dgst_pos3 = 1;
7315 break;
7316
7317 case 111: hash_type = HASH_TYPE_SHA1;
7318 salt_type = SALT_TYPE_EMBEDDED;
7319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7320 opts_type = OPTS_TYPE_PT_GENERATE_BE
7321 | OPTS_TYPE_ST_ADD80
7322 | OPTS_TYPE_ST_ADDBITS15;
7323 kern_type = KERN_TYPE_SHA1_PWSLT;
7324 dgst_size = DGST_SIZE_4_5;
7325 parse_func = sha1b64s_parse_hash;
7326 sort_by_digest = sort_by_digest_4_5;
7327 opti_type = OPTI_TYPE_ZERO_BYTE
7328 | OPTI_TYPE_PRECOMPUTE_INIT
7329 | OPTI_TYPE_PRECOMPUTE_MERKLE
7330 | OPTI_TYPE_EARLY_SKIP
7331 | OPTI_TYPE_NOT_ITERATED
7332 | OPTI_TYPE_APPENDED_SALT
7333 | OPTI_TYPE_RAW_HASH;
7334 dgst_pos0 = 3;
7335 dgst_pos1 = 4;
7336 dgst_pos2 = 2;
7337 dgst_pos3 = 1;
7338 break;
7339
7340 case 112: hash_type = HASH_TYPE_SHA1;
7341 salt_type = SALT_TYPE_INTERN;
7342 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7343 opts_type = OPTS_TYPE_PT_GENERATE_BE
7344 | OPTS_TYPE_ST_ADD80
7345 | OPTS_TYPE_ST_ADDBITS15
7346 | OPTS_TYPE_ST_HEX;
7347 kern_type = KERN_TYPE_SHA1_PWSLT;
7348 dgst_size = DGST_SIZE_4_5;
7349 parse_func = oracles_parse_hash;
7350 sort_by_digest = sort_by_digest_4_5;
7351 opti_type = OPTI_TYPE_ZERO_BYTE
7352 | OPTI_TYPE_PRECOMPUTE_INIT
7353 | OPTI_TYPE_PRECOMPUTE_MERKLE
7354 | OPTI_TYPE_EARLY_SKIP
7355 | OPTI_TYPE_NOT_ITERATED
7356 | OPTI_TYPE_APPENDED_SALT
7357 | OPTI_TYPE_RAW_HASH;
7358 dgst_pos0 = 3;
7359 dgst_pos1 = 4;
7360 dgst_pos2 = 2;
7361 dgst_pos3 = 1;
7362 break;
7363
7364 case 120: hash_type = HASH_TYPE_SHA1;
7365 salt_type = SALT_TYPE_INTERN;
7366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7367 opts_type = OPTS_TYPE_PT_GENERATE_BE
7368 | OPTS_TYPE_PT_ADD80
7369 | OPTS_TYPE_PT_ADDBITS15;
7370 kern_type = KERN_TYPE_SHA1_SLTPW;
7371 dgst_size = DGST_SIZE_4_5;
7372 parse_func = sha1s_parse_hash;
7373 sort_by_digest = sort_by_digest_4_5;
7374 opti_type = OPTI_TYPE_ZERO_BYTE
7375 | OPTI_TYPE_PRECOMPUTE_INIT
7376 | OPTI_TYPE_PRECOMPUTE_MERKLE
7377 | OPTI_TYPE_EARLY_SKIP
7378 | OPTI_TYPE_NOT_ITERATED
7379 | OPTI_TYPE_PREPENDED_SALT
7380 | OPTI_TYPE_RAW_HASH;
7381 dgst_pos0 = 3;
7382 dgst_pos1 = 4;
7383 dgst_pos2 = 2;
7384 dgst_pos3 = 1;
7385 break;
7386
7387 case 121: hash_type = HASH_TYPE_SHA1;
7388 salt_type = SALT_TYPE_INTERN;
7389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7390 opts_type = OPTS_TYPE_PT_GENERATE_BE
7391 | OPTS_TYPE_PT_ADD80
7392 | OPTS_TYPE_PT_ADDBITS15
7393 | OPTS_TYPE_ST_LOWER;
7394 kern_type = KERN_TYPE_SHA1_SLTPW;
7395 dgst_size = DGST_SIZE_4_5;
7396 parse_func = smf_parse_hash;
7397 sort_by_digest = sort_by_digest_4_5;
7398 opti_type = OPTI_TYPE_ZERO_BYTE
7399 | OPTI_TYPE_PRECOMPUTE_INIT
7400 | OPTI_TYPE_PRECOMPUTE_MERKLE
7401 | OPTI_TYPE_EARLY_SKIP
7402 | OPTI_TYPE_NOT_ITERATED
7403 | OPTI_TYPE_PREPENDED_SALT
7404 | OPTI_TYPE_RAW_HASH;
7405 dgst_pos0 = 3;
7406 dgst_pos1 = 4;
7407 dgst_pos2 = 2;
7408 dgst_pos3 = 1;
7409 break;
7410
7411 case 122: hash_type = HASH_TYPE_SHA1;
7412 salt_type = SALT_TYPE_EMBEDDED;
7413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7414 opts_type = OPTS_TYPE_PT_GENERATE_BE
7415 | OPTS_TYPE_PT_ADD80
7416 | OPTS_TYPE_PT_ADDBITS15
7417 | OPTS_TYPE_ST_HEX;
7418 kern_type = KERN_TYPE_SHA1_SLTPW;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = osx1_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_PREPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 124: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_EMBEDDED;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_ADD80
7440 | OPTS_TYPE_PT_ADDBITS15;
7441 kern_type = KERN_TYPE_SHA1_SLTPW;
7442 dgst_size = DGST_SIZE_4_5;
7443 parse_func = djangosha1_parse_hash;
7444 sort_by_digest = sort_by_digest_4_5;
7445 opti_type = OPTI_TYPE_ZERO_BYTE
7446 | OPTI_TYPE_PRECOMPUTE_INIT
7447 | OPTI_TYPE_PRECOMPUTE_MERKLE
7448 | OPTI_TYPE_EARLY_SKIP
7449 | OPTI_TYPE_NOT_ITERATED
7450 | OPTI_TYPE_PREPENDED_SALT
7451 | OPTI_TYPE_RAW_HASH;
7452 dgst_pos0 = 3;
7453 dgst_pos1 = 4;
7454 dgst_pos2 = 2;
7455 dgst_pos3 = 1;
7456 break;
7457
7458 case 125: hash_type = HASH_TYPE_SHA1;
7459 salt_type = SALT_TYPE_EMBEDDED;
7460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7461 opts_type = OPTS_TYPE_PT_GENERATE_BE
7462 | OPTS_TYPE_PT_ADD80
7463 | OPTS_TYPE_PT_ADDBITS15
7464 | OPTS_TYPE_ST_HEX;
7465 kern_type = KERN_TYPE_SHA1_SLTPW;
7466 dgst_size = DGST_SIZE_4_5;
7467 parse_func = arubaos_parse_hash;
7468 sort_by_digest = sort_by_digest_4_5;
7469 opti_type = OPTI_TYPE_ZERO_BYTE
7470 | OPTI_TYPE_PRECOMPUTE_INIT
7471 | OPTI_TYPE_PRECOMPUTE_MERKLE
7472 | OPTI_TYPE_EARLY_SKIP
7473 | OPTI_TYPE_NOT_ITERATED
7474 | OPTI_TYPE_PREPENDED_SALT
7475 | OPTI_TYPE_RAW_HASH;
7476 dgst_pos0 = 3;
7477 dgst_pos1 = 4;
7478 dgst_pos2 = 2;
7479 dgst_pos3 = 1;
7480 break;
7481
7482 case 130: hash_type = HASH_TYPE_SHA1;
7483 salt_type = SALT_TYPE_INTERN;
7484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7485 opts_type = OPTS_TYPE_PT_GENERATE_BE
7486 | OPTS_TYPE_PT_UNICODE
7487 | OPTS_TYPE_ST_ADD80
7488 | OPTS_TYPE_ST_ADDBITS15;
7489 kern_type = KERN_TYPE_SHA1_PWUSLT;
7490 dgst_size = DGST_SIZE_4_5;
7491 parse_func = sha1s_parse_hash;
7492 sort_by_digest = sort_by_digest_4_5;
7493 opti_type = OPTI_TYPE_ZERO_BYTE
7494 | OPTI_TYPE_PRECOMPUTE_INIT
7495 | OPTI_TYPE_PRECOMPUTE_MERKLE
7496 | OPTI_TYPE_EARLY_SKIP
7497 | OPTI_TYPE_NOT_ITERATED
7498 | OPTI_TYPE_APPENDED_SALT
7499 | OPTI_TYPE_RAW_HASH;
7500 dgst_pos0 = 3;
7501 dgst_pos1 = 4;
7502 dgst_pos2 = 2;
7503 dgst_pos3 = 1;
7504 break;
7505
7506 case 131: hash_type = HASH_TYPE_SHA1;
7507 salt_type = SALT_TYPE_EMBEDDED;
7508 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7509 opts_type = OPTS_TYPE_PT_GENERATE_BE
7510 | OPTS_TYPE_PT_UNICODE
7511 | OPTS_TYPE_PT_UPPER
7512 | OPTS_TYPE_ST_ADD80
7513 | OPTS_TYPE_ST_ADDBITS15
7514 | OPTS_TYPE_ST_HEX;
7515 kern_type = KERN_TYPE_SHA1_PWUSLT;
7516 dgst_size = DGST_SIZE_4_5;
7517 parse_func = mssql2000_parse_hash;
7518 sort_by_digest = sort_by_digest_4_5;
7519 opti_type = OPTI_TYPE_ZERO_BYTE
7520 | OPTI_TYPE_PRECOMPUTE_INIT
7521 | OPTI_TYPE_PRECOMPUTE_MERKLE
7522 | OPTI_TYPE_EARLY_SKIP
7523 | OPTI_TYPE_NOT_ITERATED
7524 | OPTI_TYPE_APPENDED_SALT
7525 | OPTI_TYPE_RAW_HASH;
7526 dgst_pos0 = 3;
7527 dgst_pos1 = 4;
7528 dgst_pos2 = 2;
7529 dgst_pos3 = 1;
7530 break;
7531
7532 case 132: hash_type = HASH_TYPE_SHA1;
7533 salt_type = SALT_TYPE_EMBEDDED;
7534 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7535 opts_type = OPTS_TYPE_PT_GENERATE_BE
7536 | OPTS_TYPE_PT_UNICODE
7537 | OPTS_TYPE_ST_ADD80
7538 | OPTS_TYPE_ST_ADDBITS15
7539 | OPTS_TYPE_ST_HEX;
7540 kern_type = KERN_TYPE_SHA1_PWUSLT;
7541 dgst_size = DGST_SIZE_4_5;
7542 parse_func = mssql2005_parse_hash;
7543 sort_by_digest = sort_by_digest_4_5;
7544 opti_type = OPTI_TYPE_ZERO_BYTE
7545 | OPTI_TYPE_PRECOMPUTE_INIT
7546 | OPTI_TYPE_PRECOMPUTE_MERKLE
7547 | OPTI_TYPE_EARLY_SKIP
7548 | OPTI_TYPE_NOT_ITERATED
7549 | OPTI_TYPE_APPENDED_SALT
7550 | OPTI_TYPE_RAW_HASH;
7551 dgst_pos0 = 3;
7552 dgst_pos1 = 4;
7553 dgst_pos2 = 2;
7554 dgst_pos3 = 1;
7555 break;
7556
7557 case 133: hash_type = HASH_TYPE_SHA1;
7558 salt_type = SALT_TYPE_EMBEDDED;
7559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7560 opts_type = OPTS_TYPE_PT_GENERATE_BE
7561 | OPTS_TYPE_PT_UNICODE
7562 | OPTS_TYPE_ST_ADD80
7563 | OPTS_TYPE_ST_ADDBITS15;
7564 kern_type = KERN_TYPE_SHA1_PWUSLT;
7565 dgst_size = DGST_SIZE_4_5;
7566 parse_func = peoplesoft_parse_hash;
7567 sort_by_digest = sort_by_digest_4_5;
7568 opti_type = OPTI_TYPE_ZERO_BYTE
7569 | OPTI_TYPE_PRECOMPUTE_INIT
7570 | OPTI_TYPE_PRECOMPUTE_MERKLE
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_APPENDED_SALT
7574 | OPTI_TYPE_RAW_HASH;
7575 dgst_pos0 = 3;
7576 dgst_pos1 = 4;
7577 dgst_pos2 = 2;
7578 dgst_pos3 = 1;
7579 break;
7580
7581 case 140: hash_type = HASH_TYPE_SHA1;
7582 salt_type = SALT_TYPE_INTERN;
7583 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7584 opts_type = OPTS_TYPE_PT_GENERATE_BE
7585 | OPTS_TYPE_PT_ADD80
7586 | OPTS_TYPE_PT_ADDBITS15
7587 | OPTS_TYPE_PT_UNICODE;
7588 kern_type = KERN_TYPE_SHA1_SLTPWU;
7589 dgst_size = DGST_SIZE_4_5;
7590 parse_func = sha1s_parse_hash;
7591 sort_by_digest = sort_by_digest_4_5;
7592 opti_type = OPTI_TYPE_ZERO_BYTE
7593 | OPTI_TYPE_PRECOMPUTE_INIT
7594 | OPTI_TYPE_PRECOMPUTE_MERKLE
7595 | OPTI_TYPE_EARLY_SKIP
7596 | OPTI_TYPE_NOT_ITERATED
7597 | OPTI_TYPE_PREPENDED_SALT
7598 | OPTI_TYPE_RAW_HASH;
7599 dgst_pos0 = 3;
7600 dgst_pos1 = 4;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 1;
7603 break;
7604
7605 case 141: hash_type = HASH_TYPE_SHA1;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_BE
7609 | OPTS_TYPE_PT_ADD80
7610 | OPTS_TYPE_PT_ADDBITS15
7611 | OPTS_TYPE_PT_UNICODE
7612 | OPTS_TYPE_ST_BASE64;
7613 kern_type = KERN_TYPE_SHA1_SLTPWU;
7614 dgst_size = DGST_SIZE_4_5;
7615 parse_func = episerver_parse_hash;
7616 sort_by_digest = sort_by_digest_4_5;
7617 opti_type = OPTI_TYPE_ZERO_BYTE
7618 | OPTI_TYPE_PRECOMPUTE_INIT
7619 | OPTI_TYPE_PRECOMPUTE_MERKLE
7620 | OPTI_TYPE_EARLY_SKIP
7621 | OPTI_TYPE_NOT_ITERATED
7622 | OPTI_TYPE_PREPENDED_SALT
7623 | OPTI_TYPE_RAW_HASH;
7624 dgst_pos0 = 3;
7625 dgst_pos1 = 4;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 1;
7628 break;
7629
7630 case 150: hash_type = HASH_TYPE_SHA1;
7631 salt_type = SALT_TYPE_INTERN;
7632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_BE
7634 | OPTS_TYPE_ST_ADD80
7635 | OPTS_TYPE_ST_ADDBITS15;
7636 kern_type = KERN_TYPE_HMACSHA1_PW;
7637 dgst_size = DGST_SIZE_4_5;
7638 parse_func = hmacsha1_parse_hash;
7639 sort_by_digest = sort_by_digest_4_5;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_NOT_ITERATED;
7642 dgst_pos0 = 3;
7643 dgst_pos1 = 4;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 1;
7646 break;
7647
7648 case 160: hash_type = HASH_TYPE_SHA1;
7649 salt_type = SALT_TYPE_INTERN;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_PT_ADD80
7653 | OPTS_TYPE_PT_ADDBITS15;
7654 kern_type = KERN_TYPE_HMACSHA1_SLT;
7655 dgst_size = DGST_SIZE_4_5;
7656 parse_func = hmacsha1_parse_hash;
7657 sort_by_digest = sort_by_digest_4_5;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_NOT_ITERATED;
7660 dgst_pos0 = 3;
7661 dgst_pos1 = 4;
7662 dgst_pos2 = 2;
7663 dgst_pos3 = 1;
7664 break;
7665
7666 case 190: hash_type = HASH_TYPE_SHA1;
7667 salt_type = SALT_TYPE_NONE;
7668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7669 opts_type = OPTS_TYPE_PT_GENERATE_BE
7670 | OPTS_TYPE_PT_ADD80
7671 | OPTS_TYPE_PT_ADDBITS15;
7672 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7673 dgst_size = DGST_SIZE_4_5;
7674 parse_func = sha1linkedin_parse_hash;
7675 sort_by_digest = sort_by_digest_4_5;
7676 opti_type = OPTI_TYPE_ZERO_BYTE
7677 | OPTI_TYPE_PRECOMPUTE_INIT
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_NOT_SALTED;
7681 dgst_pos0 = 0;
7682 dgst_pos1 = 4;
7683 dgst_pos2 = 3;
7684 dgst_pos3 = 2;
7685 break;
7686
7687 case 200: hash_type = HASH_TYPE_MYSQL;
7688 salt_type = SALT_TYPE_NONE;
7689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7690 opts_type = 0;
7691 kern_type = KERN_TYPE_MYSQL;
7692 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7693 parse_func = mysql323_parse_hash;
7694 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7695 opti_type = OPTI_TYPE_ZERO_BYTE;
7696 dgst_pos0 = 0;
7697 dgst_pos1 = 1;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 3;
7700 break;
7701
7702 case 300: hash_type = HASH_TYPE_SHA1;
7703 salt_type = SALT_TYPE_NONE;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15;
7708 kern_type = KERN_TYPE_MYSQL41;
7709 dgst_size = DGST_SIZE_4_5;
7710 parse_func = sha1_parse_hash;
7711 sort_by_digest = sort_by_digest_4_5;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_INIT
7714 | OPTI_TYPE_PRECOMPUTE_MERKLE
7715 | OPTI_TYPE_EARLY_SKIP
7716 | OPTI_TYPE_NOT_ITERATED
7717 | OPTI_TYPE_NOT_SALTED;
7718 dgst_pos0 = 3;
7719 dgst_pos1 = 4;
7720 dgst_pos2 = 2;
7721 dgst_pos3 = 1;
7722 break;
7723
7724 case 400: hash_type = HASH_TYPE_MD5;
7725 salt_type = SALT_TYPE_EMBEDDED;
7726 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7727 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7728 kern_type = KERN_TYPE_PHPASS;
7729 dgst_size = DGST_SIZE_4_4;
7730 parse_func = phpass_parse_hash;
7731 sort_by_digest = sort_by_digest_4_4;
7732 opti_type = OPTI_TYPE_ZERO_BYTE
7733 | OPTI_TYPE_SLOW_HASH_SIMD;
7734 dgst_pos0 = 0;
7735 dgst_pos1 = 1;
7736 dgst_pos2 = 2;
7737 dgst_pos3 = 3;
7738 break;
7739
7740 case 500: hash_type = HASH_TYPE_MD5;
7741 salt_type = SALT_TYPE_EMBEDDED;
7742 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7743 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7744 kern_type = KERN_TYPE_MD5CRYPT;
7745 dgst_size = DGST_SIZE_4_4;
7746 parse_func = md5crypt_parse_hash;
7747 sort_by_digest = sort_by_digest_4_4;
7748 opti_type = OPTI_TYPE_ZERO_BYTE;
7749 dgst_pos0 = 0;
7750 dgst_pos1 = 1;
7751 dgst_pos2 = 2;
7752 dgst_pos3 = 3;
7753 break;
7754
7755 case 501: hash_type = HASH_TYPE_MD5;
7756 salt_type = SALT_TYPE_EMBEDDED;
7757 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7758 opts_type = OPTS_TYPE_PT_GENERATE_LE
7759 | OPTS_TYPE_HASH_COPY;
7760 kern_type = KERN_TYPE_MD5CRYPT;
7761 dgst_size = DGST_SIZE_4_4;
7762 parse_func = juniper_parse_hash;
7763 sort_by_digest = sort_by_digest_4_4;
7764 opti_type = OPTI_TYPE_ZERO_BYTE;
7765 dgst_pos0 = 0;
7766 dgst_pos1 = 1;
7767 dgst_pos2 = 2;
7768 dgst_pos3 = 3;
7769 break;
7770
7771 case 900: hash_type = HASH_TYPE_MD4;
7772 salt_type = SALT_TYPE_NONE;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_LE
7775 | OPTS_TYPE_PT_ADD80
7776 | OPTS_TYPE_PT_ADDBITS14;
7777 kern_type = KERN_TYPE_MD4;
7778 dgst_size = DGST_SIZE_4_4;
7779 parse_func = md4_parse_hash;
7780 sort_by_digest = sort_by_digest_4_4;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_PRECOMPUTE_INIT
7783 | OPTI_TYPE_PRECOMPUTE_MERKLE
7784 | OPTI_TYPE_MEET_IN_MIDDLE
7785 | OPTI_TYPE_EARLY_SKIP
7786 | OPTI_TYPE_NOT_ITERATED
7787 | OPTI_TYPE_NOT_SALTED
7788 | OPTI_TYPE_RAW_HASH;
7789 dgst_pos0 = 0;
7790 dgst_pos1 = 3;
7791 dgst_pos2 = 2;
7792 dgst_pos3 = 1;
7793 break;
7794
7795 case 1000: hash_type = HASH_TYPE_MD4;
7796 salt_type = SALT_TYPE_NONE;
7797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7798 opts_type = OPTS_TYPE_PT_GENERATE_LE
7799 | OPTS_TYPE_PT_ADD80
7800 | OPTS_TYPE_PT_ADDBITS14
7801 | OPTS_TYPE_PT_UNICODE;
7802 kern_type = KERN_TYPE_MD4_PWU;
7803 dgst_size = DGST_SIZE_4_4;
7804 parse_func = md4_parse_hash;
7805 sort_by_digest = sort_by_digest_4_4;
7806 opti_type = OPTI_TYPE_ZERO_BYTE
7807 | OPTI_TYPE_PRECOMPUTE_INIT
7808 | OPTI_TYPE_PRECOMPUTE_MERKLE
7809 | OPTI_TYPE_MEET_IN_MIDDLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_NOT_SALTED
7813 | OPTI_TYPE_RAW_HASH;
7814 dgst_pos0 = 0;
7815 dgst_pos1 = 3;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 1;
7818 break;
7819
7820 case 1100: hash_type = HASH_TYPE_MD4;
7821 salt_type = SALT_TYPE_INTERN;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_LE
7824 | OPTS_TYPE_PT_ADD80
7825 | OPTS_TYPE_PT_ADDBITS14
7826 | OPTS_TYPE_PT_UNICODE
7827 | OPTS_TYPE_ST_ADD80
7828 | OPTS_TYPE_ST_UNICODE
7829 | OPTS_TYPE_ST_LOWER;
7830 kern_type = KERN_TYPE_MD44_PWUSLT;
7831 dgst_size = DGST_SIZE_4_4;
7832 parse_func = dcc_parse_hash;
7833 sort_by_digest = sort_by_digest_4_4;
7834 opti_type = OPTI_TYPE_ZERO_BYTE
7835 | OPTI_TYPE_PRECOMPUTE_INIT
7836 | OPTI_TYPE_PRECOMPUTE_MERKLE
7837 | OPTI_TYPE_EARLY_SKIP
7838 | OPTI_TYPE_NOT_ITERATED;
7839 dgst_pos0 = 0;
7840 dgst_pos1 = 3;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 1;
7843 break;
7844
7845 case 1400: hash_type = HASH_TYPE_SHA256;
7846 salt_type = SALT_TYPE_NONE;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_ADD80
7850 | OPTS_TYPE_PT_ADDBITS15;
7851 kern_type = KERN_TYPE_SHA256;
7852 dgst_size = DGST_SIZE_4_8;
7853 parse_func = sha256_parse_hash;
7854 sort_by_digest = sort_by_digest_4_8;
7855 opti_type = OPTI_TYPE_ZERO_BYTE
7856 | OPTI_TYPE_PRECOMPUTE_INIT
7857 | OPTI_TYPE_PRECOMPUTE_MERKLE
7858 | OPTI_TYPE_EARLY_SKIP
7859 | OPTI_TYPE_NOT_ITERATED
7860 | OPTI_TYPE_NOT_SALTED
7861 | OPTI_TYPE_RAW_HASH;
7862 dgst_pos0 = 3;
7863 dgst_pos1 = 7;
7864 dgst_pos2 = 2;
7865 dgst_pos3 = 6;
7866 break;
7867
7868 case 1410: hash_type = HASH_TYPE_SHA256;
7869 salt_type = SALT_TYPE_INTERN;
7870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7871 opts_type = OPTS_TYPE_PT_GENERATE_BE
7872 | OPTS_TYPE_ST_ADD80
7873 | OPTS_TYPE_ST_ADDBITS15;
7874 kern_type = KERN_TYPE_SHA256_PWSLT;
7875 dgst_size = DGST_SIZE_4_8;
7876 parse_func = sha256s_parse_hash;
7877 sort_by_digest = sort_by_digest_4_8;
7878 opti_type = OPTI_TYPE_ZERO_BYTE
7879 | OPTI_TYPE_PRECOMPUTE_INIT
7880 | OPTI_TYPE_PRECOMPUTE_MERKLE
7881 | OPTI_TYPE_EARLY_SKIP
7882 | OPTI_TYPE_NOT_ITERATED
7883 | OPTI_TYPE_APPENDED_SALT
7884 | OPTI_TYPE_RAW_HASH;
7885 dgst_pos0 = 3;
7886 dgst_pos1 = 7;
7887 dgst_pos2 = 2;
7888 dgst_pos3 = 6;
7889 break;
7890
7891 case 1420: hash_type = HASH_TYPE_SHA256;
7892 salt_type = SALT_TYPE_INTERN;
7893 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7894 opts_type = OPTS_TYPE_PT_GENERATE_BE
7895 | OPTS_TYPE_PT_ADD80
7896 | OPTS_TYPE_PT_ADDBITS15;
7897 kern_type = KERN_TYPE_SHA256_SLTPW;
7898 dgst_size = DGST_SIZE_4_8;
7899 parse_func = sha256s_parse_hash;
7900 sort_by_digest = sort_by_digest_4_8;
7901 opti_type = OPTI_TYPE_ZERO_BYTE
7902 | OPTI_TYPE_PRECOMPUTE_INIT
7903 | OPTI_TYPE_PRECOMPUTE_MERKLE
7904 | OPTI_TYPE_EARLY_SKIP
7905 | OPTI_TYPE_NOT_ITERATED
7906 | OPTI_TYPE_PREPENDED_SALT
7907 | OPTI_TYPE_RAW_HASH;
7908 dgst_pos0 = 3;
7909 dgst_pos1 = 7;
7910 dgst_pos2 = 2;
7911 dgst_pos3 = 6;
7912 break;
7913
7914 case 1421: hash_type = HASH_TYPE_SHA256;
7915 salt_type = SALT_TYPE_EMBEDDED;
7916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7917 opts_type = OPTS_TYPE_PT_GENERATE_BE
7918 | OPTS_TYPE_PT_ADD80
7919 | OPTS_TYPE_PT_ADDBITS15;
7920 kern_type = KERN_TYPE_SHA256_SLTPW;
7921 dgst_size = DGST_SIZE_4_8;
7922 parse_func = hmailserver_parse_hash;
7923 sort_by_digest = sort_by_digest_4_8;
7924 opti_type = OPTI_TYPE_ZERO_BYTE
7925 | OPTI_TYPE_PRECOMPUTE_INIT
7926 | OPTI_TYPE_PRECOMPUTE_MERKLE
7927 | OPTI_TYPE_EARLY_SKIP
7928 | OPTI_TYPE_NOT_ITERATED
7929 | OPTI_TYPE_PREPENDED_SALT
7930 | OPTI_TYPE_RAW_HASH;
7931 dgst_pos0 = 3;
7932 dgst_pos1 = 7;
7933 dgst_pos2 = 2;
7934 dgst_pos3 = 6;
7935 break;
7936
7937 case 1430: hash_type = HASH_TYPE_SHA256;
7938 salt_type = SALT_TYPE_INTERN;
7939 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7940 opts_type = OPTS_TYPE_PT_GENERATE_BE
7941 | OPTS_TYPE_PT_UNICODE
7942 | OPTS_TYPE_ST_ADD80
7943 | OPTS_TYPE_ST_ADDBITS15;
7944 kern_type = KERN_TYPE_SHA256_PWUSLT;
7945 dgst_size = DGST_SIZE_4_8;
7946 parse_func = sha256s_parse_hash;
7947 sort_by_digest = sort_by_digest_4_8;
7948 opti_type = OPTI_TYPE_ZERO_BYTE
7949 | OPTI_TYPE_PRECOMPUTE_INIT
7950 | OPTI_TYPE_PRECOMPUTE_MERKLE
7951 | OPTI_TYPE_EARLY_SKIP
7952 | OPTI_TYPE_NOT_ITERATED
7953 | OPTI_TYPE_APPENDED_SALT
7954 | OPTI_TYPE_RAW_HASH;
7955 dgst_pos0 = 3;
7956 dgst_pos1 = 7;
7957 dgst_pos2 = 2;
7958 dgst_pos3 = 6;
7959 break;
7960
7961 case 1440: hash_type = HASH_TYPE_SHA256;
7962 salt_type = SALT_TYPE_INTERN;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_PT_ADD80
7966 | OPTS_TYPE_PT_ADDBITS15
7967 | OPTS_TYPE_PT_UNICODE;
7968 kern_type = KERN_TYPE_SHA256_SLTPWU;
7969 dgst_size = DGST_SIZE_4_8;
7970 parse_func = sha256s_parse_hash;
7971 sort_by_digest = sort_by_digest_4_8;
7972 opti_type = OPTI_TYPE_ZERO_BYTE
7973 | OPTI_TYPE_PRECOMPUTE_INIT
7974 | OPTI_TYPE_PRECOMPUTE_MERKLE
7975 | OPTI_TYPE_EARLY_SKIP
7976 | OPTI_TYPE_NOT_ITERATED
7977 | OPTI_TYPE_PREPENDED_SALT
7978 | OPTI_TYPE_RAW_HASH;
7979 dgst_pos0 = 3;
7980 dgst_pos1 = 7;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 6;
7983 break;
7984
7985 case 1441: hash_type = HASH_TYPE_SHA256;
7986 salt_type = SALT_TYPE_EMBEDDED;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_PT_ADD80
7990 | OPTS_TYPE_PT_ADDBITS15
7991 | OPTS_TYPE_PT_UNICODE
7992 | OPTS_TYPE_ST_BASE64;
7993 kern_type = KERN_TYPE_SHA256_SLTPWU;
7994 dgst_size = DGST_SIZE_4_8;
7995 parse_func = episerver4_parse_hash;
7996 sort_by_digest = sort_by_digest_4_8;
7997 opti_type = OPTI_TYPE_ZERO_BYTE
7998 | OPTI_TYPE_PRECOMPUTE_INIT
7999 | OPTI_TYPE_PRECOMPUTE_MERKLE
8000 | OPTI_TYPE_EARLY_SKIP
8001 | OPTI_TYPE_NOT_ITERATED
8002 | OPTI_TYPE_PREPENDED_SALT
8003 | OPTI_TYPE_RAW_HASH;
8004 dgst_pos0 = 3;
8005 dgst_pos1 = 7;
8006 dgst_pos2 = 2;
8007 dgst_pos3 = 6;
8008 break;
8009
8010 case 1450: hash_type = HASH_TYPE_SHA256;
8011 salt_type = SALT_TYPE_INTERN;
8012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8013 opts_type = OPTS_TYPE_PT_GENERATE_BE
8014 | OPTS_TYPE_ST_ADD80;
8015 kern_type = KERN_TYPE_HMACSHA256_PW;
8016 dgst_size = DGST_SIZE_4_8;
8017 parse_func = hmacsha256_parse_hash;
8018 sort_by_digest = sort_by_digest_4_8;
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_NOT_ITERATED;
8021 dgst_pos0 = 3;
8022 dgst_pos1 = 7;
8023 dgst_pos2 = 2;
8024 dgst_pos3 = 6;
8025 break;
8026
8027 case 1460: hash_type = HASH_TYPE_SHA256;
8028 salt_type = SALT_TYPE_INTERN;
8029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030 opts_type = OPTS_TYPE_PT_GENERATE_BE
8031 | OPTS_TYPE_PT_ADD80
8032 | OPTS_TYPE_PT_ADDBITS15;
8033 kern_type = KERN_TYPE_HMACSHA256_SLT;
8034 dgst_size = DGST_SIZE_4_8;
8035 parse_func = hmacsha256_parse_hash;
8036 sort_by_digest = sort_by_digest_4_8;
8037 opti_type = OPTI_TYPE_ZERO_BYTE
8038 | OPTI_TYPE_NOT_ITERATED;
8039 dgst_pos0 = 3;
8040 dgst_pos1 = 7;
8041 dgst_pos2 = 2;
8042 dgst_pos3 = 6;
8043 break;
8044
8045 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8046 salt_type = SALT_TYPE_EMBEDDED;
8047 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8048 opts_type = OPTS_TYPE_PT_GENERATE_LE
8049 | OPTS_TYPE_PT_BITSLICE;
8050 kern_type = KERN_TYPE_DESCRYPT;
8051 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8052 parse_func = descrypt_parse_hash;
8053 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8054 opti_type = OPTI_TYPE_ZERO_BYTE
8055 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8056 dgst_pos0 = 0;
8057 dgst_pos1 = 1;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 3;
8060 break;
8061
8062 case 1600: hash_type = HASH_TYPE_MD5;
8063 salt_type = SALT_TYPE_EMBEDDED;
8064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8066 kern_type = KERN_TYPE_APR1CRYPT;
8067 dgst_size = DGST_SIZE_4_4;
8068 parse_func = md5apr1_parse_hash;
8069 sort_by_digest = sort_by_digest_4_4;
8070 opti_type = OPTI_TYPE_ZERO_BYTE;
8071 dgst_pos0 = 0;
8072 dgst_pos1 = 1;
8073 dgst_pos2 = 2;
8074 dgst_pos3 = 3;
8075 break;
8076
8077 case 1700: hash_type = HASH_TYPE_SHA512;
8078 salt_type = SALT_TYPE_NONE;
8079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8080 opts_type = OPTS_TYPE_PT_GENERATE_BE
8081 | OPTS_TYPE_PT_ADD80
8082 | OPTS_TYPE_PT_ADDBITS15;
8083 kern_type = KERN_TYPE_SHA512;
8084 dgst_size = DGST_SIZE_8_8;
8085 parse_func = sha512_parse_hash;
8086 sort_by_digest = sort_by_digest_8_8;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP
8091 | OPTI_TYPE_NOT_ITERATED
8092 | OPTI_TYPE_NOT_SALTED
8093 | OPTI_TYPE_USES_BITS_64
8094 | OPTI_TYPE_RAW_HASH;
8095 dgst_pos0 = 14;
8096 dgst_pos1 = 15;
8097 dgst_pos2 = 6;
8098 dgst_pos3 = 7;
8099 break;
8100
8101 case 1710: hash_type = HASH_TYPE_SHA512;
8102 salt_type = SALT_TYPE_INTERN;
8103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_ST_ADD80
8106 | OPTS_TYPE_ST_ADDBITS15;
8107 kern_type = KERN_TYPE_SHA512_PWSLT;
8108 dgst_size = DGST_SIZE_8_8;
8109 parse_func = sha512s_parse_hash;
8110 sort_by_digest = sort_by_digest_8_8;
8111 opti_type = OPTI_TYPE_ZERO_BYTE
8112 | OPTI_TYPE_PRECOMPUTE_INIT
8113 | OPTI_TYPE_PRECOMPUTE_MERKLE
8114 | OPTI_TYPE_EARLY_SKIP
8115 | OPTI_TYPE_NOT_ITERATED
8116 | OPTI_TYPE_APPENDED_SALT
8117 | OPTI_TYPE_USES_BITS_64
8118 | OPTI_TYPE_RAW_HASH;
8119 dgst_pos0 = 14;
8120 dgst_pos1 = 15;
8121 dgst_pos2 = 6;
8122 dgst_pos3 = 7;
8123 break;
8124
8125 case 1711: hash_type = HASH_TYPE_SHA512;
8126 salt_type = SALT_TYPE_EMBEDDED;
8127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8128 opts_type = OPTS_TYPE_PT_GENERATE_BE
8129 | OPTS_TYPE_ST_ADD80
8130 | OPTS_TYPE_ST_ADDBITS15;
8131 kern_type = KERN_TYPE_SHA512_PWSLT;
8132 dgst_size = DGST_SIZE_8_8;
8133 parse_func = sha512b64s_parse_hash;
8134 sort_by_digest = sort_by_digest_8_8;
8135 opti_type = OPTI_TYPE_ZERO_BYTE
8136 | OPTI_TYPE_PRECOMPUTE_INIT
8137 | OPTI_TYPE_PRECOMPUTE_MERKLE
8138 | OPTI_TYPE_EARLY_SKIP
8139 | OPTI_TYPE_NOT_ITERATED
8140 | OPTI_TYPE_APPENDED_SALT
8141 | OPTI_TYPE_USES_BITS_64
8142 | OPTI_TYPE_RAW_HASH;
8143 dgst_pos0 = 14;
8144 dgst_pos1 = 15;
8145 dgst_pos2 = 6;
8146 dgst_pos3 = 7;
8147 break;
8148
8149 case 1720: hash_type = HASH_TYPE_SHA512;
8150 salt_type = SALT_TYPE_INTERN;
8151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8152 opts_type = OPTS_TYPE_PT_GENERATE_BE
8153 | OPTS_TYPE_PT_ADD80
8154 | OPTS_TYPE_PT_ADDBITS15;
8155 kern_type = KERN_TYPE_SHA512_SLTPW;
8156 dgst_size = DGST_SIZE_8_8;
8157 parse_func = sha512s_parse_hash;
8158 sort_by_digest = sort_by_digest_8_8;
8159 opti_type = OPTI_TYPE_ZERO_BYTE
8160 | OPTI_TYPE_PRECOMPUTE_INIT
8161 | OPTI_TYPE_PRECOMPUTE_MERKLE
8162 | OPTI_TYPE_EARLY_SKIP
8163 | OPTI_TYPE_NOT_ITERATED
8164 | OPTI_TYPE_PREPENDED_SALT
8165 | OPTI_TYPE_USES_BITS_64
8166 | OPTI_TYPE_RAW_HASH;
8167 dgst_pos0 = 14;
8168 dgst_pos1 = 15;
8169 dgst_pos2 = 6;
8170 dgst_pos3 = 7;
8171 break;
8172
8173 case 1722: hash_type = HASH_TYPE_SHA512;
8174 salt_type = SALT_TYPE_EMBEDDED;
8175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8176 opts_type = OPTS_TYPE_PT_GENERATE_BE
8177 | OPTS_TYPE_PT_ADD80
8178 | OPTS_TYPE_PT_ADDBITS15
8179 | OPTS_TYPE_ST_HEX;
8180 kern_type = KERN_TYPE_SHA512_SLTPW;
8181 dgst_size = DGST_SIZE_8_8;
8182 parse_func = osx512_parse_hash;
8183 sort_by_digest = sort_by_digest_8_8;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_PRECOMPUTE_INIT
8186 | OPTI_TYPE_PRECOMPUTE_MERKLE
8187 | OPTI_TYPE_EARLY_SKIP
8188 | OPTI_TYPE_NOT_ITERATED
8189 | OPTI_TYPE_PREPENDED_SALT
8190 | OPTI_TYPE_USES_BITS_64
8191 | OPTI_TYPE_RAW_HASH;
8192 dgst_pos0 = 14;
8193 dgst_pos1 = 15;
8194 dgst_pos2 = 6;
8195 dgst_pos3 = 7;
8196 break;
8197
8198 case 1730: hash_type = HASH_TYPE_SHA512;
8199 salt_type = SALT_TYPE_INTERN;
8200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8201 opts_type = OPTS_TYPE_PT_GENERATE_BE
8202 | OPTS_TYPE_PT_UNICODE
8203 | OPTS_TYPE_ST_ADD80
8204 | OPTS_TYPE_ST_ADDBITS15;
8205 kern_type = KERN_TYPE_SHA512_PWSLTU;
8206 dgst_size = DGST_SIZE_8_8;
8207 parse_func = sha512s_parse_hash;
8208 sort_by_digest = sort_by_digest_8_8;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_PRECOMPUTE_INIT
8211 | OPTI_TYPE_PRECOMPUTE_MERKLE
8212 | OPTI_TYPE_EARLY_SKIP
8213 | OPTI_TYPE_NOT_ITERATED
8214 | OPTI_TYPE_APPENDED_SALT
8215 | OPTI_TYPE_USES_BITS_64
8216 | OPTI_TYPE_RAW_HASH;
8217 dgst_pos0 = 14;
8218 dgst_pos1 = 15;
8219 dgst_pos2 = 6;
8220 dgst_pos3 = 7;
8221 break;
8222
8223 case 1731: hash_type = HASH_TYPE_SHA512;
8224 salt_type = SALT_TYPE_EMBEDDED;
8225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8226 opts_type = OPTS_TYPE_PT_GENERATE_BE
8227 | OPTS_TYPE_PT_UNICODE
8228 | OPTS_TYPE_ST_ADD80
8229 | OPTS_TYPE_ST_ADDBITS15
8230 | OPTS_TYPE_ST_HEX;
8231 kern_type = KERN_TYPE_SHA512_PWSLTU;
8232 dgst_size = DGST_SIZE_8_8;
8233 parse_func = mssql2012_parse_hash;
8234 sort_by_digest = sort_by_digest_8_8;
8235 opti_type = OPTI_TYPE_ZERO_BYTE
8236 | OPTI_TYPE_PRECOMPUTE_INIT
8237 | OPTI_TYPE_PRECOMPUTE_MERKLE
8238 | OPTI_TYPE_EARLY_SKIP
8239 | OPTI_TYPE_NOT_ITERATED
8240 | OPTI_TYPE_APPENDED_SALT
8241 | OPTI_TYPE_USES_BITS_64
8242 | OPTI_TYPE_RAW_HASH;
8243 dgst_pos0 = 14;
8244 dgst_pos1 = 15;
8245 dgst_pos2 = 6;
8246 dgst_pos3 = 7;
8247 break;
8248
8249 case 1740: hash_type = HASH_TYPE_SHA512;
8250 salt_type = SALT_TYPE_INTERN;
8251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_BE
8253 | OPTS_TYPE_PT_ADD80
8254 | OPTS_TYPE_PT_ADDBITS15
8255 | OPTS_TYPE_PT_UNICODE;
8256 kern_type = KERN_TYPE_SHA512_SLTPWU;
8257 dgst_size = DGST_SIZE_8_8;
8258 parse_func = sha512s_parse_hash;
8259 sort_by_digest = sort_by_digest_8_8;
8260 opti_type = OPTI_TYPE_ZERO_BYTE
8261 | OPTI_TYPE_PRECOMPUTE_INIT
8262 | OPTI_TYPE_PRECOMPUTE_MERKLE
8263 | OPTI_TYPE_EARLY_SKIP
8264 | OPTI_TYPE_NOT_ITERATED
8265 | OPTI_TYPE_PREPENDED_SALT
8266 | OPTI_TYPE_USES_BITS_64
8267 | OPTI_TYPE_RAW_HASH;
8268 dgst_pos0 = 14;
8269 dgst_pos1 = 15;
8270 dgst_pos2 = 6;
8271 dgst_pos3 = 7;
8272 break;
8273
8274 case 1750: hash_type = HASH_TYPE_SHA512;
8275 salt_type = SALT_TYPE_INTERN;
8276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_BE
8278 | OPTS_TYPE_ST_ADD80;
8279 kern_type = KERN_TYPE_HMACSHA512_PW;
8280 dgst_size = DGST_SIZE_8_8;
8281 parse_func = hmacsha512_parse_hash;
8282 sort_by_digest = sort_by_digest_8_8;
8283 opti_type = OPTI_TYPE_ZERO_BYTE
8284 | OPTI_TYPE_USES_BITS_64
8285 | OPTI_TYPE_NOT_ITERATED;
8286 dgst_pos0 = 14;
8287 dgst_pos1 = 15;
8288 dgst_pos2 = 6;
8289 dgst_pos3 = 7;
8290 break;
8291
8292 case 1760: hash_type = HASH_TYPE_SHA512;
8293 salt_type = SALT_TYPE_INTERN;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_BE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS15;
8298 kern_type = KERN_TYPE_HMACSHA512_SLT;
8299 dgst_size = DGST_SIZE_8_8;
8300 parse_func = hmacsha512_parse_hash;
8301 sort_by_digest = sort_by_digest_8_8;
8302 opti_type = OPTI_TYPE_ZERO_BYTE
8303 | OPTI_TYPE_USES_BITS_64
8304 | OPTI_TYPE_NOT_ITERATED;
8305 dgst_pos0 = 14;
8306 dgst_pos1 = 15;
8307 dgst_pos2 = 6;
8308 dgst_pos3 = 7;
8309 break;
8310
8311 case 1800: hash_type = HASH_TYPE_SHA512;
8312 salt_type = SALT_TYPE_EMBEDDED;
8313 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8314 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8315 kern_type = KERN_TYPE_SHA512CRYPT;
8316 dgst_size = DGST_SIZE_8_8;
8317 parse_func = sha512crypt_parse_hash;
8318 sort_by_digest = sort_by_digest_8_8;
8319 opti_type = OPTI_TYPE_ZERO_BYTE
8320 | OPTI_TYPE_USES_BITS_64;
8321 dgst_pos0 = 0;
8322 dgst_pos1 = 1;
8323 dgst_pos2 = 2;
8324 dgst_pos3 = 3;
8325 break;
8326
8327 case 2100: hash_type = HASH_TYPE_DCC2;
8328 salt_type = SALT_TYPE_EMBEDDED;
8329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8330 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8331 | OPTS_TYPE_ST_LOWER
8332 | OPTS_TYPE_ST_UNICODE;
8333 kern_type = KERN_TYPE_DCC2;
8334 dgst_size = DGST_SIZE_4_4;
8335 parse_func = dcc2_parse_hash;
8336 sort_by_digest = sort_by_digest_4_4;
8337 opti_type = OPTI_TYPE_ZERO_BYTE
8338 | OPTI_TYPE_SLOW_HASH_SIMD;
8339 dgst_pos0 = 0;
8340 dgst_pos1 = 1;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 3;
8343 break;
8344
8345 case 2400: hash_type = HASH_TYPE_MD5;
8346 salt_type = SALT_TYPE_NONE;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8349 kern_type = KERN_TYPE_MD5PIX;
8350 dgst_size = DGST_SIZE_4_4;
8351 parse_func = md5pix_parse_hash;
8352 sort_by_digest = sort_by_digest_4_4;
8353 opti_type = OPTI_TYPE_ZERO_BYTE
8354 | OPTI_TYPE_PRECOMPUTE_INIT
8355 | OPTI_TYPE_PRECOMPUTE_MERKLE
8356 | OPTI_TYPE_EARLY_SKIP
8357 | OPTI_TYPE_NOT_ITERATED
8358 | OPTI_TYPE_NOT_SALTED;
8359 dgst_pos0 = 0;
8360 dgst_pos1 = 3;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 1;
8363 break;
8364
8365 case 2410: hash_type = HASH_TYPE_MD5;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8369 kern_type = KERN_TYPE_MD5ASA;
8370 dgst_size = DGST_SIZE_4_4;
8371 parse_func = md5asa_parse_hash;
8372 sort_by_digest = sort_by_digest_4_4;
8373 opti_type = OPTI_TYPE_ZERO_BYTE
8374 | OPTI_TYPE_PRECOMPUTE_INIT
8375 | OPTI_TYPE_PRECOMPUTE_MERKLE
8376 | OPTI_TYPE_EARLY_SKIP
8377 | OPTI_TYPE_NOT_ITERATED;
8378 dgst_pos0 = 0;
8379 dgst_pos1 = 3;
8380 dgst_pos2 = 2;
8381 dgst_pos3 = 1;
8382 break;
8383
8384 case 2500: hash_type = HASH_TYPE_WPA;
8385 salt_type = SALT_TYPE_EMBEDDED;
8386 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8387 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8388 kern_type = KERN_TYPE_WPA;
8389 dgst_size = DGST_SIZE_4_4;
8390 parse_func = wpa_parse_hash;
8391 sort_by_digest = sort_by_digest_4_4;
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_SLOW_HASH_SIMD;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 1;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 3;
8398 break;
8399
8400 case 2600: hash_type = HASH_TYPE_MD5;
8401 salt_type = SALT_TYPE_VIRTUAL;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_ADD80
8405 | OPTS_TYPE_PT_ADDBITS14
8406 | OPTS_TYPE_ST_ADD80;
8407 kern_type = KERN_TYPE_MD55_PWSLT1;
8408 dgst_size = DGST_SIZE_4_4;
8409 parse_func = md5md5_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 dgst_pos0 = 0;
8416 dgst_pos1 = 3;
8417 dgst_pos2 = 2;
8418 dgst_pos3 = 1;
8419 break;
8420
8421 case 2611: hash_type = HASH_TYPE_MD5;
8422 salt_type = SALT_TYPE_INTERN;
8423 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8424 opts_type = OPTS_TYPE_PT_GENERATE_LE
8425 | OPTS_TYPE_PT_ADD80
8426 | OPTS_TYPE_PT_ADDBITS14
8427 | OPTS_TYPE_ST_ADD80;
8428 kern_type = KERN_TYPE_MD55_PWSLT1;
8429 dgst_size = DGST_SIZE_4_4;
8430 parse_func = vb3_parse_hash;
8431 sort_by_digest = sort_by_digest_4_4;
8432 opti_type = OPTI_TYPE_ZERO_BYTE
8433 | OPTI_TYPE_PRECOMPUTE_INIT
8434 | OPTI_TYPE_PRECOMPUTE_MERKLE
8435 | OPTI_TYPE_EARLY_SKIP;
8436 dgst_pos0 = 0;
8437 dgst_pos1 = 3;
8438 dgst_pos2 = 2;
8439 dgst_pos3 = 1;
8440 break;
8441
8442 case 2612: hash_type = HASH_TYPE_MD5;
8443 salt_type = SALT_TYPE_EMBEDDED;
8444 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8445 opts_type = OPTS_TYPE_PT_GENERATE_LE
8446 | OPTS_TYPE_PT_ADD80
8447 | OPTS_TYPE_PT_ADDBITS14
8448 | OPTS_TYPE_ST_ADD80
8449 | OPTS_TYPE_ST_HEX;
8450 kern_type = KERN_TYPE_MD55_PWSLT1;
8451 dgst_size = DGST_SIZE_4_4;
8452 parse_func = phps_parse_hash;
8453 sort_by_digest = sort_by_digest_4_4;
8454 opti_type = OPTI_TYPE_ZERO_BYTE
8455 | OPTI_TYPE_PRECOMPUTE_INIT
8456 | OPTI_TYPE_PRECOMPUTE_MERKLE
8457 | OPTI_TYPE_EARLY_SKIP;
8458 dgst_pos0 = 0;
8459 dgst_pos1 = 3;
8460 dgst_pos2 = 2;
8461 dgst_pos3 = 1;
8462 break;
8463
8464 case 2711: hash_type = HASH_TYPE_MD5;
8465 salt_type = SALT_TYPE_INTERN;
8466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8467 opts_type = OPTS_TYPE_PT_GENERATE_LE
8468 | OPTS_TYPE_PT_ADD80
8469 | OPTS_TYPE_PT_ADDBITS14
8470 | OPTS_TYPE_ST_ADD80;
8471 kern_type = KERN_TYPE_MD55_PWSLT2;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = vb30_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_PRECOMPUTE_INIT
8477 | OPTI_TYPE_EARLY_SKIP;
8478 dgst_pos0 = 0;
8479 dgst_pos1 = 3;
8480 dgst_pos2 = 2;
8481 dgst_pos3 = 1;
8482 break;
8483
8484 case 2811: hash_type = HASH_TYPE_MD5;
8485 salt_type = SALT_TYPE_INTERN;
8486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8487 opts_type = OPTS_TYPE_PT_GENERATE_LE
8488 | OPTS_TYPE_PT_ADD80
8489 | OPTS_TYPE_PT_ADDBITS14;
8490 kern_type = KERN_TYPE_MD55_SLTPW;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = ipb2_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_EARLY_SKIP;
8497 dgst_pos0 = 0;
8498 dgst_pos1 = 3;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 1;
8501 break;
8502
8503 case 3000: hash_type = HASH_TYPE_LM;
8504 salt_type = SALT_TYPE_NONE;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_LE
8507 | OPTS_TYPE_PT_UPPER
8508 | OPTS_TYPE_PT_BITSLICE;
8509 kern_type = KERN_TYPE_LM;
8510 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8511 parse_func = lm_parse_hash;
8512 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8513 opti_type = OPTI_TYPE_ZERO_BYTE
8514 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8515 dgst_pos0 = 0;
8516 dgst_pos1 = 1;
8517 dgst_pos2 = 2;
8518 dgst_pos3 = 3;
8519 break;
8520
8521 case 3100: hash_type = HASH_TYPE_ORACLEH;
8522 salt_type = SALT_TYPE_INTERN;
8523 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8524 opts_type = OPTS_TYPE_PT_GENERATE_LE
8525 | OPTS_TYPE_PT_UPPER
8526 | OPTS_TYPE_ST_UPPER;
8527 kern_type = KERN_TYPE_ORACLEH;
8528 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8529 parse_func = oracleh_parse_hash;
8530 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8531 opti_type = OPTI_TYPE_ZERO_BYTE;
8532 dgst_pos0 = 0;
8533 dgst_pos1 = 1;
8534 dgst_pos2 = 2;
8535 dgst_pos3 = 3;
8536 break;
8537
8538 case 3200: hash_type = HASH_TYPE_BCRYPT;
8539 salt_type = SALT_TYPE_EMBEDDED;
8540 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8541 opts_type = OPTS_TYPE_PT_GENERATE_LE
8542 | OPTS_TYPE_ST_GENERATE_LE;
8543 kern_type = KERN_TYPE_BCRYPT;
8544 dgst_size = DGST_SIZE_4_6;
8545 parse_func = bcrypt_parse_hash;
8546 sort_by_digest = sort_by_digest_4_6;
8547 opti_type = OPTI_TYPE_ZERO_BYTE;
8548 dgst_pos0 = 0;
8549 dgst_pos1 = 1;
8550 dgst_pos2 = 2;
8551 dgst_pos3 = 3;
8552 break;
8553
8554 case 3710: hash_type = HASH_TYPE_MD5;
8555 salt_type = SALT_TYPE_INTERN;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_LE
8558 | OPTS_TYPE_PT_ADD80
8559 | OPTS_TYPE_PT_ADDBITS14;
8560 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8561 dgst_size = DGST_SIZE_4_4;
8562 parse_func = md5s_parse_hash;
8563 sort_by_digest = sort_by_digest_4_4;
8564 opti_type = OPTI_TYPE_ZERO_BYTE
8565 | OPTI_TYPE_PRECOMPUTE_INIT
8566 | OPTI_TYPE_PRECOMPUTE_MERKLE
8567 | OPTI_TYPE_EARLY_SKIP;
8568 dgst_pos0 = 0;
8569 dgst_pos1 = 3;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 3711: hash_type = HASH_TYPE_MD5;
8575 salt_type = SALT_TYPE_EMBEDDED;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADD80
8579 | OPTS_TYPE_PT_ADDBITS14;
8580 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8581 dgst_size = DGST_SIZE_4_4;
8582 parse_func = mediawiki_b_parse_hash;
8583 sort_by_digest = sort_by_digest_4_4;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP;
8588 dgst_pos0 = 0;
8589 dgst_pos1 = 3;
8590 dgst_pos2 = 2;
8591 dgst_pos3 = 1;
8592 break;
8593
8594 case 3800: hash_type = HASH_TYPE_MD5;
8595 salt_type = SALT_TYPE_INTERN;
8596 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8597 opts_type = OPTS_TYPE_PT_GENERATE_LE
8598 | OPTS_TYPE_ST_ADDBITS14;
8599 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8600 dgst_size = DGST_SIZE_4_4;
8601 parse_func = md5s_parse_hash;
8602 sort_by_digest = sort_by_digest_4_4;
8603 opti_type = OPTI_TYPE_ZERO_BYTE
8604 | OPTI_TYPE_PRECOMPUTE_INIT
8605 | OPTI_TYPE_PRECOMPUTE_MERKLE
8606 | OPTI_TYPE_EARLY_SKIP
8607 | OPTI_TYPE_NOT_ITERATED
8608 | OPTI_TYPE_RAW_HASH;
8609 dgst_pos0 = 0;
8610 dgst_pos1 = 3;
8611 dgst_pos2 = 2;
8612 dgst_pos3 = 1;
8613 break;
8614
8615 case 4300: hash_type = HASH_TYPE_MD5;
8616 salt_type = SALT_TYPE_VIRTUAL;
8617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8618 opts_type = OPTS_TYPE_PT_GENERATE_LE
8619 | OPTS_TYPE_PT_ADD80
8620 | OPTS_TYPE_PT_ADDBITS14
8621 | OPTS_TYPE_ST_ADD80;
8622 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8623 dgst_size = DGST_SIZE_4_4;
8624 parse_func = md5md5_parse_hash;
8625 sort_by_digest = sort_by_digest_4_4;
8626 opti_type = OPTI_TYPE_ZERO_BYTE
8627 | OPTI_TYPE_PRECOMPUTE_INIT
8628 | OPTI_TYPE_PRECOMPUTE_MERKLE
8629 | OPTI_TYPE_EARLY_SKIP;
8630 dgst_pos0 = 0;
8631 dgst_pos1 = 3;
8632 dgst_pos2 = 2;
8633 dgst_pos3 = 1;
8634 break;
8635
8636
8637 case 4400: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_NONE;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_BE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS15;
8643 kern_type = KERN_TYPE_MD5_SHA1;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = md5_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP
8651 | OPTI_TYPE_NOT_ITERATED
8652 | OPTI_TYPE_NOT_SALTED
8653 | OPTI_TYPE_RAW_HASH;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 3;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 1;
8658 break;
8659
8660 case 4500: hash_type = HASH_TYPE_SHA1;
8661 salt_type = SALT_TYPE_NONE;
8662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_BE
8664 | OPTS_TYPE_PT_ADD80
8665 | OPTS_TYPE_PT_ADDBITS15;
8666 kern_type = KERN_TYPE_SHA11;
8667 dgst_size = DGST_SIZE_4_5;
8668 parse_func = sha1_parse_hash;
8669 sort_by_digest = sort_by_digest_4_5;
8670 opti_type = OPTI_TYPE_ZERO_BYTE
8671 | OPTI_TYPE_PRECOMPUTE_INIT
8672 | OPTI_TYPE_PRECOMPUTE_MERKLE
8673 | OPTI_TYPE_EARLY_SKIP
8674 | OPTI_TYPE_NOT_SALTED;
8675 dgst_pos0 = 3;
8676 dgst_pos1 = 4;
8677 dgst_pos2 = 2;
8678 dgst_pos3 = 1;
8679 break;
8680
8681 case 4700: hash_type = HASH_TYPE_SHA1;
8682 salt_type = SALT_TYPE_NONE;
8683 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8684 opts_type = OPTS_TYPE_PT_GENERATE_LE
8685 | OPTS_TYPE_PT_ADD80
8686 | OPTS_TYPE_PT_ADDBITS14;
8687 kern_type = KERN_TYPE_SHA1_MD5;
8688 dgst_size = DGST_SIZE_4_5;
8689 parse_func = sha1_parse_hash;
8690 sort_by_digest = sort_by_digest_4_5;
8691 opti_type = OPTI_TYPE_ZERO_BYTE
8692 | OPTI_TYPE_PRECOMPUTE_INIT
8693 | OPTI_TYPE_PRECOMPUTE_MERKLE
8694 | OPTI_TYPE_EARLY_SKIP
8695 | OPTI_TYPE_NOT_ITERATED
8696 | OPTI_TYPE_NOT_SALTED
8697 | OPTI_TYPE_RAW_HASH;
8698 dgst_pos0 = 3;
8699 dgst_pos1 = 4;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 4800: hash_type = HASH_TYPE_MD5;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_LE
8708 | OPTS_TYPE_PT_ADDBITS14;
8709 kern_type = KERN_TYPE_MD5_CHAP;
8710 dgst_size = DGST_SIZE_4_4;
8711 parse_func = chap_parse_hash;
8712 sort_by_digest = sort_by_digest_4_4;
8713 opti_type = OPTI_TYPE_ZERO_BYTE
8714 | OPTI_TYPE_PRECOMPUTE_INIT
8715 | OPTI_TYPE_PRECOMPUTE_MERKLE
8716 | OPTI_TYPE_MEET_IN_MIDDLE
8717 | OPTI_TYPE_EARLY_SKIP
8718 | OPTI_TYPE_NOT_ITERATED
8719 | OPTI_TYPE_RAW_HASH;
8720 dgst_pos0 = 0;
8721 dgst_pos1 = 3;
8722 dgst_pos2 = 2;
8723 dgst_pos3 = 1;
8724 break;
8725
8726 case 4900: hash_type = HASH_TYPE_SHA1;
8727 salt_type = SALT_TYPE_INTERN;
8728 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8730 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8731 dgst_size = DGST_SIZE_4_5;
8732 parse_func = sha1s_parse_hash;
8733 sort_by_digest = sort_by_digest_4_5;
8734 opti_type = OPTI_TYPE_ZERO_BYTE
8735 | OPTI_TYPE_PRECOMPUTE_INIT
8736 | OPTI_TYPE_PRECOMPUTE_MERKLE
8737 | OPTI_TYPE_EARLY_SKIP;
8738 dgst_pos0 = 3;
8739 dgst_pos1 = 4;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 1;
8742 break;
8743
8744 case 5000: hash_type = HASH_TYPE_KECCAK;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD01;
8749 kern_type = KERN_TYPE_KECCAK;
8750 dgst_size = DGST_SIZE_8_25;
8751 parse_func = keccak_parse_hash;
8752 sort_by_digest = sort_by_digest_8_25;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_USES_BITS_64
8755 | OPTI_TYPE_RAW_HASH;
8756 dgst_pos0 = 2;
8757 dgst_pos1 = 3;
8758 dgst_pos2 = 4;
8759 dgst_pos3 = 5;
8760 break;
8761
8762 case 5100: hash_type = HASH_TYPE_MD5H;
8763 salt_type = SALT_TYPE_NONE;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_LE
8766 | OPTS_TYPE_PT_ADD80
8767 | OPTS_TYPE_PT_ADDBITS14;
8768 kern_type = KERN_TYPE_MD5H;
8769 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8770 parse_func = md5half_parse_hash;
8771 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8772 opti_type = OPTI_TYPE_ZERO_BYTE
8773 | OPTI_TYPE_RAW_HASH;
8774 dgst_pos0 = 0;
8775 dgst_pos1 = 1;
8776 dgst_pos2 = 2;
8777 dgst_pos3 = 3;
8778 break;
8779
8780 case 5200: hash_type = HASH_TYPE_SHA256;
8781 salt_type = SALT_TYPE_EMBEDDED;
8782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8783 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8784 kern_type = KERN_TYPE_PSAFE3;
8785 dgst_size = DGST_SIZE_4_8;
8786 parse_func = psafe3_parse_hash;
8787 sort_by_digest = sort_by_digest_4_8;
8788 opti_type = OPTI_TYPE_ZERO_BYTE;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 5300: hash_type = HASH_TYPE_MD5;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE
8799 | OPTS_TYPE_ST_ADD80;
8800 kern_type = KERN_TYPE_IKEPSK_MD5;
8801 dgst_size = DGST_SIZE_4_4;
8802 parse_func = ikepsk_md5_parse_hash;
8803 sort_by_digest = sort_by_digest_4_4;
8804 opti_type = OPTI_TYPE_ZERO_BYTE;
8805 dgst_pos0 = 0;
8806 dgst_pos1 = 3;
8807 dgst_pos2 = 2;
8808 dgst_pos3 = 1;
8809 break;
8810
8811 case 5400: hash_type = HASH_TYPE_SHA1;
8812 salt_type = SALT_TYPE_EMBEDDED;
8813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8814 opts_type = OPTS_TYPE_PT_GENERATE_BE
8815 | OPTS_TYPE_ST_ADD80;
8816 kern_type = KERN_TYPE_IKEPSK_SHA1;
8817 dgst_size = DGST_SIZE_4_5;
8818 parse_func = ikepsk_sha1_parse_hash;
8819 sort_by_digest = sort_by_digest_4_5;
8820 opti_type = OPTI_TYPE_ZERO_BYTE;
8821 dgst_pos0 = 3;
8822 dgst_pos1 = 4;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 1;
8825 break;
8826
8827 case 5500: hash_type = HASH_TYPE_NETNTLM;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE
8831 | OPTS_TYPE_PT_ADD80
8832 | OPTS_TYPE_PT_ADDBITS14
8833 | OPTS_TYPE_PT_UNICODE
8834 | OPTS_TYPE_ST_HEX;
8835 kern_type = KERN_TYPE_NETNTLMv1;
8836 dgst_size = DGST_SIZE_4_4;
8837 parse_func = netntlmv1_parse_hash;
8838 sort_by_digest = sort_by_digest_4_4;
8839 opti_type = OPTI_TYPE_ZERO_BYTE
8840 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8841 dgst_pos0 = 0;
8842 dgst_pos1 = 1;
8843 dgst_pos2 = 2;
8844 dgst_pos3 = 3;
8845 break;
8846
8847 case 5600: hash_type = HASH_TYPE_MD5;
8848 salt_type = SALT_TYPE_EMBEDDED;
8849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8850 opts_type = OPTS_TYPE_PT_GENERATE_LE
8851 | OPTS_TYPE_PT_ADD80
8852 | OPTS_TYPE_PT_ADDBITS14
8853 | OPTS_TYPE_PT_UNICODE;
8854 kern_type = KERN_TYPE_NETNTLMv2;
8855 dgst_size = DGST_SIZE_4_4;
8856 parse_func = netntlmv2_parse_hash;
8857 sort_by_digest = sort_by_digest_4_4;
8858 opti_type = OPTI_TYPE_ZERO_BYTE;
8859 dgst_pos0 = 0;
8860 dgst_pos1 = 3;
8861 dgst_pos2 = 2;
8862 dgst_pos3 = 1;
8863 break;
8864
8865 case 5700: hash_type = HASH_TYPE_SHA256;
8866 salt_type = SALT_TYPE_NONE;
8867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8868 opts_type = OPTS_TYPE_PT_GENERATE_BE
8869 | OPTS_TYPE_PT_ADD80
8870 | OPTS_TYPE_PT_ADDBITS15;
8871 kern_type = KERN_TYPE_SHA256;
8872 dgst_size = DGST_SIZE_4_8;
8873 parse_func = cisco4_parse_hash;
8874 sort_by_digest = sort_by_digest_4_8;
8875 opti_type = OPTI_TYPE_ZERO_BYTE
8876 | OPTI_TYPE_PRECOMPUTE_INIT
8877 | OPTI_TYPE_PRECOMPUTE_MERKLE
8878 | OPTI_TYPE_EARLY_SKIP
8879 | OPTI_TYPE_NOT_ITERATED
8880 | OPTI_TYPE_NOT_SALTED
8881 | OPTI_TYPE_RAW_HASH;
8882 dgst_pos0 = 3;
8883 dgst_pos1 = 7;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 6;
8886 break;
8887
8888 case 5800: hash_type = HASH_TYPE_SHA1;
8889 salt_type = SALT_TYPE_INTERN;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8892 | OPTS_TYPE_ST_ADD80;
8893 kern_type = KERN_TYPE_ANDROIDPIN;
8894 dgst_size = DGST_SIZE_4_5;
8895 parse_func = androidpin_parse_hash;
8896 sort_by_digest = sort_by_digest_4_5;
8897 opti_type = OPTI_TYPE_ZERO_BYTE;
8898 dgst_pos0 = 0;
8899 dgst_pos1 = 1;
8900 dgst_pos2 = 2;
8901 dgst_pos3 = 3;
8902 break;
8903
8904 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8905 salt_type = SALT_TYPE_NONE;
8906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8907 opts_type = OPTS_TYPE_PT_GENERATE_LE
8908 | OPTS_TYPE_PT_ADD80;
8909 kern_type = KERN_TYPE_RIPEMD160;
8910 dgst_size = DGST_SIZE_4_5;
8911 parse_func = ripemd160_parse_hash;
8912 sort_by_digest = sort_by_digest_4_5;
8913 opti_type = OPTI_TYPE_ZERO_BYTE;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 1;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 3;
8918 break;
8919
8920 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8921 salt_type = SALT_TYPE_NONE;
8922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_BE
8924 | OPTS_TYPE_PT_ADD80;
8925 kern_type = KERN_TYPE_WHIRLPOOL;
8926 dgst_size = DGST_SIZE_4_16;
8927 parse_func = whirlpool_parse_hash;
8928 sort_by_digest = sort_by_digest_4_16;
8929 opti_type = OPTI_TYPE_ZERO_BYTE;
8930 dgst_pos0 = 0;
8931 dgst_pos1 = 1;
8932 dgst_pos2 = 2;
8933 dgst_pos3 = 3;
8934 break;
8935
8936 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8937 salt_type = SALT_TYPE_EMBEDDED;
8938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8940 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8941 dgst_size = DGST_SIZE_4_5;
8942 parse_func = truecrypt_parse_hash_2k;
8943 sort_by_digest = sort_by_digest_4_5;
8944 opti_type = OPTI_TYPE_ZERO_BYTE;
8945 dgst_pos0 = 0;
8946 dgst_pos1 = 1;
8947 dgst_pos2 = 2;
8948 dgst_pos3 = 3;
8949 break;
8950
8951 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8952 salt_type = SALT_TYPE_EMBEDDED;
8953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8955 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8956 dgst_size = DGST_SIZE_4_5;
8957 parse_func = truecrypt_parse_hash_2k;
8958 sort_by_digest = sort_by_digest_4_5;
8959 opti_type = OPTI_TYPE_ZERO_BYTE;
8960 dgst_pos0 = 0;
8961 dgst_pos1 = 1;
8962 dgst_pos2 = 2;
8963 dgst_pos3 = 3;
8964 break;
8965
8966 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8967 salt_type = SALT_TYPE_EMBEDDED;
8968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8970 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8971 dgst_size = DGST_SIZE_4_5;
8972 parse_func = truecrypt_parse_hash_2k;
8973 sort_by_digest = sort_by_digest_4_5;
8974 opti_type = OPTI_TYPE_ZERO_BYTE;
8975 dgst_pos0 = 0;
8976 dgst_pos1 = 1;
8977 dgst_pos2 = 2;
8978 dgst_pos3 = 3;
8979 break;
8980
8981 case 6221: hash_type = HASH_TYPE_SHA512;
8982 salt_type = SALT_TYPE_EMBEDDED;
8983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8984 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8985 kern_type = KERN_TYPE_TCSHA512_XTS512;
8986 dgst_size = DGST_SIZE_8_8;
8987 parse_func = truecrypt_parse_hash_1k;
8988 sort_by_digest = sort_by_digest_8_8;
8989 opti_type = OPTI_TYPE_ZERO_BYTE
8990 | OPTI_TYPE_USES_BITS_64;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6222: hash_type = HASH_TYPE_SHA512;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9001 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9002 dgst_size = DGST_SIZE_8_8;
9003 parse_func = truecrypt_parse_hash_1k;
9004 sort_by_digest = sort_by_digest_8_8;
9005 opti_type = OPTI_TYPE_ZERO_BYTE
9006 | OPTI_TYPE_USES_BITS_64;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 1;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 3;
9011 break;
9012
9013 case 6223: hash_type = HASH_TYPE_SHA512;
9014 salt_type = SALT_TYPE_EMBEDDED;
9015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9017 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9018 dgst_size = DGST_SIZE_8_8;
9019 parse_func = truecrypt_parse_hash_1k;
9020 sort_by_digest = sort_by_digest_8_8;
9021 opti_type = OPTI_TYPE_ZERO_BYTE
9022 | OPTI_TYPE_USES_BITS_64;
9023 dgst_pos0 = 0;
9024 dgst_pos1 = 1;
9025 dgst_pos2 = 2;
9026 dgst_pos3 = 3;
9027 break;
9028
9029 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9030 salt_type = SALT_TYPE_EMBEDDED;
9031 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9032 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9033 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9034 dgst_size = DGST_SIZE_4_8;
9035 parse_func = truecrypt_parse_hash_1k;
9036 sort_by_digest = sort_by_digest_4_8;
9037 opti_type = OPTI_TYPE_ZERO_BYTE;
9038 dgst_pos0 = 0;
9039 dgst_pos1 = 1;
9040 dgst_pos2 = 2;
9041 dgst_pos3 = 3;
9042 break;
9043
9044 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9045 salt_type = SALT_TYPE_EMBEDDED;
9046 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9047 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9048 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9049 dgst_size = DGST_SIZE_4_8;
9050 parse_func = truecrypt_parse_hash_1k;
9051 sort_by_digest = sort_by_digest_4_8;
9052 opti_type = OPTI_TYPE_ZERO_BYTE;
9053 dgst_pos0 = 0;
9054 dgst_pos1 = 1;
9055 dgst_pos2 = 2;
9056 dgst_pos3 = 3;
9057 break;
9058
9059 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9060 salt_type = SALT_TYPE_EMBEDDED;
9061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9062 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9063 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9064 dgst_size = DGST_SIZE_4_8;
9065 parse_func = truecrypt_parse_hash_1k;
9066 sort_by_digest = sort_by_digest_4_8;
9067 opti_type = OPTI_TYPE_ZERO_BYTE;
9068 dgst_pos0 = 0;
9069 dgst_pos1 = 1;
9070 dgst_pos2 = 2;
9071 dgst_pos3 = 3;
9072 break;
9073
9074 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9075 salt_type = SALT_TYPE_EMBEDDED;
9076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9077 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9078 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9079 dgst_size = DGST_SIZE_4_5;
9080 parse_func = truecrypt_parse_hash_1k;
9081 sort_by_digest = sort_by_digest_4_5;
9082 opti_type = OPTI_TYPE_ZERO_BYTE;
9083 dgst_pos0 = 0;
9084 dgst_pos1 = 1;
9085 dgst_pos2 = 2;
9086 dgst_pos3 = 3;
9087 break;
9088
9089 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9090 salt_type = SALT_TYPE_EMBEDDED;
9091 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9092 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9093 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9094 dgst_size = DGST_SIZE_4_5;
9095 parse_func = truecrypt_parse_hash_1k;
9096 sort_by_digest = sort_by_digest_4_5;
9097 opti_type = OPTI_TYPE_ZERO_BYTE;
9098 dgst_pos0 = 0;
9099 dgst_pos1 = 1;
9100 dgst_pos2 = 2;
9101 dgst_pos3 = 3;
9102 break;
9103
9104 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9105 salt_type = SALT_TYPE_EMBEDDED;
9106 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9107 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9108 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9109 dgst_size = DGST_SIZE_4_5;
9110 parse_func = truecrypt_parse_hash_1k;
9111 sort_by_digest = sort_by_digest_4_5;
9112 opti_type = OPTI_TYPE_ZERO_BYTE;
9113 dgst_pos0 = 0;
9114 dgst_pos1 = 1;
9115 dgst_pos2 = 2;
9116 dgst_pos3 = 3;
9117 break;
9118
9119 case 6300: hash_type = HASH_TYPE_MD5;
9120 salt_type = SALT_TYPE_EMBEDDED;
9121 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9122 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9123 kern_type = KERN_TYPE_MD5AIX;
9124 dgst_size = DGST_SIZE_4_4;
9125 parse_func = md5aix_parse_hash;
9126 sort_by_digest = sort_by_digest_4_4;
9127 opti_type = OPTI_TYPE_ZERO_BYTE;
9128 dgst_pos0 = 0;
9129 dgst_pos1 = 1;
9130 dgst_pos2 = 2;
9131 dgst_pos3 = 3;
9132 break;
9133
9134 case 6400: hash_type = HASH_TYPE_SHA256;
9135 salt_type = SALT_TYPE_EMBEDDED;
9136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9138 kern_type = KERN_TYPE_SHA256AIX;
9139 dgst_size = DGST_SIZE_4_8;
9140 parse_func = sha256aix_parse_hash;
9141 sort_by_digest = sort_by_digest_4_8;
9142 opti_type = OPTI_TYPE_ZERO_BYTE;
9143 dgst_pos0 = 0;
9144 dgst_pos1 = 1;
9145 dgst_pos2 = 2;
9146 dgst_pos3 = 3;
9147 break;
9148
9149 case 6500: hash_type = HASH_TYPE_SHA512;
9150 salt_type = SALT_TYPE_EMBEDDED;
9151 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9152 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9153 kern_type = KERN_TYPE_SHA512AIX;
9154 dgst_size = DGST_SIZE_8_8;
9155 parse_func = sha512aix_parse_hash;
9156 sort_by_digest = sort_by_digest_8_8;
9157 opti_type = OPTI_TYPE_ZERO_BYTE
9158 | OPTI_TYPE_USES_BITS_64;
9159 dgst_pos0 = 0;
9160 dgst_pos1 = 1;
9161 dgst_pos2 = 2;
9162 dgst_pos3 = 3;
9163 break;
9164
9165 case 6600: hash_type = HASH_TYPE_AES;
9166 salt_type = SALT_TYPE_EMBEDDED;
9167 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9168 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9169 kern_type = KERN_TYPE_AGILEKEY;
9170 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9171 parse_func = agilekey_parse_hash;
9172 sort_by_digest = sort_by_digest_4_5;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 0;
9175 dgst_pos1 = 1;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 3;
9178 break;
9179
9180 case 6700: hash_type = HASH_TYPE_SHA1;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9184 kern_type = KERN_TYPE_SHA1AIX;
9185 dgst_size = DGST_SIZE_4_5;
9186 parse_func = sha1aix_parse_hash;
9187 sort_by_digest = sort_by_digest_4_5;
9188 opti_type = OPTI_TYPE_ZERO_BYTE;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 6800: hash_type = HASH_TYPE_AES;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9199 kern_type = KERN_TYPE_LASTPASS;
9200 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9201 parse_func = lastpass_parse_hash;
9202 sort_by_digest = sort_by_digest_4_8;
9203 opti_type = OPTI_TYPE_ZERO_BYTE;
9204 dgst_pos0 = 0;
9205 dgst_pos1 = 1;
9206 dgst_pos2 = 2;
9207 dgst_pos3 = 3;
9208 break;
9209
9210 case 6900: hash_type = HASH_TYPE_GOST;
9211 salt_type = SALT_TYPE_NONE;
9212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9213 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9214 kern_type = KERN_TYPE_GOST;
9215 dgst_size = DGST_SIZE_4_8;
9216 parse_func = gost_parse_hash;
9217 sort_by_digest = sort_by_digest_4_8;
9218 opti_type = OPTI_TYPE_ZERO_BYTE;
9219 dgst_pos0 = 0;
9220 dgst_pos1 = 1;
9221 dgst_pos2 = 2;
9222 dgst_pos3 = 3;
9223 break;
9224
9225 case 7100: hash_type = HASH_TYPE_SHA512;
9226 salt_type = SALT_TYPE_EMBEDDED;
9227 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9228 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9229 kern_type = KERN_TYPE_PBKDF2_SHA512;
9230 dgst_size = DGST_SIZE_8_16;
9231 parse_func = sha512osx_parse_hash;
9232 sort_by_digest = sort_by_digest_8_16;
9233 opti_type = OPTI_TYPE_ZERO_BYTE
9234 | OPTI_TYPE_USES_BITS_64
9235 | OPTI_TYPE_SLOW_HASH_SIMD;
9236 dgst_pos0 = 0;
9237 dgst_pos1 = 1;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 3;
9240 break;
9241
9242 case 7200: hash_type = HASH_TYPE_SHA512;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9246 kern_type = KERN_TYPE_PBKDF2_SHA512;
9247 dgst_size = DGST_SIZE_8_16;
9248 parse_func = sha512grub_parse_hash;
9249 sort_by_digest = sort_by_digest_8_16;
9250 opti_type = OPTI_TYPE_ZERO_BYTE
9251 | OPTI_TYPE_USES_BITS_64
9252 | OPTI_TYPE_SLOW_HASH_SIMD;
9253 dgst_pos0 = 0;
9254 dgst_pos1 = 1;
9255 dgst_pos2 = 2;
9256 dgst_pos3 = 3;
9257 break;
9258
9259 case 7300: hash_type = HASH_TYPE_SHA1;
9260 salt_type = SALT_TYPE_EMBEDDED;
9261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9262 opts_type = OPTS_TYPE_PT_GENERATE_BE
9263 | OPTS_TYPE_ST_ADD80
9264 | OPTS_TYPE_ST_ADDBITS15;
9265 kern_type = KERN_TYPE_RAKP;
9266 dgst_size = DGST_SIZE_4_5;
9267 parse_func = rakp_parse_hash;
9268 sort_by_digest = sort_by_digest_4_5;
9269 opti_type = OPTI_TYPE_ZERO_BYTE
9270 | OPTI_TYPE_NOT_ITERATED;
9271 dgst_pos0 = 3;
9272 dgst_pos1 = 4;
9273 dgst_pos2 = 2;
9274 dgst_pos3 = 1;
9275 break;
9276
9277 case 7400: hash_type = HASH_TYPE_SHA256;
9278 salt_type = SALT_TYPE_EMBEDDED;
9279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9280 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9281 kern_type = KERN_TYPE_SHA256CRYPT;
9282 dgst_size = DGST_SIZE_4_8;
9283 parse_func = sha256crypt_parse_hash;
9284 sort_by_digest = sort_by_digest_4_8;
9285 opti_type = OPTI_TYPE_ZERO_BYTE;
9286 dgst_pos0 = 0;
9287 dgst_pos1 = 1;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 3;
9290 break;
9291
9292 case 7500: hash_type = HASH_TYPE_KRB5PA;
9293 salt_type = SALT_TYPE_EMBEDDED;
9294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9296 kern_type = KERN_TYPE_KRB5PA;
9297 dgst_size = DGST_SIZE_4_4;
9298 parse_func = krb5pa_parse_hash;
9299 sort_by_digest = sort_by_digest_4_4;
9300 opti_type = OPTI_TYPE_ZERO_BYTE
9301 | OPTI_TYPE_NOT_ITERATED;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 7600: hash_type = HASH_TYPE_SHA1;
9309 salt_type = SALT_TYPE_INTERN;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_BE
9312 | OPTS_TYPE_PT_ADD80
9313 | OPTS_TYPE_PT_ADDBITS15;
9314 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9315 dgst_size = DGST_SIZE_4_5;
9316 parse_func = redmine_parse_hash;
9317 sort_by_digest = sort_by_digest_4_5;
9318 opti_type = OPTI_TYPE_ZERO_BYTE
9319 | OPTI_TYPE_PRECOMPUTE_INIT
9320 | OPTI_TYPE_EARLY_SKIP
9321 | OPTI_TYPE_NOT_ITERATED
9322 | OPTI_TYPE_PREPENDED_SALT;
9323 dgst_pos0 = 3;
9324 dgst_pos1 = 4;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 1;
9327 break;
9328
9329 case 7700: hash_type = HASH_TYPE_SAPB;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE
9333 | OPTS_TYPE_PT_UPPER
9334 | OPTS_TYPE_ST_UPPER;
9335 kern_type = KERN_TYPE_SAPB;
9336 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9337 parse_func = sapb_parse_hash;
9338 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9339 opti_type = OPTI_TYPE_ZERO_BYTE
9340 | OPTI_TYPE_PRECOMPUTE_INIT
9341 | OPTI_TYPE_NOT_ITERATED;
9342 dgst_pos0 = 0;
9343 dgst_pos1 = 1;
9344 dgst_pos2 = 2;
9345 dgst_pos3 = 3;
9346 break;
9347
9348 case 7800: hash_type = HASH_TYPE_SAPG;
9349 salt_type = SALT_TYPE_EMBEDDED;
9350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9351 opts_type = OPTS_TYPE_PT_GENERATE_BE
9352 | OPTS_TYPE_ST_ADD80
9353 | OPTS_TYPE_ST_UPPER;
9354 kern_type = KERN_TYPE_SAPG;
9355 dgst_size = DGST_SIZE_4_5;
9356 parse_func = sapg_parse_hash;
9357 sort_by_digest = sort_by_digest_4_5;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_PRECOMPUTE_INIT
9360 | OPTI_TYPE_NOT_ITERATED;
9361 dgst_pos0 = 3;
9362 dgst_pos1 = 4;
9363 dgst_pos2 = 2;
9364 dgst_pos3 = 1;
9365 break;
9366
9367 case 7900: hash_type = HASH_TYPE_SHA512;
9368 salt_type = SALT_TYPE_EMBEDDED;
9369 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9370 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9371 kern_type = KERN_TYPE_DRUPAL7;
9372 dgst_size = DGST_SIZE_8_8;
9373 parse_func = drupal7_parse_hash;
9374 sort_by_digest = sort_by_digest_8_8;
9375 opti_type = OPTI_TYPE_ZERO_BYTE
9376 | OPTI_TYPE_USES_BITS_64;
9377 dgst_pos0 = 0;
9378 dgst_pos1 = 1;
9379 dgst_pos2 = 2;
9380 dgst_pos3 = 3;
9381 break;
9382
9383 case 8000: hash_type = HASH_TYPE_SHA256;
9384 salt_type = SALT_TYPE_EMBEDDED;
9385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9386 opts_type = OPTS_TYPE_PT_GENERATE_BE
9387 | OPTS_TYPE_PT_UNICODE
9388 | OPTS_TYPE_ST_ADD80
9389 | OPTS_TYPE_ST_HEX;
9390 kern_type = KERN_TYPE_SYBASEASE;
9391 dgst_size = DGST_SIZE_4_8;
9392 parse_func = sybasease_parse_hash;
9393 sort_by_digest = sort_by_digest_4_8;
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_PRECOMPUTE_INIT
9396 | OPTI_TYPE_EARLY_SKIP
9397 | OPTI_TYPE_NOT_ITERATED
9398 | OPTI_TYPE_RAW_HASH;
9399 dgst_pos0 = 3;
9400 dgst_pos1 = 7;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 6;
9403 break;
9404
9405 case 8100: hash_type = HASH_TYPE_SHA1;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9409 kern_type = KERN_TYPE_NETSCALER;
9410 dgst_size = DGST_SIZE_4_5;
9411 parse_func = netscaler_parse_hash;
9412 sort_by_digest = sort_by_digest_4_5;
9413 opti_type = OPTI_TYPE_ZERO_BYTE
9414 | OPTI_TYPE_PRECOMPUTE_INIT
9415 | OPTI_TYPE_PRECOMPUTE_MERKLE
9416 | OPTI_TYPE_EARLY_SKIP
9417 | OPTI_TYPE_NOT_ITERATED
9418 | OPTI_TYPE_PREPENDED_SALT
9419 | OPTI_TYPE_RAW_HASH;
9420 dgst_pos0 = 3;
9421 dgst_pos1 = 4;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 1;
9424 break;
9425
9426 case 8200: hash_type = HASH_TYPE_SHA256;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9430 kern_type = KERN_TYPE_CLOUDKEY;
9431 dgst_size = DGST_SIZE_4_8;
9432 parse_func = cloudkey_parse_hash;
9433 sort_by_digest = sort_by_digest_4_8;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 8300: hash_type = HASH_TYPE_SHA1;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_BE
9445 | OPTS_TYPE_ST_HEX
9446 | OPTS_TYPE_ST_ADD80;
9447 kern_type = KERN_TYPE_NSEC3;
9448 dgst_size = DGST_SIZE_4_5;
9449 parse_func = nsec3_parse_hash;
9450 sort_by_digest = sort_by_digest_4_5;
9451 opti_type = OPTI_TYPE_ZERO_BYTE;
9452 dgst_pos0 = 3;
9453 dgst_pos1 = 4;
9454 dgst_pos2 = 2;
9455 dgst_pos3 = 1;
9456 break;
9457
9458 case 8400: hash_type = HASH_TYPE_SHA1;
9459 salt_type = SALT_TYPE_INTERN;
9460 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9461 opts_type = OPTS_TYPE_PT_GENERATE_BE
9462 | OPTS_TYPE_PT_ADD80
9463 | OPTS_TYPE_PT_ADDBITS15;
9464 kern_type = KERN_TYPE_WBB3;
9465 dgst_size = DGST_SIZE_4_5;
9466 parse_func = wbb3_parse_hash;
9467 sort_by_digest = sort_by_digest_4_5;
9468 opti_type = OPTI_TYPE_ZERO_BYTE
9469 | OPTI_TYPE_PRECOMPUTE_INIT
9470 | OPTI_TYPE_NOT_ITERATED;
9471 dgst_pos0 = 3;
9472 dgst_pos1 = 4;
9473 dgst_pos2 = 2;
9474 dgst_pos3 = 1;
9475 break;
9476
9477 case 8500: hash_type = HASH_TYPE_DESRACF;
9478 salt_type = SALT_TYPE_EMBEDDED;
9479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9480 opts_type = OPTS_TYPE_PT_GENERATE_LE
9481 | OPTS_TYPE_ST_UPPER;
9482 kern_type = KERN_TYPE_RACF;
9483 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9484 parse_func = racf_parse_hash;
9485 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9486 opti_type = OPTI_TYPE_ZERO_BYTE
9487 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9488 dgst_pos0 = 0;
9489 dgst_pos1 = 1;
9490 dgst_pos2 = 2;
9491 dgst_pos3 = 3;
9492 break;
9493
9494 case 8600: hash_type = HASH_TYPE_LOTUS5;
9495 salt_type = SALT_TYPE_NONE;
9496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9498 kern_type = KERN_TYPE_LOTUS5;
9499 dgst_size = DGST_SIZE_4_4;
9500 parse_func = lotus5_parse_hash;
9501 sort_by_digest = sort_by_digest_4_4;
9502 opti_type = OPTI_TYPE_EARLY_SKIP
9503 | OPTI_TYPE_NOT_ITERATED
9504 | OPTI_TYPE_NOT_SALTED
9505 | OPTI_TYPE_RAW_HASH;
9506 dgst_pos0 = 0;
9507 dgst_pos1 = 1;
9508 dgst_pos2 = 2;
9509 dgst_pos3 = 3;
9510 break;
9511
9512 case 8700: hash_type = HASH_TYPE_LOTUS6;
9513 salt_type = SALT_TYPE_EMBEDDED;
9514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9515 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9516 kern_type = KERN_TYPE_LOTUS6;
9517 dgst_size = DGST_SIZE_4_4;
9518 parse_func = lotus6_parse_hash;
9519 sort_by_digest = sort_by_digest_4_4;
9520 opti_type = OPTI_TYPE_EARLY_SKIP
9521 | OPTI_TYPE_NOT_ITERATED
9522 | OPTI_TYPE_RAW_HASH;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_ANDROIDFDE;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = androidfde_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 8900: hash_type = HASH_TYPE_SCRYPT;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9548 kern_type = KERN_TYPE_SCRYPT;
9549 dgst_size = DGST_SIZE_4_8;
9550 parse_func = scrypt_parse_hash;
9551 sort_by_digest = sort_by_digest_4_8;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9000: hash_type = HASH_TYPE_SHA1;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_ST_GENERATE_LE;
9564 kern_type = KERN_TYPE_PSAFE2;
9565 dgst_size = DGST_SIZE_4_5;
9566 parse_func = psafe2_parse_hash;
9567 sort_by_digest = sort_by_digest_4_5;
9568 opti_type = OPTI_TYPE_ZERO_BYTE;
9569 dgst_pos0 = 0;
9570 dgst_pos1 = 1;
9571 dgst_pos2 = 2;
9572 dgst_pos3 = 3;
9573 break;
9574
9575 case 9100: hash_type = HASH_TYPE_LOTUS8;
9576 salt_type = SALT_TYPE_EMBEDDED;
9577 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9579 kern_type = KERN_TYPE_LOTUS8;
9580 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9581 parse_func = lotus8_parse_hash;
9582 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9583 opti_type = OPTI_TYPE_ZERO_BYTE;
9584 dgst_pos0 = 0;
9585 dgst_pos1 = 1;
9586 dgst_pos2 = 2;
9587 dgst_pos3 = 3;
9588 break;
9589
9590 case 9200: hash_type = HASH_TYPE_SHA256;
9591 salt_type = SALT_TYPE_EMBEDDED;
9592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9593 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9594 kern_type = KERN_TYPE_PBKDF2_SHA256;
9595 dgst_size = DGST_SIZE_4_32;
9596 parse_func = cisco8_parse_hash;
9597 sort_by_digest = sort_by_digest_4_32;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_SLOW_HASH_SIMD;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 9300: hash_type = HASH_TYPE_SCRYPT;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9610 kern_type = KERN_TYPE_SCRYPT;
9611 dgst_size = DGST_SIZE_4_8;
9612 parse_func = cisco9_parse_hash;
9613 sort_by_digest = sort_by_digest_4_8;
9614 opti_type = OPTI_TYPE_ZERO_BYTE;
9615 dgst_pos0 = 0;
9616 dgst_pos1 = 1;
9617 dgst_pos2 = 2;
9618 dgst_pos3 = 3;
9619 break;
9620
9621 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9622 salt_type = SALT_TYPE_EMBEDDED;
9623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9625 kern_type = KERN_TYPE_OFFICE2007;
9626 dgst_size = DGST_SIZE_4_4;
9627 parse_func = office2007_parse_hash;
9628 sort_by_digest = sort_by_digest_4_4;
9629 opti_type = OPTI_TYPE_ZERO_BYTE;
9630 dgst_pos0 = 0;
9631 dgst_pos1 = 1;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 3;
9634 break;
9635
9636 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9640 kern_type = KERN_TYPE_OFFICE2010;
9641 dgst_size = DGST_SIZE_4_4;
9642 parse_func = office2010_parse_hash;
9643 sort_by_digest = sort_by_digest_4_4;
9644 opti_type = OPTI_TYPE_ZERO_BYTE;
9645 dgst_pos0 = 0;
9646 dgst_pos1 = 1;
9647 dgst_pos2 = 2;
9648 dgst_pos3 = 3;
9649 break;
9650
9651 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9652 salt_type = SALT_TYPE_EMBEDDED;
9653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9654 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9655 kern_type = KERN_TYPE_OFFICE2013;
9656 dgst_size = DGST_SIZE_4_4;
9657 parse_func = office2013_parse_hash;
9658 sort_by_digest = sort_by_digest_4_4;
9659 opti_type = OPTI_TYPE_ZERO_BYTE;
9660 dgst_pos0 = 0;
9661 dgst_pos1 = 1;
9662 dgst_pos2 = 2;
9663 dgst_pos3 = 3;
9664 break;
9665
9666 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9667 salt_type = SALT_TYPE_EMBEDDED;
9668 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9669 opts_type = OPTS_TYPE_PT_GENERATE_LE
9670 | OPTS_TYPE_PT_ADD80
9671 | OPTS_TYPE_PT_UNICODE;
9672 kern_type = KERN_TYPE_OLDOFFICE01;
9673 dgst_size = DGST_SIZE_4_4;
9674 parse_func = oldoffice01_parse_hash;
9675 sort_by_digest = sort_by_digest_4_4;
9676 opti_type = OPTI_TYPE_ZERO_BYTE
9677 | OPTI_TYPE_PRECOMPUTE_INIT
9678 | OPTI_TYPE_NOT_ITERATED;
9679 dgst_pos0 = 0;
9680 dgst_pos1 = 1;
9681 dgst_pos2 = 2;
9682 dgst_pos3 = 3;
9683 break;
9684
9685 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9686 salt_type = SALT_TYPE_EMBEDDED;
9687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9688 opts_type = OPTS_TYPE_PT_GENERATE_LE
9689 | OPTS_TYPE_PT_ADD80;
9690 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9691 dgst_size = DGST_SIZE_4_4;
9692 parse_func = oldoffice01cm1_parse_hash;
9693 sort_by_digest = sort_by_digest_4_4;
9694 opti_type = OPTI_TYPE_ZERO_BYTE
9695 | OPTI_TYPE_PRECOMPUTE_INIT
9696 | OPTI_TYPE_NOT_ITERATED;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 1;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 3;
9701 break;
9702
9703 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_LE
9707 | OPTS_TYPE_PT_ADD80
9708 | OPTS_TYPE_PT_UNICODE
9709 | OPTS_TYPE_PT_NEVERCRACK;
9710 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9711 dgst_size = DGST_SIZE_4_4;
9712 parse_func = oldoffice01cm2_parse_hash;
9713 sort_by_digest = sort_by_digest_4_4;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_PRECOMPUTE_INIT
9716 | OPTI_TYPE_NOT_ITERATED;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_BE
9727 | OPTS_TYPE_PT_ADD80
9728 | OPTS_TYPE_PT_UNICODE;
9729 kern_type = KERN_TYPE_OLDOFFICE34;
9730 dgst_size = DGST_SIZE_4_4;
9731 parse_func = oldoffice34_parse_hash;
9732 sort_by_digest = sort_by_digest_4_4;
9733 opti_type = OPTI_TYPE_ZERO_BYTE
9734 | OPTI_TYPE_PRECOMPUTE_INIT
9735 | OPTI_TYPE_NOT_ITERATED;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 1;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 3;
9740 break;
9741
9742 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9746 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9747 dgst_size = DGST_SIZE_4_4;
9748 parse_func = oldoffice34cm1_parse_hash;
9749 sort_by_digest = sort_by_digest_4_4;
9750 opti_type = OPTI_TYPE_ZERO_BYTE
9751 | OPTI_TYPE_PRECOMPUTE_INIT
9752 | OPTI_TYPE_NOT_ITERATED;
9753 dgst_pos0 = 0;
9754 dgst_pos1 = 1;
9755 dgst_pos2 = 2;
9756 dgst_pos3 = 3;
9757 break;
9758
9759 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9760 salt_type = SALT_TYPE_EMBEDDED;
9761 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9762 opts_type = OPTS_TYPE_PT_GENERATE_BE
9763 | OPTS_TYPE_PT_ADD80
9764 | OPTS_TYPE_PT_UNICODE
9765 | OPTS_TYPE_PT_NEVERCRACK;
9766 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9767 dgst_size = DGST_SIZE_4_4;
9768 parse_func = oldoffice34cm2_parse_hash;
9769 sort_by_digest = sort_by_digest_4_4;
9770 opti_type = OPTI_TYPE_ZERO_BYTE
9771 | OPTI_TYPE_PRECOMPUTE_INIT
9772 | OPTI_TYPE_NOT_ITERATED;
9773 dgst_pos0 = 0;
9774 dgst_pos1 = 1;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 3;
9777 break;
9778
9779 case 9900: hash_type = HASH_TYPE_MD5;
9780 salt_type = SALT_TYPE_NONE;
9781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9783 kern_type = KERN_TYPE_RADMIN2;
9784 dgst_size = DGST_SIZE_4_4;
9785 parse_func = radmin2_parse_hash;
9786 sort_by_digest = sort_by_digest_4_4;
9787 opti_type = OPTI_TYPE_ZERO_BYTE
9788 | OPTI_TYPE_PRECOMPUTE_INIT
9789 | OPTI_TYPE_EARLY_SKIP
9790 | OPTI_TYPE_NOT_ITERATED
9791 | OPTI_TYPE_NOT_SALTED;
9792 dgst_pos0 = 0;
9793 dgst_pos1 = 3;
9794 dgst_pos2 = 2;
9795 dgst_pos3 = 1;
9796 break;
9797
9798 case 10000: hash_type = HASH_TYPE_SHA256;
9799 salt_type = SALT_TYPE_EMBEDDED;
9800 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9801 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9802 kern_type = KERN_TYPE_PBKDF2_SHA256;
9803 dgst_size = DGST_SIZE_4_32;
9804 parse_func = djangopbkdf2_parse_hash;
9805 sort_by_digest = sort_by_digest_4_32;
9806 opti_type = OPTI_TYPE_ZERO_BYTE
9807 | OPTI_TYPE_SLOW_HASH_SIMD;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 10100: hash_type = HASH_TYPE_SIPHASH;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9818 kern_type = KERN_TYPE_SIPHASH;
9819 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9820 parse_func = siphash_parse_hash;
9821 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_NOT_ITERATED
9824 | OPTI_TYPE_RAW_HASH;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 10200: hash_type = HASH_TYPE_MD5;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_LE
9835 | OPTS_TYPE_ST_ADD80
9836 | OPTS_TYPE_ST_ADDBITS14;
9837 kern_type = KERN_TYPE_HMACMD5_PW;
9838 dgst_size = DGST_SIZE_4_4;
9839 parse_func = crammd5_parse_hash;
9840 sort_by_digest = sort_by_digest_4_4;
9841 opti_type = OPTI_TYPE_ZERO_BYTE
9842 | OPTI_TYPE_NOT_ITERATED;
9843 dgst_pos0 = 0;
9844 dgst_pos1 = 3;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 1;
9847 break;
9848
9849 case 10300: hash_type = HASH_TYPE_SHA1;
9850 salt_type = SALT_TYPE_EMBEDDED;
9851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9853 kern_type = KERN_TYPE_SAPH_SHA1;
9854 dgst_size = DGST_SIZE_4_5;
9855 parse_func = saph_sha1_parse_hash;
9856 sort_by_digest = sort_by_digest_4_5;
9857 opti_type = OPTI_TYPE_ZERO_BYTE;
9858 dgst_pos0 = 0;
9859 dgst_pos1 = 1;
9860 dgst_pos2 = 2;
9861 dgst_pos3 = 3;
9862 break;
9863
9864 case 10400: hash_type = HASH_TYPE_PDFU16;
9865 salt_type = SALT_TYPE_EMBEDDED;
9866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9867 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9868 kern_type = KERN_TYPE_PDF11;
9869 dgst_size = DGST_SIZE_4_4;
9870 parse_func = pdf11_parse_hash;
9871 sort_by_digest = sort_by_digest_4_4;
9872 opti_type = OPTI_TYPE_ZERO_BYTE
9873 | OPTI_TYPE_NOT_ITERATED;
9874 dgst_pos0 = 0;
9875 dgst_pos1 = 1;
9876 dgst_pos2 = 2;
9877 dgst_pos3 = 3;
9878 break;
9879
9880 case 10410: hash_type = HASH_TYPE_PDFU16;
9881 salt_type = SALT_TYPE_EMBEDDED;
9882 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9884 kern_type = KERN_TYPE_PDF11CM1;
9885 dgst_size = DGST_SIZE_4_4;
9886 parse_func = pdf11cm1_parse_hash;
9887 sort_by_digest = sort_by_digest_4_4;
9888 opti_type = OPTI_TYPE_ZERO_BYTE
9889 | OPTI_TYPE_NOT_ITERATED;
9890 dgst_pos0 = 0;
9891 dgst_pos1 = 1;
9892 dgst_pos2 = 2;
9893 dgst_pos3 = 3;
9894 break;
9895
9896 case 10420: hash_type = HASH_TYPE_PDFU16;
9897 salt_type = SALT_TYPE_EMBEDDED;
9898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9900 kern_type = KERN_TYPE_PDF11CM2;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = pdf11cm2_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_NOT_ITERATED;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 1;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 3;
9910 break;
9911
9912 case 10500: hash_type = HASH_TYPE_PDFU16;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9916 kern_type = KERN_TYPE_PDF14;
9917 dgst_size = DGST_SIZE_4_4;
9918 parse_func = pdf14_parse_hash;
9919 sort_by_digest = sort_by_digest_4_4;
9920 opti_type = OPTI_TYPE_ZERO_BYTE
9921 | OPTI_TYPE_NOT_ITERATED;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 10600: hash_type = HASH_TYPE_SHA256;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_BE
9932 | OPTS_TYPE_ST_ADD80
9933 | OPTS_TYPE_ST_ADDBITS15
9934 | OPTS_TYPE_HASH_COPY;
9935 kern_type = KERN_TYPE_SHA256_PWSLT;
9936 dgst_size = DGST_SIZE_4_8;
9937 parse_func = pdf17l3_parse_hash;
9938 sort_by_digest = sort_by_digest_4_8;
9939 opti_type = OPTI_TYPE_ZERO_BYTE
9940 | OPTI_TYPE_PRECOMPUTE_INIT
9941 | OPTI_TYPE_PRECOMPUTE_MERKLE
9942 | OPTI_TYPE_EARLY_SKIP
9943 | OPTI_TYPE_NOT_ITERATED
9944 | OPTI_TYPE_APPENDED_SALT
9945 | OPTI_TYPE_RAW_HASH;
9946 dgst_pos0 = 3;
9947 dgst_pos1 = 7;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 6;
9950 break;
9951
9952 case 10700: hash_type = HASH_TYPE_PDFU32;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE
9956 | OPTS_TYPE_HASH_COPY;
9957 kern_type = KERN_TYPE_PDF17L8;
9958 dgst_size = DGST_SIZE_4_8;
9959 parse_func = pdf17l8_parse_hash;
9960 sort_by_digest = sort_by_digest_4_8;
9961 opti_type = OPTI_TYPE_ZERO_BYTE
9962 | OPTI_TYPE_NOT_ITERATED;
9963 dgst_pos0 = 0;
9964 dgst_pos1 = 1;
9965 dgst_pos2 = 2;
9966 dgst_pos3 = 3;
9967 break;
9968
9969 case 10800: hash_type = HASH_TYPE_SHA384;
9970 salt_type = SALT_TYPE_NONE;
9971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9972 opts_type = OPTS_TYPE_PT_GENERATE_BE
9973 | OPTS_TYPE_PT_ADD80
9974 | OPTS_TYPE_PT_ADDBITS15;
9975 kern_type = KERN_TYPE_SHA384;
9976 dgst_size = DGST_SIZE_8_8;
9977 parse_func = sha384_parse_hash;
9978 sort_by_digest = sort_by_digest_8_8;
9979 opti_type = OPTI_TYPE_ZERO_BYTE
9980 | OPTI_TYPE_PRECOMPUTE_INIT
9981 | OPTI_TYPE_PRECOMPUTE_MERKLE
9982 | OPTI_TYPE_EARLY_SKIP
9983 | OPTI_TYPE_NOT_ITERATED
9984 | OPTI_TYPE_NOT_SALTED
9985 | OPTI_TYPE_USES_BITS_64
9986 | OPTI_TYPE_RAW_HASH;
9987 dgst_pos0 = 6;
9988 dgst_pos1 = 7;
9989 dgst_pos2 = 4;
9990 dgst_pos3 = 5;
9991 break;
9992
9993 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9994 salt_type = SALT_TYPE_EMBEDDED;
9995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE
9997 | OPTS_TYPE_ST_BASE64
9998 | OPTS_TYPE_HASH_COPY;
9999 kern_type = KERN_TYPE_PBKDF2_SHA256;
10000 dgst_size = DGST_SIZE_4_32;
10001 parse_func = pbkdf2_sha256_parse_hash;
10002 sort_by_digest = sort_by_digest_4_32;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_SLOW_HASH_SIMD;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 11000: hash_type = HASH_TYPE_MD5;
10012 salt_type = SALT_TYPE_INTERN;
10013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE
10015 | OPTS_TYPE_PT_ADD80;
10016 kern_type = KERN_TYPE_PRESTASHOP;
10017 dgst_size = DGST_SIZE_4_4;
10018 parse_func = prestashop_parse_hash;
10019 sort_by_digest = sort_by_digest_4_4;
10020 opti_type = OPTI_TYPE_ZERO_BYTE
10021 | OPTI_TYPE_PRECOMPUTE_INIT
10022 | OPTI_TYPE_NOT_ITERATED
10023 | OPTI_TYPE_PREPENDED_SALT;
10024 dgst_pos0 = 0;
10025 dgst_pos1 = 3;
10026 dgst_pos2 = 2;
10027 dgst_pos3 = 1;
10028 break;
10029
10030 case 11100: hash_type = HASH_TYPE_MD5;
10031 salt_type = SALT_TYPE_EMBEDDED;
10032 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10033 opts_type = OPTS_TYPE_PT_GENERATE_LE
10034 | OPTS_TYPE_ST_ADD80;
10035 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10036 dgst_size = DGST_SIZE_4_4;
10037 parse_func = postgresql_auth_parse_hash;
10038 sort_by_digest = sort_by_digest_4_4;
10039 opti_type = OPTI_TYPE_ZERO_BYTE
10040 | OPTI_TYPE_PRECOMPUTE_INIT
10041 | OPTI_TYPE_PRECOMPUTE_MERKLE
10042 | OPTI_TYPE_EARLY_SKIP;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 3;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 1;
10047 break;
10048
10049 case 11200: hash_type = HASH_TYPE_SHA1;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_BE
10053 | OPTS_TYPE_PT_ADD80
10054 | OPTS_TYPE_ST_HEX;
10055 kern_type = KERN_TYPE_MYSQL_AUTH;
10056 dgst_size = DGST_SIZE_4_5;
10057 parse_func = mysql_auth_parse_hash;
10058 sort_by_digest = sort_by_digest_4_5;
10059 opti_type = OPTI_TYPE_ZERO_BYTE
10060 | OPTI_TYPE_EARLY_SKIP;
10061 dgst_pos0 = 3;
10062 dgst_pos1 = 4;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 1;
10065 break;
10066
10067 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE
10071 | OPTS_TYPE_ST_HEX
10072 | OPTS_TYPE_ST_ADD80;
10073 kern_type = KERN_TYPE_BITCOIN_WALLET;
10074 dgst_size = DGST_SIZE_4_4;
10075 parse_func = bitcoin_wallet_parse_hash;
10076 sort_by_digest = sort_by_digest_4_4;
10077 opti_type = OPTI_TYPE_ZERO_BYTE;
10078 dgst_pos0 = 0;
10079 dgst_pos1 = 1;
10080 dgst_pos2 = 2;
10081 dgst_pos3 = 3;
10082 break;
10083
10084 case 11400: hash_type = HASH_TYPE_MD5;
10085 salt_type = SALT_TYPE_EMBEDDED;
10086 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10087 opts_type = OPTS_TYPE_PT_GENERATE_LE
10088 | OPTS_TYPE_PT_ADD80
10089 | OPTS_TYPE_HASH_COPY;
10090 kern_type = KERN_TYPE_SIP_AUTH;
10091 dgst_size = DGST_SIZE_4_4;
10092 parse_func = sip_auth_parse_hash;
10093 sort_by_digest = sort_by_digest_4_4;
10094 opti_type = OPTI_TYPE_ZERO_BYTE;
10095 dgst_pos0 = 0;
10096 dgst_pos1 = 3;
10097 dgst_pos2 = 2;
10098 dgst_pos3 = 1;
10099 break;
10100
10101 case 11500: hash_type = HASH_TYPE_CRC32;
10102 salt_type = SALT_TYPE_INTERN;
10103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10104 opts_type = OPTS_TYPE_PT_GENERATE_LE
10105 | OPTS_TYPE_ST_GENERATE_LE
10106 | OPTS_TYPE_ST_HEX;
10107 kern_type = KERN_TYPE_CRC32;
10108 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10109 parse_func = crc32_parse_hash;
10110 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10111 opti_type = OPTI_TYPE_ZERO_BYTE;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 11600: hash_type = HASH_TYPE_AES;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_LE
10122 | OPTS_TYPE_PT_NEVERCRACK;
10123 kern_type = KERN_TYPE_SEVEN_ZIP;
10124 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10125 parse_func = seven_zip_parse_hash;
10126 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10127 opti_type = OPTI_TYPE_ZERO_BYTE;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10135 salt_type = SALT_TYPE_NONE;
10136 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE
10138 | OPTS_TYPE_PT_ADD01;
10139 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10140 dgst_size = DGST_SIZE_4_8;
10141 parse_func = gost2012sbog_256_parse_hash;
10142 sort_by_digest = sort_by_digest_4_8;
10143 opti_type = OPTI_TYPE_ZERO_BYTE;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10151 salt_type = SALT_TYPE_NONE;
10152 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE
10154 | OPTS_TYPE_PT_ADD01;
10155 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10156 dgst_size = DGST_SIZE_4_16;
10157 parse_func = gost2012sbog_512_parse_hash;
10158 sort_by_digest = sort_by_digest_4_16;
10159 opti_type = OPTI_TYPE_ZERO_BYTE;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10167 salt_type = SALT_TYPE_EMBEDDED;
10168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_LE
10170 | OPTS_TYPE_ST_BASE64
10171 | OPTS_TYPE_HASH_COPY;
10172 kern_type = KERN_TYPE_PBKDF2_MD5;
10173 dgst_size = DGST_SIZE_4_32;
10174 parse_func = pbkdf2_md5_parse_hash;
10175 sort_by_digest = sort_by_digest_4_32;
10176 opti_type = OPTI_TYPE_ZERO_BYTE
10177 | OPTI_TYPE_SLOW_HASH_SIMD;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_BASE64
10189 | OPTS_TYPE_HASH_COPY;
10190 kern_type = KERN_TYPE_PBKDF2_SHA1;
10191 dgst_size = DGST_SIZE_4_32;
10192 parse_func = pbkdf2_sha1_parse_hash;
10193 sort_by_digest = sort_by_digest_4_32;
10194 opti_type = OPTI_TYPE_ZERO_BYTE
10195 | OPTI_TYPE_SLOW_HASH_SIMD;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 1;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 3;
10200 break;
10201
10202 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE
10206 | OPTS_TYPE_ST_BASE64
10207 | OPTS_TYPE_HASH_COPY;
10208 kern_type = KERN_TYPE_PBKDF2_SHA512;
10209 dgst_size = DGST_SIZE_8_16;
10210 parse_func = pbkdf2_sha512_parse_hash;
10211 sort_by_digest = sort_by_digest_8_16;
10212 opti_type = OPTI_TYPE_ZERO_BYTE
10213 | OPTI_TYPE_USES_BITS_64
10214 | OPTI_TYPE_SLOW_HASH_SIMD;
10215 dgst_pos0 = 0;
10216 dgst_pos1 = 1;
10217 dgst_pos2 = 2;
10218 dgst_pos3 = 3;
10219 break;
10220
10221 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10222 salt_type = SALT_TYPE_EMBEDDED;
10223 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10224 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10225 kern_type = KERN_TYPE_ECRYPTFS;
10226 dgst_size = DGST_SIZE_8_8;
10227 parse_func = ecryptfs_parse_hash;
10228 sort_by_digest = sort_by_digest_8_8;
10229 opti_type = OPTI_TYPE_ZERO_BYTE
10230 | OPTI_TYPE_USES_BITS_64;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 12300: hash_type = HASH_TYPE_ORACLET;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_ORACLET;
10242 dgst_size = DGST_SIZE_8_16;
10243 parse_func = oraclet_parse_hash;
10244 sort_by_digest = sort_by_digest_8_16;
10245 opti_type = OPTI_TYPE_ZERO_BYTE
10246 | OPTI_TYPE_USES_BITS_64;
10247 dgst_pos0 = 0;
10248 dgst_pos1 = 1;
10249 dgst_pos2 = 2;
10250 dgst_pos3 = 3;
10251 break;
10252
10253 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10254 salt_type = SALT_TYPE_EMBEDDED;
10255 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10257 kern_type = KERN_TYPE_BSDICRYPT;
10258 dgst_size = DGST_SIZE_4_4;
10259 parse_func = bsdicrypt_parse_hash;
10260 sort_by_digest = sort_by_digest_4_4;
10261 opti_type = OPTI_TYPE_ZERO_BYTE
10262 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10263 dgst_pos0 = 0;
10264 dgst_pos1 = 1;
10265 dgst_pos2 = 2;
10266 dgst_pos3 = 3;
10267 break;
10268
10269 case 12500: hash_type = HASH_TYPE_RAR3HP;
10270 salt_type = SALT_TYPE_EMBEDDED;
10271 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10272 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10273 kern_type = KERN_TYPE_RAR3;
10274 dgst_size = DGST_SIZE_4_4;
10275 parse_func = rar3hp_parse_hash;
10276 sort_by_digest = sort_by_digest_4_4;
10277 opti_type = OPTI_TYPE_ZERO_BYTE;
10278 dgst_pos0 = 0;
10279 dgst_pos1 = 1;
10280 dgst_pos2 = 2;
10281 dgst_pos3 = 3;
10282 break;
10283
10284 case 12600: hash_type = HASH_TYPE_SHA256;
10285 salt_type = SALT_TYPE_INTERN;
10286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10287 opts_type = OPTS_TYPE_PT_GENERATE_BE
10288 | OPTS_TYPE_PT_ADD80;
10289 kern_type = KERN_TYPE_CF10;
10290 dgst_size = DGST_SIZE_4_8;
10291 parse_func = cf10_parse_hash;
10292 sort_by_digest = sort_by_digest_4_8;
10293 opti_type = OPTI_TYPE_ZERO_BYTE
10294 | OPTI_TYPE_PRECOMPUTE_INIT
10295 | OPTI_TYPE_EARLY_SKIP
10296 | OPTI_TYPE_NOT_ITERATED;
10297 dgst_pos0 = 3;
10298 dgst_pos1 = 7;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 6;
10301 break;
10302
10303 case 12700: hash_type = HASH_TYPE_AES;
10304 salt_type = SALT_TYPE_EMBEDDED;
10305 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_LE
10307 | OPTS_TYPE_HASH_COPY;
10308 kern_type = KERN_TYPE_MYWALLET;
10309 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10310 parse_func = mywallet_parse_hash;
10311 sort_by_digest = sort_by_digest_4_5;
10312 opti_type = OPTI_TYPE_ZERO_BYTE;
10313 dgst_pos0 = 0;
10314 dgst_pos1 = 1;
10315 dgst_pos2 = 2;
10316 dgst_pos3 = 3;
10317 break;
10318
10319 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10323 kern_type = KERN_TYPE_MS_DRSR;
10324 dgst_size = DGST_SIZE_4_8;
10325 parse_func = ms_drsr_parse_hash;
10326 sort_by_digest = sort_by_digest_4_8;
10327 opti_type = OPTI_TYPE_ZERO_BYTE;
10328 dgst_pos0 = 0;
10329 dgst_pos1 = 1;
10330 dgst_pos2 = 2;
10331 dgst_pos3 = 3;
10332 break;
10333
10334 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10335 salt_type = SALT_TYPE_EMBEDDED;
10336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10337 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10338 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10339 dgst_size = DGST_SIZE_4_8;
10340 parse_func = androidfde_samsung_parse_hash;
10341 sort_by_digest = sort_by_digest_4_8;
10342 opti_type = OPTI_TYPE_ZERO_BYTE;
10343 dgst_pos0 = 0;
10344 dgst_pos1 = 1;
10345 dgst_pos2 = 2;
10346 dgst_pos3 = 3;
10347 break;
10348
10349 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10350 salt_type = SALT_TYPE_EMBEDDED;
10351 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10352 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10353 kern_type = KERN_TYPE_RAR5;
10354 dgst_size = DGST_SIZE_4_4;
10355 parse_func = rar5_parse_hash;
10356 sort_by_digest = sort_by_digest_4_4;
10357 opti_type = OPTI_TYPE_ZERO_BYTE;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10365 salt_type = SALT_TYPE_EMBEDDED;
10366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10368 kern_type = KERN_TYPE_KRB5TGS;
10369 dgst_size = DGST_SIZE_4_4;
10370 parse_func = krb5tgs_parse_hash;
10371 sort_by_digest = sort_by_digest_4_4;
10372 opti_type = OPTI_TYPE_ZERO_BYTE
10373 | OPTI_TYPE_NOT_ITERATED;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 13200: hash_type = HASH_TYPE_AES;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_AXCRYPT;
10385 dgst_size = DGST_SIZE_4_4;
10386 parse_func = axcrypt_parse_hash;
10387 sort_by_digest = sort_by_digest_4_4;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 13300: hash_type = HASH_TYPE_SHA1;
10396 salt_type = SALT_TYPE_NONE;
10397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_BE
10399 | OPTS_TYPE_PT_ADD80
10400 | OPTS_TYPE_PT_ADDBITS15;
10401 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10402 dgst_size = DGST_SIZE_4_5;
10403 parse_func = sha1axcrypt_parse_hash;
10404 sort_by_digest = sort_by_digest_4_5;
10405 opti_type = OPTI_TYPE_ZERO_BYTE
10406 | OPTI_TYPE_PRECOMPUTE_INIT
10407 | OPTI_TYPE_EARLY_SKIP
10408 | OPTI_TYPE_NOT_ITERATED
10409 | OPTI_TYPE_NOT_SALTED;
10410 dgst_pos0 = 0;
10411 dgst_pos1 = 4;
10412 dgst_pos2 = 3;
10413 dgst_pos3 = 2;
10414 break;
10415
10416 case 13400: hash_type = HASH_TYPE_AES;
10417 salt_type = SALT_TYPE_EMBEDDED;
10418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10419 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10420 kern_type = KERN_TYPE_KEEPASS;
10421 dgst_size = DGST_SIZE_4_4;
10422 parse_func = keepass_parse_hash;
10423 sort_by_digest = sort_by_digest_4_4;
10424 opti_type = OPTI_TYPE_ZERO_BYTE;
10425 dgst_pos0 = 0;
10426 dgst_pos1 = 1;
10427 dgst_pos2 = 2;
10428 dgst_pos3 = 3;
10429 break;
10430
10431 case 13500: hash_type = HASH_TYPE_SHA1;
10432 salt_type = SALT_TYPE_EMBEDDED;
10433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10434 opts_type = OPTS_TYPE_PT_GENERATE_BE
10435 | OPTS_TYPE_PT_UNICODE
10436 | OPTS_TYPE_PT_ADD80;
10437 kern_type = KERN_TYPE_PSTOKEN;
10438 dgst_size = DGST_SIZE_4_5;
10439 parse_func = pstoken_parse_hash;
10440 sort_by_digest = sort_by_digest_4_5;
10441 opti_type = OPTI_TYPE_ZERO_BYTE
10442 | OPTI_TYPE_PRECOMPUTE_INIT
10443 | OPTI_TYPE_EARLY_SKIP
10444 | OPTI_TYPE_NOT_ITERATED
10445 | OPTI_TYPE_PREPENDED_SALT
10446 | OPTI_TYPE_RAW_HASH;
10447 dgst_pos0 = 3;
10448 dgst_pos1 = 4;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 1;
10451 break;
10452
10453 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10454 salt_type = SALT_TYPE_EMBEDDED;
10455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10457 kern_type = KERN_TYPE_ZIP2;
10458 dgst_size = DGST_SIZE_4_4;
10459 parse_func = zip2_parse_hash;
10460 sort_by_digest = sort_by_digest_4_4;
10461 opti_type = OPTI_TYPE_ZERO_BYTE;
10462 dgst_pos0 = 0;
10463 dgst_pos1 = 1;
10464 dgst_pos2 = 2;
10465 dgst_pos3 = 3;
10466 break;
10467
10468 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10469 salt_type = SALT_TYPE_EMBEDDED;
10470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10472 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10473 dgst_size = DGST_SIZE_4_5;
10474 parse_func = veracrypt_parse_hash_655331;
10475 sort_by_digest = sort_by_digest_4_5;
10476 opti_type = OPTI_TYPE_ZERO_BYTE;
10477 dgst_pos0 = 0;
10478 dgst_pos1 = 1;
10479 dgst_pos2 = 2;
10480 dgst_pos3 = 3;
10481 break;
10482
10483 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10484 salt_type = SALT_TYPE_EMBEDDED;
10485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10487 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10488 dgst_size = DGST_SIZE_4_5;
10489 parse_func = veracrypt_parse_hash_655331;
10490 sort_by_digest = sort_by_digest_4_5;
10491 opti_type = OPTI_TYPE_ZERO_BYTE;
10492 dgst_pos0 = 0;
10493 dgst_pos1 = 1;
10494 dgst_pos2 = 2;
10495 dgst_pos3 = 3;
10496 break;
10497
10498 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10499 salt_type = SALT_TYPE_EMBEDDED;
10500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10502 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10503 dgst_size = DGST_SIZE_4_5;
10504 parse_func = veracrypt_parse_hash_655331;
10505 sort_by_digest = sort_by_digest_4_5;
10506 opti_type = OPTI_TYPE_ZERO_BYTE;
10507 dgst_pos0 = 0;
10508 dgst_pos1 = 1;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 3;
10511 break;
10512
10513 case 13721: hash_type = HASH_TYPE_SHA512;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10517 kern_type = KERN_TYPE_TCSHA512_XTS512;
10518 dgst_size = DGST_SIZE_8_8;
10519 parse_func = veracrypt_parse_hash_500000;
10520 sort_by_digest = sort_by_digest_8_8;
10521 opti_type = OPTI_TYPE_ZERO_BYTE
10522 | OPTI_TYPE_USES_BITS_64;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13722: hash_type = HASH_TYPE_SHA512;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10533 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10534 dgst_size = DGST_SIZE_8_8;
10535 parse_func = veracrypt_parse_hash_500000;
10536 sort_by_digest = sort_by_digest_8_8;
10537 opti_type = OPTI_TYPE_ZERO_BYTE
10538 | OPTI_TYPE_USES_BITS_64;
10539 dgst_pos0 = 0;
10540 dgst_pos1 = 1;
10541 dgst_pos2 = 2;
10542 dgst_pos3 = 3;
10543 break;
10544
10545 case 13723: hash_type = HASH_TYPE_SHA512;
10546 salt_type = SALT_TYPE_EMBEDDED;
10547 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10548 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10549 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10550 dgst_size = DGST_SIZE_8_8;
10551 parse_func = veracrypt_parse_hash_500000;
10552 sort_by_digest = sort_by_digest_8_8;
10553 opti_type = OPTI_TYPE_ZERO_BYTE
10554 | OPTI_TYPE_USES_BITS_64;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10565 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10566 dgst_size = DGST_SIZE_4_8;
10567 parse_func = veracrypt_parse_hash_500000;
10568 sort_by_digest = sort_by_digest_4_8;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10580 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10581 dgst_size = DGST_SIZE_4_8;
10582 parse_func = veracrypt_parse_hash_500000;
10583 sort_by_digest = sort_by_digest_4_8;
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10592 salt_type = SALT_TYPE_EMBEDDED;
10593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10595 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10596 dgst_size = DGST_SIZE_4_8;
10597 parse_func = veracrypt_parse_hash_500000;
10598 sort_by_digest = sort_by_digest_4_8;
10599 opti_type = OPTI_TYPE_ZERO_BYTE;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10610 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10611 dgst_size = DGST_SIZE_4_5;
10612 parse_func = veracrypt_parse_hash_327661;
10613 sort_by_digest = sort_by_digest_4_5;
10614 opti_type = OPTI_TYPE_ZERO_BYTE;
10615 dgst_pos0 = 0;
10616 dgst_pos1 = 1;
10617 dgst_pos2 = 2;
10618 dgst_pos3 = 3;
10619 break;
10620
10621 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10622 salt_type = SALT_TYPE_EMBEDDED;
10623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10625 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10626 dgst_size = DGST_SIZE_4_5;
10627 parse_func = veracrypt_parse_hash_327661;
10628 sort_by_digest = sort_by_digest_4_5;
10629 opti_type = OPTI_TYPE_ZERO_BYTE;
10630 dgst_pos0 = 0;
10631 dgst_pos1 = 1;
10632 dgst_pos2 = 2;
10633 dgst_pos3 = 3;
10634 break;
10635
10636 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10637 salt_type = SALT_TYPE_EMBEDDED;
10638 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10639 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10640 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10641 dgst_size = DGST_SIZE_4_5;
10642 parse_func = veracrypt_parse_hash_327661;
10643 sort_by_digest = sort_by_digest_4_5;
10644 opti_type = OPTI_TYPE_ZERO_BYTE;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 13751: hash_type = HASH_TYPE_SHA256;
10652 salt_type = SALT_TYPE_EMBEDDED;
10653 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10655 kern_type = KERN_TYPE_VCSHA256_XTS512;
10656 dgst_size = DGST_SIZE_4_8;
10657 parse_func = veracrypt_parse_hash_500000;
10658 sort_by_digest = sort_by_digest_4_8;
10659 opti_type = OPTI_TYPE_ZERO_BYTE;
10660 dgst_pos0 = 0;
10661 dgst_pos1 = 1;
10662 dgst_pos2 = 2;
10663 dgst_pos3 = 3;
10664 break;
10665
10666 case 13752: hash_type = HASH_TYPE_SHA256;
10667 salt_type = SALT_TYPE_EMBEDDED;
10668 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10669 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10670 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10671 dgst_size = DGST_SIZE_4_8;
10672 parse_func = veracrypt_parse_hash_500000;
10673 sort_by_digest = sort_by_digest_4_8;
10674 opti_type = OPTI_TYPE_ZERO_BYTE;
10675 dgst_pos0 = 0;
10676 dgst_pos1 = 1;
10677 dgst_pos2 = 2;
10678 dgst_pos3 = 3;
10679 break;
10680
10681 case 13753: hash_type = HASH_TYPE_SHA256;
10682 salt_type = SALT_TYPE_EMBEDDED;
10683 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10684 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10685 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10686 dgst_size = DGST_SIZE_4_8;
10687 parse_func = veracrypt_parse_hash_500000;
10688 sort_by_digest = sort_by_digest_4_8;
10689 opti_type = OPTI_TYPE_ZERO_BYTE;
10690 dgst_pos0 = 0;
10691 dgst_pos1 = 1;
10692 dgst_pos2 = 2;
10693 dgst_pos3 = 3;
10694 break;
10695
10696 case 13761: hash_type = HASH_TYPE_SHA256;
10697 salt_type = SALT_TYPE_EMBEDDED;
10698 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10699 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10700 kern_type = KERN_TYPE_VCSHA256_XTS512;
10701 dgst_size = DGST_SIZE_4_8;
10702 parse_func = veracrypt_parse_hash_200000;
10703 sort_by_digest = sort_by_digest_4_8;
10704 opti_type = OPTI_TYPE_ZERO_BYTE;
10705 dgst_pos0 = 0;
10706 dgst_pos1 = 1;
10707 dgst_pos2 = 2;
10708 dgst_pos3 = 3;
10709 break;
10710
10711 case 13762: hash_type = HASH_TYPE_SHA256;
10712 salt_type = SALT_TYPE_EMBEDDED;
10713 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10714 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10715 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10716 dgst_size = DGST_SIZE_4_8;
10717 parse_func = veracrypt_parse_hash_200000;
10718 sort_by_digest = sort_by_digest_4_8;
10719 opti_type = OPTI_TYPE_ZERO_BYTE;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 13763: hash_type = HASH_TYPE_SHA256;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10730 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10731 dgst_size = DGST_SIZE_4_8;
10732 parse_func = veracrypt_parse_hash_200000;
10733 sort_by_digest = sort_by_digest_4_8;
10734 opti_type = OPTI_TYPE_ZERO_BYTE;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741
10742 default: usage_mini_print (PROGNAME); return (-1);
10743 }
10744
10745 /**
10746 * parser
10747 */
10748
10749 data.parse_func = parse_func;
10750
10751 /**
10752 * misc stuff
10753 */
10754
10755 if (hex_salt)
10756 {
10757 if (salt_type == SALT_TYPE_INTERN)
10758 {
10759 opts_type |= OPTS_TYPE_ST_HEX;
10760 }
10761 else
10762 {
10763 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10764
10765 return (-1);
10766 }
10767 }
10768
10769 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10770 | (salt_type == SALT_TYPE_EXTERN)
10771 | (salt_type == SALT_TYPE_EMBEDDED)
10772 | (salt_type == SALT_TYPE_VIRTUAL));
10773
10774 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10775
10776 data.hash_type = hash_type;
10777 data.attack_mode = attack_mode;
10778 data.attack_kern = attack_kern;
10779 data.attack_exec = attack_exec;
10780 data.kern_type = kern_type;
10781 data.opts_type = opts_type;
10782 data.dgst_size = dgst_size;
10783 data.salt_type = salt_type;
10784 data.isSalted = isSalted;
10785 data.sort_by_digest = sort_by_digest;
10786 data.dgst_pos0 = dgst_pos0;
10787 data.dgst_pos1 = dgst_pos1;
10788 data.dgst_pos2 = dgst_pos2;
10789 data.dgst_pos3 = dgst_pos3;
10790
10791 esalt_size = 0;
10792
10793 switch (hash_mode)
10794 {
10795 case 2500: esalt_size = sizeof (wpa_t); break;
10796 case 5300: esalt_size = sizeof (ikepsk_t); break;
10797 case 5400: esalt_size = sizeof (ikepsk_t); break;
10798 case 5500: esalt_size = sizeof (netntlm_t); break;
10799 case 5600: esalt_size = sizeof (netntlm_t); break;
10800 case 6211: esalt_size = sizeof (tc_t); break;
10801 case 6212: esalt_size = sizeof (tc_t); break;
10802 case 6213: esalt_size = sizeof (tc_t); break;
10803 case 6221: esalt_size = sizeof (tc_t); break;
10804 case 6222: esalt_size = sizeof (tc_t); break;
10805 case 6223: esalt_size = sizeof (tc_t); break;
10806 case 6231: esalt_size = sizeof (tc_t); break;
10807 case 6232: esalt_size = sizeof (tc_t); break;
10808 case 6233: esalt_size = sizeof (tc_t); break;
10809 case 6241: esalt_size = sizeof (tc_t); break;
10810 case 6242: esalt_size = sizeof (tc_t); break;
10811 case 6243: esalt_size = sizeof (tc_t); break;
10812 case 6600: esalt_size = sizeof (agilekey_t); break;
10813 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10814 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10815 case 7300: esalt_size = sizeof (rakp_t); break;
10816 case 7500: esalt_size = sizeof (krb5pa_t); break;
10817 case 8200: esalt_size = sizeof (cloudkey_t); break;
10818 case 8800: esalt_size = sizeof (androidfde_t); break;
10819 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10820 case 9400: esalt_size = sizeof (office2007_t); break;
10821 case 9500: esalt_size = sizeof (office2010_t); break;
10822 case 9600: esalt_size = sizeof (office2013_t); break;
10823 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10824 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10825 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10826 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10827 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10828 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10829 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10830 case 10200: esalt_size = sizeof (cram_md5_t); break;
10831 case 10400: esalt_size = sizeof (pdf_t); break;
10832 case 10410: esalt_size = sizeof (pdf_t); break;
10833 case 10420: esalt_size = sizeof (pdf_t); break;
10834 case 10500: esalt_size = sizeof (pdf_t); break;
10835 case 10600: esalt_size = sizeof (pdf_t); break;
10836 case 10700: esalt_size = sizeof (pdf_t); break;
10837 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10838 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10839 case 11400: esalt_size = sizeof (sip_t); break;
10840 case 11600: esalt_size = sizeof (seven_zip_t); break;
10841 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10842 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10843 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10844 case 13000: esalt_size = sizeof (rar5_t); break;
10845 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10846 case 13400: esalt_size = sizeof (keepass_t); break;
10847 case 13500: esalt_size = sizeof (pstoken_t); break;
10848 case 13600: esalt_size = sizeof (zip2_t); break;
10849 case 13711: esalt_size = sizeof (tc_t); break;
10850 case 13712: esalt_size = sizeof (tc_t); break;
10851 case 13713: esalt_size = sizeof (tc_t); break;
10852 case 13721: esalt_size = sizeof (tc_t); break;
10853 case 13722: esalt_size = sizeof (tc_t); break;
10854 case 13723: esalt_size = sizeof (tc_t); break;
10855 case 13731: esalt_size = sizeof (tc_t); break;
10856 case 13732: esalt_size = sizeof (tc_t); break;
10857 case 13733: esalt_size = sizeof (tc_t); break;
10858 case 13741: esalt_size = sizeof (tc_t); break;
10859 case 13742: esalt_size = sizeof (tc_t); break;
10860 case 13743: esalt_size = sizeof (tc_t); break;
10861 case 13751: esalt_size = sizeof (tc_t); break;
10862 case 13752: esalt_size = sizeof (tc_t); break;
10863 case 13753: esalt_size = sizeof (tc_t); break;
10864 case 13761: esalt_size = sizeof (tc_t); break;
10865 case 13762: esalt_size = sizeof (tc_t); break;
10866 case 13763: esalt_size = sizeof (tc_t); break;
10867 }
10868
10869 data.esalt_size = esalt_size;
10870
10871 /**
10872 * choose dictionary parser
10873 */
10874
10875 if (hash_type == HASH_TYPE_LM)
10876 {
10877 get_next_word_func = get_next_word_lm;
10878 }
10879 else if (opts_type & OPTS_TYPE_PT_UPPER)
10880 {
10881 get_next_word_func = get_next_word_uc;
10882 }
10883 else
10884 {
10885 get_next_word_func = get_next_word_std;
10886 }
10887
10888 /**
10889 * dictstat
10890 */
10891
10892 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10893
10894 #ifdef _POSIX
10895 size_t dictstat_nmemb = 0;
10896 #endif
10897
10898 #ifdef _WIN
10899 uint dictstat_nmemb = 0;
10900 #endif
10901
10902 char dictstat[256] = { 0 };
10903
10904 FILE *dictstat_fp = NULL;
10905
10906 if (keyspace == 0)
10907 {
10908 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10909
10910 dictstat_fp = fopen (dictstat, "rb");
10911
10912 if (dictstat_fp)
10913 {
10914 #ifdef _POSIX
10915 struct stat tmpstat;
10916
10917 fstat (fileno (dictstat_fp), &tmpstat);
10918 #endif
10919
10920 #ifdef _WIN
10921 struct stat64 tmpstat;
10922
10923 _fstat64 (fileno (dictstat_fp), &tmpstat);
10924 #endif
10925
10926 if (tmpstat.st_mtime < COMPTIME)
10927 {
10928 /* with v0.15 the format changed so we have to ensure user is using a good version
10929 since there is no version-header in the dictstat file */
10930
10931 fclose (dictstat_fp);
10932
10933 unlink (dictstat);
10934 }
10935 else
10936 {
10937 while (!feof (dictstat_fp))
10938 {
10939 dictstat_t d;
10940
10941 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10942
10943 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10944
10945 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10946 {
10947 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10948
10949 return -1;
10950 }
10951 }
10952
10953 fclose (dictstat_fp);
10954 }
10955 }
10956 }
10957
10958 /**
10959 * potfile
10960 */
10961
10962 char potfile[256] = { 0 };
10963
10964 if (potfile_path == NULL)
10965 {
10966 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10967 }
10968 else
10969 {
10970 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10971 }
10972
10973 data.pot_fp = NULL;
10974
10975 FILE *out_fp = NULL;
10976 FILE *pot_fp = NULL;
10977
10978 if (show == 1 || left == 1)
10979 {
10980 pot_fp = fopen (potfile, "rb");
10981
10982 if (pot_fp == NULL)
10983 {
10984 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10985
10986 return (-1);
10987 }
10988
10989 if (outfile != NULL)
10990 {
10991 if ((out_fp = fopen (outfile, "ab")) == NULL)
10992 {
10993 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10994
10995 fclose (pot_fp);
10996
10997 return (-1);
10998 }
10999 }
11000 else
11001 {
11002 out_fp = stdout;
11003 }
11004 }
11005 else
11006 {
11007 if (potfile_disable == 0)
11008 {
11009 pot_fp = fopen (potfile, "ab");
11010
11011 if (pot_fp == NULL)
11012 {
11013 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11014
11015 return (-1);
11016 }
11017
11018 data.pot_fp = pot_fp;
11019 }
11020 }
11021
11022 pot_t *pot = NULL;
11023
11024 uint pot_cnt = 0;
11025 uint pot_avail = 0;
11026
11027 if (show == 1 || left == 1)
11028 {
11029 SUPPRESS_OUTPUT = 1;
11030
11031 pot_avail = count_lines (pot_fp);
11032
11033 rewind (pot_fp);
11034
11035 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11036
11037 uint pot_hashes_avail = 0;
11038
11039 uint line_num = 0;
11040
11041 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11042
11043 while (!feof (pot_fp))
11044 {
11045 line_num++;
11046
11047 int line_len = fgetl (pot_fp, line_buf);
11048
11049 if (line_len == 0) continue;
11050
11051 char *plain_buf = line_buf + line_len;
11052
11053 pot_t *pot_ptr = &pot[pot_cnt];
11054
11055 hash_t *hashes_buf = &pot_ptr->hash;
11056
11057 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11058 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11059
11060 if (pot_cnt == pot_hashes_avail)
11061 {
11062 uint pos = 0;
11063
11064 for (pos = 0; pos < INCR_POT; pos++)
11065 {
11066 if ((pot_cnt + pos) >= pot_avail) break;
11067
11068 pot_t *tmp_pot = &pot[pot_cnt + pos];
11069
11070 hash_t *tmp_hash = &tmp_pot->hash;
11071
11072 tmp_hash->digest = mymalloc (dgst_size);
11073
11074 if (isSalted)
11075 {
11076 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11077 }
11078
11079 if (esalt_size)
11080 {
11081 tmp_hash->esalt = mymalloc (esalt_size);
11082 }
11083
11084 pot_hashes_avail++;
11085 }
11086 }
11087
11088 int plain_len = 0;
11089
11090 int parser_status;
11091
11092 int iter = MAX_CUT_TRIES;
11093
11094 do
11095 {
11096 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11097 {
11098 if (line_buf[i] == ':')
11099 {
11100 line_len--;
11101
11102 break;
11103 }
11104 }
11105
11106 if (data.hash_mode != 2500)
11107 {
11108 parser_status = parse_func (line_buf, line_len, hashes_buf);
11109 }
11110 else
11111 {
11112 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11113
11114 if (line_len > max_salt_size)
11115 {
11116 parser_status = PARSER_GLOBAL_LENGTH;
11117 }
11118 else
11119 {
11120 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11121
11122 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11123
11124 hashes_buf->salt->salt_len = line_len;
11125
11126 parser_status = PARSER_OK;
11127 }
11128 }
11129
11130 // if NOT parsed without error, we add the ":" to the plain
11131
11132 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11133 {
11134 plain_len++;
11135 plain_buf--;
11136 }
11137
11138 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11139
11140 if (parser_status < PARSER_GLOBAL_ZERO)
11141 {
11142 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11143
11144 continue;
11145 }
11146
11147 if (plain_len >= 255) continue;
11148
11149 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11150
11151 pot_ptr->plain_len = plain_len;
11152
11153 pot_cnt++;
11154 }
11155
11156 myfree (line_buf);
11157
11158 fclose (pot_fp);
11159
11160 SUPPRESS_OUTPUT = 0;
11161
11162 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11163 }
11164
11165 /**
11166 * word len
11167 */
11168
11169 uint pw_min = PW_MIN;
11170 uint pw_max = PW_MAX;
11171
11172 switch (hash_mode)
11173 {
11174 case 125: if (pw_max > 32) pw_max = 32;
11175 break;
11176 case 400: if (pw_max > 40) pw_max = 40;
11177 break;
11178 case 500: if (pw_max > 16) pw_max = 16;
11179 break;
11180 case 1500: if (pw_max > 8) pw_max = 8;
11181 break;
11182 case 1600: if (pw_max > 16) pw_max = 16;
11183 break;
11184 case 1800: if (pw_max > 16) pw_max = 16;
11185 break;
11186 case 2100: if (pw_max > 16) pw_max = 16;
11187 break;
11188 case 2500: if (pw_min < 8) pw_min = 8;
11189 break;
11190 case 3000: if (pw_max > 7) pw_max = 7;
11191 break;
11192 case 5200: if (pw_max > 24) pw_max = 24;
11193 break;
11194 case 5800: if (pw_max > 16) pw_max = 16;
11195 break;
11196 case 6300: if (pw_max > 16) pw_max = 16;
11197 break;
11198 case 7400: if (pw_max > 16) pw_max = 16;
11199 break;
11200 case 7500: if (pw_max > 8) pw_max = 8;
11201 break;
11202 case 7900: if (pw_max > 48) pw_max = 48;
11203 break;
11204 case 8500: if (pw_max > 8) pw_max = 8;
11205 break;
11206 case 8600: if (pw_max > 16) pw_max = 16;
11207 break;
11208 case 9710: pw_min = 5;
11209 pw_max = 5;
11210 break;
11211 case 9810: pw_min = 5;
11212 pw_max = 5;
11213 break;
11214 case 10410: pw_min = 5;
11215 pw_max = 5;
11216 break;
11217 case 10300: if (pw_max < 3) pw_min = 3;
11218 if (pw_max > 40) pw_max = 40;
11219 break;
11220 case 10500: if (pw_max < 3) pw_min = 3;
11221 if (pw_max > 40) pw_max = 40;
11222 break;
11223 case 10700: if (pw_max > 16) pw_max = 16;
11224 break;
11225 case 11300: if (pw_max > 40) pw_max = 40;
11226 break;
11227 case 11600: if (pw_max > 32) pw_max = 32;
11228 break;
11229 case 12500: if (pw_max > 20) pw_max = 20;
11230 break;
11231 case 12800: if (pw_max > 24) pw_max = 24;
11232 break;
11233 }
11234
11235 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11236 {
11237 switch (attack_kern)
11238 {
11239 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11240 break;
11241 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11242 break;
11243 }
11244 }
11245
11246 /**
11247 * charsets : keep them together for more easy maintainnce
11248 */
11249
11250 cs_t mp_sys[6] = { { { 0 }, 0 } };
11251 cs_t mp_usr[4] = { { { 0 }, 0 } };
11252
11253 mp_setup_sys (mp_sys);
11254
11255 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11256 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11257 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11258 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11259
11260 /**
11261 * load hashes, part I: find input mode, count hashes
11262 */
11263
11264 uint hashlist_mode = 0;
11265 uint hashlist_format = HLFMT_HASHCAT;
11266
11267 uint hashes_avail = 0;
11268
11269 if (benchmark == 0)
11270 {
11271 struct stat f;
11272
11273 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11274
11275 if ((hash_mode == 2500) ||
11276 (hash_mode == 5200) ||
11277 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11278 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11279 (hash_mode == 9000))
11280 {
11281 hashlist_mode = HL_MODE_ARG;
11282
11283 char *hashfile = myargv[optind];
11284
11285 data.hashfile = hashfile;
11286
11287 logfile_top_var_string ("target", hashfile);
11288 }
11289
11290 if (hashlist_mode == HL_MODE_ARG)
11291 {
11292 if (hash_mode == 2500)
11293 {
11294 struct stat st;
11295
11296 if (stat (data.hashfile, &st) == -1)
11297 {
11298 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11299
11300 return (-1);
11301 }
11302
11303 hashes_avail = st.st_size / sizeof (hccap_t);
11304 }
11305 else
11306 {
11307 hashes_avail = 1;
11308 }
11309 }
11310 else if (hashlist_mode == HL_MODE_FILE)
11311 {
11312 char *hashfile = myargv[optind];
11313
11314 data.hashfile = hashfile;
11315
11316 logfile_top_var_string ("target", hashfile);
11317
11318 FILE *fp = NULL;
11319
11320 if ((fp = fopen (hashfile, "rb")) == NULL)
11321 {
11322 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11323
11324 return (-1);
11325 }
11326
11327 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11328
11329 hashes_avail = count_lines (fp);
11330
11331 rewind (fp);
11332
11333 if (hashes_avail == 0)
11334 {
11335 log_error ("ERROR: hashfile is empty or corrupt");
11336
11337 fclose (fp);
11338
11339 return (-1);
11340 }
11341
11342 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11343
11344 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11345 {
11346 log_error ("ERROR: remove not supported in native hashfile-format mode");
11347
11348 fclose (fp);
11349
11350 return (-1);
11351 }
11352
11353 fclose (fp);
11354 }
11355 }
11356 else
11357 {
11358 hashlist_mode = HL_MODE_ARG;
11359
11360 hashes_avail = 1;
11361 }
11362
11363 if (hash_mode == 3000) hashes_avail *= 2;
11364
11365 data.hashlist_mode = hashlist_mode;
11366 data.hashlist_format = hashlist_format;
11367
11368 logfile_top_uint (hashlist_mode);
11369 logfile_top_uint (hashlist_format);
11370
11371 /**
11372 * load hashes, part II: allocate required memory, set pointers
11373 */
11374
11375 hash_t *hashes_buf = NULL;
11376 void *digests_buf = NULL;
11377 salt_t *salts_buf = NULL;
11378 void *esalts_buf = NULL;
11379
11380 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11381
11382 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11383
11384 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11385 {
11386 u32 hash_pos;
11387
11388 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11389 {
11390 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11391
11392 hashes_buf[hash_pos].hash_info = hash_info;
11393
11394 if (username && (remove || show || left))
11395 {
11396 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11397 }
11398
11399 if (benchmark)
11400 {
11401 hash_info->orighash = (char *) mymalloc (256);
11402 }
11403 }
11404 }
11405
11406 if (isSalted)
11407 {
11408 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11409
11410 if (esalt_size)
11411 {
11412 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11413 }
11414 }
11415 else
11416 {
11417 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11418 }
11419
11420 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11421 {
11422 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11423
11424 if (isSalted)
11425 {
11426 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11427
11428 if (esalt_size)
11429 {
11430 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11431 }
11432 }
11433 else
11434 {
11435 hashes_buf[hash_pos].salt = &salts_buf[0];
11436 }
11437 }
11438
11439 /**
11440 * load hashes, part III: parse hashes or generate them if benchmark
11441 */
11442
11443 uint hashes_cnt = 0;
11444
11445 if (benchmark == 0)
11446 {
11447 if (keyspace == 1)
11448 {
11449 // useless to read hash file for keyspace, cheat a little bit w/ optind
11450 }
11451 else if (hashes_avail == 0)
11452 {
11453 }
11454 else if (hashlist_mode == HL_MODE_ARG)
11455 {
11456 char *input_buf = myargv[optind];
11457
11458 uint input_len = strlen (input_buf);
11459
11460 logfile_top_var_string ("target", input_buf);
11461
11462 char *hash_buf = NULL;
11463 int hash_len = 0;
11464
11465 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11466
11467 bool hash_fmt_error = 0;
11468
11469 if (hash_len < 1) hash_fmt_error = 1;
11470 if (hash_buf == NULL) hash_fmt_error = 1;
11471
11472 if (hash_fmt_error)
11473 {
11474 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11475 }
11476 else
11477 {
11478 if (opts_type & OPTS_TYPE_HASH_COPY)
11479 {
11480 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11481
11482 hash_info_tmp->orighash = mystrdup (hash_buf);
11483 }
11484
11485 if (isSalted)
11486 {
11487 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11488 }
11489
11490 int parser_status = PARSER_OK;
11491
11492 if (hash_mode == 2500)
11493 {
11494 if (hash_len == 0)
11495 {
11496 log_error ("ERROR: hccap file not specified");
11497
11498 return (-1);
11499 }
11500
11501 hashlist_mode = HL_MODE_FILE;
11502
11503 data.hashlist_mode = hashlist_mode;
11504
11505 FILE *fp = fopen (hash_buf, "rb");
11506
11507 if (fp == NULL)
11508 {
11509 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11510
11511 return (-1);
11512 }
11513
11514 if (hashes_avail < 1)
11515 {
11516 log_error ("ERROR: hccap file is empty or corrupt");
11517
11518 fclose (fp);
11519
11520 return (-1);
11521 }
11522
11523 uint hccap_size = sizeof (hccap_t);
11524
11525 char *in = (char *) mymalloc (hccap_size);
11526
11527 while (!feof (fp))
11528 {
11529 int n = fread (in, hccap_size, 1, fp);
11530
11531 if (n != 1)
11532 {
11533 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11534
11535 break;
11536 }
11537
11538 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11539
11540 if (parser_status != PARSER_OK)
11541 {
11542 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11543
11544 continue;
11545 }
11546
11547 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11548
11549 if ((show == 1) || (left == 1))
11550 {
11551 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11552
11553 char *salt_ptr = (char *) tmp_salt->salt_buf;
11554
11555 int cur_pos = tmp_salt->salt_len;
11556 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11557
11558 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11559
11560 // do the appending task
11561
11562 snprintf (salt_ptr + cur_pos,
11563 rem_len,
11564 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11565 wpa->orig_mac1[0],
11566 wpa->orig_mac1[1],
11567 wpa->orig_mac1[2],
11568 wpa->orig_mac1[3],
11569 wpa->orig_mac1[4],
11570 wpa->orig_mac1[5],
11571 wpa->orig_mac2[0],
11572 wpa->orig_mac2[1],
11573 wpa->orig_mac2[2],
11574 wpa->orig_mac2[3],
11575 wpa->orig_mac2[4],
11576 wpa->orig_mac2[5]);
11577
11578 // memset () the remaining part of the salt
11579
11580 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11581 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11582
11583 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11584
11585 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11586 }
11587
11588 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);
11589 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);
11590
11591 hashes_cnt++;
11592 }
11593
11594 fclose (fp);
11595
11596 myfree (in);
11597 }
11598 else if (hash_mode == 3000)
11599 {
11600 if (hash_len == 32)
11601 {
11602 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11603
11604 hash_t *lm_hash_left = NULL;
11605
11606 if (parser_status == PARSER_OK)
11607 {
11608 lm_hash_left = &hashes_buf[hashes_cnt];
11609
11610 hashes_cnt++;
11611 }
11612 else
11613 {
11614 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11615 }
11616
11617 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11618
11619 hash_t *lm_hash_right = NULL;
11620
11621 if (parser_status == PARSER_OK)
11622 {
11623 lm_hash_right = &hashes_buf[hashes_cnt];
11624
11625 hashes_cnt++;
11626 }
11627 else
11628 {
11629 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11630 }
11631
11632 // show / left
11633
11634 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11635 {
11636 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);
11637 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);
11638 }
11639 }
11640 else
11641 {
11642 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11643
11644 if (parser_status == PARSER_OK)
11645 {
11646 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11647 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11648 }
11649
11650 if (parser_status == PARSER_OK)
11651 {
11652 hashes_cnt++;
11653 }
11654 else
11655 {
11656 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11657 }
11658 }
11659 }
11660 else
11661 {
11662 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11663
11664 if (parser_status == PARSER_OK)
11665 {
11666 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11667 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11668 }
11669
11670 if (parser_status == PARSER_OK)
11671 {
11672 hashes_cnt++;
11673 }
11674 else
11675 {
11676 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11677 }
11678 }
11679 }
11680 }
11681 else if (hashlist_mode == HL_MODE_FILE)
11682 {
11683 char *hashfile = data.hashfile;
11684
11685 FILE *fp;
11686
11687 if ((fp = fopen (hashfile, "rb")) == NULL)
11688 {
11689 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11690
11691 return (-1);
11692 }
11693
11694 uint line_num = 0;
11695
11696 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11697
11698 while (!feof (fp))
11699 {
11700 line_num++;
11701
11702 int line_len = fgetl (fp, line_buf);
11703
11704 if (line_len == 0) continue;
11705
11706 char *hash_buf = NULL;
11707 int hash_len = 0;
11708
11709 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11710
11711 bool hash_fmt_error = 0;
11712
11713 if (hash_len < 1) hash_fmt_error = 1;
11714 if (hash_buf == NULL) hash_fmt_error = 1;
11715
11716 if (hash_fmt_error)
11717 {
11718 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11719
11720 continue;
11721 }
11722
11723 if (username)
11724 {
11725 char *user_buf = NULL;
11726 int user_len = 0;
11727
11728 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11729
11730 if (remove || show)
11731 {
11732 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11733
11734 *user = (user_t *) mymalloc (sizeof (user_t));
11735
11736 user_t *user_ptr = *user;
11737
11738 if (user_buf != NULL)
11739 {
11740 user_ptr->user_name = mystrdup (user_buf);
11741 }
11742 else
11743 {
11744 user_ptr->user_name = mystrdup ("");
11745 }
11746
11747 user_ptr->user_len = user_len;
11748 }
11749 }
11750
11751 if (opts_type & OPTS_TYPE_HASH_COPY)
11752 {
11753 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11754
11755 hash_info_tmp->orighash = mystrdup (hash_buf);
11756 }
11757
11758 if (isSalted)
11759 {
11760 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11761 }
11762
11763 if (hash_mode == 3000)
11764 {
11765 if (hash_len == 32)
11766 {
11767 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11768
11769 if (parser_status < PARSER_GLOBAL_ZERO)
11770 {
11771 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11772
11773 continue;
11774 }
11775
11776 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11777
11778 hashes_cnt++;
11779
11780 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11781
11782 if (parser_status < PARSER_GLOBAL_ZERO)
11783 {
11784 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11785
11786 continue;
11787 }
11788
11789 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11790
11791 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);
11792
11793 hashes_cnt++;
11794
11795 // show / left
11796
11797 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);
11798 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);
11799 }
11800 else
11801 {
11802 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11803
11804 if (parser_status < PARSER_GLOBAL_ZERO)
11805 {
11806 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11807
11808 continue;
11809 }
11810
11811 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);
11812
11813 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11814 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11815
11816 hashes_cnt++;
11817 }
11818 }
11819 else
11820 {
11821 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11822
11823 if (parser_status < PARSER_GLOBAL_ZERO)
11824 {
11825 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11826
11827 continue;
11828 }
11829
11830 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);
11831
11832 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11833 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11834
11835 hashes_cnt++;
11836 }
11837 }
11838
11839 myfree (line_buf);
11840
11841 fclose (fp);
11842
11843 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11844
11845 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11846 }
11847 }
11848 else
11849 {
11850 if (isSalted)
11851 {
11852 hashes_buf[0].salt->salt_len = 8;
11853
11854 // special salt handling
11855
11856 switch (hash_mode)
11857 {
11858 case 1500: hashes_buf[0].salt->salt_len = 2;
11859 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11860 break;
11861 case 1731: hashes_buf[0].salt->salt_len = 4;
11862 break;
11863 case 2410: hashes_buf[0].salt->salt_len = 4;
11864 break;
11865 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11866 break;
11867 case 3100: hashes_buf[0].salt->salt_len = 1;
11868 break;
11869 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11870 break;
11871 case 5800: hashes_buf[0].salt->salt_len = 16;
11872 break;
11873 case 6800: hashes_buf[0].salt->salt_len = 32;
11874 break;
11875 case 8400: hashes_buf[0].salt->salt_len = 40;
11876 break;
11877 case 8800: hashes_buf[0].salt->salt_len = 16;
11878 break;
11879 case 8900: hashes_buf[0].salt->salt_len = 16;
11880 hashes_buf[0].salt->scrypt_N = 1024;
11881 hashes_buf[0].salt->scrypt_r = 1;
11882 hashes_buf[0].salt->scrypt_p = 1;
11883 break;
11884 case 9100: hashes_buf[0].salt->salt_len = 16;
11885 break;
11886 case 9300: hashes_buf[0].salt->salt_len = 14;
11887 hashes_buf[0].salt->scrypt_N = 16384;
11888 hashes_buf[0].salt->scrypt_r = 1;
11889 hashes_buf[0].salt->scrypt_p = 1;
11890 break;
11891 case 9400: hashes_buf[0].salt->salt_len = 16;
11892 break;
11893 case 9500: hashes_buf[0].salt->salt_len = 16;
11894 break;
11895 case 9600: hashes_buf[0].salt->salt_len = 16;
11896 break;
11897 case 9700: hashes_buf[0].salt->salt_len = 16;
11898 break;
11899 case 9710: hashes_buf[0].salt->salt_len = 16;
11900 break;
11901 case 9720: hashes_buf[0].salt->salt_len = 16;
11902 break;
11903 case 9800: hashes_buf[0].salt->salt_len = 16;
11904 break;
11905 case 9810: hashes_buf[0].salt->salt_len = 16;
11906 break;
11907 case 9820: hashes_buf[0].salt->salt_len = 16;
11908 break;
11909 case 10300: hashes_buf[0].salt->salt_len = 12;
11910 break;
11911 case 11500: hashes_buf[0].salt->salt_len = 4;
11912 break;
11913 case 11600: hashes_buf[0].salt->salt_len = 4;
11914 break;
11915 case 12400: hashes_buf[0].salt->salt_len = 4;
11916 break;
11917 case 12500: hashes_buf[0].salt->salt_len = 8;
11918 break;
11919 case 12600: hashes_buf[0].salt->salt_len = 64;
11920 break;
11921 }
11922
11923 // special esalt handling
11924
11925 switch (hash_mode)
11926 {
11927 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11928 break;
11929 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11930 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11931 break;
11932 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11933 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11934 break;
11935 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11936 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11937 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11938 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11939 break;
11940 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11941 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11942 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11943 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11944 break;
11945 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11946 break;
11947 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11948 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11949 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11950 break;
11951 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11952 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11953 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11954 break;
11955 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11956 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11957 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11958 break;
11959 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11960 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11961 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11962 break;
11963 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11964 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11965 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11966 break;
11967 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11968 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11969 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11970 break;
11971 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11972 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11973 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11974 break;
11975 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11976 break;
11977 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11978 break;
11979 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11980 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11981 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11982 break;
11983 }
11984 }
11985
11986 // set hashfile
11987
11988 switch (hash_mode)
11989 {
11990 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11991 break;
11992 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11993 break;
11994 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11995 break;
11996 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11997 break;
11998 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11999 break;
12000 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12001 break;
12002 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12003 break;
12004 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12005 break;
12006 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12007 break;
12008 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12009 break;
12010 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12011 break;
12012 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12013 break;
12014 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12015 break;
12016 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12017 break;
12018 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12019 break;
12020 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12021 break;
12022 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12023 break;
12024 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12025 break;
12026 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12027 break;
12028 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12029 break;
12030 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12031 break;
12032 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12033 break;
12034 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12035 break;
12036 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12037 break;
12038 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12039 break;
12040 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12041 break;
12042 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12043 break;
12044 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12045 break;
12046 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12047 break;
12048 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12049 break;
12050 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12051 break;
12052 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12053 break;
12054 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12055 break;
12056 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12057 break;
12058 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12059 break;
12060 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12061 break;
12062 }
12063
12064 // set default iterations
12065
12066 switch (hash_mode)
12067 {
12068 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12069 break;
12070 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12071 break;
12072 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12073 break;
12074 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12075 break;
12076 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12077 break;
12078 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12079 break;
12080 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12081 break;
12082 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12083 break;
12084 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12085 break;
12086 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12087 break;
12088 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12089 break;
12090 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12091 break;
12092 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12093 break;
12094 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12095 break;
12096 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12097 break;
12098 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12099 break;
12100 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12101 break;
12102 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12103 break;
12104 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12105 break;
12106 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12107 break;
12108 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12109 break;
12110 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12111 break;
12112 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12113 break;
12114 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12115 break;
12116 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12117 break;
12118 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12119 break;
12120 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12121 break;
12122 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12123 break;
12124 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12125 break;
12126 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12127 break;
12128 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12129 break;
12130 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12131 break;
12132 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12133 break;
12134 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12135 break;
12136 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12137 break;
12138 case 8900: hashes_buf[0].salt->salt_iter = 1;
12139 break;
12140 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12141 break;
12142 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12143 break;
12144 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12145 break;
12146 case 9300: hashes_buf[0].salt->salt_iter = 1;
12147 break;
12148 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12149 break;
12150 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12151 break;
12152 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12153 break;
12154 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12155 break;
12156 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12157 break;
12158 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12159 break;
12160 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12161 break;
12162 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12163 break;
12164 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12165 break;
12166 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12167 break;
12168 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12169 break;
12170 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12171 break;
12172 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12173 break;
12174 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12175 break;
12176 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12177 break;
12178 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12179 break;
12180 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12181 break;
12182 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12183 break;
12184 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12185 break;
12186 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12187 break;
12188 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12189 break;
12190 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12191 break;
12192 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12193 break;
12194 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12195 break;
12196 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12197 break;
12198 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12199 break;
12200 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12201 break;
12202 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12203 break;
12204 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12205 break;
12206 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12207 break;
12208 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12209 break;
12210 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12211 break;
12212 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12213 break;
12214 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12215 break;
12216 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12217 break;
12218 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12219 break;
12220 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12221 break;
12222 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12223 break;
12224 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12225 break;
12226 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12227 break;
12228 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12229 break;
12230 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12231 break;
12232 }
12233
12234 hashes_cnt = 1;
12235 }
12236
12237 if (show == 1 || left == 1)
12238 {
12239 for (uint i = 0; i < pot_cnt; i++)
12240 {
12241 pot_t *pot_ptr = &pot[i];
12242
12243 hash_t *hashes_buf = &pot_ptr->hash;
12244
12245 local_free (hashes_buf->digest);
12246
12247 if (isSalted)
12248 {
12249 local_free (hashes_buf->salt);
12250 }
12251 }
12252
12253 local_free (pot);
12254
12255 if (data.quiet == 0) log_info_nn ("");
12256
12257 return (0);
12258 }
12259
12260 if (keyspace == 0)
12261 {
12262 if (hashes_cnt == 0)
12263 {
12264 log_error ("ERROR: No hashes loaded");
12265
12266 return (-1);
12267 }
12268 }
12269
12270 /**
12271 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12272 */
12273
12274 if (data.outfile != NULL)
12275 {
12276 if (data.hashfile != NULL)
12277 {
12278 #ifdef _POSIX
12279 struct stat tmpstat_outfile;
12280 struct stat tmpstat_hashfile;
12281 #endif
12282
12283 #ifdef _WIN
12284 struct stat64 tmpstat_outfile;
12285 struct stat64 tmpstat_hashfile;
12286 #endif
12287
12288 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12289
12290 if (tmp_outfile_fp)
12291 {
12292 #ifdef _POSIX
12293 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12294 #endif
12295
12296 #ifdef _WIN
12297 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12298 #endif
12299
12300 fclose (tmp_outfile_fp);
12301 }
12302
12303 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12304
12305 if (tmp_hashfile_fp)
12306 {
12307 #ifdef _POSIX
12308 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12309 #endif
12310
12311 #ifdef _WIN
12312 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12313 #endif
12314
12315 fclose (tmp_hashfile_fp);
12316 }
12317
12318 if (tmp_outfile_fp && tmp_outfile_fp)
12319 {
12320 tmpstat_outfile.st_mode = 0;
12321 tmpstat_outfile.st_nlink = 0;
12322 tmpstat_outfile.st_uid = 0;
12323 tmpstat_outfile.st_gid = 0;
12324 tmpstat_outfile.st_rdev = 0;
12325 tmpstat_outfile.st_atime = 0;
12326
12327 tmpstat_hashfile.st_mode = 0;
12328 tmpstat_hashfile.st_nlink = 0;
12329 tmpstat_hashfile.st_uid = 0;
12330 tmpstat_hashfile.st_gid = 0;
12331 tmpstat_hashfile.st_rdev = 0;
12332 tmpstat_hashfile.st_atime = 0;
12333
12334 #ifdef _POSIX
12335 tmpstat_outfile.st_blksize = 0;
12336 tmpstat_outfile.st_blocks = 0;
12337
12338 tmpstat_hashfile.st_blksize = 0;
12339 tmpstat_hashfile.st_blocks = 0;
12340 #endif
12341
12342 #ifdef _POSIX
12343 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12344 {
12345 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12346
12347 return (-1);
12348 }
12349 #endif
12350
12351 #ifdef _WIN
12352 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12353 {
12354 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12355
12356 return (-1);
12357 }
12358 #endif
12359 }
12360 }
12361 }
12362
12363 /**
12364 * Remove duplicates
12365 */
12366
12367 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12368
12369 if (isSalted)
12370 {
12371 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12372 }
12373 else
12374 {
12375 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12376 }
12377
12378 uint hashes_cnt_orig = hashes_cnt;
12379
12380 hashes_cnt = 1;
12381
12382 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12383 {
12384 if (isSalted)
12385 {
12386 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12387 {
12388 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12389 }
12390 }
12391 else
12392 {
12393 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12394 }
12395
12396 if (hashes_pos > hashes_cnt)
12397 {
12398 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12399 }
12400
12401 hashes_cnt++;
12402 }
12403
12404 /**
12405 * Potfile removes
12406 */
12407
12408 uint potfile_remove_cracks = 0;
12409
12410 if (potfile_disable == 0)
12411 {
12412 hash_t hash_buf;
12413
12414 hash_buf.digest = mymalloc (dgst_size);
12415 hash_buf.salt = NULL;
12416 hash_buf.esalt = NULL;
12417 hash_buf.hash_info = NULL;
12418 hash_buf.cracked = 0;
12419
12420 if (isSalted)
12421 {
12422 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12423 }
12424
12425 if (esalt_size)
12426 {
12427 hash_buf.esalt = mymalloc (esalt_size);
12428 }
12429
12430 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12431
12432 // no solution for these special hash types (for instane because they use hashfile in output etc)
12433 if ((hash_mode != 5200) &&
12434 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12435 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12436 (hash_mode != 9000))
12437 {
12438 FILE *fp = fopen (potfile, "rb");
12439
12440 if (fp != NULL)
12441 {
12442 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12443
12444 // to be safe work with a copy (because of line_len loop, i etc)
12445 // moved up here because it's easier to handle continue case
12446 // it's just 64kb
12447
12448 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12449
12450 while (!feof (fp))
12451 {
12452 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12453
12454 if (ptr == NULL) break;
12455
12456 int line_len = strlen (line_buf);
12457
12458 if (line_len == 0) continue;
12459
12460 int iter = MAX_CUT_TRIES;
12461
12462 for (int i = line_len - 1; i && iter; i--, line_len--)
12463 {
12464 if (line_buf[i] != ':') continue;
12465
12466 if (isSalted)
12467 {
12468 memset (hash_buf.salt, 0, sizeof (salt_t));
12469 }
12470
12471 hash_t *found = NULL;
12472
12473 if (hash_mode == 6800)
12474 {
12475 if (i < 64) // 64 = 16 * uint in salt_buf[]
12476 {
12477 // manipulate salt_buf
12478 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12479
12480 hash_buf.salt->salt_len = i;
12481
12482 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12483 }
12484 }
12485 else if (hash_mode == 2500)
12486 {
12487 if (i < 64) // 64 = 16 * uint in salt_buf[]
12488 {
12489 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12490 // manipulate salt_buf
12491
12492 memcpy (line_buf_cpy, line_buf, i);
12493
12494 char *mac2_pos = strrchr (line_buf_cpy, ':');
12495
12496 if (mac2_pos == NULL) continue;
12497
12498 mac2_pos[0] = 0;
12499 mac2_pos++;
12500
12501 if (strlen (mac2_pos) != 12) continue;
12502
12503 char *mac1_pos = strrchr (line_buf_cpy, ':');
12504
12505 if (mac1_pos == NULL) continue;
12506
12507 mac1_pos[0] = 0;
12508 mac1_pos++;
12509
12510 if (strlen (mac1_pos) != 12) continue;
12511
12512 uint essid_length = mac1_pos - line_buf_cpy - 1;
12513
12514 // here we need the ESSID
12515 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12516
12517 hash_buf.salt->salt_len = essid_length;
12518
12519 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12520
12521 if (found)
12522 {
12523 wpa_t *wpa = (wpa_t *) found->esalt;
12524
12525 // compare hex string(s) vs binary MAC address(es)
12526
12527 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12528 {
12529 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12530 {
12531 found = NULL;
12532
12533 break;
12534 }
12535 }
12536
12537 // early skip ;)
12538 if (!found) continue;
12539
12540 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12541 {
12542 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12543 {
12544 found = NULL;
12545
12546 break;
12547 }
12548 }
12549 }
12550 }
12551 }
12552 else
12553 {
12554 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12555
12556 if (parser_status == PARSER_OK)
12557 {
12558 if (isSalted)
12559 {
12560 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12561 }
12562 else
12563 {
12564 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12565 }
12566 }
12567 }
12568
12569 if (found == NULL) continue;
12570
12571 if (!found->cracked) potfile_remove_cracks++;
12572
12573 found->cracked = 1;
12574
12575 if (found) break;
12576
12577 iter--;
12578 }
12579 }
12580
12581 myfree (line_buf_cpy);
12582
12583 myfree (line_buf);
12584
12585 fclose (fp);
12586 }
12587 }
12588
12589 if (esalt_size)
12590 {
12591 local_free (hash_buf.esalt);
12592 }
12593
12594 if (isSalted)
12595 {
12596 local_free (hash_buf.salt);
12597 }
12598
12599 local_free (hash_buf.digest);
12600 }
12601
12602 /**
12603 * Now generate all the buffers required for later
12604 */
12605
12606 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12607
12608 salt_t *salts_buf_new = NULL;
12609 void *esalts_buf_new = NULL;
12610
12611 if (isSalted)
12612 {
12613 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12614
12615 if (esalt_size)
12616 {
12617 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12618 }
12619 }
12620 else
12621 {
12622 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12623 }
12624
12625 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12626
12627 uint digests_cnt = hashes_cnt;
12628 uint digests_done = 0;
12629
12630 size_t size_digests = digests_cnt * dgst_size;
12631 size_t size_shown = digests_cnt * sizeof (uint);
12632
12633 uint *digests_shown = (uint *) mymalloc (size_shown);
12634 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12635
12636 uint salts_cnt = 0;
12637 uint salts_done = 0;
12638
12639 hashinfo_t **hash_info = NULL;
12640
12641 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12642 {
12643 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12644
12645 if (username && (remove || show))
12646 {
12647 uint user_pos;
12648
12649 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12650 {
12651 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12652
12653 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12654 }
12655 }
12656 }
12657
12658 uint *salts_shown = (uint *) mymalloc (size_shown);
12659
12660 salt_t *salt_buf;
12661
12662 {
12663 // copied from inner loop
12664
12665 salt_buf = &salts_buf_new[salts_cnt];
12666
12667 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12668
12669 if (esalt_size)
12670 {
12671 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12672 }
12673
12674 salt_buf->digests_cnt = 0;
12675 salt_buf->digests_done = 0;
12676 salt_buf->digests_offset = 0;
12677
12678 salts_cnt++;
12679 }
12680
12681 if (hashes_buf[0].cracked == 1)
12682 {
12683 digests_shown[0] = 1;
12684
12685 digests_done++;
12686
12687 salt_buf->digests_done++;
12688 }
12689
12690 salt_buf->digests_cnt++;
12691
12692 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12693
12694 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12695 {
12696 hash_info[0] = hashes_buf[0].hash_info;
12697 }
12698
12699 // copy from inner loop
12700
12701 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12702 {
12703 if (isSalted)
12704 {
12705 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12706 {
12707 salt_buf = &salts_buf_new[salts_cnt];
12708
12709 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12710
12711 if (esalt_size)
12712 {
12713 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12714 }
12715
12716 salt_buf->digests_cnt = 0;
12717 salt_buf->digests_done = 0;
12718 salt_buf->digests_offset = hashes_pos;
12719
12720 salts_cnt++;
12721 }
12722 }
12723
12724 if (hashes_buf[hashes_pos].cracked == 1)
12725 {
12726 digests_shown[hashes_pos] = 1;
12727
12728 digests_done++;
12729
12730 salt_buf->digests_done++;
12731 }
12732
12733 salt_buf->digests_cnt++;
12734
12735 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12736
12737 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12738 {
12739 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12740 }
12741 }
12742
12743 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12744 {
12745 salt_t *salt_buf = &salts_buf_new[salt_pos];
12746
12747 if (salt_buf->digests_done == salt_buf->digests_cnt)
12748 {
12749 salts_shown[salt_pos] = 1;
12750
12751 salts_done++;
12752 }
12753
12754 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12755 }
12756
12757 local_free (digests_buf);
12758 local_free (salts_buf);
12759 local_free (esalts_buf);
12760
12761 digests_buf = digests_buf_new;
12762 salts_buf = salts_buf_new;
12763 esalts_buf = esalts_buf_new;
12764
12765 local_free (hashes_buf);
12766
12767 /**
12768 * special modification not set from parser
12769 */
12770
12771 switch (hash_mode)
12772 {
12773 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12774 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12775 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12776 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12777 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12778 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12779 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12780 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12781 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12782 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12783 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12784 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12785 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12786 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12787 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12788 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12789 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12790 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12791 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12792 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12793 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12794 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12795 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12796 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12797 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12798 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12799 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12800 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12801 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12802 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12803 }
12804
12805 if (truecrypt_keyfiles)
12806 {
12807 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12808
12809 char *keyfiles = strdup (truecrypt_keyfiles);
12810
12811 char *keyfile = strtok (keyfiles, ",");
12812
12813 do
12814 {
12815 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12816
12817 } while ((keyfile = strtok (NULL, ",")) != NULL);
12818
12819 free (keyfiles);
12820 }
12821
12822 if (veracrypt_keyfiles)
12823 {
12824 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12825
12826 char *keyfiles = strdup (veracrypt_keyfiles);
12827
12828 char *keyfile = strtok (keyfiles, ",");
12829
12830 do
12831 {
12832 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12833
12834 } while ((keyfile = strtok (NULL, ",")) != NULL);
12835
12836 free (keyfiles);
12837 }
12838
12839 data.digests_cnt = digests_cnt;
12840 data.digests_done = digests_done;
12841 data.digests_buf = digests_buf;
12842 data.digests_shown = digests_shown;
12843 data.digests_shown_tmp = digests_shown_tmp;
12844
12845 data.salts_cnt = salts_cnt;
12846 data.salts_done = salts_done;
12847 data.salts_buf = salts_buf;
12848 data.salts_shown = salts_shown;
12849
12850 data.esalts_buf = esalts_buf;
12851 data.hash_info = hash_info;
12852
12853 /**
12854 * Automatic Optimizers
12855 */
12856
12857 if (salts_cnt == 1)
12858 opti_type |= OPTI_TYPE_SINGLE_SALT;
12859
12860 if (digests_cnt == 1)
12861 opti_type |= OPTI_TYPE_SINGLE_HASH;
12862
12863 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12864 opti_type |= OPTI_TYPE_NOT_ITERATED;
12865
12866 if (attack_mode == ATTACK_MODE_BF)
12867 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12868
12869 data.opti_type = opti_type;
12870
12871 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12872 {
12873 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12874 {
12875 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12876 {
12877 if (opts_type & OPTS_TYPE_ST_ADD80)
12878 {
12879 opts_type &= ~OPTS_TYPE_ST_ADD80;
12880 opts_type |= OPTS_TYPE_PT_ADD80;
12881 }
12882
12883 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12884 {
12885 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12886 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12887 }
12888
12889 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12890 {
12891 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12892 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12893 }
12894 }
12895 }
12896 }
12897
12898 /**
12899 * Some algorithm, like descrypt, can benefit from JIT compilation
12900 */
12901
12902 int force_jit_compilation = -1;
12903
12904 if (hash_mode == 8900)
12905 {
12906 force_jit_compilation = 8900;
12907 }
12908 else if (hash_mode == 9300)
12909 {
12910 force_jit_compilation = 8900;
12911 }
12912 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12913 {
12914 force_jit_compilation = 1500;
12915 }
12916
12917 /**
12918 * generate bitmap tables
12919 */
12920
12921 const uint bitmap_shift1 = 5;
12922 const uint bitmap_shift2 = 13;
12923
12924 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12925
12926 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12927 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12928 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12929 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12930 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12931 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12932 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12933 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12934
12935 uint bitmap_bits;
12936 uint bitmap_nums;
12937 uint bitmap_mask;
12938 uint bitmap_size;
12939
12940 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12941 {
12942 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12943
12944 bitmap_nums = 1 << bitmap_bits;
12945
12946 bitmap_mask = bitmap_nums - 1;
12947
12948 bitmap_size = bitmap_nums * sizeof (uint);
12949
12950 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12951
12952 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;
12953 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;
12954
12955 break;
12956 }
12957
12958 bitmap_nums = 1 << bitmap_bits;
12959
12960 bitmap_mask = bitmap_nums - 1;
12961
12962 bitmap_size = bitmap_nums * sizeof (uint);
12963
12964 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);
12965 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);
12966
12967 /**
12968 * prepare quick rule
12969 */
12970
12971 data.rule_buf_l = rule_buf_l;
12972 data.rule_buf_r = rule_buf_r;
12973
12974 int rule_len_l = (int) strlen (rule_buf_l);
12975 int rule_len_r = (int) strlen (rule_buf_r);
12976
12977 data.rule_len_l = rule_len_l;
12978 data.rule_len_r = rule_len_r;
12979
12980 /**
12981 * load rules
12982 */
12983
12984 uint *all_kernel_rules_cnt = NULL;
12985
12986 kernel_rule_t **all_kernel_rules_buf = NULL;
12987
12988 if (rp_files_cnt)
12989 {
12990 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12991
12992 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12993 }
12994
12995 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12996
12997 int rule_len = 0;
12998
12999 for (uint i = 0; i < rp_files_cnt; i++)
13000 {
13001 uint kernel_rules_avail = 0;
13002
13003 uint kernel_rules_cnt = 0;
13004
13005 kernel_rule_t *kernel_rules_buf = NULL;
13006
13007 char *rp_file = rp_files[i];
13008
13009 char in[BLOCK_SIZE] = { 0 };
13010 char out[BLOCK_SIZE] = { 0 };
13011
13012 FILE *fp = NULL;
13013
13014 uint rule_line = 0;
13015
13016 if ((fp = fopen (rp_file, "rb")) == NULL)
13017 {
13018 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13019
13020 return (-1);
13021 }
13022
13023 while (!feof (fp))
13024 {
13025 memset (rule_buf, 0, HCBUFSIZ);
13026
13027 rule_len = fgetl (fp, rule_buf);
13028
13029 rule_line++;
13030
13031 if (rule_len == 0) continue;
13032
13033 if (rule_buf[0] == '#') continue;
13034
13035 if (kernel_rules_avail == kernel_rules_cnt)
13036 {
13037 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13038
13039 kernel_rules_avail += INCR_RULES;
13040 }
13041
13042 memset (in, 0, BLOCK_SIZE);
13043 memset (out, 0, BLOCK_SIZE);
13044
13045 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13046
13047 if (result == -1)
13048 {
13049 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13050
13051 continue;
13052 }
13053
13054 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13055 {
13056 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13057
13058 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13059
13060 continue;
13061 }
13062
13063 /* its so slow
13064 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13065 {
13066 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13067
13068 continue;
13069 }
13070 */
13071
13072 kernel_rules_cnt++;
13073 }
13074
13075 fclose (fp);
13076
13077 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13078
13079 all_kernel_rules_buf[i] = kernel_rules_buf;
13080 }
13081
13082 /**
13083 * merge rules or automatic rule generator
13084 */
13085
13086 uint kernel_rules_cnt = 0;
13087
13088 kernel_rule_t *kernel_rules_buf = NULL;
13089
13090 if (attack_mode == ATTACK_MODE_STRAIGHT)
13091 {
13092 if (rp_files_cnt)
13093 {
13094 kernel_rules_cnt = 1;
13095
13096 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13097
13098 repeats[0] = kernel_rules_cnt;
13099
13100 for (uint i = 0; i < rp_files_cnt; i++)
13101 {
13102 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13103
13104 repeats[i + 1] = kernel_rules_cnt;
13105 }
13106
13107 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13108
13109 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13110
13111 for (uint i = 0; i < kernel_rules_cnt; i++)
13112 {
13113 uint out_pos = 0;
13114
13115 kernel_rule_t *out = &kernel_rules_buf[i];
13116
13117 for (uint j = 0; j < rp_files_cnt; j++)
13118 {
13119 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13120 uint in_pos;
13121
13122 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13123
13124 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13125 {
13126 if (out_pos == RULES_MAX - 1)
13127 {
13128 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13129
13130 break;
13131 }
13132
13133 out->cmds[out_pos] = in->cmds[in_pos];
13134 }
13135 }
13136 }
13137
13138 local_free (repeats);
13139 }
13140 else if (rp_gen)
13141 {
13142 uint kernel_rules_avail = 0;
13143
13144 while (kernel_rules_cnt < rp_gen)
13145 {
13146 if (kernel_rules_avail == kernel_rules_cnt)
13147 {
13148 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13149
13150 kernel_rules_avail += INCR_RULES;
13151 }
13152
13153 memset (rule_buf, 0, HCBUFSIZ);
13154
13155 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13156
13157 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13158
13159 kernel_rules_cnt++;
13160 }
13161 }
13162 }
13163
13164 myfree (rule_buf);
13165
13166 /**
13167 * generate NOP rules
13168 */
13169
13170 if (kernel_rules_cnt == 0)
13171 {
13172 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13173
13174 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13175
13176 kernel_rules_cnt++;
13177 }
13178
13179 data.kernel_rules_cnt = kernel_rules_cnt;
13180 data.kernel_rules_buf = kernel_rules_buf;
13181
13182 /**
13183 * OpenCL platforms: detect
13184 */
13185
13186 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13187 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13188
13189 cl_uint platforms_cnt = 0;
13190 cl_uint platform_devices_cnt = 0;
13191
13192 if (keyspace == 0)
13193 {
13194 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13195
13196 if (platforms_cnt == 0)
13197 {
13198 log_info ("");
13199 log_info ("ATTENTION! No OpenCL compatible platform found");
13200 log_info ("");
13201 log_info ("You're probably missing the OpenCL runtime installation");
13202 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13203 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13204 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13205 log_info ("");
13206
13207 return (-1);
13208 }
13209
13210 if (opencl_platforms_filter != (uint) -1)
13211 {
13212 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13213
13214 if (opencl_platforms_filter > platform_cnt_mask)
13215 {
13216 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13217
13218 return (-1);
13219 }
13220 }
13221 }
13222
13223 /**
13224 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13225 */
13226
13227 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13228 {
13229 cl_platform_id platform = platforms[platform_id];
13230
13231 char platform_vendor[INFOSZ] = { 0 };
13232
13233 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13234
13235 #ifdef HAVE_HWMON
13236 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13237 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13238 {
13239 // make sure that we do not directly control the fan for NVidia
13240
13241 gpu_temp_retain = 0;
13242
13243 data.gpu_temp_retain = gpu_temp_retain;
13244 }
13245 #endif // HAVE_NVML || HAVE_NVAPI
13246 #endif
13247 }
13248
13249 /**
13250 * OpenCL device types:
13251 * 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.
13252 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13253 */
13254
13255 if (opencl_device_types == NULL)
13256 {
13257 cl_device_type device_types_all = 0;
13258
13259 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13260 {
13261 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13262
13263 cl_platform_id platform = platforms[platform_id];
13264
13265 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13266
13267 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13268 {
13269 cl_device_id device = platform_devices[platform_devices_id];
13270
13271 cl_device_type device_type;
13272
13273 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13274
13275 device_types_all |= device_type;
13276 }
13277 }
13278
13279 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13280 {
13281 device_types_filter |= CL_DEVICE_TYPE_CPU;
13282 }
13283 }
13284
13285 /**
13286 * OpenCL devices: simply push all devices from all platforms into the same device array
13287 */
13288
13289 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13290
13291 data.devices_param = devices_param;
13292
13293 uint devices_cnt = 0;
13294
13295 uint devices_active = 0;
13296
13297 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13298 {
13299 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13300
13301 cl_platform_id platform = platforms[platform_id];
13302
13303 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13304
13305 char platform_vendor[INFOSZ] = { 0 };
13306
13307 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13308
13309 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13310 // this causes trouble with vendor id based macros
13311 // we'll assign generic to those without special optimization available
13312
13313 cl_uint platform_vendor_id = 0;
13314
13315 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13316 {
13317 platform_vendor_id = VENDOR_ID_AMD;
13318 }
13319 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13320 {
13321 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13322 }
13323 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13324 {
13325 platform_vendor_id = VENDOR_ID_APPLE;
13326 }
13327 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13328 {
13329 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13330 }
13331 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13332 {
13333 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13334 }
13335 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13336 {
13337 platform_vendor_id = VENDOR_ID_MESA;
13338 }
13339 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13340 {
13341 platform_vendor_id = VENDOR_ID_NV;
13342 }
13343 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13344 {
13345 platform_vendor_id = VENDOR_ID_POCL;
13346 }
13347 else
13348 {
13349 platform_vendor_id = VENDOR_ID_GENERIC;
13350 }
13351
13352 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13353 {
13354 size_t param_value_size = 0;
13355
13356 const uint device_id = devices_cnt;
13357
13358 hc_device_param_t *device_param = &data.devices_param[device_id];
13359
13360 device_param->platform_vendor_id = platform_vendor_id;
13361
13362 device_param->device = platform_devices[platform_devices_id];
13363
13364 device_param->device_id = device_id;
13365
13366 device_param->platform_devices_id = platform_devices_id;
13367
13368 // device_type
13369
13370 cl_device_type device_type;
13371
13372 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13373
13374 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13375
13376 device_param->device_type = device_type;
13377
13378 // device_name
13379
13380 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13381
13382 char *device_name = (char *) mymalloc (param_value_size);
13383
13384 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13385
13386 device_param->device_name = device_name;
13387
13388 // device_vendor
13389
13390 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13391
13392 char *device_vendor = (char *) mymalloc (param_value_size);
13393
13394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13395
13396 device_param->device_vendor = device_vendor;
13397
13398 cl_uint device_vendor_id = 0;
13399
13400 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13401 {
13402 device_vendor_id = VENDOR_ID_AMD;
13403 }
13404 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13405 {
13406 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13407 }
13408 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13409 {
13410 device_vendor_id = VENDOR_ID_APPLE;
13411 }
13412 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13413 {
13414 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13415 }
13416 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13417 {
13418 device_vendor_id = VENDOR_ID_INTEL_SDK;
13419 }
13420 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13421 {
13422 device_vendor_id = VENDOR_ID_MESA;
13423 }
13424 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13425 {
13426 device_vendor_id = VENDOR_ID_NV;
13427 }
13428 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13429 {
13430 device_vendor_id = VENDOR_ID_POCL;
13431 }
13432 else
13433 {
13434 device_vendor_id = VENDOR_ID_GENERIC;
13435 }
13436
13437 device_param->device_vendor_id = device_vendor_id;
13438
13439 // tuning db
13440
13441 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13442
13443 // device_version
13444
13445 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13446
13447 char *device_version = (char *) mymalloc (param_value_size);
13448
13449 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13450
13451 device_param->device_version = device_version;
13452
13453 // device_opencl_version
13454
13455 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13456
13457 char *device_opencl_version = (char *) mymalloc (param_value_size);
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13460
13461 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13462
13463 myfree (device_opencl_version);
13464
13465 // vector_width
13466
13467 cl_uint vector_width;
13468
13469 if (opencl_vector_width_chgd == 0)
13470 {
13471 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13472 {
13473 if (opti_type & OPTI_TYPE_USES_BITS_64)
13474 {
13475 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13476 }
13477 else
13478 {
13479 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13480 }
13481 }
13482 else
13483 {
13484 vector_width = (cl_uint) tuningdb_entry->vector_width;
13485 }
13486 }
13487 else
13488 {
13489 vector_width = opencl_vector_width;
13490 }
13491
13492 if (vector_width > 16) vector_width = 16;
13493
13494 device_param->vector_width = vector_width;
13495
13496 // max_compute_units
13497
13498 cl_uint device_processors;
13499
13500 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13501
13502 device_param->device_processors = device_processors;
13503
13504 // device_maxmem_alloc
13505 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13506
13507 cl_ulong device_maxmem_alloc;
13508
13509 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13510
13511 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13512
13513 // device_global_mem
13514
13515 cl_ulong device_global_mem;
13516
13517 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13518
13519 device_param->device_global_mem = device_global_mem;
13520
13521 // max_work_group_size
13522
13523 size_t device_maxworkgroup_size;
13524
13525 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13526
13527 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13528
13529 // max_clock_frequency
13530
13531 cl_uint device_maxclock_frequency;
13532
13533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13534
13535 device_param->device_maxclock_frequency = device_maxclock_frequency;
13536
13537 // device_endian_little
13538
13539 cl_bool device_endian_little;
13540
13541 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13542
13543 if (device_endian_little == CL_FALSE)
13544 {
13545 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13546
13547 device_param->skipped = 1;
13548 }
13549
13550 // device_available
13551
13552 cl_bool device_available;
13553
13554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13555
13556 if (device_available == CL_FALSE)
13557 {
13558 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13559
13560 device_param->skipped = 1;
13561 }
13562
13563 // device_compiler_available
13564
13565 cl_bool device_compiler_available;
13566
13567 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13568
13569 if (device_compiler_available == CL_FALSE)
13570 {
13571 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13572
13573 device_param->skipped = 1;
13574 }
13575
13576 // device_execution_capabilities
13577
13578 cl_device_exec_capabilities device_execution_capabilities;
13579
13580 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13581
13582 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13583 {
13584 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13585
13586 device_param->skipped = 1;
13587 }
13588
13589 // device_extensions
13590
13591 size_t device_extensions_size;
13592
13593 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13594
13595 char *device_extensions = mymalloc (device_extensions_size + 1);
13596
13597 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13598
13599 if (strstr (device_extensions, "base_atomics") == 0)
13600 {
13601 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13602
13603 device_param->skipped = 1;
13604 }
13605
13606 if (strstr (device_extensions, "byte_addressable_store") == 0)
13607 {
13608 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13609
13610 device_param->skipped = 1;
13611 }
13612
13613 myfree (device_extensions);
13614
13615 // device_local_mem_size
13616
13617 cl_ulong device_local_mem_size;
13618
13619 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13620
13621 if (device_local_mem_size < 32768)
13622 {
13623 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13624
13625 device_param->skipped = 1;
13626 }
13627
13628 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13629 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13630 // This results in both utilizing it for 50%
13631 // However, Intel has much better SIMD control over their own hardware
13632 // It makes sense to give them full control over their own hardware
13633
13634 if (device_type & CL_DEVICE_TYPE_CPU)
13635 {
13636 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13637 {
13638 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13639
13640 device_param->skipped = 1;
13641 }
13642 }
13643
13644 // skipped
13645
13646 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13647 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13648
13649 // driver_version
13650
13651 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13652
13653 char *driver_version = (char *) mymalloc (param_value_size);
13654
13655 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13656
13657 device_param->driver_version = driver_version;
13658
13659 // device_name_chksum
13660
13661 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13662
13663 #if __x86_64__
13664 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);
13665 #else
13666 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);
13667 #endif
13668
13669 uint device_name_digest[4] = { 0 };
13670
13671 md5_64 ((uint *) device_name_chksum, device_name_digest);
13672
13673 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13674
13675 device_param->device_name_chksum = device_name_chksum;
13676
13677 // device_processor_cores
13678
13679 if (device_type & CL_DEVICE_TYPE_CPU)
13680 {
13681 cl_uint device_processor_cores = 1;
13682
13683 device_param->device_processor_cores = device_processor_cores;
13684 }
13685
13686 if (device_type & CL_DEVICE_TYPE_GPU)
13687 {
13688 if (device_vendor_id == VENDOR_ID_AMD)
13689 {
13690 cl_uint device_processor_cores = 0;
13691
13692 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13693
13694 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13695
13696 device_param->device_processor_cores = device_processor_cores;
13697 }
13698 else if (device_vendor_id == VENDOR_ID_NV)
13699 {
13700 cl_uint kernel_exec_timeout = 0;
13701
13702 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13703
13704 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13705
13706 device_param->kernel_exec_timeout = kernel_exec_timeout;
13707
13708 cl_uint device_processor_cores = 0;
13709
13710 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13711
13712 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13713
13714 device_param->device_processor_cores = device_processor_cores;
13715
13716 cl_uint sm_minor = 0;
13717 cl_uint sm_major = 0;
13718
13719 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13720 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13721
13722 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13723 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13724
13725 device_param->sm_minor = sm_minor;
13726 device_param->sm_major = sm_major;
13727 }
13728 else
13729 {
13730 cl_uint device_processor_cores = 1;
13731
13732 device_param->device_processor_cores = device_processor_cores;
13733 }
13734 }
13735
13736 // display results
13737
13738 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13739 {
13740 if (machine_readable == 0)
13741 {
13742 if (device_param->skipped == 0)
13743 {
13744 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13745 device_id + 1,
13746 device_name,
13747 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13748 (unsigned int) (device_global_mem / 1024 / 1024),
13749 (unsigned int) device_processors);
13750 }
13751 else
13752 {
13753 log_info ("Device #%u: %s, skipped",
13754 device_id + 1,
13755 device_name);
13756 }
13757 }
13758 }
13759
13760 // common driver check
13761
13762 if (device_param->skipped == 0)
13763 {
13764 if (device_type & CL_DEVICE_TYPE_GPU)
13765 {
13766 if (platform_vendor_id == VENDOR_ID_AMD)
13767 {
13768 int catalyst_check = (force == 1) ? 0 : 1;
13769
13770 int catalyst_warn = 0;
13771
13772 int catalyst_broken = 0;
13773
13774 if (catalyst_check == 1)
13775 {
13776 catalyst_warn = 1;
13777
13778 // v14.9 and higher
13779 if (atoi (device_param->driver_version) >= 1573)
13780 {
13781 catalyst_warn = 0;
13782 }
13783
13784 catalyst_check = 0;
13785 }
13786
13787 if (catalyst_broken == 1)
13788 {
13789 log_info ("");
13790 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13791 log_info ("It will pass over cracked hashes and does not report them as cracked");
13792 log_info ("You are STRONGLY encouraged not to use it");
13793 log_info ("You can use --force to override this but do not post error reports if you do so");
13794 log_info ("");
13795
13796 return (-1);
13797 }
13798
13799 if (catalyst_warn == 1)
13800 {
13801 log_info ("");
13802 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13803 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13804 log_info ("See hashcat's homepage for official supported catalyst drivers");
13805 #ifdef _WIN
13806 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13807 #endif
13808 log_info ("You can use --force to override this but do not post error reports if you do so");
13809 log_info ("");
13810
13811 return (-1);
13812 }
13813 }
13814 else if (platform_vendor_id == VENDOR_ID_NV)
13815 {
13816 if (device_param->kernel_exec_timeout != 0)
13817 {
13818 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);
13819 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13820 }
13821 }
13822 }
13823
13824 /* turns out pocl still creates segfaults (because of llvm)
13825 if (device_type & CL_DEVICE_TYPE_CPU)
13826 {
13827 if (platform_vendor_id == VENDOR_ID_AMD)
13828 {
13829 if (force == 0)
13830 {
13831 log_info ("");
13832 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13833 log_info ("You are STRONGLY encouraged not to use it");
13834 log_info ("You can use --force to override this but do not post error reports if you do so");
13835 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13836 log_info ("");
13837
13838 return (-1);
13839 }
13840 }
13841 }
13842 */
13843
13844 /**
13845 * kernel accel and loops tuning db adjustment
13846 */
13847
13848 device_param->kernel_accel_min = 1;
13849 device_param->kernel_accel_max = 1024;
13850
13851 device_param->kernel_loops_min = 1;
13852 device_param->kernel_loops_max = 1024;
13853
13854 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13855
13856 if (tuningdb_entry)
13857 {
13858 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13859 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13860
13861 if (_kernel_accel)
13862 {
13863 device_param->kernel_accel_min = _kernel_accel;
13864 device_param->kernel_accel_max = _kernel_accel;
13865 }
13866
13867 if (_kernel_loops)
13868 {
13869 if (workload_profile == 1)
13870 {
13871 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13872 }
13873 else if (workload_profile == 2)
13874 {
13875 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13876 }
13877
13878 device_param->kernel_loops_min = _kernel_loops;
13879 device_param->kernel_loops_max = _kernel_loops;
13880 }
13881 }
13882
13883 // commandline parameters overwrite tuningdb entries
13884
13885 if (kernel_accel)
13886 {
13887 device_param->kernel_accel_min = kernel_accel;
13888 device_param->kernel_accel_max = kernel_accel;
13889 }
13890
13891 if (kernel_loops)
13892 {
13893 device_param->kernel_loops_min = kernel_loops;
13894 device_param->kernel_loops_max = kernel_loops;
13895 }
13896
13897 /**
13898 * activate device
13899 */
13900
13901 devices_active++;
13902 }
13903
13904 // next please
13905
13906 devices_cnt++;
13907 }
13908 }
13909
13910 if (keyspace == 0 && devices_active == 0)
13911 {
13912 log_error ("ERROR: No devices found/left");
13913
13914 return (-1);
13915 }
13916
13917 // 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)
13918
13919 if (devices_filter != (uint) -1)
13920 {
13921 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13922
13923 if (devices_filter > devices_cnt_mask)
13924 {
13925 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13926
13927 return (-1);
13928 }
13929 }
13930
13931 data.devices_cnt = devices_cnt;
13932
13933 data.devices_active = devices_active;
13934
13935 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13936 {
13937 if (machine_readable == 0)
13938 {
13939 log_info ("");
13940 }
13941 }
13942
13943 /**
13944 * HM devices: init
13945 */
13946
13947 #ifdef HAVE_HWMON
13948 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13949 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13950 #endif
13951
13952 #ifdef HAVE_ADL
13953 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13954 #endif
13955
13956 if (gpu_temp_disable == 0)
13957 {
13958 #if defined(WIN) && defined(HAVE_NVAPI)
13959 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13960
13961 if (nvapi_init (nvapi) == 0)
13962 data.hm_nv = nvapi;
13963
13964 if (data.hm_nv)
13965 {
13966 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13967 {
13968 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13969
13970 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13971
13972 int tmp_out = 0;
13973
13974 for (int i = 0; i < tmp_in; i++)
13975 {
13976 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13977 }
13978
13979 for (int i = 0; i < tmp_out; i++)
13980 {
13981 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13982
13983 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13984
13985 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13986 }
13987 }
13988 }
13989 #endif // WIN && HAVE_NVAPI
13990
13991 #if defined(LINUX) && defined(HAVE_NVML)
13992 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13993
13994 if (nvml_init (nvml) == 0)
13995 data.hm_nv = nvml;
13996
13997 if (data.hm_nv)
13998 {
13999 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14000 {
14001 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14002
14003 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14004
14005 int tmp_out = 0;
14006
14007 for (int i = 0; i < tmp_in; i++)
14008 {
14009 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14010 }
14011
14012 for (int i = 0; i < tmp_out; i++)
14013 {
14014 unsigned int speed;
14015
14016 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
14017 }
14018 }
14019 }
14020 #endif // LINUX && HAVE_NVML
14021
14022 data.hm_amd = NULL;
14023
14024 #ifdef HAVE_ADL
14025 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14026
14027 if (adl_init (adl) == 0)
14028 data.hm_amd = adl;
14029
14030 if (data.hm_amd)
14031 {
14032 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14033 {
14034 // total number of adapters
14035
14036 int hm_adapters_num;
14037
14038 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14039
14040 // adapter info
14041
14042 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14043
14044 if (lpAdapterInfo == NULL) return (-1);
14045
14046 // get a list (of ids of) valid/usable adapters
14047
14048 int num_adl_adapters = 0;
14049
14050 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14051
14052 if (num_adl_adapters > 0)
14053 {
14054 hc_thread_mutex_lock (mux_adl);
14055
14056 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14057
14058 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14059
14060 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14061 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14062
14063 hc_thread_mutex_unlock (mux_adl);
14064 }
14065
14066 myfree (valid_adl_device_list);
14067 myfree (lpAdapterInfo);
14068 }
14069 }
14070 #endif // HAVE_ADL
14071
14072 if (data.hm_amd == NULL && data.hm_nv == NULL)
14073 {
14074 gpu_temp_disable = 1;
14075 }
14076 }
14077
14078 /**
14079 * OpenCL devices: allocate buffer for device specific information
14080 */
14081
14082 #ifdef HAVE_HWMON
14083 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14084
14085 #ifdef HAVE_ADL
14086 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14087
14088 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14089 #endif // ADL
14090 #endif
14091
14092 /**
14093 * enable custom signal handler(s)
14094 */
14095
14096 if (benchmark == 0)
14097 {
14098 hc_signal (sigHandler_default);
14099 }
14100 else
14101 {
14102 hc_signal (sigHandler_benchmark);
14103 }
14104
14105 /**
14106 * User-defined GPU temp handling
14107 */
14108
14109 #ifdef HAVE_HWMON
14110 if (gpu_temp_disable == 1)
14111 {
14112 gpu_temp_abort = 0;
14113 gpu_temp_retain = 0;
14114 }
14115
14116 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14117 {
14118 if (gpu_temp_abort < gpu_temp_retain)
14119 {
14120 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14121
14122 return (-1);
14123 }
14124 }
14125
14126 data.gpu_temp_disable = gpu_temp_disable;
14127 data.gpu_temp_abort = gpu_temp_abort;
14128 data.gpu_temp_retain = gpu_temp_retain;
14129 #endif
14130
14131 /**
14132 * inform the user
14133 */
14134
14135 if (data.quiet == 0)
14136 {
14137 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14138
14139 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);
14140
14141 if (attack_mode == ATTACK_MODE_STRAIGHT)
14142 {
14143 log_info ("Rules: %u", kernel_rules_cnt);
14144 }
14145
14146 if (opti_type)
14147 {
14148 log_info ("Applicable Optimizers:");
14149
14150 for (uint i = 0; i < 32; i++)
14151 {
14152 const uint opti_bit = 1u << i;
14153
14154 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14155 }
14156 }
14157
14158 /**
14159 * Watchdog and Temperature balance
14160 */
14161
14162 #ifdef HAVE_HWMON
14163 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14164 {
14165 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14166 }
14167
14168 if (gpu_temp_abort == 0)
14169 {
14170 log_info ("Watchdog: Temperature abort trigger disabled");
14171 }
14172 else
14173 {
14174 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14175 }
14176
14177 if (gpu_temp_retain == 0)
14178 {
14179 log_info ("Watchdog: Temperature retain trigger disabled");
14180 }
14181 else
14182 {
14183 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14184 }
14185
14186 if (data.quiet == 0) log_info ("");
14187 #endif
14188 }
14189
14190 /**
14191 * HM devices: copy
14192 */
14193
14194 if (gpu_temp_disable == 0)
14195 {
14196 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14197 {
14198 hc_device_param_t *device_param = &data.devices_param[device_id];
14199
14200 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14201
14202 if (device_param->skipped) continue;
14203
14204 const uint platform_devices_id = device_param->platform_devices_id;
14205
14206 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14207 if (device_param->device_vendor_id == VENDOR_ID_NV)
14208 {
14209 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14210 }
14211 #endif
14212
14213 #ifdef HAVE_ADL
14214 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14215 {
14216 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14217 }
14218 #endif
14219 }
14220 }
14221
14222 /*
14223 * Temporary fix:
14224 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14225 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14226 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14227 * Driver / ADL bug?
14228 */
14229
14230 #ifdef HAVE_ADL
14231 if (powertune_enable == 1)
14232 {
14233 hc_thread_mutex_lock (mux_adl);
14234
14235 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14236 {
14237 hc_device_param_t *device_param = &data.devices_param[device_id];
14238
14239 if (device_param->skipped) continue;
14240
14241 if (data.hm_device[device_id].od_version == 6)
14242 {
14243 // set powertune value only
14244
14245 int powertune_supported = 0;
14246
14247 int ADL_rc = 0;
14248
14249 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14250 {
14251 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14252
14253 return (-1);
14254 }
14255
14256 if (powertune_supported != 0)
14257 {
14258 // powertune set
14259 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14260
14261 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14262 {
14263 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14264
14265 return (-1);
14266 }
14267
14268 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14269 {
14270 log_error ("ERROR: Failed to set new ADL PowerControl values");
14271
14272 return (-1);
14273 }
14274 }
14275 }
14276 }
14277
14278 hc_thread_mutex_unlock (mux_adl);
14279 }
14280 #endif // HAVE_ADK
14281 #endif // HAVE_HWMON
14282
14283 #ifdef DEBUG
14284 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14285 #endif
14286
14287 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14288
14289 uint kernel_power_all = 0;
14290
14291 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14292 {
14293 /**
14294 * host buffer
14295 */
14296
14297 hc_device_param_t *device_param = &data.devices_param[device_id];
14298
14299 if (device_param->skipped) continue;
14300
14301 /**
14302 * device properties
14303 */
14304
14305 const char *device_name_chksum = device_param->device_name_chksum;
14306 const u32 device_processors = device_param->device_processors;
14307 const u32 device_processor_cores = device_param->device_processor_cores;
14308
14309 /**
14310 * create context for each device
14311 */
14312
14313 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14314
14315 /**
14316 * create command-queue
14317 */
14318
14319 // not supported with NV
14320 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14321
14322 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14323
14324 /**
14325 * kernel threads: some algorithms need a fixed kernel-threads count
14326 * because of shared memory usage or bitslice
14327 * there needs to be some upper limit, otherwise there's too much overhead
14328 */
14329
14330 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14331
14332 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14333 {
14334 kernel_threads = KERNEL_THREADS_MAX_CPU;
14335 }
14336
14337 if (hash_mode == 1500) kernel_threads = 64; // DES
14338 if (hash_mode == 3000) kernel_threads = 64; // DES
14339 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14340 if (hash_mode == 7500) kernel_threads = 64; // RC4
14341 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14342 if (hash_mode == 9700) kernel_threads = 64; // RC4
14343 if (hash_mode == 9710) kernel_threads = 64; // RC4
14344 if (hash_mode == 9800) kernel_threads = 64; // RC4
14345 if (hash_mode == 9810) kernel_threads = 64; // RC4
14346 if (hash_mode == 10400) kernel_threads = 64; // RC4
14347 if (hash_mode == 10410) kernel_threads = 64; // RC4
14348 if (hash_mode == 10500) kernel_threads = 64; // RC4
14349 if (hash_mode == 13100) kernel_threads = 64; // RC4
14350
14351 /**
14352 * create input buffers on device : calculate size of fixed memory buffers
14353 */
14354
14355 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14356 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14357
14358 device_param->size_root_css = size_root_css;
14359 device_param->size_markov_css = size_markov_css;
14360
14361 size_t size_results = sizeof (uint);
14362
14363 device_param->size_results = size_results;
14364
14365 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14366 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14367
14368 size_t size_plains = digests_cnt * sizeof (plain_t);
14369 size_t size_salts = salts_cnt * sizeof (salt_t);
14370 size_t size_esalts = salts_cnt * esalt_size;
14371
14372 device_param->size_plains = size_plains;
14373 device_param->size_digests = size_digests;
14374 device_param->size_shown = size_shown;
14375 device_param->size_salts = size_salts;
14376
14377 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14378 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14379 size_t size_tm = 32 * sizeof (bs_word_t);
14380
14381 // scryptV stuff
14382
14383 size_t size_scryptV = 1;
14384
14385 if ((hash_mode == 8900) || (hash_mode == 9300))
14386 {
14387 uint tmto_start = 0;
14388 uint tmto_stop = 10;
14389
14390 if (scrypt_tmto)
14391 {
14392 tmto_start = scrypt_tmto;
14393 }
14394 else
14395 {
14396 // in case the user did not specify the tmto manually
14397 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14398 // but set the lower end only in case the user has a device with too less memory
14399
14400 if (hash_mode == 8900)
14401 {
14402 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14403 {
14404 tmto_start = 1;
14405 }
14406 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14407 {
14408 tmto_start = 2;
14409 }
14410 }
14411 else if (hash_mode == 9300)
14412 {
14413 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14414 {
14415 tmto_start = 2;
14416 }
14417 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14418 {
14419 tmto_start = 2;
14420 }
14421 }
14422 }
14423
14424 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14425 {
14426 // TODO: in theory the following calculation needs to be done per salt, not global
14427 // we assume all hashes have the same scrypt settings
14428
14429 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14430
14431 size_scryptV /= 1 << tmto;
14432
14433 size_scryptV *= device_processors * device_processor_cores;
14434
14435 if (size_scryptV > device_param->device_maxmem_alloc)
14436 {
14437 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14438
14439 continue;
14440 }
14441
14442 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14443 {
14444 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14445 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14446 }
14447
14448 break;
14449 }
14450
14451 if (data.salts_buf[0].scrypt_phy == 0)
14452 {
14453 log_error ("ERROR: can't allocate enough device memory");
14454
14455 return -1;
14456 }
14457
14458 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14459 }
14460
14461 /**
14462 * some algorithms need a fixed kernel-loops count
14463 */
14464
14465 if (hash_mode == 1500)
14466 {
14467 const u32 kernel_loops_fixed = 1024;
14468
14469 device_param->kernel_loops_min = kernel_loops_fixed;
14470 device_param->kernel_loops_max = kernel_loops_fixed;
14471 }
14472
14473 if (hash_mode == 3000)
14474 {
14475 const u32 kernel_loops_fixed = 1024;
14476
14477 device_param->kernel_loops_min = kernel_loops_fixed;
14478 device_param->kernel_loops_max = kernel_loops_fixed;
14479 }
14480
14481 if (hash_mode == 8900)
14482 {
14483 const u32 kernel_loops_fixed = 1;
14484
14485 device_param->kernel_loops_min = kernel_loops_fixed;
14486 device_param->kernel_loops_max = kernel_loops_fixed;
14487 }
14488
14489 if (hash_mode == 9300)
14490 {
14491 const u32 kernel_loops_fixed = 1;
14492
14493 device_param->kernel_loops_min = kernel_loops_fixed;
14494 device_param->kernel_loops_max = kernel_loops_fixed;
14495 }
14496
14497 if (hash_mode == 12500)
14498 {
14499 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14500
14501 device_param->kernel_loops_min = kernel_loops_fixed;
14502 device_param->kernel_loops_max = kernel_loops_fixed;
14503 }
14504
14505 /**
14506 * some algorithms have a maximum kernel-loops count
14507 */
14508
14509 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14510 {
14511 u32 innerloop_cnt = 0;
14512
14513 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14514 {
14515 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14516 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14517 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14518 }
14519 else
14520 {
14521 innerloop_cnt = data.salts_buf[0].salt_iter;
14522 }
14523
14524 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14525 (innerloop_cnt <= device_param->kernel_loops_max))
14526 {
14527 device_param->kernel_loops_max = innerloop_cnt;
14528 }
14529 }
14530
14531 u32 kernel_accel_min = device_param->kernel_accel_min;
14532 u32 kernel_accel_max = device_param->kernel_accel_max;
14533
14534 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14535
14536 size_t size_pws = 4;
14537 size_t size_tmps = 4;
14538 size_t size_hooks = 4;
14539
14540 while (kernel_accel_max >= kernel_accel_min)
14541 {
14542 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14543
14544 // size_pws
14545
14546 size_pws = kernel_power_max * sizeof (pw_t);
14547
14548 // size_tmps
14549
14550 switch (hash_mode)
14551 {
14552 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14553 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14554 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14555 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14556 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14557 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14558 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14559 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14560 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14561 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14562 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14563 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14564 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14565 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14566 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14567 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14568 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14569 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14570 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14571 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14572 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14573 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14574 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14575 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14576 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14577 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14578 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14579 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14580 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14581 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14582 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14583 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14584 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14585 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14586 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14587 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14588 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14589 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14590 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14591 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14592 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14593 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14594 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14595 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14596 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14597 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14598 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14599 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14600 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14601 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14602 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14603 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14604 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14605 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14606 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14607 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14608 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14609 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14610 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14611 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14612 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14613 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14614 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14615 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14616 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14617 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14618 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14619 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14620 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14621 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14622 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14623 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14624 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14625 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14626 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14627 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14628 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14629 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14630 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14631 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14632 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14633 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14634 };
14635
14636 // size_hooks
14637
14638 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14639 {
14640 // none yet
14641 }
14642
14643 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14644 // if not, decrease amplifier and try again
14645
14646 int skip = 0;
14647
14648 const u64 size_total
14649 = bitmap_size
14650 + bitmap_size
14651 + bitmap_size
14652 + bitmap_size
14653 + bitmap_size
14654 + bitmap_size
14655 + bitmap_size
14656 + bitmap_size
14657 + size_bfs
14658 + size_combs
14659 + size_digests
14660 + size_esalts
14661 + size_hooks
14662 + size_markov_css
14663 + size_plains
14664 + size_pws
14665 + size_pws // not a bug
14666 + size_results
14667 + size_root_css
14668 + size_rules
14669 + size_rules_c
14670 + size_salts
14671 + size_scryptV
14672 + size_shown
14673 + size_tm
14674 + size_tmps;
14675
14676 // Don't ask me, ask AMD!
14677
14678 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14679 if (size_total > device_param->device_global_mem) skip = 1;
14680
14681 if (skip == 1)
14682 {
14683 kernel_accel_max--;
14684
14685 continue;
14686 }
14687
14688 break;
14689 }
14690
14691 /*
14692 if (kernel_accel_max == 0)
14693 {
14694 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14695
14696 return -1;
14697 }
14698 */
14699
14700 device_param->kernel_accel_min = kernel_accel_min;
14701 device_param->kernel_accel_max = kernel_accel_max;
14702
14703 /*
14704 if (kernel_accel_max < kernel_accel)
14705 {
14706 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14707
14708 device_param->kernel_accel = kernel_accel_max;
14709 }
14710 */
14711
14712 device_param->size_bfs = size_bfs;
14713 device_param->size_combs = size_combs;
14714 device_param->size_rules = size_rules;
14715 device_param->size_rules_c = size_rules_c;
14716 device_param->size_pws = size_pws;
14717 device_param->size_tmps = size_tmps;
14718 device_param->size_hooks = size_hooks;
14719
14720 // do not confuse kernel_accel_max with kernel_accel here
14721
14722 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14723
14724 device_param->kernel_threads = kernel_threads;
14725 device_param->kernel_power_user = kernel_power;
14726
14727 kernel_power_all += kernel_power;
14728
14729 /**
14730 * default building options
14731 */
14732
14733 char build_opts[1024] = { 0 };
14734
14735 // we don't have sm_* on vendors not NV but it doesn't matter
14736
14737 #if _WIN
14738 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);
14739 #else
14740 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);
14741 #endif
14742
14743 char build_opts_new[1024] = { 0 };
14744
14745 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);
14746
14747 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14748
14749 /*
14750 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14751 {
14752 // we do vectorizing much better than the auto-vectorizer
14753
14754 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14755
14756 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14757 }
14758 */
14759
14760 #ifdef DEBUG
14761 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14762 #endif
14763
14764 /**
14765 * main kernel
14766 */
14767
14768 {
14769 /**
14770 * kernel source filename
14771 */
14772
14773 char source_file[256] = { 0 };
14774
14775 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14776
14777 struct stat sst;
14778
14779 if (stat (source_file, &sst) == -1)
14780 {
14781 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14782
14783 return -1;
14784 }
14785
14786 /**
14787 * kernel cached filename
14788 */
14789
14790 char cached_file[256] = { 0 };
14791
14792 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14793
14794 int cached = 1;
14795
14796 struct stat cst;
14797
14798 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14799 {
14800 cached = 0;
14801 }
14802
14803 /**
14804 * kernel compile or load
14805 */
14806
14807 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14808
14809 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14810
14811 if (force_jit_compilation == -1)
14812 {
14813 if (cached == 0)
14814 {
14815 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14816
14817 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14818
14819 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14820
14821 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14822
14823 #ifdef DEBUG
14824 size_t build_log_size = 0;
14825
14826 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14827
14828 if (build_log_size > 1)
14829 {
14830 char *build_log = (char *) malloc (build_log_size + 1);
14831
14832 memset (build_log, 0, build_log_size + 1);
14833
14834 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14835
14836 puts (build_log);
14837
14838 free (build_log);
14839 }
14840 #endif
14841
14842 if (rc != 0)
14843 {
14844 device_param->skipped = true;
14845
14846 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14847
14848 continue;
14849 }
14850
14851 size_t binary_size;
14852
14853 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14854
14855 u8 *binary = (u8 *) mymalloc (binary_size);
14856
14857 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14858
14859 writeProgramBin (cached_file, binary, binary_size);
14860
14861 local_free (binary);
14862 }
14863 else
14864 {
14865 #ifdef DEBUG
14866 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14867 #endif
14868
14869 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14870
14871 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14872
14873 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14874 }
14875 }
14876 else
14877 {
14878 #ifdef DEBUG
14879 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14880 #endif
14881
14882 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14883
14884 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14885
14886 char build_opts_update[1024] = { 0 };
14887
14888 if (force_jit_compilation == 1500)
14889 {
14890 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14891 }
14892 else if (force_jit_compilation == 8900)
14893 {
14894 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);
14895 }
14896 else
14897 {
14898 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14899 }
14900
14901 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14902
14903 #ifdef DEBUG
14904 size_t build_log_size = 0;
14905
14906 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14907
14908 if (build_log_size > 1)
14909 {
14910 char *build_log = (char *) malloc (build_log_size + 1);
14911
14912 memset (build_log, 0, build_log_size + 1);
14913
14914 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14915
14916 puts (build_log);
14917
14918 free (build_log);
14919 }
14920 #endif
14921
14922 if (rc != 0)
14923 {
14924 device_param->skipped = true;
14925
14926 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14927 }
14928 }
14929
14930 local_free (kernel_lengths);
14931 local_free (kernel_sources[0]);
14932 local_free (kernel_sources);
14933 }
14934
14935 /**
14936 * word generator kernel
14937 */
14938
14939 if (attack_mode != ATTACK_MODE_STRAIGHT)
14940 {
14941 /**
14942 * kernel mp source filename
14943 */
14944
14945 char source_file[256] = { 0 };
14946
14947 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14948
14949 struct stat sst;
14950
14951 if (stat (source_file, &sst) == -1)
14952 {
14953 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14954
14955 return -1;
14956 }
14957
14958 /**
14959 * kernel mp cached filename
14960 */
14961
14962 char cached_file[256] = { 0 };
14963
14964 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14965
14966 int cached = 1;
14967
14968 struct stat cst;
14969
14970 if (stat (cached_file, &cst) == -1)
14971 {
14972 cached = 0;
14973 }
14974
14975 /**
14976 * kernel compile or load
14977 */
14978
14979 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14980
14981 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14982
14983 if (cached == 0)
14984 {
14985 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14986 if (quiet == 0) log_info ("");
14987
14988 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14989
14990 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14991
14992 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14993
14994 if (rc != 0)
14995 {
14996 device_param->skipped = true;
14997
14998 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14999
15000 continue;
15001 }
15002
15003 size_t binary_size;
15004
15005 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15006
15007 u8 *binary = (u8 *) mymalloc (binary_size);
15008
15009 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15010
15011 writeProgramBin (cached_file, binary, binary_size);
15012
15013 local_free (binary);
15014 }
15015 else
15016 {
15017 #ifdef DEBUG
15018 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15019 #endif
15020
15021 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15022
15023 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15024
15025 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15026 }
15027
15028 local_free (kernel_lengths);
15029 local_free (kernel_sources[0]);
15030 local_free (kernel_sources);
15031 }
15032
15033 /**
15034 * amplifier kernel
15035 */
15036
15037 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15038 {
15039
15040 }
15041 else
15042 {
15043 /**
15044 * kernel amp source filename
15045 */
15046
15047 char source_file[256] = { 0 };
15048
15049 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15050
15051 struct stat sst;
15052
15053 if (stat (source_file, &sst) == -1)
15054 {
15055 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15056
15057 return -1;
15058 }
15059
15060 /**
15061 * kernel amp cached filename
15062 */
15063
15064 char cached_file[256] = { 0 };
15065
15066 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15067
15068 int cached = 1;
15069
15070 struct stat cst;
15071
15072 if (stat (cached_file, &cst) == -1)
15073 {
15074 cached = 0;
15075 }
15076
15077 /**
15078 * kernel compile or load
15079 */
15080
15081 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15082
15083 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15084
15085 if (cached == 0)
15086 {
15087 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15088 if (quiet == 0) log_info ("");
15089
15090 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15091
15092 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15093
15094 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15095
15096 if (rc != 0)
15097 {
15098 device_param->skipped = true;
15099
15100 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15101
15102 continue;
15103 }
15104
15105 size_t binary_size;
15106
15107 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15108
15109 u8 *binary = (u8 *) mymalloc (binary_size);
15110
15111 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15112
15113 writeProgramBin (cached_file, binary, binary_size);
15114
15115 local_free (binary);
15116 }
15117 else
15118 {
15119 #ifdef DEBUG
15120 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15121 #endif
15122
15123 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15124
15125 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15126
15127 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15128 }
15129
15130 local_free (kernel_lengths);
15131 local_free (kernel_sources[0]);
15132 local_free (kernel_sources);
15133 }
15134
15135 // some algorithm collide too fast, make that impossible
15136
15137 if (benchmark == 1)
15138 {
15139 ((uint *) digests_buf)[0] = -1;
15140 ((uint *) digests_buf)[1] = -1;
15141 ((uint *) digests_buf)[2] = -1;
15142 ((uint *) digests_buf)[3] = -1;
15143 }
15144
15145 /**
15146 * global buffers
15147 */
15148
15149 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15150 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15151 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15152 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15153 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15154 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15155 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15156 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15157 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15158 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15159 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15160 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15161 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15162 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15163 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15164 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15165 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15166 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15167
15168 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);
15169 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);
15170 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);
15171 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);
15172 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);
15173 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);
15174 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);
15175 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);
15176 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15177 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15178 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15179
15180 /**
15181 * special buffers
15182 */
15183
15184 if (attack_kern == ATTACK_KERN_STRAIGHT)
15185 {
15186 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15187 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15188
15189 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15190 }
15191 else if (attack_kern == ATTACK_KERN_COMBI)
15192 {
15193 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15194 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15195 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15196 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15197 }
15198 else if (attack_kern == ATTACK_KERN_BF)
15199 {
15200 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15201 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15202 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15203 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15204 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15205 }
15206
15207 if (size_esalts)
15208 {
15209 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15210
15211 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15212 }
15213
15214 /**
15215 * main host data
15216 */
15217
15218 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15219
15220 device_param->pws_buf = pws_buf;
15221
15222 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15223
15224 device_param->combs_buf = combs_buf;
15225
15226 void *hooks_buf = mymalloc (size_hooks);
15227
15228 device_param->hooks_buf = hooks_buf;
15229
15230 /**
15231 * kernel args
15232 */
15233
15234 device_param->kernel_params_buf32[21] = bitmap_mask;
15235 device_param->kernel_params_buf32[22] = bitmap_shift1;
15236 device_param->kernel_params_buf32[23] = bitmap_shift2;
15237 device_param->kernel_params_buf32[24] = 0; // salt_pos
15238 device_param->kernel_params_buf32[25] = 0; // loop_pos
15239 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15240 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15241 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15242 device_param->kernel_params_buf32[29] = 0; // digests_offset
15243 device_param->kernel_params_buf32[30] = 0; // combs_mode
15244 device_param->kernel_params_buf32[31] = 0; // gid_max
15245
15246 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15247 ? &device_param->d_pws_buf
15248 : &device_param->d_pws_amp_buf;
15249 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15250 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15251 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15252 device_param->kernel_params[ 4] = &device_param->d_tmps;
15253 device_param->kernel_params[ 5] = &device_param->d_hooks;
15254 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15255 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15256 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15257 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15258 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15259 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15260 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15261 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15262 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15263 device_param->kernel_params[15] = &device_param->d_digests_buf;
15264 device_param->kernel_params[16] = &device_param->d_digests_shown;
15265 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15266 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15267 device_param->kernel_params[19] = &device_param->d_result;
15268 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15269 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15270 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15271 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15272 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15273 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15274 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15275 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15276 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15277 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15278 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15279 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15280
15281 device_param->kernel_params_mp_buf64[3] = 0;
15282 device_param->kernel_params_mp_buf32[4] = 0;
15283 device_param->kernel_params_mp_buf32[5] = 0;
15284 device_param->kernel_params_mp_buf32[6] = 0;
15285 device_param->kernel_params_mp_buf32[7] = 0;
15286 device_param->kernel_params_mp_buf32[8] = 0;
15287
15288 device_param->kernel_params_mp[0] = NULL;
15289 device_param->kernel_params_mp[1] = NULL;
15290 device_param->kernel_params_mp[2] = NULL;
15291 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15292 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15293 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15294 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15295 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15296 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15297
15298 device_param->kernel_params_mp_l_buf64[3] = 0;
15299 device_param->kernel_params_mp_l_buf32[4] = 0;
15300 device_param->kernel_params_mp_l_buf32[5] = 0;
15301 device_param->kernel_params_mp_l_buf32[6] = 0;
15302 device_param->kernel_params_mp_l_buf32[7] = 0;
15303 device_param->kernel_params_mp_l_buf32[8] = 0;
15304 device_param->kernel_params_mp_l_buf32[9] = 0;
15305
15306 device_param->kernel_params_mp_l[0] = NULL;
15307 device_param->kernel_params_mp_l[1] = NULL;
15308 device_param->kernel_params_mp_l[2] = NULL;
15309 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15310 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15311 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15312 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15313 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15314 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15315 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15316
15317 device_param->kernel_params_mp_r_buf64[3] = 0;
15318 device_param->kernel_params_mp_r_buf32[4] = 0;
15319 device_param->kernel_params_mp_r_buf32[5] = 0;
15320 device_param->kernel_params_mp_r_buf32[6] = 0;
15321 device_param->kernel_params_mp_r_buf32[7] = 0;
15322 device_param->kernel_params_mp_r_buf32[8] = 0;
15323
15324 device_param->kernel_params_mp_r[0] = NULL;
15325 device_param->kernel_params_mp_r[1] = NULL;
15326 device_param->kernel_params_mp_r[2] = NULL;
15327 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15328 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15329 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15330 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15331 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15332 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15333
15334 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15335 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15336
15337 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15338 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15339 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15340 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15341 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15342 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15343 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15344
15345 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15346 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15347
15348 device_param->kernel_params_memset_buf32[1] = 0; // value
15349 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15350
15351 device_param->kernel_params_memset[0] = NULL;
15352 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15353 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15354
15355 /**
15356 * kernel name
15357 */
15358
15359 size_t kernel_wgs_tmp;
15360
15361 char kernel_name[64] = { 0 };
15362
15363 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15364 {
15365 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15366 {
15367 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15368
15369 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15370
15371 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15372
15373 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15374
15375 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15376
15377 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15378 }
15379 else
15380 {
15381 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15382
15383 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15384
15385 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15386
15387 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15388
15389 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15390
15391 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15392 }
15393
15394 if (data.attack_mode == ATTACK_MODE_BF)
15395 {
15396 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15397 {
15398 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15399
15400 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15401
15402 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);
15403 }
15404 }
15405 }
15406 else
15407 {
15408 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15409
15410 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15411
15412 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15413
15414 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15415
15416 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15417
15418 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15419
15420 if (opts_type & OPTS_TYPE_HOOK12)
15421 {
15422 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15423
15424 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15425
15426 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);
15427 }
15428
15429 if (opts_type & OPTS_TYPE_HOOK23)
15430 {
15431 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15432
15433 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15434
15435 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);
15436 }
15437 }
15438
15439 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);
15440 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);
15441 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);
15442
15443 for (uint i = 0; i <= 20; i++)
15444 {
15445 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15446 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15447 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15448
15449 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15450 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15451 }
15452
15453 for (uint i = 21; i <= 31; i++)
15454 {
15455 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15456 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15457 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15458
15459 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15460 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15461 }
15462
15463 // GPU memset
15464
15465 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15466
15467 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);
15468
15469 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15470 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15471 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15472
15473 // MP start
15474
15475 if (attack_mode == ATTACK_MODE_BF)
15476 {
15477 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15478 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15479
15480 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);
15481 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);
15482
15483 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15484 {
15485 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15486 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15487 }
15488 }
15489 else if (attack_mode == ATTACK_MODE_HYBRID1)
15490 {
15491 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15492
15493 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);
15494 }
15495 else if (attack_mode == ATTACK_MODE_HYBRID2)
15496 {
15497 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15498
15499 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);
15500 }
15501
15502 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15503 {
15504 // nothing to do
15505 }
15506 else
15507 {
15508 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15509
15510 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);
15511 }
15512
15513 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15514 {
15515 // nothing to do
15516 }
15517 else
15518 {
15519 for (uint i = 0; i < 5; i++)
15520 {
15521 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15522 }
15523
15524 for (uint i = 5; i < 7; i++)
15525 {
15526 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15527 }
15528 }
15529
15530 // maybe this has been updated by clGetKernelWorkGroupInfo()
15531 // value can only be decreased, so we don't need to reallocate buffers
15532
15533 device_param->kernel_threads = kernel_threads;
15534
15535 // zero some data buffers
15536
15537 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15538 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15539 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15540 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15541 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15542 run_kernel_bzero (device_param, device_param->d_result, size_results);
15543
15544 /**
15545 * special buffers
15546 */
15547
15548 if (attack_kern == ATTACK_KERN_STRAIGHT)
15549 {
15550 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15551 }
15552 else if (attack_kern == ATTACK_KERN_COMBI)
15553 {
15554 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15555 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15556 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15557 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15558 }
15559 else if (attack_kern == ATTACK_KERN_BF)
15560 {
15561 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15562 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15563 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15564 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15565 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15566 }
15567
15568 /**
15569 * Store initial fanspeed if gpu_temp_retain is enabled
15570 */
15571
15572 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15573 int gpu_temp_retain_set = 0;
15574
15575 if (gpu_temp_disable == 0)
15576 {
15577 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15578 {
15579 hc_thread_mutex_lock (mux_adl);
15580
15581 if (data.hm_device[device_id].fan_supported == 1)
15582 {
15583 if (gpu_temp_retain_chgd == 0)
15584 {
15585 uint cur_temp = 0;
15586 uint default_temp = 0;
15587
15588 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15589
15590 if (ADL_rc == ADL_OK)
15591 {
15592 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15593
15594 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15595
15596 // special case with multi gpu setups: always use minimum retain
15597
15598 if (gpu_temp_retain_set == 0)
15599 {
15600 gpu_temp_retain = gpu_temp_retain_target;
15601 gpu_temp_retain_set = 1;
15602 }
15603 else
15604 {
15605 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15606 }
15607
15608 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15609 }
15610 }
15611
15612 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15613
15614 temp_retain_fanspeed_value[device_id] = fan_speed;
15615
15616 if (fan_speed == -1)
15617 {
15618 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15619
15620 temp_retain_fanspeed_value[device_id] = 0;
15621 }
15622 }
15623
15624 hc_thread_mutex_unlock (mux_adl);
15625 }
15626 }
15627
15628 /**
15629 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15630 */
15631
15632 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15633 {
15634 hc_thread_mutex_lock (mux_adl);
15635
15636 if (data.hm_device[device_id].od_version == 6)
15637 {
15638 int ADL_rc;
15639
15640 // check powertune capabilities first, if not available then skip device
15641
15642 int powertune_supported = 0;
15643
15644 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15645 {
15646 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15647
15648 return (-1);
15649 }
15650
15651 if (powertune_supported != 0)
15652 {
15653 // powercontrol settings
15654
15655 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15656
15657 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15658 {
15659 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15660 }
15661
15662 if (ADL_rc != ADL_OK)
15663 {
15664 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15665
15666 return (-1);
15667 }
15668
15669 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15670 {
15671 log_error ("ERROR: Failed to set new ADL PowerControl values");
15672
15673 return (-1);
15674 }
15675
15676 // clocks
15677
15678 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15679
15680 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15681
15682 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15683 {
15684 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15685
15686 return (-1);
15687 }
15688
15689 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15690
15691 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15692
15693 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15694 {
15695 log_error ("ERROR: Failed to get ADL device capabilities");
15696
15697 return (-1);
15698 }
15699
15700 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15701 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15702
15703 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15704 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15705
15706 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15707 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15708
15709 // warning if profile has too low max values
15710
15711 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15712 {
15713 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15714 }
15715
15716 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15717 {
15718 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15719 }
15720
15721 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15722
15723 performance_state->iNumberOfPerformanceLevels = 2;
15724
15725 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15726 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15727 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15728 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15729
15730 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15731 {
15732 log_info ("ERROR: Failed to set ADL performance state");
15733
15734 return (-1);
15735 }
15736
15737 local_free (performance_state);
15738 }
15739 }
15740
15741 hc_thread_mutex_unlock (mux_adl);
15742 }
15743 #endif // HAVE_HWMON && HAVE_ADL
15744 }
15745
15746 data.kernel_power_all = kernel_power_all;
15747
15748 if (data.quiet == 0) log_info_nn ("");
15749
15750 /**
15751 * In benchmark-mode, inform user which algorithm is checked
15752 */
15753
15754 if (benchmark == 1)
15755 {
15756 if (machine_readable == 0)
15757 {
15758 quiet = 0;
15759
15760 data.quiet = quiet;
15761
15762 char *hash_type = strhashtype (data.hash_mode); // not a bug
15763
15764 log_info ("Hashtype: %s", hash_type);
15765 log_info ("");
15766 }
15767 }
15768
15769 /**
15770 * keep track of the progress
15771 */
15772
15773 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15774 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15775 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15776
15777 /**
15778 * open filehandles
15779 */
15780
15781 #if _WIN
15782 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15783 {
15784 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15785
15786 return (-1);
15787 }
15788
15789 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15790 {
15791 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15792
15793 return (-1);
15794 }
15795
15796 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15797 {
15798 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15799
15800 return (-1);
15801 }
15802 #endif
15803
15804 /**
15805 * dictionary pad
15806 */
15807
15808 segment_size *= (1024 * 1024);
15809
15810 data.segment_size = segment_size;
15811
15812 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15813
15814 wl_data->buf = (char *) mymalloc (segment_size);
15815 wl_data->avail = segment_size;
15816 wl_data->incr = segment_size;
15817 wl_data->cnt = 0;
15818 wl_data->pos = 0;
15819
15820 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15821
15822 data.wordlist_mode = wordlist_mode;
15823
15824 cs_t *css_buf = NULL;
15825 uint css_cnt = 0;
15826 uint dictcnt = 0;
15827 uint maskcnt = 1;
15828 char **masks = NULL;
15829 char **dictfiles = NULL;
15830
15831 uint mask_from_file = 0;
15832
15833 if (attack_mode == ATTACK_MODE_STRAIGHT)
15834 {
15835 if (wordlist_mode == WL_MODE_FILE)
15836 {
15837 int wls_left = myargc - (optind + 1);
15838
15839 for (int i = 0; i < wls_left; i++)
15840 {
15841 char *l0_filename = myargv[optind + 1 + i];
15842
15843 struct stat l0_stat;
15844
15845 if (stat (l0_filename, &l0_stat) == -1)
15846 {
15847 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15848
15849 return (-1);
15850 }
15851
15852 uint is_dir = S_ISDIR (l0_stat.st_mode);
15853
15854 if (is_dir == 0)
15855 {
15856 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15857
15858 dictcnt++;
15859
15860 dictfiles[dictcnt - 1] = l0_filename;
15861 }
15862 else
15863 {
15864 // do not allow --keyspace w/ a directory
15865
15866 if (keyspace == 1)
15867 {
15868 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15869
15870 return (-1);
15871 }
15872
15873 char **dictionary_files = NULL;
15874
15875 dictionary_files = scan_directory (l0_filename);
15876
15877 if (dictionary_files != NULL)
15878 {
15879 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15880
15881 for (int d = 0; dictionary_files[d] != NULL; d++)
15882 {
15883 char *l1_filename = dictionary_files[d];
15884
15885 struct stat l1_stat;
15886
15887 if (stat (l1_filename, &l1_stat) == -1)
15888 {
15889 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15890
15891 return (-1);
15892 }
15893
15894 if (S_ISREG (l1_stat.st_mode))
15895 {
15896 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15897
15898 dictcnt++;
15899
15900 dictfiles[dictcnt - 1] = strdup (l1_filename);
15901 }
15902 }
15903 }
15904
15905 local_free (dictionary_files);
15906 }
15907 }
15908
15909 if (dictcnt < 1)
15910 {
15911 log_error ("ERROR: No usable dictionary file found.");
15912
15913 return (-1);
15914 }
15915 }
15916 else if (wordlist_mode == WL_MODE_STDIN)
15917 {
15918 dictcnt = 1;
15919 }
15920 }
15921 else if (attack_mode == ATTACK_MODE_COMBI)
15922 {
15923 // display
15924
15925 char *dictfile1 = myargv[optind + 1 + 0];
15926 char *dictfile2 = myargv[optind + 1 + 1];
15927
15928 // find the bigger dictionary and use as base
15929
15930 FILE *fp1 = NULL;
15931 FILE *fp2 = NULL;
15932
15933 struct stat tmp_stat;
15934
15935 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15936 {
15937 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15938
15939 return (-1);
15940 }
15941
15942 if (stat (dictfile1, &tmp_stat) == -1)
15943 {
15944 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15945
15946 fclose (fp1);
15947
15948 return (-1);
15949 }
15950
15951 if (S_ISDIR (tmp_stat.st_mode))
15952 {
15953 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15954
15955 fclose (fp1);
15956
15957 return (-1);
15958 }
15959
15960 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15961 {
15962 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15963
15964 fclose (fp1);
15965
15966 return (-1);
15967 }
15968
15969 if (stat (dictfile2, &tmp_stat) == -1)
15970 {
15971 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15972
15973 fclose (fp1);
15974 fclose (fp2);
15975
15976 return (-1);
15977 }
15978
15979 if (S_ISDIR (tmp_stat.st_mode))
15980 {
15981 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15982
15983 fclose (fp1);
15984 fclose (fp2);
15985
15986 return (-1);
15987 }
15988
15989 data.combs_cnt = 1;
15990
15991 data.quiet = 1;
15992
15993 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15994
15995 data.quiet = quiet;
15996
15997 if (words1_cnt == 0)
15998 {
15999 log_error ("ERROR: %s: empty file", dictfile1);
16000
16001 fclose (fp1);
16002 fclose (fp2);
16003
16004 return (-1);
16005 }
16006
16007 data.combs_cnt = 1;
16008
16009 data.quiet = 1;
16010
16011 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16012
16013 data.quiet = quiet;
16014
16015 if (words2_cnt == 0)
16016 {
16017 log_error ("ERROR: %s: empty file", dictfile2);
16018
16019 fclose (fp1);
16020 fclose (fp2);
16021
16022 return (-1);
16023 }
16024
16025 fclose (fp1);
16026 fclose (fp2);
16027
16028 data.dictfile = dictfile1;
16029 data.dictfile2 = dictfile2;
16030
16031 if (words1_cnt >= words2_cnt)
16032 {
16033 data.combs_cnt = words2_cnt;
16034 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16035
16036 dictfiles = &data.dictfile;
16037
16038 dictcnt = 1;
16039 }
16040 else
16041 {
16042 data.combs_cnt = words1_cnt;
16043 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16044
16045 dictfiles = &data.dictfile2;
16046
16047 dictcnt = 1;
16048
16049 // we also have to switch wordlist related rules!
16050
16051 char *tmpc = data.rule_buf_l;
16052
16053 data.rule_buf_l = data.rule_buf_r;
16054 data.rule_buf_r = tmpc;
16055
16056 int tmpi = data.rule_len_l;
16057
16058 data.rule_len_l = data.rule_len_r;
16059 data.rule_len_r = tmpi;
16060 }
16061 }
16062 else if (attack_mode == ATTACK_MODE_BF)
16063 {
16064 char *mask = NULL;
16065
16066 maskcnt = 0;
16067
16068 if (benchmark == 0)
16069 {
16070 mask = myargv[optind + 1];
16071
16072 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16073
16074 if ((optind + 2) <= myargc)
16075 {
16076 struct stat file_stat;
16077
16078 if (stat (mask, &file_stat) == -1)
16079 {
16080 maskcnt = 1;
16081
16082 masks[maskcnt - 1] = mystrdup (mask);
16083 }
16084 else
16085 {
16086 int wls_left = myargc - (optind + 1);
16087
16088 uint masks_avail = INCR_MASKS;
16089
16090 for (int i = 0; i < wls_left; i++)
16091 {
16092 if (i != 0)
16093 {
16094 mask = myargv[optind + 1 + i];
16095
16096 if (stat (mask, &file_stat) == -1)
16097 {
16098 log_error ("ERROR: %s: %s", mask, strerror (errno));
16099
16100 return (-1);
16101 }
16102 }
16103
16104 uint is_file = S_ISREG (file_stat.st_mode);
16105
16106 if (is_file == 1)
16107 {
16108 FILE *mask_fp;
16109
16110 if ((mask_fp = fopen (mask, "r")) == NULL)
16111 {
16112 log_error ("ERROR: %s: %s", mask, strerror (errno));
16113
16114 return (-1);
16115 }
16116
16117 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16118
16119 while (!feof (mask_fp))
16120 {
16121 memset (line_buf, 0, HCBUFSIZ);
16122
16123 int line_len = fgetl (mask_fp, line_buf);
16124
16125 if (line_len == 0) continue;
16126
16127 if (line_buf[0] == '#') continue;
16128
16129 if (masks_avail == maskcnt)
16130 {
16131 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16132
16133 masks_avail += INCR_MASKS;
16134 }
16135
16136 masks[maskcnt] = mystrdup (line_buf);
16137
16138 maskcnt++;
16139 }
16140
16141 myfree (line_buf);
16142
16143 fclose (mask_fp);
16144 }
16145 else
16146 {
16147 log_error ("ERROR: %s: unsupported file-type", mask);
16148
16149 return (-1);
16150 }
16151 }
16152
16153 mask_from_file = 1;
16154 }
16155 }
16156 else
16157 {
16158 custom_charset_1 = (char *) "?l?d?u";
16159 custom_charset_2 = (char *) "?l?d";
16160 custom_charset_3 = (char *) "?l?d*!$@_";
16161
16162 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16163 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16164 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16165
16166 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16167
16168 wordlist_mode = WL_MODE_MASK;
16169
16170 data.wordlist_mode = wordlist_mode;
16171
16172 increment = 1;
16173
16174 maskcnt = 1;
16175 }
16176 }
16177 else
16178 {
16179 /**
16180 * generate full masks and charsets
16181 */
16182
16183 masks = (char **) mymalloc (sizeof (char *));
16184
16185 switch (hash_mode)
16186 {
16187 case 1731: pw_min = 5;
16188 pw_max = 5;
16189 mask = mystrdup ("?b?b?b?b?b");
16190 break;
16191 case 12500: pw_min = 5;
16192 pw_max = 5;
16193 mask = mystrdup ("?b?b?b?b?b");
16194 break;
16195 default: pw_min = 7;
16196 pw_max = 7;
16197 mask = mystrdup ("?b?b?b?b?b?b?b");
16198 break;
16199 }
16200
16201 maskcnt = 1;
16202
16203 masks[maskcnt - 1] = mystrdup (mask);
16204
16205 wordlist_mode = WL_MODE_MASK;
16206
16207 data.wordlist_mode = wordlist_mode;
16208
16209 increment = 1;
16210 }
16211
16212 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16213
16214 if (increment)
16215 {
16216 if (increment_min > pw_min) pw_min = increment_min;
16217
16218 if (increment_max < pw_max) pw_max = increment_max;
16219 }
16220 }
16221 else if (attack_mode == ATTACK_MODE_HYBRID1)
16222 {
16223 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16224
16225 // display
16226
16227 char *mask = myargv[myargc - 1];
16228
16229 maskcnt = 0;
16230
16231 masks = (char **) mymalloc (1 * sizeof (char *));
16232
16233 // mod
16234
16235 struct stat file_stat;
16236
16237 if (stat (mask, &file_stat) == -1)
16238 {
16239 maskcnt = 1;
16240
16241 masks[maskcnt - 1] = mystrdup (mask);
16242 }
16243 else
16244 {
16245 uint is_file = S_ISREG (file_stat.st_mode);
16246
16247 if (is_file == 1)
16248 {
16249 FILE *mask_fp;
16250
16251 if ((mask_fp = fopen (mask, "r")) == NULL)
16252 {
16253 log_error ("ERROR: %s: %s", mask, strerror (errno));
16254
16255 return (-1);
16256 }
16257
16258 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16259
16260 uint masks_avail = 1;
16261
16262 while (!feof (mask_fp))
16263 {
16264 memset (line_buf, 0, HCBUFSIZ);
16265
16266 int line_len = fgetl (mask_fp, line_buf);
16267
16268 if (line_len == 0) continue;
16269
16270 if (line_buf[0] == '#') continue;
16271
16272 if (masks_avail == maskcnt)
16273 {
16274 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16275
16276 masks_avail += INCR_MASKS;
16277 }
16278
16279 masks[maskcnt] = mystrdup (line_buf);
16280
16281 maskcnt++;
16282 }
16283
16284 myfree (line_buf);
16285
16286 fclose (mask_fp);
16287
16288 mask_from_file = 1;
16289 }
16290 else
16291 {
16292 maskcnt = 1;
16293
16294 masks[maskcnt - 1] = mystrdup (mask);
16295 }
16296 }
16297
16298 // base
16299
16300 int wls_left = myargc - (optind + 2);
16301
16302 for (int i = 0; i < wls_left; i++)
16303 {
16304 char *filename = myargv[optind + 1 + i];
16305
16306 struct stat file_stat;
16307
16308 if (stat (filename, &file_stat) == -1)
16309 {
16310 log_error ("ERROR: %s: %s", filename, strerror (errno));
16311
16312 return (-1);
16313 }
16314
16315 uint is_dir = S_ISDIR (file_stat.st_mode);
16316
16317 if (is_dir == 0)
16318 {
16319 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16320
16321 dictcnt++;
16322
16323 dictfiles[dictcnt - 1] = filename;
16324 }
16325 else
16326 {
16327 // do not allow --keyspace w/ a directory
16328
16329 if (keyspace == 1)
16330 {
16331 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16332
16333 return (-1);
16334 }
16335
16336 char **dictionary_files = NULL;
16337
16338 dictionary_files = scan_directory (filename);
16339
16340 if (dictionary_files != NULL)
16341 {
16342 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16343
16344 for (int d = 0; dictionary_files[d] != NULL; d++)
16345 {
16346 char *l1_filename = dictionary_files[d];
16347
16348 struct stat l1_stat;
16349
16350 if (stat (l1_filename, &l1_stat) == -1)
16351 {
16352 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16353
16354 return (-1);
16355 }
16356
16357 if (S_ISREG (l1_stat.st_mode))
16358 {
16359 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16360
16361 dictcnt++;
16362
16363 dictfiles[dictcnt - 1] = strdup (l1_filename);
16364 }
16365 }
16366 }
16367
16368 local_free (dictionary_files);
16369 }
16370 }
16371
16372 if (dictcnt < 1)
16373 {
16374 log_error ("ERROR: No usable dictionary file found.");
16375
16376 return (-1);
16377 }
16378
16379 if (increment)
16380 {
16381 maskcnt = 0;
16382
16383 uint mask_min = increment_min; // we can't reject smaller masks here
16384 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16385
16386 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16387 {
16388 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16389
16390 if (cur_mask == NULL) break;
16391
16392 masks[maskcnt] = cur_mask;
16393
16394 maskcnt++;
16395
16396 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16397 }
16398 }
16399 }
16400 else if (attack_mode == ATTACK_MODE_HYBRID2)
16401 {
16402 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16403
16404 // display
16405
16406 char *mask = myargv[optind + 1 + 0];
16407
16408 maskcnt = 0;
16409
16410 masks = (char **) mymalloc (1 * sizeof (char *));
16411
16412 // mod
16413
16414 struct stat file_stat;
16415
16416 if (stat (mask, &file_stat) == -1)
16417 {
16418 maskcnt = 1;
16419
16420 masks[maskcnt - 1] = mystrdup (mask);
16421 }
16422 else
16423 {
16424 uint is_file = S_ISREG (file_stat.st_mode);
16425
16426 if (is_file == 1)
16427 {
16428 FILE *mask_fp;
16429
16430 if ((mask_fp = fopen (mask, "r")) == NULL)
16431 {
16432 log_error ("ERROR: %s: %s", mask, strerror (errno));
16433
16434 return (-1);
16435 }
16436
16437 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16438
16439 uint masks_avail = 1;
16440
16441 while (!feof (mask_fp))
16442 {
16443 memset (line_buf, 0, HCBUFSIZ);
16444
16445 int line_len = fgetl (mask_fp, line_buf);
16446
16447 if (line_len == 0) continue;
16448
16449 if (line_buf[0] == '#') continue;
16450
16451 if (masks_avail == maskcnt)
16452 {
16453 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16454
16455 masks_avail += INCR_MASKS;
16456 }
16457
16458 masks[maskcnt] = mystrdup (line_buf);
16459
16460 maskcnt++;
16461 }
16462
16463 myfree (line_buf);
16464
16465 fclose (mask_fp);
16466
16467 mask_from_file = 1;
16468 }
16469 else
16470 {
16471 maskcnt = 1;
16472
16473 masks[maskcnt - 1] = mystrdup (mask);
16474 }
16475 }
16476
16477 // base
16478
16479 int wls_left = myargc - (optind + 2);
16480
16481 for (int i = 0; i < wls_left; i++)
16482 {
16483 char *filename = myargv[optind + 2 + i];
16484
16485 struct stat file_stat;
16486
16487 if (stat (filename, &file_stat) == -1)
16488 {
16489 log_error ("ERROR: %s: %s", filename, strerror (errno));
16490
16491 return (-1);
16492 }
16493
16494 uint is_dir = S_ISDIR (file_stat.st_mode);
16495
16496 if (is_dir == 0)
16497 {
16498 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16499
16500 dictcnt++;
16501
16502 dictfiles[dictcnt - 1] = filename;
16503 }
16504 else
16505 {
16506 // do not allow --keyspace w/ a directory
16507
16508 if (keyspace == 1)
16509 {
16510 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16511
16512 return (-1);
16513 }
16514
16515 char **dictionary_files = NULL;
16516
16517 dictionary_files = scan_directory (filename);
16518
16519 if (dictionary_files != NULL)
16520 {
16521 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16522
16523 for (int d = 0; dictionary_files[d] != NULL; d++)
16524 {
16525 char *l1_filename = dictionary_files[d];
16526
16527 struct stat l1_stat;
16528
16529 if (stat (l1_filename, &l1_stat) == -1)
16530 {
16531 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16532
16533 return (-1);
16534 }
16535
16536 if (S_ISREG (l1_stat.st_mode))
16537 {
16538 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16539
16540 dictcnt++;
16541
16542 dictfiles[dictcnt - 1] = strdup (l1_filename);
16543 }
16544 }
16545 }
16546
16547 local_free (dictionary_files);
16548 }
16549 }
16550
16551 if (dictcnt < 1)
16552 {
16553 log_error ("ERROR: No usable dictionary file found.");
16554
16555 return (-1);
16556 }
16557
16558 if (increment)
16559 {
16560 maskcnt = 0;
16561
16562 uint mask_min = increment_min; // we can't reject smaller masks here
16563 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16564
16565 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16566 {
16567 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16568
16569 if (cur_mask == NULL) break;
16570
16571 masks[maskcnt] = cur_mask;
16572
16573 maskcnt++;
16574
16575 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16576 }
16577 }
16578 }
16579
16580 data.pw_min = pw_min;
16581 data.pw_max = pw_max;
16582
16583 /**
16584 * weak hash check
16585 */
16586
16587 if (weak_hash_threshold >= salts_cnt)
16588 {
16589 hc_device_param_t *device_param = NULL;
16590
16591 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16592 {
16593 device_param = &data.devices_param[device_id];
16594
16595 if (device_param->skipped) continue;
16596
16597 break;
16598 }
16599
16600 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16601
16602 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16603 {
16604 weak_hash_check (device_param, salt_pos);
16605 }
16606
16607 // Display hack, guarantee that there is at least one \r before real start
16608
16609 //if (data.quiet == 0) log_info ("");
16610 }
16611
16612 /**
16613 * status and monitor threads
16614 */
16615
16616 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16617
16618 hc_thread_t i_thread = 0;
16619
16620 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16621 {
16622 hc_thread_create (i_thread, thread_keypress, &benchmark);
16623 }
16624
16625 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16626
16627 uint ni_threads_cnt = 0;
16628
16629 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16630
16631 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16632
16633 ni_threads_cnt++;
16634
16635 /**
16636 * Outfile remove
16637 */
16638
16639 if (keyspace == 0)
16640 {
16641 if (outfile_check_timer != 0)
16642 {
16643 if (data.outfile_check_directory != NULL)
16644 {
16645 if ((hash_mode != 5200) &&
16646 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16647 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16648 (hash_mode != 9000))
16649 {
16650 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16651
16652 ni_threads_cnt++;
16653 }
16654 else
16655 {
16656 outfile_check_timer = 0;
16657 }
16658 }
16659 else
16660 {
16661 outfile_check_timer = 0;
16662 }
16663 }
16664 }
16665
16666 /**
16667 * Inform the user if we got some hashes remove because of the pot file remove feature
16668 */
16669
16670 if (data.quiet == 0)
16671 {
16672 if (potfile_remove_cracks > 0)
16673 {
16674 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16675 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16676 }
16677 }
16678
16679 data.outfile_check_timer = outfile_check_timer;
16680
16681 /**
16682 * main loop
16683 */
16684
16685 char **induction_dictionaries = NULL;
16686
16687 int induction_dictionaries_cnt = 0;
16688
16689 hcstat_table_t *root_table_buf = NULL;
16690 hcstat_table_t *markov_table_buf = NULL;
16691
16692 uint initial_restore_done = 0;
16693
16694 data.maskcnt = maskcnt;
16695
16696 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16697 {
16698 if (data.devices_status == STATUS_CRACKED) break;
16699
16700 data.devices_status = STATUS_INIT;
16701
16702 if (maskpos > rd->maskpos)
16703 {
16704 rd->dictpos = 0;
16705 }
16706
16707 rd->maskpos = maskpos;
16708 data.maskpos = maskpos;
16709
16710 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16711 {
16712 char *mask = masks[maskpos];
16713
16714 if (mask_from_file == 1)
16715 {
16716 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16717
16718 char *str_ptr;
16719 uint str_pos;
16720
16721 uint mask_offset = 0;
16722
16723 uint separator_cnt;
16724
16725 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16726 {
16727 str_ptr = strstr (mask + mask_offset, ",");
16728
16729 if (str_ptr == NULL) break;
16730
16731 str_pos = str_ptr - mask;
16732
16733 // escaped separator, i.e. "\,"
16734
16735 if (str_pos > 0)
16736 {
16737 if (mask[str_pos - 1] == '\\')
16738 {
16739 separator_cnt --;
16740
16741 mask_offset = str_pos + 1;
16742
16743 continue;
16744 }
16745 }
16746
16747 // reset the offset
16748
16749 mask_offset = 0;
16750
16751 mask[str_pos] = '\0';
16752
16753 switch (separator_cnt)
16754 {
16755 case 0:
16756 mp_reset_usr (mp_usr, 0);
16757
16758 custom_charset_1 = mask;
16759 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16760 break;
16761
16762 case 1:
16763 mp_reset_usr (mp_usr, 1);
16764
16765 custom_charset_2 = mask;
16766 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16767 break;
16768
16769 case 2:
16770 mp_reset_usr (mp_usr, 2);
16771
16772 custom_charset_3 = mask;
16773 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16774 break;
16775
16776 case 3:
16777 mp_reset_usr (mp_usr, 3);
16778
16779 custom_charset_4 = mask;
16780 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16781 break;
16782 }
16783
16784 mask = mask + str_pos + 1;
16785 }
16786 }
16787
16788 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16789 {
16790 if (maskpos > 0)
16791 {
16792 local_free (css_buf);
16793 local_free (data.root_css_buf);
16794 local_free (data.markov_css_buf);
16795
16796 local_free (masks[maskpos - 1]);
16797 }
16798
16799 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16800
16801 data.mask = mask;
16802 data.css_cnt = css_cnt;
16803 data.css_buf = css_buf;
16804
16805 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16806
16807 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16808
16809 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16810 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16811
16812 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16813
16814 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16815
16816 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16817 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16818
16819 data.root_css_buf = root_css_buf;
16820 data.markov_css_buf = markov_css_buf;
16821
16822 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16823
16824 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16825
16826 local_free (root_table_buf);
16827 local_free (markov_table_buf);
16828
16829 // args
16830
16831 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16832 {
16833 hc_device_param_t *device_param = &data.devices_param[device_id];
16834
16835 if (device_param->skipped) continue;
16836
16837 device_param->kernel_params_mp[0] = &device_param->d_combs;
16838 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16839 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16840
16841 device_param->kernel_params_mp_buf64[3] = 0;
16842 device_param->kernel_params_mp_buf32[4] = css_cnt;
16843 device_param->kernel_params_mp_buf32[5] = 0;
16844 device_param->kernel_params_mp_buf32[6] = 0;
16845 device_param->kernel_params_mp_buf32[7] = 0;
16846
16847 if (attack_mode == ATTACK_MODE_HYBRID1)
16848 {
16849 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16850 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16851 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16852 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16853 }
16854 else if (attack_mode == ATTACK_MODE_HYBRID2)
16855 {
16856 device_param->kernel_params_mp_buf32[5] = 0;
16857 device_param->kernel_params_mp_buf32[6] = 0;
16858 device_param->kernel_params_mp_buf32[7] = 0;
16859 }
16860
16861 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]);
16862 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]);
16863 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]);
16864
16865 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);
16866 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);
16867 }
16868 }
16869 else if (attack_mode == ATTACK_MODE_BF)
16870 {
16871 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16872
16873 if (increment)
16874 {
16875 for (uint i = 0; i < dictcnt; i++)
16876 {
16877 local_free (dictfiles[i]);
16878 }
16879
16880 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16881 {
16882 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16883
16884 if (l1_filename == NULL) break;
16885
16886 dictcnt++;
16887
16888 dictfiles[dictcnt - 1] = l1_filename;
16889 }
16890 }
16891 else
16892 {
16893 dictcnt++;
16894
16895 dictfiles[dictcnt - 1] = mask;
16896 }
16897
16898 if (dictcnt == 0)
16899 {
16900 log_error ("ERROR: Mask is too small");
16901
16902 return (-1);
16903 }
16904 }
16905 }
16906
16907 free (induction_dictionaries);
16908
16909 // induction_dictionaries_cnt = 0; // implied
16910
16911 if (attack_mode != ATTACK_MODE_BF)
16912 {
16913 if (keyspace == 0)
16914 {
16915 induction_dictionaries = scan_directory (induction_directory);
16916
16917 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16918 }
16919 }
16920
16921 if (induction_dictionaries_cnt)
16922 {
16923 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16924 }
16925
16926 /**
16927 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16928 */
16929 if (keyspace == 1)
16930 {
16931 if ((maskcnt > 1) || (dictcnt > 1))
16932 {
16933 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16934
16935 return (-1);
16936 }
16937 }
16938
16939 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16940 {
16941 char *subid = logfile_generate_subid ();
16942
16943 data.subid = subid;
16944
16945 logfile_sub_msg ("START");
16946
16947 data.devices_status = STATUS_INIT;
16948
16949 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16950 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16951 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16952
16953 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16954
16955 data.cpt_pos = 0;
16956
16957 data.cpt_start = time (NULL);
16958
16959 data.cpt_total = 0;
16960
16961 if (data.restore == 0)
16962 {
16963 rd->words_cur = skip;
16964
16965 skip = 0;
16966
16967 data.skip = 0;
16968 }
16969
16970 data.ms_paused = 0;
16971
16972 data.words_cur = rd->words_cur;
16973
16974 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16975 {
16976 hc_device_param_t *device_param = &data.devices_param[device_id];
16977
16978 if (device_param->skipped) continue;
16979
16980 device_param->speed_pos = 0;
16981
16982 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16983 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16984
16985 device_param->exec_pos = 0;
16986
16987 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16988
16989 device_param->kernel_power = device_param->kernel_power_user;
16990
16991 device_param->outerloop_pos = 0;
16992 device_param->outerloop_left = 0;
16993 device_param->innerloop_pos = 0;
16994 device_param->innerloop_left = 0;
16995
16996 // some more resets:
16997
16998 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16999
17000 device_param->pws_cnt = 0;
17001
17002 device_param->words_off = 0;
17003 device_param->words_done = 0;
17004 }
17005
17006 data.kernel_power_div = 0;
17007
17008 // figure out some workload
17009
17010 if (attack_mode == ATTACK_MODE_STRAIGHT)
17011 {
17012 if (data.wordlist_mode == WL_MODE_FILE)
17013 {
17014 char *dictfile = NULL;
17015
17016 if (induction_dictionaries_cnt)
17017 {
17018 dictfile = induction_dictionaries[0];
17019 }
17020 else
17021 {
17022 dictfile = dictfiles[dictpos];
17023 }
17024
17025 data.dictfile = dictfile;
17026
17027 logfile_sub_string (dictfile);
17028
17029 for (uint i = 0; i < rp_files_cnt; i++)
17030 {
17031 logfile_sub_var_string ("rulefile", rp_files[i]);
17032 }
17033
17034 FILE *fd2 = fopen (dictfile, "rb");
17035
17036 if (fd2 == NULL)
17037 {
17038 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17039
17040 return (-1);
17041 }
17042
17043 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17044
17045 fclose (fd2);
17046
17047 if (data.words_cnt == 0)
17048 {
17049 if (data.devices_status == STATUS_CRACKED) break;
17050 if (data.devices_status == STATUS_ABORTED) break;
17051
17052 dictpos++;
17053
17054 continue;
17055 }
17056 }
17057 }
17058 else if (attack_mode == ATTACK_MODE_COMBI)
17059 {
17060 char *dictfile = data.dictfile;
17061 char *dictfile2 = data.dictfile2;
17062
17063 logfile_sub_string (dictfile);
17064 logfile_sub_string (dictfile2);
17065
17066 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17067 {
17068 FILE *fd2 = fopen (dictfile, "rb");
17069
17070 if (fd2 == NULL)
17071 {
17072 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17073
17074 return (-1);
17075 }
17076
17077 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17078
17079 fclose (fd2);
17080 }
17081 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17082 {
17083 FILE *fd2 = fopen (dictfile2, "rb");
17084
17085 if (fd2 == NULL)
17086 {
17087 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17088
17089 return (-1);
17090 }
17091
17092 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17093
17094 fclose (fd2);
17095 }
17096
17097 if (data.words_cnt == 0)
17098 {
17099 if (data.devices_status == STATUS_CRACKED) break;
17100 if (data.devices_status == STATUS_ABORTED) break;
17101
17102 dictpos++;
17103
17104 continue;
17105 }
17106 }
17107 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17108 {
17109 char *dictfile = NULL;
17110
17111 if (induction_dictionaries_cnt)
17112 {
17113 dictfile = induction_dictionaries[0];
17114 }
17115 else
17116 {
17117 dictfile = dictfiles[dictpos];
17118 }
17119
17120 data.dictfile = dictfile;
17121
17122 char *mask = data.mask;
17123
17124 logfile_sub_string (dictfile);
17125 logfile_sub_string (mask);
17126
17127 FILE *fd2 = fopen (dictfile, "rb");
17128
17129 if (fd2 == NULL)
17130 {
17131 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17132
17133 return (-1);
17134 }
17135
17136 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17137
17138 fclose (fd2);
17139
17140 if (data.words_cnt == 0)
17141 {
17142 if (data.devices_status == STATUS_CRACKED) break;
17143 if (data.devices_status == STATUS_ABORTED) break;
17144
17145 dictpos++;
17146
17147 continue;
17148 }
17149 }
17150 else if (attack_mode == ATTACK_MODE_BF)
17151 {
17152 local_free (css_buf);
17153 local_free (data.root_css_buf);
17154 local_free (data.markov_css_buf);
17155
17156 char *mask = dictfiles[dictpos];
17157
17158 logfile_sub_string (mask);
17159
17160 // base
17161
17162 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17163
17164 if (opts_type & OPTS_TYPE_PT_UNICODE)
17165 {
17166 uint css_cnt_unicode = css_cnt * 2;
17167
17168 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17169
17170 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17171 {
17172 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17173
17174 css_buf_unicode[j + 1].cs_buf[0] = 0;
17175 css_buf_unicode[j + 1].cs_len = 1;
17176 }
17177
17178 free (css_buf);
17179
17180 css_buf = css_buf_unicode;
17181 css_cnt = css_cnt_unicode;
17182 }
17183
17184 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17185
17186 uint mask_min = pw_min;
17187 uint mask_max = pw_max;
17188
17189 if (opts_type & OPTS_TYPE_PT_UNICODE)
17190 {
17191 mask_min *= 2;
17192 mask_max *= 2;
17193 }
17194
17195 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17196 {
17197 if (css_cnt < mask_min)
17198 {
17199 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17200 }
17201
17202 if (css_cnt > mask_max)
17203 {
17204 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17205 }
17206
17207 // skip to next mask
17208
17209 dictpos++;
17210
17211 rd->dictpos = dictpos;
17212
17213 logfile_sub_msg ("STOP");
17214
17215 continue;
17216 }
17217
17218 uint save_css_cnt = css_cnt;
17219
17220 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17221 {
17222 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17223 {
17224 uint salt_len = (uint) data.salts_buf[0].salt_len;
17225 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17226
17227 uint css_cnt_salt = css_cnt + salt_len;
17228
17229 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17230
17231 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17232
17233 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17234 {
17235 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17236 css_buf_salt[j].cs_len = 1;
17237 }
17238
17239 free (css_buf);
17240
17241 css_buf = css_buf_salt;
17242 css_cnt = css_cnt_salt;
17243 }
17244 }
17245
17246 data.mask = mask;
17247 data.css_cnt = css_cnt;
17248 data.css_buf = css_buf;
17249
17250 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17251
17252 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17253
17254 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17255
17256 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17257 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17258
17259 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17260
17261 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17262
17263 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17264 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17265
17266 data.root_css_buf = root_css_buf;
17267 data.markov_css_buf = markov_css_buf;
17268
17269 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17270
17271 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17272
17273 local_free (root_table_buf);
17274 local_free (markov_table_buf);
17275
17276 // copy + args
17277
17278 uint css_cnt_l = css_cnt;
17279 uint css_cnt_r;
17280
17281 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17282 {
17283 if (save_css_cnt < 6)
17284 {
17285 css_cnt_r = 1;
17286 }
17287 else if (save_css_cnt == 6)
17288 {
17289 css_cnt_r = 2;
17290 }
17291 else
17292 {
17293 if (opts_type & OPTS_TYPE_PT_UNICODE)
17294 {
17295 if (save_css_cnt == 8 || save_css_cnt == 10)
17296 {
17297 css_cnt_r = 2;
17298 }
17299 else
17300 {
17301 css_cnt_r = 4;
17302 }
17303 }
17304 else
17305 {
17306 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17307 {
17308 css_cnt_r = 3;
17309 }
17310 else
17311 {
17312 css_cnt_r = 4;
17313 }
17314 }
17315 }
17316 }
17317 else
17318 {
17319 css_cnt_r = 1;
17320
17321 /* unfinished code?
17322 int sum = css_buf[css_cnt_r - 1].cs_len;
17323
17324 for (uint i = 1; i < 4 && i < css_cnt; i++)
17325 {
17326 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17327
17328 css_cnt_r++;
17329
17330 sum *= css_buf[css_cnt_r - 1].cs_len;
17331 }
17332 */
17333 }
17334
17335 css_cnt_l -= css_cnt_r;
17336
17337 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17338
17339 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17340 {
17341 hc_device_param_t *device_param = &data.devices_param[device_id];
17342
17343 if (device_param->skipped) continue;
17344
17345 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17346 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17347 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17348
17349 device_param->kernel_params_mp_l_buf64[3] = 0;
17350 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17351 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17352 device_param->kernel_params_mp_l_buf32[6] = 0;
17353 device_param->kernel_params_mp_l_buf32[7] = 0;
17354 device_param->kernel_params_mp_l_buf32[8] = 0;
17355
17356 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17357 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17358 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17359 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17360
17361 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17362 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17363 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17364
17365 device_param->kernel_params_mp_r_buf64[3] = 0;
17366 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17367 device_param->kernel_params_mp_r_buf32[5] = 0;
17368 device_param->kernel_params_mp_r_buf32[6] = 0;
17369 device_param->kernel_params_mp_r_buf32[7] = 0;
17370
17371 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]);
17372 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]);
17373 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]);
17374
17375 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]);
17376 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]);
17377 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]);
17378
17379 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);
17380 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);
17381 }
17382 }
17383
17384 u64 words_base = data.words_cnt;
17385
17386 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17387 {
17388 if (data.kernel_rules_cnt)
17389 {
17390 words_base /= data.kernel_rules_cnt;
17391 }
17392 }
17393 else if (data.attack_kern == ATTACK_KERN_COMBI)
17394 {
17395 if (data.combs_cnt)
17396 {
17397 words_base /= data.combs_cnt;
17398 }
17399 }
17400 else if (data.attack_kern == ATTACK_KERN_BF)
17401 {
17402 if (data.bfs_cnt)
17403 {
17404 words_base /= data.bfs_cnt;
17405 }
17406 }
17407
17408 data.words_base = words_base;
17409
17410 if (keyspace == 1)
17411 {
17412 log_info ("%llu", (unsigned long long int) words_base);
17413
17414 return (0);
17415 }
17416
17417 if (data.words_cur > data.words_base)
17418 {
17419 log_error ("ERROR: restore value greater keyspace");
17420
17421 return (-1);
17422 }
17423
17424 if (data.words_cur)
17425 {
17426 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17427 {
17428 for (uint i = 0; i < data.salts_cnt; i++)
17429 {
17430 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17431 }
17432 }
17433 else if (data.attack_kern == ATTACK_KERN_COMBI)
17434 {
17435 for (uint i = 0; i < data.salts_cnt; i++)
17436 {
17437 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17438 }
17439 }
17440 else if (data.attack_kern == ATTACK_KERN_BF)
17441 {
17442 for (uint i = 0; i < data.salts_cnt; i++)
17443 {
17444 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17445 }
17446 }
17447 }
17448
17449 /*
17450 * Inform user about possible slow speeds
17451 */
17452
17453 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17454 {
17455 if (data.words_base < kernel_power_all)
17456 {
17457 if (quiet == 0)
17458 {
17459 log_info ("ATTENTION!");
17460 log_info (" The wordlist or mask you are using is too small.");
17461 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17462 log_info (" The cracking speed will drop.");
17463 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17464 log_info ("");
17465 }
17466 }
17467 }
17468
17469 /*
17470 * Update loopback file
17471 */
17472
17473 if (loopback == 1)
17474 {
17475 time_t now;
17476
17477 time (&now);
17478
17479 uint random_num = get_random_num (0, 9999);
17480
17481 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17482
17483 data.loopback_file = loopback_file;
17484 }
17485
17486 /*
17487 * Update dictionary statistic
17488 */
17489
17490 if (keyspace == 0)
17491 {
17492 dictstat_fp = fopen (dictstat, "wb");
17493
17494 if (dictstat_fp)
17495 {
17496 lock_file (dictstat_fp);
17497
17498 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17499
17500 fclose (dictstat_fp);
17501 }
17502 }
17503
17504 data.devices_status = STATUS_RUNNING;
17505
17506 if (initial_restore_done == 0)
17507 {
17508 if (data.restore_disable == 0) cycle_restore ();
17509
17510 initial_restore_done = 1;
17511 }
17512
17513 hc_timer_set (&data.timer_running);
17514
17515 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17516 {
17517 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17518 {
17519 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17520 if (quiet == 0) fflush (stdout);
17521 }
17522 }
17523 else if (wordlist_mode == WL_MODE_STDIN)
17524 {
17525 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17526 if (data.quiet == 0) log_info ("");
17527 }
17528
17529 time_t runtime_start;
17530
17531 time (&runtime_start);
17532
17533 data.runtime_start = runtime_start;
17534
17535 /**
17536 * create cracker threads
17537 */
17538
17539 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17540
17541 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17542 {
17543 hc_device_param_t *device_param = &devices_param[device_id];
17544
17545 if (wordlist_mode == WL_MODE_STDIN)
17546 {
17547 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17548 }
17549 else
17550 {
17551 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17552 }
17553 }
17554
17555 // wait for crack threads to exit
17556
17557 hc_thread_wait (data.devices_cnt, c_threads);
17558
17559 local_free (c_threads);
17560
17561 data.restore = 0;
17562
17563 // finalize task
17564
17565 logfile_sub_var_uint ("status-after-work", data.devices_status);
17566
17567 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17568
17569 if (data.devices_status == STATUS_CRACKED) break;
17570 if (data.devices_status == STATUS_ABORTED) break;
17571
17572 if (data.devices_status == STATUS_BYPASS)
17573 {
17574 data.devices_status = STATUS_RUNNING;
17575 }
17576
17577 if (induction_dictionaries_cnt)
17578 {
17579 unlink (induction_dictionaries[0]);
17580 }
17581
17582 free (induction_dictionaries);
17583
17584 if (attack_mode != ATTACK_MODE_BF)
17585 {
17586 induction_dictionaries = scan_directory (induction_directory);
17587
17588 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17589 }
17590
17591 if (benchmark == 0)
17592 {
17593 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17594 {
17595 if (quiet == 0) clear_prompt ();
17596
17597 if (quiet == 0) log_info ("");
17598
17599 if (status == 1)
17600 {
17601 status_display ();
17602 }
17603 else
17604 {
17605 if (quiet == 0) status_display ();
17606 }
17607
17608 if (quiet == 0) log_info ("");
17609 }
17610 }
17611
17612 if (attack_mode == ATTACK_MODE_BF)
17613 {
17614 dictpos++;
17615
17616 rd->dictpos = dictpos;
17617 }
17618 else
17619 {
17620 if (induction_dictionaries_cnt)
17621 {
17622 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17623 }
17624 else
17625 {
17626 dictpos++;
17627
17628 rd->dictpos = dictpos;
17629 }
17630 }
17631
17632 time_t runtime_stop;
17633
17634 time (&runtime_stop);
17635
17636 data.runtime_stop = runtime_stop;
17637
17638 logfile_sub_uint (runtime_start);
17639 logfile_sub_uint (runtime_stop);
17640
17641 logfile_sub_msg ("STOP");
17642
17643 global_free (subid);
17644 }
17645
17646 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17647
17648 if (data.devices_status == STATUS_CRACKED) break;
17649 if (data.devices_status == STATUS_ABORTED) break;
17650 if (data.devices_status == STATUS_QUIT) break;
17651
17652 if (data.devices_status == STATUS_BYPASS)
17653 {
17654 data.devices_status = STATUS_RUNNING;
17655 }
17656 }
17657
17658 // 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
17659
17660 if (attack_mode == ATTACK_MODE_STRAIGHT)
17661 {
17662 if (data.wordlist_mode == WL_MODE_FILE)
17663 {
17664 if (data.dictfile == NULL)
17665 {
17666 if (dictfiles != NULL)
17667 {
17668 data.dictfile = dictfiles[0];
17669
17670 hc_timer_set (&data.timer_running);
17671 }
17672 }
17673 }
17674 }
17675 // NOTE: combi is okay because it is already set beforehand
17676 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17677 {
17678 if (data.dictfile == NULL)
17679 {
17680 if (dictfiles != NULL)
17681 {
17682 hc_timer_set (&data.timer_running);
17683
17684 data.dictfile = dictfiles[0];
17685 }
17686 }
17687 }
17688 else if (attack_mode == ATTACK_MODE_BF)
17689 {
17690 if (data.mask == NULL)
17691 {
17692 hc_timer_set (&data.timer_running);
17693
17694 data.mask = masks[0];
17695 }
17696 }
17697
17698 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17699 {
17700 data.devices_status = STATUS_EXHAUSTED;
17701 }
17702
17703 // if cracked / aborted remove last induction dictionary
17704
17705 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17706 {
17707 struct stat induct_stat;
17708
17709 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17710 {
17711 unlink (induction_dictionaries[file_pos]);
17712 }
17713 }
17714
17715 // wait for non-interactive threads
17716
17717 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17718 {
17719 hc_thread_wait (1, &ni_threads[thread_idx]);
17720 }
17721
17722 local_free (ni_threads);
17723
17724 // wait for interactive threads
17725
17726 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17727 {
17728 hc_thread_wait (1, &i_thread);
17729 }
17730
17731 // we dont need restore file anymore
17732 if (data.restore_disable == 0)
17733 {
17734 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17735 {
17736 unlink (eff_restore_file);
17737 unlink (new_restore_file);
17738 }
17739 else
17740 {
17741 cycle_restore ();
17742 }
17743 }
17744
17745 // finally save left hashes
17746
17747 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17748 {
17749 save_hash ();
17750 }
17751
17752 /**
17753 * Clean up
17754 */
17755
17756 if (benchmark == 1)
17757 {
17758 status_benchmark ();
17759
17760 if (machine_readable == 0)
17761 {
17762 log_info ("");
17763 }
17764 }
17765 else
17766 {
17767 if (quiet == 0) clear_prompt ();
17768
17769 if (quiet == 0) log_info ("");
17770
17771 if (status == 1)
17772 {
17773 status_display ();
17774 }
17775 else
17776 {
17777 if (quiet == 0) status_display ();
17778 }
17779
17780 if (quiet == 0) log_info ("");
17781 }
17782
17783 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17784 {
17785 hc_device_param_t *device_param = &data.devices_param[device_id];
17786
17787 if (device_param->skipped) continue;
17788
17789 local_free (device_param->combs_buf);
17790
17791 local_free (device_param->hooks_buf);
17792
17793 local_free (device_param->device_name);
17794
17795 local_free (device_param->device_name_chksum);
17796
17797 local_free (device_param->device_version);
17798
17799 local_free (device_param->driver_version);
17800
17801 if (device_param->pws_buf) myfree (device_param->pws_buf);
17802 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17803 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17804 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17805 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17806 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17807 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17808 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17809 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17810 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17811 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17812 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17813 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17814 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17815 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17816 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17817 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17818 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17819 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17820 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17821 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17822 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17823 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17824 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17825 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17826 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17827 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17828 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17829 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17830
17831 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17832 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17833 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17834 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17835 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17836 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17837 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17838 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17839 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17840 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17841 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17842
17843 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17844 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17845 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17846
17847 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17848 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17849 }
17850
17851 // reset default fan speed
17852
17853 #ifdef HAVE_HWMON
17854 if (gpu_temp_disable == 0)
17855 {
17856 #ifdef HAVE_ADL
17857 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17858 {
17859 hc_thread_mutex_lock (mux_adl);
17860
17861 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17862 {
17863 hc_device_param_t *device_param = &data.devices_param[device_id];
17864
17865 if (device_param->skipped) continue;
17866
17867 if (data.hm_device[device_id].fan_supported == 1)
17868 {
17869 int fanspeed = temp_retain_fanspeed_value[device_id];
17870
17871 if (fanspeed == -1) continue;
17872
17873 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17874
17875 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17876 }
17877 }
17878
17879 hc_thread_mutex_unlock (mux_adl);
17880 }
17881 #endif // HAVE_ADL
17882 }
17883
17884 #ifdef HAVE_ADL
17885 // reset power tuning
17886
17887 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17888 {
17889 hc_thread_mutex_lock (mux_adl);
17890
17891 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17892 {
17893 hc_device_param_t *device_param = &data.devices_param[device_id];
17894
17895 if (device_param->skipped) continue;
17896
17897 if (data.hm_device[device_id].od_version == 6)
17898 {
17899 // check powertune capabilities first, if not available then skip device
17900
17901 int powertune_supported = 0;
17902
17903 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17904 {
17905 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17906
17907 return (-1);
17908 }
17909
17910 if (powertune_supported != 0)
17911 {
17912 // powercontrol settings
17913
17914 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17915 {
17916 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17917
17918 return (-1);
17919 }
17920
17921 // clocks
17922
17923 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17924
17925 performance_state->iNumberOfPerformanceLevels = 2;
17926
17927 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17928 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17929 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17930 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17931
17932 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17933 {
17934 log_info ("ERROR: Failed to restore ADL performance state");
17935
17936 return (-1);
17937 }
17938
17939 local_free (performance_state);
17940 }
17941 }
17942 }
17943
17944 hc_thread_mutex_unlock (mux_adl);
17945 }
17946 #endif // HAVE_ADL
17947
17948 if (gpu_temp_disable == 0)
17949 {
17950 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17951 if (data.hm_nv)
17952 {
17953 #if defined(LINUX) && defined(HAVE_NVML)
17954
17955 hm_NVML_nvmlShutdown (data.hm_nv);
17956
17957 nvml_close (data.hm_nv);
17958
17959 #elif defined(WIN) && (HAVE_NVAPI)
17960
17961 hm_NvAPI_Unload (data.hm_nv);
17962
17963 nvapi_close (data.hm_nv);
17964
17965 #endif
17966
17967 data.hm_nv = NULL;
17968 }
17969 #endif
17970
17971 #ifdef HAVE_ADL
17972 if (data.hm_amd)
17973 {
17974 hm_ADL_Main_Control_Destroy (data.hm_amd);
17975
17976 adl_close (data.hm_amd);
17977 data.hm_amd = NULL;
17978 }
17979 #endif
17980 }
17981 #endif // HAVE_HWMON
17982
17983 // free memory
17984
17985 local_free (masks);
17986
17987 local_free (dictstat_base);
17988
17989 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17990 {
17991 pot_t *pot_ptr = &pot[pot_pos];
17992
17993 hash_t *hash = &pot_ptr->hash;
17994
17995 local_free (hash->digest);
17996
17997 if (isSalted)
17998 {
17999 local_free (hash->salt);
18000 }
18001 }
18002
18003 local_free (pot);
18004
18005 local_free (all_kernel_rules_cnt);
18006 local_free (all_kernel_rules_buf);
18007
18008 local_free (wl_data->buf);
18009 local_free (wl_data);
18010
18011 local_free (bitmap_s1_a);
18012 local_free (bitmap_s1_b);
18013 local_free (bitmap_s1_c);
18014 local_free (bitmap_s1_d);
18015 local_free (bitmap_s2_a);
18016 local_free (bitmap_s2_b);
18017 local_free (bitmap_s2_c);
18018 local_free (bitmap_s2_d);
18019
18020 #ifdef HAVE_HWMON
18021 local_free (temp_retain_fanspeed_value);
18022 #ifdef HAVE_ADL
18023 local_free (od_clock_mem_status);
18024 local_free (od_power_control_status);
18025 #endif // ADL
18026 #endif
18027
18028 global_free (devices_param);
18029
18030 global_free (kernel_rules_buf);
18031
18032 global_free (root_css_buf);
18033 global_free (markov_css_buf);
18034
18035 global_free (digests_buf);
18036 global_free (digests_shown);
18037 global_free (digests_shown_tmp);
18038
18039 global_free (salts_buf);
18040 global_free (salts_shown);
18041
18042 global_free (esalts_buf);
18043
18044 global_free (words_progress_done);
18045 global_free (words_progress_rejected);
18046 global_free (words_progress_restored);
18047
18048 if (pot_fp) fclose (pot_fp);
18049
18050 if (data.devices_status == STATUS_QUIT) break;
18051 }
18052
18053 // destroy others mutex
18054
18055 hc_thread_mutex_delete (mux_dispatcher);
18056 hc_thread_mutex_delete (mux_counter);
18057 hc_thread_mutex_delete (mux_display);
18058 hc_thread_mutex_delete (mux_adl);
18059
18060 // free memory
18061
18062 local_free (eff_restore_file);
18063 local_free (new_restore_file);
18064
18065 local_free (rd);
18066
18067 // tuning db
18068
18069 tuning_db_destroy (tuning_db);
18070
18071 // loopback
18072
18073 local_free (loopback_file);
18074
18075 if (loopback == 1) unlink (loopback_file);
18076
18077 // induction directory
18078
18079 if (induction_dir == NULL)
18080 {
18081 if (attack_mode != ATTACK_MODE_BF)
18082 {
18083 if (rmdir (induction_directory) == -1)
18084 {
18085 if (errno == ENOENT)
18086 {
18087 // good, we can ignore
18088 }
18089 else if (errno == ENOTEMPTY)
18090 {
18091 // good, we can ignore
18092 }
18093 else
18094 {
18095 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18096
18097 return (-1);
18098 }
18099 }
18100
18101 local_free (induction_directory);
18102 }
18103 }
18104
18105 // outfile-check directory
18106
18107 if (outfile_check_dir == NULL)
18108 {
18109 if (rmdir (outfile_check_directory) == -1)
18110 {
18111 if (errno == ENOENT)
18112 {
18113 // good, we can ignore
18114 }
18115 else if (errno == ENOTEMPTY)
18116 {
18117 // good, we can ignore
18118 }
18119 else
18120 {
18121 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18122
18123 return (-1);
18124 }
18125 }
18126
18127 local_free (outfile_check_directory);
18128 }
18129
18130 time_t proc_stop;
18131
18132 time (&proc_stop);
18133
18134 logfile_top_uint (proc_start);
18135 logfile_top_uint (proc_stop);
18136
18137 logfile_top_msg ("STOP");
18138
18139 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18140 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18141
18142 if (data.ocl) ocl_close (data.ocl);
18143
18144 if (data.devices_status == STATUS_ABORTED) return 2;
18145 if (data.devices_status == STATUS_QUIT) return 2;
18146 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18147 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18148 if (data.devices_status == STATUS_CRACKED) return 0;
18149
18150 return -1;
18151 }
Hashcat additions to support pwdhash