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