projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
save_hash() always works with a file, therefore no branch required
[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 STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 0
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS_MAX 256
88 #define KERNEL_THREADS_MAX_CPU 16
89 #define POWERTUNE_ENABLE 0
90 #define LOGFILE_DISABLE 0
91 #define SCRYPT_TMTO 0
92 #define OPENCL_VECTOR_WIDTH 0
93
94 #define WL_MODE_STDIN 1
95 #define WL_MODE_FILE 2
96 #define WL_MODE_MASK 3
97
98 #define HL_MODE_FILE 4
99 #define HL_MODE_ARG 5
100
101 #define HLFMTS_CNT 11
102 #define HLFMT_HASHCAT 0
103 #define HLFMT_PWDUMP 1
104 #define HLFMT_PASSWD 2
105 #define HLFMT_SHADOW 3
106 #define HLFMT_DCC 4
107 #define HLFMT_DCC2 5
108 #define HLFMT_NETNTLM1 7
109 #define HLFMT_NETNTLM2 8
110 #define HLFMT_NSLDAP 9
111 #define HLFMT_NSLDAPS 10
112
113 #define HLFMT_TEXT_HASHCAT "native hashcat"
114 #define HLFMT_TEXT_PWDUMP "pwdump"
115 #define HLFMT_TEXT_PASSWD "passwd"
116 #define HLFMT_TEXT_SHADOW "shadow"
117 #define HLFMT_TEXT_DCC "DCC"
118 #define HLFMT_TEXT_DCC2 "DCC 2"
119 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
120 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
121 #define HLFMT_TEXT_NSLDAP "nsldap"
122 #define HLFMT_TEXT_NSLDAPS "nsldaps"
123
124 #define ATTACK_MODE_STRAIGHT 0
125 #define ATTACK_MODE_COMBI 1
126 #define ATTACK_MODE_TOGGLE 2
127 #define ATTACK_MODE_BF 3
128 #define ATTACK_MODE_PERM 4
129 #define ATTACK_MODE_TABLE 5
130 #define ATTACK_MODE_HYBRID1 6
131 #define ATTACK_MODE_HYBRID2 7
132 #define ATTACK_MODE_NONE 100
133
134 #define ATTACK_KERN_STRAIGHT 0
135 #define ATTACK_KERN_COMBI 1
136 #define ATTACK_KERN_BF 3
137 #define ATTACK_KERN_NONE 100
138
139 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
140 #define ATTACK_EXEC_INSIDE_KERNEL 11
141
142 #define COMBINATOR_MODE_BASE_LEFT 10001
143 #define COMBINATOR_MODE_BASE_RIGHT 10002
144
145 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
146 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
147
148 #define MAX_CUT_TRIES 4
149
150 #define MAX_DICTSTAT 10000
151
152 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
153
154 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
155
156 #define global_free(attr) \
157 { \
158 myfree ((void *) data.attr); \
159 \
160 data.attr = NULL; \
161 }
162
163 #define local_free(attr) \
164 { \
165 myfree ((void *) attr); \
166 \
167 attr = NULL; \
168 }
169
170 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
171 #define HC_API_CALL __stdcall
172 #else
173 #define HC_API_CALL
174 #endif
175
176 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
177 {
178 900,
179 0,
180 5100,
181 100,
182 1400,
183 10800,
184 1700,
185 5000,
186 10100,
187 6000,
188 6100,
189 6900,
190 11700,
191 11800,
192 400,
193 8900,
194 11900,
195 12000,
196 10900,
197 12100,
198 23,
199 2500,
200 5300,
201 5400,
202 5500,
203 5600,
204 7300,
205 7500,
206 13100,
207 8300,
208 11100,
209 11200,
210 11400,
211 121,
212 2611,
213 2711,
214 2811,
215 8400,
216 11,
217 2612,
218 7900,
219 21,
220 11000,
221 124,
222 10000,
223 3711,
224 7600,
225 12,
226 131,
227 132,
228 1731,
229 200,
230 300,
231 3100,
232 112,
233 12300,
234 8000,
235 141,
236 1441,
237 1600,
238 12600,
239 1421,
240 101,
241 111,
242 1711,
243 3000,
244 1000,
245 1100,
246 2100,
247 12800,
248 1500,
249 12400,
250 500,
251 3200,
252 7400,
253 1800,
254 122,
255 1722,
256 7100,
257 6300,
258 6700,
259 6400,
260 6500,
261 2400,
262 2410,
263 5700,
264 9200,
265 9300,
266 22,
267 501,
268 5800,
269 8100,
270 8500,
271 7200,
272 9900,
273 7700,
274 7800,
275 10300,
276 8600,
277 8700,
278 9100,
279 133,
280 13500,
281 11600,
282 13600,
283 12500,
284 13000,
285 13200,
286 13300,
287 6211,
288 6221,
289 6231,
290 6241,
291 13711,
292 13721,
293 13731,
294 13741,
295 13751,
296 13761,
297 8800,
298 12900,
299 12200,
300 9700,
301 9710,
302 9800,
303 9810,
304 9400,
305 9500,
306 9600,
307 10400,
308 10410,
309 10500,
310 10600,
311 10700,
312 9000,
313 5200,
314 6800,
315 6600,
316 8200,
317 11300,
318 12700,
319 13400,
320 125
321 };
322
323 /**
324 * types
325 */
326
327 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
328
329 /**
330 * globals
331 */
332
333 static unsigned int full01 = 0x01010101;
334 static unsigned int full80 = 0x80808080;
335
336 int SUPPRESS_OUTPUT = 0;
337
338 hc_thread_mutex_t mux_adl;
339 hc_thread_mutex_t mux_counter;
340 hc_thread_mutex_t mux_dispatcher;
341 hc_thread_mutex_t mux_display;
342
343 hc_global_data_t data;
344
345 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
346
347 const char *USAGE_MINI[] =
348 {
349 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
350 "",
351 "Try --help for more help.",
352 NULL
353 };
354
355 const char *USAGE_BIG[] =
356 {
357 "%s, advanced password recovery",
358 "",
359 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
360 "",
361 "- [ Options ] -",
362 "",
363 " Options Short / Long | Type | Description | Example",
364 "===============================|======|======================================================|=======================",
365 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
366 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
367 " -V, --version | | Print version |",
368 " -h, --help | | Print help |",
369 " --quiet | | Suppress output |",
370 " --hex-charset | | Assume charset is given in hex |",
371 " --hex-salt | | Assume salt is given in hex |",
372 " --hex-wordlist | | Assume words in wordlist is given in hex |",
373 " --force | | Ignore warnings |",
374 " --status | | Enable automatic update of the status-screen |",
375 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
376 " --machine-readable | | Display the status view in a machine readable format |",
377 " --loopback | | Add new plains to induct directory |",
378 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
379 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
380 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
381 " --markov-classic | | Enables classic markov-chains, no per-position |",
382 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
383 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
384 " --session | Str | Define specific session name | --session=mysession",
385 " --restore | | Restore session from --session |",
386 " --restore-disable | | Do not write restore file |",
387 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
388 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
389 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
390 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
391 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
392 " --stdout | | Do not crack a hash, instead print candidates only |",
393 " --show | | Show cracked passwords only |",
394 " --left | | Show un-cracked passwords only |",
395 " --username | | Enable ignoring of usernames in hashfile |",
396 " --remove | | Enable remove of hash once it is cracked |",
397 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
398 " --potfile-disable | | Do not write potfile |",
399 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
400 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
401 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
402 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
403 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
404 " --logfile-disable | | Disable the logfile |",
405 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
406 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
407 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
408 " -b, --benchmark | | Run benchmark |",
409 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
410 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
411 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
413 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
414 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
415 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
416 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
417 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
418 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
419 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
420 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
423 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
424 " --powertune-enable | | Enable power tuning, restores settings when finished |",
425 #endif
426 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
427 " -s, --skip | Num | Skip X words from the start | -s 1000000",
428 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
429 " --keyspace | | Show keyspace base:mod values and quit |",
430 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
431 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
432 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
433 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
434 " --generate-rules-func-min | Num | Force min X funcs per rule |",
435 " --generate-rules-func-max | Num | Force max X funcs per rule |",
436 " --generate-rules-seed | Num | Force RNG seed set to X |",
437 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
438 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
439 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
440 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
441 " -i, --increment | | Enable mask increment mode |",
442 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
443 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
444 "",
445 "- [ Hash modes ] -",
446 "",
447 " # | Name | Category",
448 " ======+==================================================+======================================",
449 " 900 | MD4 | Raw Hash",
450 " 0 | MD5 | Raw Hash",
451 " 5100 | Half MD5 | Raw Hash",
452 " 100 | SHA1 | Raw Hash",
453 " 10800 | SHA-384 | Raw Hash",
454 " 1400 | SHA-256 | Raw Hash",
455 " 1700 | SHA-512 | Raw Hash",
456 " 5000 | SHA-3(Keccak) | Raw Hash",
457 " 10100 | SipHash | Raw Hash",
458 " 6000 | RipeMD160 | Raw Hash",
459 " 6100 | Whirlpool | Raw Hash",
460 " 6900 | GOST R 34.11-94 | Raw Hash",
461 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
462 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
463 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
465 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
466 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
467 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
468 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
469 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
470 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
471 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
472 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
473 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
474 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
475 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
477 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
479 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
484 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
485 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
486 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
487 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
488 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
489 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
490 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
491 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
492 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
493 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
494 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
495 " 400 | phpass | Generic KDF",
496 " 8900 | scrypt | Generic KDF",
497 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
498 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
499 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
500 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
501 " 23 | Skype | Network protocols",
502 " 2500 | WPA/WPA2 | Network protocols",
503 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
504 " 5300 | IKE-PSK MD5 | Network protocols",
505 " 5400 | IKE-PSK SHA1 | Network protocols",
506 " 5500 | NetNTLMv1 | Network protocols",
507 " 5500 | NetNTLMv1 + ESS | Network protocols",
508 " 5600 | NetNTLMv2 | Network protocols",
509 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
510 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
511 " 8300 | DNSSEC (NSEC3) | Network protocols",
512 " 10200 | Cram MD5 | Network protocols",
513 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
514 " 11200 | MySQL CRAM (SHA1) | Network protocols",
515 " 11400 | SIP digest authentication (MD5) | Network protocols",
516 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
517 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
519 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
520 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
521 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
522 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
523 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
524 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
525 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
526 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
527 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
528 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
529 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
530 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
531 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
532 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
533 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
534 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
535 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
536 " 12 | PostgreSQL | Database Server",
537 " 131 | MSSQL(2000) | Database Server",
538 " 132 | MSSQL(2005) | Database Server",
539 " 1731 | MSSQL(2012) | Database Server",
540 " 1731 | MSSQL(2014) | Database Server",
541 " 200 | MySQL323 | Database Server",
542 " 300 | MySQL4.1/MySQL5 | Database Server",
543 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
544 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
545 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
546 " 8000 | Sybase ASE | Database Server",
547 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
548 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
549 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
550 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
551 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
552 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
553 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
554 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
555 " 11500 | CRC32 | Checksums",
556 " 3000 | LM | Operating-Systems",
557 " 1000 | NTLM | Operating-Systems",
558 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
559 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
560 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
561 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
562 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
563 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
564 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
565 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
566 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
567 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
568 " 1722 | OSX v10.7 | Operating-Systems",
569 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
570 " 6300 | AIX {smd5} | Operating-Systems",
571 " 6700 | AIX {ssha1} | Operating-Systems",
572 " 6400 | AIX {ssha256} | Operating-Systems",
573 " 6500 | AIX {ssha512} | Operating-Systems",
574 " 2400 | Cisco-PIX | Operating-Systems",
575 " 2410 | Cisco-ASA | Operating-Systems",
576 " 500 | Cisco-IOS $1$ | Operating-Systems",
577 " 5700 | Cisco-IOS $4$ | Operating-Systems",
578 " 9200 | Cisco-IOS $8$ | Operating-Systems",
579 " 9300 | Cisco-IOS $9$ | Operating-Systems",
580 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
581 " 501 | Juniper IVE | Operating-Systems",
582 " 5800 | Android PIN | Operating-Systems",
583 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
584 " 8100 | Citrix Netscaler | Operating-Systems",
585 " 8500 | RACF | Operating-Systems",
586 " 7200 | GRUB 2 | Operating-Systems",
587 " 9900 | Radmin2 | Operating-Systems",
588 " 125 | ArubaOS | Operating-Systems",
589 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
590 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
591 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
592 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
593 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
594 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
595 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
596 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
597 " 11600 | 7-Zip | Archives",
598 " 12500 | RAR3-hp | Archives",
599 " 13000 | RAR5 | Archives",
600 " 13200 | AxCrypt | Archives",
601 " 13300 | AxCrypt in memory SHA1 | Archives",
602 " 13600 | WinZip | Archives",
603 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
604 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
605 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
606 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
607 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
609 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
617 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
618 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
619 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
620 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
621 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
622 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
623 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
624 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
625 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
626 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
627 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
629 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
637 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
638 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
639 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
640 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
641 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
642 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
643 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
644 " 9400 | MS Office 2007 | Documents",
645 " 9500 | MS Office 2010 | Documents",
646 " 9600 | MS Office 2013 | Documents",
647 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
648 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
649 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
650 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
651 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
652 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
653 " 9000 | Password Safe v2 | Password Managers",
654 " 5200 | Password Safe v3 | Password Managers",
655 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
656 " 6600 | 1Password, agilekeychain | Password Managers",
657 " 8200 | 1Password, cloudkeychain | Password Managers",
658 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
659 " 12700 | Blockchain, My Wallet | Password Managers",
660 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
661 "",
662 "- [ Outfile Formats ] -",
663 "",
664 " # | Format",
665 " ===+========",
666 " 1 | hash[:salt]",
667 " 2 | plain",
668 " 3 | hash[:salt]:plain",
669 " 4 | hex_plain",
670 " 5 | hash[:salt]:hex_plain",
671 " 6 | plain:hex_plain",
672 " 7 | hash[:salt]:plain:hex_plain",
673 " 8 | crackpos",
674 " 9 | hash[:salt]:crack_pos",
675 " 10 | plain:crack_pos",
676 " 11 | hash[:salt]:plain:crack_pos",
677 " 12 | hex_plain:crack_pos",
678 " 13 | hash[:salt]:hex_plain:crack_pos",
679 " 14 | plain:hex_plain:crack_pos",
680 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
681 "",
682 "- [ Rule Debugging Modes ] -",
683 "",
684 " # | Format",
685 " ===+========",
686 " 1 | Finding-Rule",
687 " 2 | Original-Word",
688 " 3 | Original-Word:Finding-Rule",
689 " 4 | Original-Word:Finding-Rule:Processed-Word",
690 "",
691 "- [ Attack Modes ] -",
692 "",
693 " # | Mode",
694 " ===+======",
695 " 0 | Straight",
696 " 1 | Combination",
697 " 3 | Brute-force",
698 " 6 | Hybrid Wordlist + Mask",
699 " 7 | Hybrid Mask + Wordlist",
700 "",
701 "- [ Built-in Charsets ] -",
702 "",
703 " ? | Charset",
704 " ===+=========",
705 " l | abcdefghijklmnopqrstuvwxyz",
706 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
707 " d | 0123456789",
708 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
709 " a | ?l?u?d?s",
710 " b | 0x00 - 0xff",
711 "",
712 "- [ OpenCL Device Types ] -",
713 "",
714 " # | Device Type",
715 " ===+=============",
716 " 1 | CPU",
717 " 2 | GPU",
718 " 3 | FPGA, DSP, Co-Processor",
719 "",
720 "- [ Workload Profiles ] -",
721 "",
722 " # | Performance | Runtime | Power Consumption | Desktop Impact",
723 " ===+=============+=========+===================+=================",
724 " 1 | Low | 2 ms | Low | Minimal",
725 " 2 | Default | 12 ms | Economic | Noticeable",
726 " 3 | High | 96 ms | High | Unresponsive",
727 " 4 | Nightmare | 480 ms | Insane | Headless",
728 "",
729 "If you have no idea what just happened then visit the following pages:",
730 "",
731 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
732 "* https://hashcat.net/wiki/#frequently_asked_questions",
733 "",
734 NULL
735 };
736
737 /**
738 * hashcat specific functions
739 */
740
741 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
742 {
743 int exec_pos = (int) device_param->exec_pos - last_num_entries;
744
745 if (exec_pos < 0) exec_pos += EXEC_CACHE;
746
747 double exec_ms_sum = 0;
748
749 int exec_ms_cnt = 0;
750
751 for (int i = 0; i < last_num_entries; i++)
752 {
753 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
754
755 if (exec_ms)
756 {
757 exec_ms_sum += exec_ms;
758
759 exec_ms_cnt++;
760 }
761 }
762
763 if (exec_ms_cnt == 0) return 0;
764
765 return exec_ms_sum / exec_ms_cnt;
766 }
767
768 void status_display_machine_readable ()
769 {
770 FILE *out = stdout;
771
772 fprintf (out, "STATUS\t%u\t", data.devices_status);
773
774 /**
775 * speed new
776 */
777
778 fprintf (out, "SPEED\t");
779
780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
781 {
782 hc_device_param_t *device_param = &data.devices_param[device_id];
783
784 if (device_param->skipped) continue;
785
786 u64 speed_cnt = 0;
787 double speed_ms = 0;
788
789 for (int i = 0; i < SPEED_CACHE; i++)
790 {
791 speed_cnt += device_param->speed_cnt[i];
792 speed_ms += device_param->speed_ms[i];
793 }
794
795 speed_cnt /= SPEED_CACHE;
796 speed_ms /= SPEED_CACHE;
797
798 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
799 }
800
801 /**
802 * exec time
803 */
804
805 fprintf (out, "EXEC_RUNTIME\t");
806
807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
808 {
809 hc_device_param_t *device_param = &data.devices_param[device_id];
810
811 if (device_param->skipped) continue;
812
813 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
814
815 fprintf (out, "%f\t", exec_ms_avg);
816 }
817
818 /**
819 * words_cur
820 */
821
822 u64 words_cur = get_lowest_words_done ();
823
824 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
825
826 /**
827 * counter
828 */
829
830 u64 progress_total = data.words_cnt * data.salts_cnt;
831
832 u64 all_done = 0;
833 u64 all_rejected = 0;
834 u64 all_restored = 0;
835
836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
837 {
838 all_done += data.words_progress_done[salt_pos];
839 all_rejected += data.words_progress_rejected[salt_pos];
840 all_restored += data.words_progress_restored[salt_pos];
841 }
842
843 u64 progress_cur = all_restored + all_done + all_rejected;
844 u64 progress_end = progress_total;
845
846 u64 progress_skip = 0;
847
848 if (data.skip)
849 {
850 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
855 }
856
857 if (data.limit)
858 {
859 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
860
861 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
862 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
863 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
864 }
865
866 u64 progress_cur_relative_skip = progress_cur - progress_skip;
867 u64 progress_end_relative_skip = progress_end - progress_skip;
868
869 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
870
871 /**
872 * cracks
873 */
874
875 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
876 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
877
878 /**
879 * temperature
880 */
881
882 #ifdef HAVE_HWMON
883 if (data.gpu_temp_disable == 0)
884 {
885 fprintf (out, "TEMP\t");
886
887 hc_thread_mutex_lock (mux_adl);
888
889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
890 {
891 hc_device_param_t *device_param = &data.devices_param[device_id];
892
893 if (device_param->skipped) continue;
894
895 int temp = hm_get_temperature_with_device_id (device_id);
896
897 fprintf (out, "%d\t", temp);
898 }
899
900 hc_thread_mutex_unlock (mux_adl);
901 }
902 #endif // HAVE_HWMON
903
904 /**
905 * flush
906 */
907
908 #ifdef _WIN
909 fputc ('\r', out);
910 fputc ('\n', out);
911 #endif
912
913 #ifdef _POSIX
914 fputc ('\n', out);
915 #endif
916
917 fflush (out);
918 }
919
920 void status_display ()
921 {
922 if (data.devices_status == STATUS_INIT) return;
923 if (data.devices_status == STATUS_STARTING) return;
924 if (data.devices_status == STATUS_BYPASS) return;
925
926 if (data.machine_readable == 1)
927 {
928 status_display_machine_readable ();
929
930 return;
931 }
932
933 char tmp_buf[1000] = { 0 };
934
935 uint tmp_len = 0;
936
937 log_info ("Session.Name...: %s", data.session);
938
939 char *status_type = strstatus (data.devices_status);
940
941 uint hash_mode = data.hash_mode;
942
943 char *hash_type = strhashtype (hash_mode); // not a bug
944
945 log_info ("Status.........: %s", status_type);
946
947 /**
948 * show rules
949 */
950
951 if (data.rp_files_cnt)
952 {
953 uint i;
954
955 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
956 {
957 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
958 }
959
960 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
961
962 log_info ("Rules.Type.....: %s", tmp_buf);
963
964 tmp_len = 0;
965 }
966
967 if (data.rp_gen)
968 {
969 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
970
971 if (data.rp_gen_seed)
972 {
973 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
974 }
975 }
976
977 /**
978 * show input
979 */
980
981 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
982 {
983 if (data.wordlist_mode == WL_MODE_FILE)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
986 }
987 else if (data.wordlist_mode == WL_MODE_STDIN)
988 {
989 log_info ("Input.Mode.....: Pipe");
990 }
991 }
992 else if (data.attack_mode == ATTACK_MODE_COMBI)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
995 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
996 }
997 else if (data.attack_mode == ATTACK_MODE_BF)
998 {
999 char *mask = data.mask;
1000
1001 if (mask != NULL)
1002 {
1003 uint mask_len = data.css_cnt;
1004
1005 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1006
1007 if (mask_len > 0)
1008 {
1009 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1010 {
1011 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1012 {
1013 mask_len -= data.salts_buf[0].salt_len;
1014 }
1015 }
1016
1017 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1020 }
1021
1022 if (data.maskcnt > 1)
1023 {
1024 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1027 }
1028
1029 log_info ("Input.Mode.....: %s", tmp_buf);
1030 }
1031
1032 tmp_len = 0;
1033 }
1034 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1035 {
1036 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1037 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1040 {
1041 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1042 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1043 }
1044
1045 if (data.digests_cnt == 1)
1046 {
1047 if (data.hash_mode == 2500)
1048 {
1049 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1050
1051 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1052 (char *) data.salts_buf[0].salt_buf,
1053 wpa->orig_mac1[0],
1054 wpa->orig_mac1[1],
1055 wpa->orig_mac1[2],
1056 wpa->orig_mac1[3],
1057 wpa->orig_mac1[4],
1058 wpa->orig_mac1[5],
1059 wpa->orig_mac2[0],
1060 wpa->orig_mac2[1],
1061 wpa->orig_mac2[2],
1062 wpa->orig_mac2[3],
1063 wpa->orig_mac2[4],
1064 wpa->orig_mac2[5]);
1065 }
1066 else if (data.hash_mode == 5200)
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 else if (data.hash_mode == 9000)
1071 {
1072 log_info ("Hash.Target....: File (%s)", data.hashfile);
1073 }
1074 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1075 {
1076 log_info ("Hash.Target....: File (%s)", data.hashfile);
1077 }
1078 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1079 {
1080 log_info ("Hash.Target....: File (%s)", data.hashfile);
1081 }
1082 else
1083 {
1084 char out_buf[HCBUFSIZ] = { 0 };
1085
1086 ascii_digest (out_buf, 0, 0);
1087
1088 // limit length
1089 if (strlen (out_buf) > 40)
1090 {
1091 out_buf[41] = '.';
1092 out_buf[42] = '.';
1093 out_buf[43] = '.';
1094 out_buf[44] = 0;
1095 }
1096
1097 log_info ("Hash.Target....: %s", out_buf);
1098 }
1099 }
1100 else
1101 {
1102 if (data.hash_mode == 3000)
1103 {
1104 char out_buf1[32] = { 0 };
1105 char out_buf2[32] = { 0 };
1106
1107 ascii_digest (out_buf1, 0, 0);
1108 ascii_digest (out_buf2, 0, 1);
1109
1110 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1111 }
1112 else
1113 {
1114 log_info ("Hash.Target....: File (%s)", data.hashfile);
1115 }
1116 }
1117
1118 log_info ("Hash.Type......: %s", hash_type);
1119
1120 /**
1121 * speed new
1122 */
1123
1124 u64 speed_cnt[DEVICES_MAX] = { 0 };
1125 double speed_ms[DEVICES_MAX] = { 0 };
1126
1127 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1128 {
1129 hc_device_param_t *device_param = &data.devices_param[device_id];
1130
1131 if (device_param->skipped) continue;
1132
1133 speed_cnt[device_id] = 0;
1134 speed_ms[device_id] = 0;
1135
1136 for (int i = 0; i < SPEED_CACHE; i++)
1137 {
1138 speed_cnt[device_id] += device_param->speed_cnt[i];
1139 speed_ms[device_id] += device_param->speed_ms[i];
1140 }
1141
1142 speed_cnt[device_id] /= SPEED_CACHE;
1143 speed_ms[device_id] /= SPEED_CACHE;
1144 }
1145
1146 double hashes_all_ms = 0;
1147
1148 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1149
1150 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1151 {
1152 hc_device_param_t *device_param = &data.devices_param[device_id];
1153
1154 if (device_param->skipped) continue;
1155
1156 hashes_dev_ms[device_id] = 0;
1157
1158 if (speed_ms[device_id])
1159 {
1160 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1161
1162 hashes_all_ms += hashes_dev_ms[device_id];
1163 }
1164 }
1165
1166 /**
1167 * exec time
1168 */
1169
1170 double exec_all_ms[DEVICES_MAX] = { 0 };
1171
1172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1173 {
1174 hc_device_param_t *device_param = &data.devices_param[device_id];
1175
1176 if (device_param->skipped) continue;
1177
1178 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1179
1180 exec_all_ms[device_id] = exec_ms_avg;
1181 }
1182
1183 /**
1184 * timers
1185 */
1186
1187 double ms_running = 0;
1188
1189 hc_timer_get (data.timer_running, ms_running);
1190
1191 double ms_paused = data.ms_paused;
1192
1193 if (data.devices_status == STATUS_PAUSED)
1194 {
1195 double ms_paused_tmp = 0;
1196
1197 hc_timer_get (data.timer_paused, ms_paused_tmp);
1198
1199 ms_paused += ms_paused_tmp;
1200 }
1201
1202 #ifdef WIN
1203
1204 __time64_t sec_run = ms_running / 1000;
1205
1206 #else
1207
1208 time_t sec_run = ms_running / 1000;
1209
1210 #endif
1211
1212 if (sec_run)
1213 {
1214 char display_run[32] = { 0 };
1215
1216 struct tm tm_run;
1217
1218 struct tm *tmp = NULL;
1219
1220 #ifdef WIN
1221
1222 tmp = _gmtime64 (&sec_run);
1223
1224 #else
1225
1226 tmp = gmtime (&sec_run);
1227
1228 #endif
1229
1230 if (tmp != NULL)
1231 {
1232 memset (&tm_run, 0, sizeof (tm_run));
1233
1234 memcpy (&tm_run, tmp, sizeof (tm_run));
1235
1236 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1237
1238 char *start = ctime (&data.proc_start);
1239
1240 size_t start_len = strlen (start);
1241
1242 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1243 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1244
1245 log_info ("Time.Started...: %s (%s)", start, display_run);
1246 }
1247 }
1248 else
1249 {
1250 log_info ("Time.Started...: 0 secs");
1251 }
1252
1253 /**
1254 * counters
1255 */
1256
1257 u64 progress_total = data.words_cnt * data.salts_cnt;
1258
1259 u64 all_done = 0;
1260 u64 all_rejected = 0;
1261 u64 all_restored = 0;
1262
1263 u64 progress_noneed = 0;
1264
1265 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1266 {
1267 all_done += data.words_progress_done[salt_pos];
1268 all_rejected += data.words_progress_rejected[salt_pos];
1269 all_restored += data.words_progress_restored[salt_pos];
1270
1271 // Important for ETA only
1272
1273 if (data.salts_shown[salt_pos] == 1)
1274 {
1275 const u64 all = data.words_progress_done[salt_pos]
1276 + data.words_progress_rejected[salt_pos]
1277 + data.words_progress_restored[salt_pos];
1278
1279 const u64 left = data.words_cnt - all;
1280
1281 progress_noneed += left;
1282 }
1283 }
1284
1285 u64 progress_cur = all_restored + all_done + all_rejected;
1286 u64 progress_end = progress_total;
1287
1288 u64 progress_skip = 0;
1289
1290 if (data.skip)
1291 {
1292 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1297 }
1298
1299 if (data.limit)
1300 {
1301 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1302
1303 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1306 }
1307
1308 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1309 u64 progress_end_relative_skip = progress_end - progress_skip;
1310
1311 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1312 {
1313 if (data.devices_status != STATUS_CRACKED)
1314 {
1315 #ifdef WIN
1316 __time64_t sec_etc = 0;
1317 #else
1318 time_t sec_etc = 0;
1319 #endif
1320
1321 if (hashes_all_ms)
1322 {
1323 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1324
1325 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1326
1327 sec_etc = ms_left / 1000;
1328 }
1329
1330 if (sec_etc == 0)
1331 {
1332 //log_info ("Time.Estimated.: 0 secs");
1333 }
1334 else if ((u64) sec_etc > ETC_MAX)
1335 {
1336 log_info ("Time.Estimated.: > 10 Years");
1337 }
1338 else
1339 {
1340 char display_etc[32] = { 0 };
1341
1342 struct tm tm_etc;
1343
1344 struct tm *tmp = NULL;
1345
1346 #ifdef WIN
1347
1348 tmp = _gmtime64 (&sec_etc);
1349
1350 #else
1351
1352 tmp = gmtime (&sec_etc);
1353
1354 #endif
1355
1356 if (tmp != NULL)
1357 {
1358 memset (&tm_etc, 0, sizeof (tm_etc));
1359
1360 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1361
1362 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1363
1364 time_t now;
1365
1366 time (&now);
1367
1368 now += sec_etc;
1369
1370 char *etc = ctime (&now);
1371
1372 size_t etc_len = strlen (etc);
1373
1374 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1375 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1376
1377 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1378 }
1379 }
1380 }
1381 }
1382
1383 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1384 {
1385 hc_device_param_t *device_param = &data.devices_param[device_id];
1386
1387 if (device_param->skipped) continue;
1388
1389 char display_dev_cur[16] = { 0 };
1390
1391 strncpy (display_dev_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1394
1395 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1396 }
1397
1398 char display_all_cur[16] = { 0 };
1399
1400 strncpy (display_all_cur, "0.00", 4);
1401
1402 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1403
1404 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1405
1406 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1407 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1408
1409 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);
1410
1411 // crack-per-time
1412
1413 if (data.digests_cnt > 100)
1414 {
1415 time_t now = time (NULL);
1416
1417 int cpt_cur_min = 0;
1418 int cpt_cur_hour = 0;
1419 int cpt_cur_day = 0;
1420
1421 for (int i = 0; i < CPT_BUF; i++)
1422 {
1423 const uint cracked = data.cpt_buf[i].cracked;
1424 const time_t timestamp = data.cpt_buf[i].timestamp;
1425
1426 if ((timestamp + 60) > now)
1427 {
1428 cpt_cur_min += cracked;
1429 }
1430
1431 if ((timestamp + 3600) > now)
1432 {
1433 cpt_cur_hour += cracked;
1434 }
1435
1436 if ((timestamp + 86400) > now)
1437 {
1438 cpt_cur_day += cracked;
1439 }
1440 }
1441
1442 double ms_real = ms_running - ms_paused;
1443
1444 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1445 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1446 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1447
1448 if ((data.cpt_start + 86400) < now)
1449 {
1450 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1451 cpt_cur_min,
1452 cpt_cur_hour,
1453 cpt_cur_day,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 3600) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_cur_hour,
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 else if ((data.cpt_start + 60) < now)
1468 {
1469 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1470 cpt_cur_min,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else
1476 {
1477 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 }
1483
1484 // Restore point
1485
1486 u64 restore_point = get_lowest_words_done ();
1487
1488 u64 restore_total = data.words_base;
1489
1490 float percent_restore = 0;
1491
1492 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1493
1494 if (progress_end_relative_skip)
1495 {
1496 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1497 {
1498 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1499 float percent_rejected = 0.0;
1500
1501 if (progress_cur)
1502 {
1503 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1504 }
1505
1506 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);
1507 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1508
1509 if (data.restore_disable == 0)
1510 {
1511 if (percent_finished != 1)
1512 {
1513 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1514 }
1515 }
1516 }
1517 }
1518 else
1519 {
1520 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1521 {
1522 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1523 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1524
1525 if (data.restore_disable == 0)
1526 {
1527 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1528 }
1529 }
1530 else
1531 {
1532 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1533 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1534
1535 // --restore not allowed if stdin is used -- really? why?
1536
1537 //if (data.restore_disable == 0)
1538 //{
1539 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1540 //}
1541 }
1542 }
1543
1544 #ifdef HAVE_HWMON
1545
1546 if (data.devices_status == STATUS_EXHAUSTED) return;
1547 if (data.devices_status == STATUS_CRACKED) return;
1548 if (data.devices_status == STATUS_ABORTED) return;
1549 if (data.devices_status == STATUS_QUIT) return;
1550
1551 if (data.gpu_temp_disable == 0)
1552 {
1553 hc_thread_mutex_lock (mux_adl);
1554
1555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1556 {
1557 hc_device_param_t *device_param = &data.devices_param[device_id];
1558
1559 if (device_param->skipped) continue;
1560
1561 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1562 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1563 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1564 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1565 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1566 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1567 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1568
1569 char output_buf[256] = { 0 };
1570
1571 int output_len = 0;
1572
1573 if (num_temperature >= 0)
1574 {
1575 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1576
1577 output_len = strlen (output_buf);
1578 }
1579
1580 if (num_fanspeed >= 0)
1581 {
1582 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1583
1584 output_len = strlen (output_buf);
1585 }
1586
1587 if (num_utilization >= 0)
1588 {
1589 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1590
1591 output_len = strlen (output_buf);
1592 }
1593
1594 if (num_corespeed >= 0)
1595 {
1596 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1597
1598 output_len = strlen (output_buf);
1599 }
1600
1601 if (num_memoryspeed >= 0)
1602 {
1603 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1604
1605 output_len = strlen (output_buf);
1606 }
1607
1608 if (num_buslanes >= 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 if (num_throttle == 1)
1616 {
1617 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1618
1619 output_len = strlen (output_buf);
1620 }
1621
1622 if (output_len == 0)
1623 {
1624 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1625
1626 output_len = strlen (output_buf);
1627 }
1628
1629 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634
1635 #endif // HAVE_HWMON
1636 }
1637
1638 static void status_benchmark_automate ()
1639 {
1640 u64 speed_cnt[DEVICES_MAX] = { 0 };
1641 double speed_ms[DEVICES_MAX] = { 0 };
1642
1643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1644 {
1645 hc_device_param_t *device_param = &data.devices_param[device_id];
1646
1647 if (device_param->skipped) continue;
1648
1649 speed_cnt[device_id] = device_param->speed_cnt[0];
1650 speed_ms[device_id] = device_param->speed_ms[0];
1651 }
1652
1653 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 hashes_dev_ms[device_id] = 0;
1662
1663 if (speed_ms[device_id])
1664 {
1665 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1666 }
1667 }
1668
1669 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1670 {
1671 hc_device_param_t *device_param = &data.devices_param[device_id];
1672
1673 if (device_param->skipped) continue;
1674
1675 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1676 }
1677 }
1678
1679 static void status_benchmark ()
1680 {
1681 if (data.devices_status == STATUS_INIT) return;
1682 if (data.devices_status == STATUS_STARTING) return;
1683 if (data.devices_status == STATUS_BYPASS) return;
1684
1685 if (data.machine_readable == 1)
1686 {
1687 status_benchmark_automate ();
1688
1689 return;
1690 }
1691
1692 u64 speed_cnt[DEVICES_MAX] = { 0 };
1693 double speed_ms[DEVICES_MAX] = { 0 };
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 speed_cnt[device_id] = device_param->speed_cnt[0];
1702 speed_ms[device_id] = device_param->speed_ms[0];
1703 }
1704
1705 double hashes_all_ms = 0;
1706
1707 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1708
1709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1710 {
1711 hc_device_param_t *device_param = &data.devices_param[device_id];
1712
1713 if (device_param->skipped) continue;
1714
1715 hashes_dev_ms[device_id] = 0;
1716
1717 if (speed_ms[device_id])
1718 {
1719 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1720
1721 hashes_all_ms += hashes_dev_ms[device_id];
1722 }
1723 }
1724
1725 /**
1726 * exec time
1727 */
1728
1729 double exec_all_ms[DEVICES_MAX] = { 0 };
1730
1731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1732 {
1733 hc_device_param_t *device_param = &data.devices_param[device_id];
1734
1735 if (device_param->skipped) continue;
1736
1737 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1738
1739 exec_all_ms[device_id] = exec_ms_avg;
1740 }
1741
1742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1743 {
1744 hc_device_param_t *device_param = &data.devices_param[device_id];
1745
1746 if (device_param->skipped) continue;
1747
1748 char display_dev_cur[16] = { 0 };
1749
1750 strncpy (display_dev_cur, "0.00", 4);
1751
1752 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1753
1754 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1755 }
1756
1757 char display_all_cur[16] = { 0 };
1758
1759 strncpy (display_all_cur, "0.00", 4);
1760
1761 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1762
1763 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1764 }
1765
1766 /**
1767 * hashcat -only- functions
1768 */
1769
1770 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1780 }
1781 else
1782 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1783 }
1784
1785 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)
1786 {
1787 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1788 {
1789 if (attack_kern == ATTACK_KERN_STRAIGHT)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_COMBI)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_BF)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 }
1796 else
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 }
1800 }
1801
1802 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1803 {
1804 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1805 {
1806 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1807 }
1808 else
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1811 }
1812 }
1813
1814 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)
1815 {
1816 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1819 }
1820 else
1821 {
1822 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1823 }
1824 }
1825
1826 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1827 {
1828 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1829 }
1830
1831 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1832 {
1833 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1834 }
1835
1836 static uint convert_from_hex (char *line_buf, const uint line_len)
1837 {
1838 if (line_len & 1) return (line_len); // not in hex
1839
1840 if (data.hex_wordlist == 1)
1841 {
1842 uint i;
1843 uint j;
1844
1845 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1846 {
1847 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1848 }
1849
1850 memset (line_buf + i, 0, line_len - i);
1851
1852 return (i);
1853 }
1854 else if (line_len >= 6) // $HEX[] = 6
1855 {
1856 if (line_buf[0] != '$') return (line_len);
1857 if (line_buf[1] != 'H') return (line_len);
1858 if (line_buf[2] != 'E') return (line_len);
1859 if (line_buf[3] != 'X') return (line_len);
1860 if (line_buf[4] != '[') return (line_len);
1861 if (line_buf[line_len - 1] != ']') return (line_len);
1862
1863 uint i;
1864 uint j;
1865
1866 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1867 {
1868 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1869 }
1870
1871 memset (line_buf + i, 0, line_len - i);
1872
1873 return (i);
1874 }
1875
1876 return (line_len);
1877 }
1878
1879 static void clear_prompt ()
1880 {
1881 fputc ('\r', stdout);
1882
1883 for (size_t i = 0; i < strlen (PROMPT); i++)
1884 {
1885 fputc (' ', stdout);
1886 }
1887
1888 fputc ('\r', stdout);
1889
1890 fflush (stdout);
1891 }
1892
1893 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1894 {
1895 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);
1896 }
1897
1898 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1899 {
1900 char *outfile = data.outfile;
1901 uint quiet = data.quiet;
1902 FILE *pot_fp = data.pot_fp;
1903 uint loopback = data.loopback;
1904 uint debug_mode = data.debug_mode;
1905 char *debug_file = data.debug_file;
1906
1907 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1908 int debug_rule_len = 0; // -1 error
1909 uint debug_plain_len = 0;
1910
1911 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1912
1913 // hash
1914
1915 char out_buf[HCBUFSIZ] = { 0 };
1916
1917 const u32 salt_pos = plain->salt_pos;
1918 const u32 digest_pos = plain->digest_pos; // relative
1919 const u32 gidvid = plain->gidvid;
1920 const u32 il_pos = plain->il_pos;
1921
1922 ascii_digest (out_buf, salt_pos, digest_pos);
1923
1924 // plain
1925
1926 u64 crackpos = device_param->words_off;
1927
1928 uint plain_buf[16] = { 0 };
1929
1930 u8 *plain_ptr = (u8 *) plain_buf;
1931
1932 unsigned int plain_len = 0;
1933
1934 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1935 {
1936 pw_t pw;
1937
1938 gidd_to_pw_t (device_param, gidvid, &pw);
1939
1940 for (int i = 0; i < 16; i++)
1941 {
1942 plain_buf[i] = pw.i[i];
1943 }
1944
1945 plain_len = pw.pw_len;
1946
1947 const uint off = device_param->innerloop_pos + il_pos;
1948
1949 if (debug_mode > 0)
1950 {
1951 debug_rule_len = 0;
1952
1953 // save rule
1954 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1955 {
1956 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1957
1958 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1959 }
1960
1961 // save plain
1962 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1963 {
1964 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1965
1966 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1967
1968 debug_plain_len = plain_len;
1969 }
1970 }
1971
1972 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1973
1974 crackpos += gidvid;
1975 crackpos *= data.kernel_rules_cnt;
1976 crackpos += device_param->innerloop_pos + il_pos;
1977
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_COMBI)
1981 {
1982 pw_t pw;
1983
1984 gidd_to_pw_t (device_param, gidvid, &pw);
1985
1986 for (int i = 0; i < 16; i++)
1987 {
1988 plain_buf[i] = pw.i[i];
1989 }
1990
1991 plain_len = pw.pw_len;
1992
1993 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1994 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1995
1996 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1997 {
1998 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1999 }
2000 else
2001 {
2002 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2003
2004 memcpy (plain_ptr, comb_buf, comb_len);
2005 }
2006
2007 plain_len += comb_len;
2008
2009 crackpos += gidvid;
2010 crackpos *= data.combs_cnt;
2011 crackpos += device_param->innerloop_pos + il_pos;
2012
2013 if (data.pw_max != PW_DICTMAX1)
2014 {
2015 if (plain_len > data.pw_max) plain_len = data.pw_max;
2016 }
2017 }
2018 else if (data.attack_mode == ATTACK_MODE_BF)
2019 {
2020 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2021 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2022
2023 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2024 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2025
2026 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2027 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2028
2029 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2030 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2031
2032 plain_len = data.css_cnt;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.bfs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037 }
2038 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2039 {
2040 pw_t pw;
2041
2042 gidd_to_pw_t (device_param, gidvid, &pw);
2043
2044 for (int i = 0; i < 16; i++)
2045 {
2046 plain_buf[i] = pw.i[i];
2047 }
2048
2049 plain_len = pw.pw_len;
2050
2051 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2052
2053 uint start = 0;
2054 uint stop = device_param->kernel_params_mp_buf32[4];
2055
2056 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2057
2058 plain_len += start + stop;
2059
2060 crackpos += gidvid;
2061 crackpos *= data.combs_cnt;
2062 crackpos += device_param->innerloop_pos + il_pos;
2063
2064 if (data.pw_max != PW_DICTMAX1)
2065 {
2066 if (plain_len > data.pw_max) plain_len = data.pw_max;
2067 }
2068 }
2069 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2070 {
2071 pw_t pw;
2072
2073 gidd_to_pw_t (device_param, gidvid, &pw);
2074
2075 for (int i = 0; i < 16; i++)
2076 {
2077 plain_buf[i] = pw.i[i];
2078 }
2079
2080 plain_len = pw.pw_len;
2081
2082 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2083
2084 uint start = 0;
2085 uint stop = device_param->kernel_params_mp_buf32[4];
2086
2087 memmove (plain_ptr + stop, plain_ptr, plain_len);
2088
2089 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2090
2091 plain_len += start + stop;
2092
2093 crackpos += gidvid;
2094 crackpos *= data.combs_cnt;
2095 crackpos += device_param->innerloop_pos + il_pos;
2096
2097 if (data.pw_max != PW_DICTMAX1)
2098 {
2099 if (plain_len > data.pw_max) plain_len = data.pw_max;
2100 }
2101 }
2102
2103 if (data.attack_mode == ATTACK_MODE_BF)
2104 {
2105 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2106 {
2107 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2108 {
2109 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2110 {
2111 plain_len = plain_len - data.salts_buf[0].salt_len;
2112 }
2113 }
2114
2115 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2116 {
2117 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2118 {
2119 plain_ptr[j] = plain_ptr[i];
2120 }
2121
2122 plain_len = plain_len / 2;
2123 }
2124 }
2125 }
2126
2127 // if enabled, update also the potfile
2128
2129 if (pot_fp)
2130 {
2131 lock_file (pot_fp);
2132
2133 fprintf (pot_fp, "%s:", out_buf);
2134
2135 format_plain (pot_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', pot_fp);
2138
2139 fflush (pot_fp);
2140
2141 unlock_file (pot_fp);
2142 }
2143
2144 // outfile
2145
2146 FILE *out_fp = NULL;
2147
2148 if (outfile != NULL)
2149 {
2150 if ((out_fp = fopen (outfile, "ab")) == NULL)
2151 {
2152 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2153
2154 out_fp = stdout;
2155 }
2156
2157 lock_file (out_fp);
2158 }
2159 else
2160 {
2161 out_fp = stdout;
2162
2163 if (quiet == 0) clear_prompt ();
2164 }
2165
2166 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2167
2168 if (outfile != NULL)
2169 {
2170 if (out_fp != stdout)
2171 {
2172 fclose (out_fp);
2173 }
2174 }
2175 else
2176 {
2177 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2178 {
2179 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2180 {
2181 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2182 if (quiet == 0) fflush (stdout);
2183 }
2184 }
2185 }
2186
2187 // loopback
2188
2189 if (loopback)
2190 {
2191 char *loopback_file = data.loopback_file;
2192
2193 FILE *fb_fp = NULL;
2194
2195 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2196 {
2197 lock_file (fb_fp);
2198
2199 format_plain (fb_fp, plain_ptr, plain_len, 1);
2200
2201 fputc ('\n', fb_fp);
2202
2203 fclose (fb_fp);
2204 }
2205 }
2206
2207 // (rule) debug mode
2208
2209 // the next check implies that:
2210 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2211 // - debug_mode > 0
2212
2213 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2214 {
2215 if (debug_rule_len < 0) debug_rule_len = 0;
2216
2217 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2218
2219 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2220
2221 if ((quiet == 0) && (debug_file == NULL))
2222 {
2223 fprintf (stdout, "%s", PROMPT);
2224
2225 fflush (stdout);
2226 }
2227 }
2228 }
2229
2230 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2231 {
2232 salt_t *salt_buf = &data.salts_buf[salt_pos];
2233
2234 u32 num_cracked;
2235
2236 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2237
2238 if (num_cracked)
2239 {
2240 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2241
2242 log_info_nn ("");
2243
2244 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2245
2246 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);
2247
2248 uint cpt_cracked = 0;
2249
2250 for (uint i = 0; i < num_cracked; i++)
2251 {
2252 const uint hash_pos = cracked[i].hash_pos;
2253
2254 if (data.digests_shown[hash_pos] == 1) continue;
2255
2256 hc_thread_mutex_lock (mux_display);
2257
2258 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2259 {
2260 data.digests_shown[hash_pos] = 1;
2261
2262 data.digests_done++;
2263
2264 cpt_cracked++;
2265
2266 salt_buf->digests_done++;
2267
2268 if (salt_buf->digests_done == salt_buf->digests_cnt)
2269 {
2270 data.salts_shown[salt_pos] = 1;
2271
2272 data.salts_done++;
2273 }
2274 }
2275
2276 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2277
2278 hc_thread_mutex_unlock (mux_display);
2279
2280 check_hash (device_param, &cracked[i]);
2281 }
2282
2283 myfree (cracked);
2284
2285 if (cpt_cracked > 0)
2286 {
2287 hc_thread_mutex_lock (mux_display);
2288
2289 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2290 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2291
2292 data.cpt_pos++;
2293
2294 data.cpt_total += cpt_cracked;
2295
2296 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2297
2298 hc_thread_mutex_unlock (mux_display);
2299 }
2300
2301 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2302 {
2303 // we need to reset cracked state on the device
2304 // otherwise host thinks again and again the hash was cracked
2305 // and returns invalid password each time
2306
2307 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2308
2309 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);
2310 }
2311
2312 num_cracked = 0;
2313
2314 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2315 }
2316 }
2317
2318 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2319 {
2320 char out_buf[HCBUFSIZ] = { 0 };
2321
2322 uint plain_buf[16] = { 0 };
2323
2324 u8 *plain_ptr = (u8 *) plain_buf;
2325
2326 uint plain_len = 0;
2327
2328 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2329
2330 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2331 {
2332 pw_t pw;
2333
2334 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2335 {
2336 gidd_to_pw_t (device_param, gidvid, &pw);
2337
2338 const uint pos = device_param->innerloop_pos;
2339
2340 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2341 {
2342 for (int i = 0; i < 8; i++)
2343 {
2344 plain_buf[i] = pw.i[i];
2345 }
2346
2347 plain_len = pw.pw_len;
2348
2349 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2350
2351 if (plain_len > data.pw_max) plain_len = data.pw_max;
2352
2353 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2354 }
2355 }
2356 }
2357 else if (data.attack_mode == ATTACK_MODE_COMBI)
2358 {
2359 pw_t pw;
2360
2361 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2362 {
2363 gidd_to_pw_t (device_param, gidvid, &pw);
2364
2365 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2366 {
2367 for (int i = 0; i < 8; i++)
2368 {
2369 plain_buf[i] = pw.i[i];
2370 }
2371
2372 plain_len = pw.pw_len;
2373
2374 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2375 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2376
2377 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2378 {
2379 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2380 }
2381 else
2382 {
2383 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2384
2385 memcpy (plain_ptr, comb_buf, comb_len);
2386 }
2387
2388 plain_len += comb_len;
2389
2390 if (data.pw_max != PW_DICTMAX1)
2391 {
2392 if (plain_len > data.pw_max) plain_len = data.pw_max;
2393 }
2394
2395 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2396 }
2397 }
2398 }
2399 else if (data.attack_mode == ATTACK_MODE_BF)
2400 {
2401 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2402 {
2403 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2404 {
2405 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2406 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2407
2408 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2409 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2410
2411 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2412 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2413
2414 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2415 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2416
2417 plain_len = data.css_cnt;
2418
2419 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2441
2442 uint start = 0;
2443 uint stop = device_param->kernel_params_mp_buf32[4];
2444
2445 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2446
2447 plain_len += start + stop;
2448
2449 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2450 }
2451 }
2452 }
2453 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2454 {
2455 pw_t pw;
2456
2457 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2458 {
2459 gidd_to_pw_t (device_param, gidvid, &pw);
2460
2461 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2462 {
2463 for (int i = 0; i < 8; i++)
2464 {
2465 plain_buf[i] = pw.i[i];
2466 }
2467
2468 plain_len = pw.pw_len;
2469
2470 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2471
2472 uint start = 0;
2473 uint stop = device_param->kernel_params_mp_buf32[4];
2474
2475 memmove (plain_ptr + stop, plain_ptr, plain_len);
2476
2477 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2478
2479 plain_len += start + stop;
2480
2481 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2482 }
2483 }
2484 }
2485 }
2486
2487 static void save_hash ()
2488 {
2489 char *hashfile = data.hashfile;
2490
2491 char new_hashfile[256] = { 0 };
2492 char old_hashfile[256] = { 0 };
2493
2494 snprintf (new_hashfile, 255, "%s.new", hashfile);
2495 snprintf (old_hashfile, 255, "%s.old", hashfile);
2496
2497 unlink (new_hashfile);
2498
2499 char separator = data.separator;
2500
2501 FILE *fp = fopen (new_hashfile, "wb");
2502
2503 if (fp == NULL)
2504 {
2505 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2506
2507 exit (-1);
2508 }
2509
2510 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2511 {
2512 if (data.salts_shown[salt_pos] == 1) continue;
2513
2514 salt_t *salt_buf = &data.salts_buf[salt_pos];
2515
2516 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2517 {
2518 uint idx = salt_buf->digests_offset + digest_pos;
2519
2520 if (data.digests_shown[idx] == 1) continue;
2521
2522 if (data.hash_mode != 2500)
2523 {
2524 if (data.username == 1)
2525 {
2526 user_t *user = data.hash_info[idx]->user;
2527
2528 uint i;
2529
2530 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2531
2532 fputc (separator, fp);
2533 }
2534
2535 char out_buf[HCBUFSIZ]; // scratch buffer
2536
2537 out_buf[0] = 0;
2538
2539 ascii_digest (out_buf, salt_pos, digest_pos);
2540
2541 fputs (out_buf, fp);
2542
2543 fputc ('\n', fp);
2544 }
2545 else
2546 {
2547 hccap_t hccap;
2548
2549 to_hccap_t (&hccap, salt_pos, digest_pos);
2550
2551 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2552 }
2553 }
2554 }
2555
2556 fflush (fp);
2557
2558 fclose (fp);
2559
2560 unlink (old_hashfile);
2561
2562 if (rename (hashfile, old_hashfile) != 0)
2563 {
2564 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2565
2566 exit (-1);
2567 }
2568
2569 unlink (hashfile);
2570
2571 if (rename (new_hashfile, hashfile) != 0)
2572 {
2573 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2574
2575 exit (-1);
2576 }
2577
2578 unlink (old_hashfile);
2579 }
2580
2581 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2582 {
2583 uint num_elements = num;
2584
2585 device_param->kernel_params_buf32[30] = data.combs_mode;
2586 device_param->kernel_params_buf32[31] = num;
2587
2588 uint kernel_threads = device_param->kernel_threads;
2589
2590 while (num_elements % kernel_threads) num_elements++;
2591
2592 cl_kernel kernel = NULL;
2593
2594 switch (kern_run)
2595 {
2596 case KERN_RUN_1: kernel = device_param->kernel1; break;
2597 case KERN_RUN_12: kernel = device_param->kernel12; break;
2598 case KERN_RUN_2: kernel = device_param->kernel2; break;
2599 case KERN_RUN_23: kernel = device_param->kernel23; break;
2600 case KERN_RUN_3: kernel = device_param->kernel3; break;
2601 }
2602
2603 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2604 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2605 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2606 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2607 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2608 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2609 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2610 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2611 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2612 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2613 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2614
2615 cl_event event;
2616
2617 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2618 {
2619 const size_t global_work_size[3] = { num_elements, 32, 1 };
2620 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2621
2622 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2623 }
2624 else
2625 {
2626 if (kern_run == KERN_RUN_2)
2627 {
2628 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2629 {
2630 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2631 }
2632 }
2633
2634 while (num_elements % kernel_threads) num_elements++;
2635
2636 const size_t global_work_size[3] = { num_elements, 1, 1 };
2637 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2638
2639 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2640 }
2641
2642 hc_clFlush (data.ocl, device_param->command_queue);
2643
2644 if (data.devices_status == STATUS_RUNNING)
2645 {
2646 if (iteration < EXPECTED_ITERATIONS)
2647 {
2648 switch (kern_run)
2649 {
2650 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration]); break;
2651 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration]); break;
2652 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration]); break;
2653 }
2654 }
2655 }
2656
2657 hc_clWaitForEvents (data.ocl, 1, &event);
2658
2659 cl_ulong time_start;
2660 cl_ulong time_end;
2661
2662 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2663 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2664
2665 const double exec_us = (double) (time_end - time_start) / 1000;
2666
2667 if (data.devices_status == STATUS_RUNNING)
2668 {
2669 if (iteration < EXPECTED_ITERATIONS)
2670 {
2671 switch (kern_run)
2672 {
2673 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2674 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2675 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2676 }
2677 }
2678 }
2679
2680 if (event_update)
2681 {
2682 uint exec_pos = device_param->exec_pos;
2683
2684 device_param->exec_ms[exec_pos] = exec_us / 1000;
2685
2686 exec_pos++;
2687
2688 if (exec_pos == EXEC_CACHE)
2689 {
2690 exec_pos = 0;
2691 }
2692
2693 device_param->exec_pos = exec_pos;
2694 }
2695
2696 hc_clReleaseEvent (data.ocl, event);
2697
2698 hc_clFinish (data.ocl, device_param->command_queue);
2699 }
2700
2701 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2702 {
2703 uint num_elements = num;
2704
2705 switch (kern_run)
2706 {
2707 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2708 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2709 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2710 }
2711
2712 // causes problems with special threads like in bcrypt
2713 // const uint kernel_threads = device_param->kernel_threads;
2714
2715 uint kernel_threads = device_param->kernel_threads;
2716
2717 while (num_elements % kernel_threads) num_elements++;
2718
2719 cl_kernel kernel = NULL;
2720
2721 switch (kern_run)
2722 {
2723 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2724 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2725 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2726 }
2727
2728 switch (kern_run)
2729 {
2730 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2731 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2732 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2733 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2734 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2735 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2736 break;
2737 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2738 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2739 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2740 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2741 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2742 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2743 break;
2744 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2745 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2746 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2747 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2748 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2749 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2750 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2751 break;
2752 }
2753
2754 const size_t global_work_size[3] = { num_elements, 1, 1 };
2755 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2756
2757 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2758
2759 hc_clFlush (data.ocl, device_param->command_queue);
2760
2761 hc_clFinish (data.ocl, device_param->command_queue);
2762 }
2763
2764 static void run_kernel_tm (hc_device_param_t *device_param)
2765 {
2766 const uint num_elements = 1024; // fixed
2767
2768 uint kernel_threads = 32;
2769
2770 cl_kernel kernel = device_param->kernel_tm;
2771
2772 const size_t global_work_size[3] = { num_elements, 1, 1 };
2773 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2774
2775 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2776
2777 hc_clFlush (data.ocl, device_param->command_queue);
2778
2779 hc_clFinish (data.ocl, device_param->command_queue);
2780 }
2781
2782 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2783 {
2784 uint num_elements = num;
2785
2786 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2787 device_param->kernel_params_amp_buf32[6] = num_elements;
2788
2789 // causes problems with special threads like in bcrypt
2790 // const uint kernel_threads = device_param->kernel_threads;
2791
2792 uint kernel_threads = device_param->kernel_threads;
2793
2794 while (num_elements % kernel_threads) num_elements++;
2795
2796 cl_kernel kernel = device_param->kernel_amp;
2797
2798 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2799 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2800
2801 const size_t global_work_size[3] = { num_elements, 1, 1 };
2802 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2803
2804 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2805
2806 hc_clFlush (data.ocl, device_param->command_queue);
2807
2808 hc_clFinish (data.ocl, device_param->command_queue);
2809 }
2810
2811 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2812 {
2813 const u32 num16d = num / 16;
2814 const u32 num16m = num % 16;
2815
2816 if (num16d)
2817 {
2818 device_param->kernel_params_memset_buf32[1] = value;
2819 device_param->kernel_params_memset_buf32[2] = num16d;
2820
2821 uint kernel_threads = device_param->kernel_threads;
2822
2823 uint num_elements = num16d;
2824
2825 while (num_elements % kernel_threads) num_elements++;
2826
2827 cl_kernel kernel = device_param->kernel_memset;
2828
2829 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2830 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2831 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2832
2833 const size_t global_work_size[3] = { num_elements, 1, 1 };
2834 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2835
2836 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2837
2838 hc_clFlush (data.ocl, device_param->command_queue);
2839
2840 hc_clFinish (data.ocl, device_param->command_queue);
2841 }
2842
2843 if (num16m)
2844 {
2845 u32 tmp[4];
2846
2847 tmp[0] = value;
2848 tmp[1] = value;
2849 tmp[2] = value;
2850 tmp[3] = value;
2851
2852 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2853 }
2854 }
2855
2856 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2857 {
2858 run_kernel_memset (device_param, buf, 0, size);
2859
2860 /*
2861 int rc = -1;
2862
2863 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2864 {
2865 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2866
2867 const cl_uchar zero = 0;
2868
2869 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2870 }
2871
2872 if (rc != 0)
2873 {
2874 // NOTE: clEnqueueFillBuffer () always fails with -59
2875 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2876 // How's that possible, OpenCL 1.2 support is advertised??
2877 // We need to workaround...
2878
2879 #define FILLSZ 0x100000
2880
2881 char *tmp = (char *) mymalloc (FILLSZ);
2882
2883 for (size_t i = 0; i < size; i += FILLSZ)
2884 {
2885 const size_t left = size - i;
2886
2887 const size_t fillsz = MIN (FILLSZ, left);
2888
2889 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2890 }
2891
2892 myfree (tmp);
2893 }
2894 */
2895 }
2896
2897 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, const uint fast_iteration)
2898 {
2899 if (data.hash_mode == 2000)
2900 {
2901 process_stdout (device_param, pws_cnt);
2902
2903 return;
2904 }
2905
2906 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2907 {
2908 if (attack_mode == ATTACK_MODE_BF)
2909 {
2910 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2911 {
2912 const uint size_tm = 32 * sizeof (bs_word_t);
2913
2914 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2915
2916 run_kernel_tm (device_param);
2917
2918 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);
2919 }
2920 }
2921
2922 if (highest_pw_len < 16)
2923 {
2924 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2925 }
2926 else if (highest_pw_len < 32)
2927 {
2928 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2929 }
2930 else
2931 {
2932 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2933 }
2934 }
2935 else
2936 {
2937 run_kernel_amp (device_param, pws_cnt);
2938
2939 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2940
2941 if (opts_type & OPTS_TYPE_HOOK12)
2942 {
2943 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2944
2945 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);
2946
2947 // do something with data
2948
2949 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);
2950 }
2951
2952 uint iter = salt_buf->salt_iter;
2953
2954 uint loop_step = device_param->kernel_loops;
2955
2956 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2957 {
2958 uint loop_left = iter - loop_pos;
2959
2960 loop_left = MIN (loop_left, loop_step);
2961
2962 device_param->kernel_params_buf32[25] = loop_pos;
2963 device_param->kernel_params_buf32[26] = loop_left;
2964
2965 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2966
2967 if (data.devices_status == STATUS_CRACKED) break;
2968 if (data.devices_status == STATUS_ABORTED) break;
2969 if (data.devices_status == STATUS_QUIT) break;
2970
2971 /**
2972 * speed
2973 */
2974
2975 const float iter_part = (float) (loop_pos + loop_left) / iter;
2976
2977 const u64 perf_sum_all = pws_cnt * iter_part;
2978
2979 double speed_ms;
2980
2981 hc_timer_get (device_param->timer_speed, speed_ms);
2982
2983 const u32 speed_pos = device_param->speed_pos;
2984
2985 device_param->speed_cnt[speed_pos] = perf_sum_all;
2986
2987 device_param->speed_ms[speed_pos] = speed_ms;
2988
2989 if (data.benchmark == 1)
2990 {
2991 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2992 }
2993 }
2994
2995 if (opts_type & OPTS_TYPE_HOOK23)
2996 {
2997 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
2998
2999 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);
3000
3001 // do something with data
3002
3003 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);
3004 }
3005
3006 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3007 }
3008 }
3009
3010 static int run_rule_engine (const int rule_len, const char *rule_buf)
3011 {
3012 if (rule_len == 0)
3013 {
3014 return 0;
3015 }
3016 else if (rule_len == 1)
3017 {
3018 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3019 }
3020
3021 return 1;
3022 }
3023
3024 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3025 {
3026 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3027 {
3028 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);
3029 }
3030 else if (data.attack_kern == ATTACK_KERN_COMBI)
3031 {
3032 if (data.attack_mode == ATTACK_MODE_COMBI)
3033 {
3034 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3035 {
3036 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3037 {
3038 for (u32 i = 0; i < pws_cnt; i++)
3039 {
3040 const u32 pw_len = device_param->pws_buf[i].pw_len;
3041
3042 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3043
3044 ptr[pw_len] = 0x01;
3045 }
3046 }
3047 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3048 {
3049 for (u32 i = 0; i < pws_cnt; i++)
3050 {
3051 const u32 pw_len = device_param->pws_buf[i].pw_len;
3052
3053 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3054
3055 ptr[pw_len] = 0x80;
3056 }
3057 }
3058 }
3059 }
3060 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3061 {
3062 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3063 {
3064 for (u32 i = 0; i < pws_cnt; i++)
3065 {
3066 const u32 pw_len = device_param->pws_buf[i].pw_len;
3067
3068 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3069
3070 ptr[pw_len] = 0x01;
3071 }
3072 }
3073 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3074 {
3075 for (u32 i = 0; i < pws_cnt; i++)
3076 {
3077 const u32 pw_len = device_param->pws_buf[i].pw_len;
3078
3079 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3080
3081 ptr[pw_len] = 0x80;
3082 }
3083 }
3084 }
3085
3086 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);
3087 }
3088 else if (data.attack_kern == ATTACK_KERN_BF)
3089 {
3090 const u64 off = device_param->words_off;
3091
3092 device_param->kernel_params_mp_l_buf64[3] = off;
3093
3094 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3095 }
3096 }
3097
3098 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3099 {
3100 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3101
3102 device_param->kernel_params_buf32[25] = 0;
3103 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3104 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3105
3106 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3107 {
3108 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3109 }
3110 else
3111 {
3112 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3113 }
3114
3115 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3116
3117 return exec_ms_prev;
3118 }
3119
3120 static void autotune (hc_device_param_t *device_param)
3121 {
3122 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3123
3124 const u32 kernel_accel_min = device_param->kernel_accel_min;
3125 const u32 kernel_accel_max = device_param->kernel_accel_max;
3126
3127 const u32 kernel_loops_min = device_param->kernel_loops_min;
3128 const u32 kernel_loops_max = device_param->kernel_loops_max;
3129
3130 u32 kernel_accel = kernel_accel_min;
3131 u32 kernel_loops = kernel_loops_min;
3132
3133 // in this case the user specified a fixed -u and -n on the commandline
3134 // no way to tune anything
3135 // but we need to run a few caching rounds
3136
3137 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3138 {
3139 if (data.hash_mode != 2000)
3140 {
3141 try_run (device_param, kernel_accel, kernel_loops);
3142 try_run (device_param, kernel_accel, kernel_loops);
3143 try_run (device_param, kernel_accel, kernel_loops);
3144 try_run (device_param, kernel_accel, kernel_loops);
3145 }
3146
3147 device_param->kernel_accel = kernel_accel;
3148 device_param->kernel_loops = kernel_loops;
3149
3150 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3151
3152 device_param->kernel_power = kernel_power;
3153
3154 return;
3155 }
3156
3157 // from here it's clear we are allowed to autotune
3158 // so let's init some fake words
3159
3160 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3161
3162 if (data.attack_kern == ATTACK_KERN_BF)
3163 {
3164 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3165 }
3166 else
3167 {
3168 for (u32 i = 0; i < kernel_power_max; i++)
3169 {
3170 device_param->pws_buf[i].i[0] = i;
3171 device_param->pws_buf[i].i[1] = 0x01234567;
3172 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3173 }
3174
3175 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);
3176 }
3177
3178 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3179 {
3180 if (data.kernel_rules_cnt > 1)
3181 {
3182 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL);
3183 }
3184 }
3185 else
3186 {
3187 run_kernel_amp (device_param, kernel_power_max);
3188 }
3189
3190 #define VERIFIER_CNT 1
3191
3192 // first find out highest kernel-loops that stays below target_ms
3193
3194 if (kernel_loops_min < kernel_loops_max)
3195 {
3196 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3197 {
3198 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3199
3200 for (int i = 0; i < VERIFIER_CNT; i++)
3201 {
3202 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3203
3204 exec_ms = MIN (exec_ms, exec_ms_v);
3205 }
3206
3207 if (exec_ms < target_ms) break;
3208 }
3209 }
3210
3211 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3212
3213 #define STEPS_CNT 10
3214
3215 if (kernel_accel_min < kernel_accel_max)
3216 {
3217 for (int i = 0; i < STEPS_CNT; i++)
3218 {
3219 const u32 kernel_accel_try = 1 << i;
3220
3221 if (kernel_accel_try < kernel_accel_min) continue;
3222 if (kernel_accel_try > kernel_accel_max) break;
3223
3224 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3225
3226 for (int i = 0; i < VERIFIER_CNT; i++)
3227 {
3228 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3229
3230 exec_ms = MIN (exec_ms, exec_ms_v);
3231 }
3232
3233 if (exec_ms > target_ms) break;
3234
3235 kernel_accel = kernel_accel_try;
3236 }
3237 }
3238
3239 // at this point we want to know the actual runtime for the following reason:
3240 // we need a reference for the balancing loop following up, and this
3241 // the balancing loop can have an effect that the creates a new opportunity, for example:
3242 // if the target is 95 ms and the current runtime is 48ms the above loop
3243 // stopped the execution because the previous exec_ms was > 95ms
3244 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3245 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3246
3247 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3248
3249 for (int i = 0; i < VERIFIER_CNT; i++)
3250 {
3251 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3252
3253 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3254 }
3255
3256 u32 diff = kernel_loops - kernel_accel;
3257
3258 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3259 {
3260 u32 kernel_accel_orig = kernel_accel;
3261 u32 kernel_loops_orig = kernel_loops;
3262
3263 for (u32 f = 1; f < 1024; f++)
3264 {
3265 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3266 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3267
3268 if (kernel_accel_try > kernel_accel_max) break;
3269 if (kernel_loops_try < kernel_loops_min) break;
3270
3271 u32 diff_new = kernel_loops_try - kernel_accel_try;
3272
3273 if (diff_new > diff) break;
3274
3275 diff_new = diff;
3276
3277 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3278
3279 for (int i = 0; i < VERIFIER_CNT; i++)
3280 {
3281 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3282
3283 exec_ms = MIN (exec_ms, exec_ms_v);
3284 }
3285
3286 if (exec_ms < exec_ms_pre_final)
3287 {
3288 exec_ms_pre_final = exec_ms;
3289
3290 kernel_accel = kernel_accel_try;
3291 kernel_loops = kernel_loops_try;
3292 }
3293 }
3294 }
3295
3296 const double exec_left = target_ms / exec_ms_pre_final;
3297
3298 const double accel_left = kernel_accel_max / kernel_accel;
3299
3300 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3301
3302 if (exec_accel_min >= 1.0)
3303 {
3304 // this is safe to not overflow kernel_accel_max because of accel_left
3305
3306 kernel_accel = (double) kernel_accel * exec_accel_min;
3307 }
3308
3309 // reset them fake words
3310
3311 /*
3312 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3313
3314 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);
3315 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);
3316 */
3317
3318 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3319
3320 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3321 {
3322 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3323 }
3324
3325 // reset timer
3326
3327 device_param->exec_pos = 0;
3328
3329 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3330
3331 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3332 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3333 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3334
3335 // store
3336
3337 device_param->kernel_accel = kernel_accel;
3338 device_param->kernel_loops = kernel_loops;
3339
3340 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3341
3342 device_param->kernel_power = kernel_power;
3343
3344 #ifdef DEBUG
3345
3346 if (data.quiet == 0)
3347 {
3348 clear_prompt ();
3349
3350 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3351 "Device #%u: autotuned kernel-loops to %u\n",
3352 device_param->device_id + 1, kernel_accel,
3353 device_param->device_id + 1, kernel_loops);
3354
3355 fprintf (stdout, "%s", PROMPT);
3356
3357 fflush (stdout);
3358 }
3359
3360 #endif
3361 }
3362
3363 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3364 {
3365 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3366
3367 // init speed timer
3368
3369 uint speed_pos = device_param->speed_pos;
3370
3371 #ifdef _POSIX
3372 if (device_param->timer_speed.tv_sec == 0)
3373 {
3374 hc_timer_set (&device_param->timer_speed);
3375 }
3376 #endif
3377
3378 #ifdef _WIN
3379 if (device_param->timer_speed.QuadPart == 0)
3380 {
3381 hc_timer_set (&device_param->timer_speed);
3382 }
3383 #endif
3384
3385 // find higest password length, this is for optimization stuff
3386
3387 uint highest_pw_len = 0;
3388
3389 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3390 {
3391 }
3392 else if (data.attack_kern == ATTACK_KERN_COMBI)
3393 {
3394 }
3395 else if (data.attack_kern == ATTACK_KERN_BF)
3396 {
3397 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3398 + device_param->kernel_params_mp_l_buf32[5];
3399 }
3400
3401 // iteration type
3402
3403 uint innerloop_step = 0;
3404 uint innerloop_cnt = 0;
3405
3406 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3407 else innerloop_step = 1;
3408
3409 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3410 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3411 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3412
3413 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3414
3415 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3416 {
3417 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3418
3419 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3420
3421 if (data.devices_status == STATUS_CRACKED) break;
3422 if (data.devices_status == STATUS_ABORTED) break;
3423 if (data.devices_status == STATUS_QUIT) break;
3424 if (data.devices_status == STATUS_BYPASS) break;
3425
3426 salt_t *salt_buf = &data.salts_buf[salt_pos];
3427
3428 device_param->kernel_params_buf32[24] = salt_pos;
3429 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3430 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3431
3432 FILE *combs_fp = device_param->combs_fp;
3433
3434 if (data.attack_mode == ATTACK_MODE_COMBI)
3435 {
3436 rewind (combs_fp);
3437 }
3438
3439 // innerloops
3440
3441 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3442 {
3443 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3444
3445 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3446
3447 if (data.devices_status == STATUS_CRACKED) break;
3448 if (data.devices_status == STATUS_ABORTED) break;
3449 if (data.devices_status == STATUS_QUIT) break;
3450 if (data.devices_status == STATUS_BYPASS) break;
3451
3452 uint fast_iteration = 0;
3453
3454 uint innerloop_left = innerloop_cnt - innerloop_pos;
3455
3456 if (innerloop_left > innerloop_step)
3457 {
3458 innerloop_left = innerloop_step;
3459
3460 fast_iteration = 1;
3461 }
3462
3463 device_param->innerloop_pos = innerloop_pos;
3464 device_param->innerloop_left = innerloop_left;
3465
3466 device_param->kernel_params_buf32[27] = innerloop_left;
3467
3468 // i think we can get rid of this
3469 if (innerloop_left == 0)
3470 {
3471 puts ("bug, how should this happen????\n");
3472
3473 continue;
3474 }
3475
3476 if (data.salts_shown[salt_pos] == 1)
3477 {
3478 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3479
3480 continue;
3481 }
3482
3483 // initialize amplifiers
3484
3485 if (data.attack_mode == ATTACK_MODE_COMBI)
3486 {
3487 uint i = 0;
3488
3489 while (i < innerloop_left)
3490 {
3491 if (feof (combs_fp)) break;
3492
3493 int line_len = fgetl (combs_fp, line_buf);
3494
3495 if (line_len >= PW_MAX1) continue;
3496
3497 line_len = convert_from_hex (line_buf, line_len);
3498
3499 char *line_buf_new = line_buf;
3500
3501 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3502 {
3503 char rule_buf_out[BLOCK_SIZE] = { 0 };
3504
3505 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3506
3507 if (rule_len_out < 0)
3508 {
3509 data.words_progress_rejected[salt_pos] += pws_cnt;
3510
3511 continue;
3512 }
3513
3514 line_len = rule_len_out;
3515
3516 line_buf_new = rule_buf_out;
3517 }
3518
3519 line_len = MIN (line_len, PW_DICTMAX);
3520
3521 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3522
3523 memcpy (ptr, line_buf_new, line_len);
3524
3525 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3526
3527 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3528 {
3529 uppercase (ptr, line_len);
3530 }
3531
3532 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3533 {
3534 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3535 {
3536 ptr[line_len] = 0x80;
3537 }
3538
3539 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3540 {
3541 ptr[line_len] = 0x01;
3542 }
3543 }
3544
3545 device_param->combs_buf[i].pw_len = line_len;
3546
3547 i++;
3548 }
3549
3550 for (uint j = i; j < innerloop_left; j++)
3551 {
3552 device_param->combs_buf[j].i[0] = 0;
3553 device_param->combs_buf[j].i[1] = 0;
3554 device_param->combs_buf[j].i[2] = 0;
3555 device_param->combs_buf[j].i[3] = 0;
3556 device_param->combs_buf[j].i[4] = 0;
3557 device_param->combs_buf[j].i[5] = 0;
3558 device_param->combs_buf[j].i[6] = 0;
3559 device_param->combs_buf[j].i[7] = 0;
3560
3561 device_param->combs_buf[j].pw_len = 0;
3562 }
3563
3564 innerloop_left = i;
3565 }
3566 else if (data.attack_mode == ATTACK_MODE_BF)
3567 {
3568 u64 off = innerloop_pos;
3569
3570 device_param->kernel_params_mp_r_buf64[3] = off;
3571
3572 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3573 }
3574 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3575 {
3576 u64 off = innerloop_pos;
3577
3578 device_param->kernel_params_mp_buf64[3] = off;
3579
3580 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3581 }
3582 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3583 {
3584 u64 off = innerloop_pos;
3585
3586 device_param->kernel_params_mp_buf64[3] = off;
3587
3588 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3589 }
3590
3591 // copy amplifiers
3592
3593 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3594 {
3595 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);
3596 }
3597 else if (data.attack_mode == ATTACK_MODE_COMBI)
3598 {
3599 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);
3600 }
3601 else if (data.attack_mode == ATTACK_MODE_BF)
3602 {
3603 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);
3604 }
3605 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3606 {
3607 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);
3608 }
3609 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3610 {
3611 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);
3612 }
3613
3614 if (data.benchmark == 1)
3615 {
3616 hc_timer_set (&device_param->timer_speed);
3617 }
3618
3619 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3620
3621 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3622
3623 if (data.devices_status == STATUS_CRACKED) break;
3624 if (data.devices_status == STATUS_ABORTED) break;
3625 if (data.devices_status == STATUS_QUIT) break;
3626
3627 /**
3628 * result
3629 */
3630
3631 if (data.benchmark == 0)
3632 {
3633 check_cracked (device_param, salt_pos);
3634 }
3635
3636 /**
3637 * progress
3638 */
3639
3640 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3641
3642 hc_thread_mutex_lock (mux_counter);
3643
3644 data.words_progress_done[salt_pos] += perf_sum_all;
3645
3646 hc_thread_mutex_unlock (mux_counter);
3647
3648 /**
3649 * speed
3650 */
3651
3652 double speed_ms;
3653
3654 hc_timer_get (device_param->timer_speed, speed_ms);
3655
3656 hc_timer_set (&device_param->timer_speed);
3657
3658 // current speed
3659
3660 //hc_thread_mutex_lock (mux_display);
3661
3662 device_param->speed_cnt[speed_pos] = perf_sum_all;
3663
3664 device_param->speed_ms[speed_pos] = speed_ms;
3665
3666 //hc_thread_mutex_unlock (mux_display);
3667
3668 speed_pos++;
3669
3670 if (speed_pos == SPEED_CACHE)
3671 {
3672 speed_pos = 0;
3673 }
3674
3675 /**
3676 * benchmark
3677 */
3678
3679 if (data.benchmark == 1) break;
3680 }
3681 }
3682
3683 device_param->speed_pos = speed_pos;
3684
3685 myfree (line_buf);
3686 }
3687
3688 static void load_segment (wl_data_t *wl_data, FILE *fd)
3689 {
3690 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3691
3692 wl_data->pos = 0;
3693
3694 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3695
3696 wl_data->buf[wl_data->cnt] = 0;
3697
3698 if (wl_data->cnt == 0) return;
3699
3700 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3701
3702 while (!feof (fd))
3703 {
3704 if (wl_data->cnt == wl_data->avail)
3705 {
3706 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3707
3708 wl_data->avail += wl_data->incr;
3709 }
3710
3711 const int c = fgetc (fd);
3712
3713 if (c == EOF) break;
3714
3715 wl_data->buf[wl_data->cnt] = (char) c;
3716
3717 wl_data->cnt++;
3718
3719 if (c == '\n') break;
3720 }
3721
3722 // ensure stream ends with a newline
3723
3724 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3725 {
3726 wl_data->cnt++;
3727
3728 wl_data->buf[wl_data->cnt - 1] = '\n';
3729 }
3730
3731 return;
3732 }
3733
3734 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3735 {
3736 char *ptr = buf;
3737
3738 for (u32 i = 0; i < sz; i++, ptr++)
3739 {
3740 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3741
3742 if (i == 7)
3743 {
3744 *off = i;
3745 *len = i;
3746
3747 return;
3748 }
3749
3750 if (*ptr != '\n') continue;
3751
3752 *off = i + 1;
3753
3754 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3755
3756 *len = i;
3757
3758 return;
3759 }
3760
3761 *off = sz;
3762 *len = sz;
3763 }
3764
3765 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3766 {
3767 char *ptr = buf;
3768
3769 for (u32 i = 0; i < sz; i++, ptr++)
3770 {
3771 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3772
3773 if (*ptr != '\n') continue;
3774
3775 *off = i + 1;
3776
3777 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3778
3779 *len = i;
3780
3781 return;
3782 }
3783
3784 *off = sz;
3785 *len = sz;
3786 }
3787
3788 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3789 {
3790 char *ptr = buf;
3791
3792 for (u32 i = 0; i < sz; i++, ptr++)
3793 {
3794 if (*ptr != '\n') continue;
3795
3796 *off = i + 1;
3797
3798 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3799
3800 *len = i;
3801
3802 return;
3803 }
3804
3805 *off = sz;
3806 *len = sz;
3807 }
3808
3809 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3810 {
3811 while (wl_data->pos < wl_data->cnt)
3812 {
3813 uint off;
3814 uint len;
3815
3816 char *ptr = wl_data->buf + wl_data->pos;
3817
3818 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3819
3820 wl_data->pos += off;
3821
3822 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3823 {
3824 char rule_buf_out[BLOCK_SIZE] = { 0 };
3825
3826 int rule_len_out = -1;
3827
3828 if (len < BLOCK_SIZE)
3829 {
3830 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3831 }
3832
3833 if (rule_len_out < 0)
3834 {
3835 continue;
3836 }
3837
3838 if (rule_len_out > PW_MAX)
3839 {
3840 continue;
3841 }
3842 }
3843 else
3844 {
3845 if (len > PW_MAX)
3846 {
3847 continue;
3848 }
3849 }
3850
3851 *out_buf = ptr;
3852 *out_len = len;
3853
3854 return;
3855 }
3856
3857 if (feof (fd))
3858 {
3859 fprintf (stderr, "BUG feof()!!\n");
3860
3861 return;
3862 }
3863
3864 load_segment (wl_data, fd);
3865
3866 get_next_word (wl_data, fd, out_buf, out_len);
3867 }
3868
3869 #ifdef _POSIX
3870 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3871 #endif
3872
3873 #ifdef _WIN
3874 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3875 #endif
3876 {
3877 hc_signal (NULL);
3878
3879 dictstat_t d;
3880
3881 d.cnt = 0;
3882
3883 #ifdef _POSIX
3884 fstat (fileno (fd), &d.stat);
3885 #endif
3886
3887 #ifdef _WIN
3888 _fstat64 (fileno (fd), &d.stat);
3889 #endif
3890
3891 d.stat.st_mode = 0;
3892 d.stat.st_nlink = 0;
3893 d.stat.st_uid = 0;
3894 d.stat.st_gid = 0;
3895 d.stat.st_rdev = 0;
3896 d.stat.st_atime = 0;
3897
3898 #ifdef _POSIX
3899 d.stat.st_blksize = 0;
3900 d.stat.st_blocks = 0;
3901 #endif
3902
3903 if (d.stat.st_size == 0) return 0;
3904
3905 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3906
3907 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3908 {
3909 if (d_cache)
3910 {
3911 u64 cnt = d_cache->cnt;
3912
3913 u64 keyspace = cnt;
3914
3915 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3916 {
3917 keyspace *= data.kernel_rules_cnt;
3918 }
3919 else if (data.attack_kern == ATTACK_KERN_COMBI)
3920 {
3921 keyspace *= data.combs_cnt;
3922 }
3923
3924 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);
3925 if (data.quiet == 0) log_info ("");
3926
3927 hc_signal (sigHandler_default);
3928
3929 return (keyspace);
3930 }
3931 }
3932
3933 time_t now = 0;
3934 time_t prev = 0;
3935
3936 u64 comp = 0;
3937 u64 cnt = 0;
3938 u64 cnt2 = 0;
3939
3940 while (!feof (fd))
3941 {
3942 load_segment (wl_data, fd);
3943
3944 comp += wl_data->cnt;
3945
3946 u32 i = 0;
3947
3948 while (i < wl_data->cnt)
3949 {
3950 u32 len;
3951 u32 off;
3952
3953 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3954
3955 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3956 {
3957 char rule_buf_out[BLOCK_SIZE] = { 0 };
3958
3959 int rule_len_out = -1;
3960
3961 if (len < BLOCK_SIZE)
3962 {
3963 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3964 }
3965
3966 if (rule_len_out < 0)
3967 {
3968 len = PW_MAX1;
3969 }
3970 else
3971 {
3972 len = rule_len_out;
3973 }
3974 }
3975
3976 if (len < PW_MAX1)
3977 {
3978 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3979 {
3980 cnt += data.kernel_rules_cnt;
3981 }
3982 else if (data.attack_kern == ATTACK_KERN_COMBI)
3983 {
3984 cnt += data.combs_cnt;
3985 }
3986
3987 d.cnt++;
3988 }
3989
3990 i += off;
3991
3992 cnt2++;
3993 }
3994
3995 time (&now);
3996
3997 if ((now - prev) == 0) continue;
3998
3999 float percent = (float) comp / (float) d.stat.st_size;
4000
4001 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);
4002
4003 time (&prev);
4004 }
4005
4006 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);
4007 if (data.quiet == 0) log_info ("");
4008
4009 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4010
4011 hc_signal (sigHandler_default);
4012
4013 return (cnt);
4014 }
4015
4016 static void *thread_monitor (void *p)
4017 {
4018 uint runtime_check = 0;
4019 uint remove_check = 0;
4020 uint status_check = 0;
4021 uint restore_check = 0;
4022
4023 uint restore_left = data.restore_timer;
4024 uint remove_left = data.remove_timer;
4025 uint status_left = data.status_timer;
4026
4027 #ifdef HAVE_HWMON
4028 uint hwmon_check = 0;
4029
4030 int slowdown_warnings = 0;
4031
4032 // these variables are mainly used for fan control
4033
4034 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4035
4036 // temperature controller "loopback" values
4037
4038 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4039 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4040
4041 int temp_threshold = 1; // degrees celcius
4042
4043 int fan_speed_min = 15; // in percentage
4044 int fan_speed_max = 100;
4045
4046 time_t last_temp_check_time;
4047 #endif // HAVE_HWMON
4048
4049 uint sleep_time = 1;
4050
4051 if (data.runtime)
4052 {
4053 runtime_check = 1;
4054 }
4055
4056 if (data.restore_timer)
4057 {
4058 restore_check = 1;
4059 }
4060
4061 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4062 {
4063 remove_check = 1;
4064 }
4065
4066 if (data.status == 1)
4067 {
4068 status_check = 1;
4069 }
4070
4071 #ifdef HAVE_HWMON
4072 if (data.gpu_temp_disable == 0)
4073 {
4074 time (&last_temp_check_time);
4075
4076 hwmon_check = 1;
4077 }
4078 #endif
4079
4080 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4081 {
4082 #ifdef HAVE_HWMON
4083 if (hwmon_check == 0)
4084 #endif
4085 return (p);
4086 }
4087
4088 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4089 {
4090 hc_sleep (sleep_time);
4091
4092 if (data.devices_status != STATUS_RUNNING) continue;
4093
4094 #ifdef HAVE_HWMON
4095
4096 if (hwmon_check == 1)
4097 {
4098 hc_thread_mutex_lock (mux_adl);
4099
4100 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4101 {
4102 hc_device_param_t *device_param = &data.devices_param[device_id];
4103
4104 if (device_param->skipped) continue;
4105
4106 if (device_param->device_vendor_id == VENDOR_ID_NV)
4107 {
4108 if (data.hm_nvapi)
4109 {
4110 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4111 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4112
4113 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4114 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4115
4116 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4117
4118 perfPolicies_status.info_value = perfPolicies_info.info_value;
4119
4120 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4121
4122 if (perfPolicies_status.throttle & 2)
4123 {
4124 if (slowdown_warnings < 3)
4125 {
4126 if (data.quiet == 0) clear_prompt ();
4127
4128 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4129
4130 if (slowdown_warnings == 2)
4131 {
4132 log_info ("");
4133 }
4134
4135 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4136 if (data.quiet == 0) fflush (stdout);
4137
4138 slowdown_warnings++;
4139 }
4140 }
4141 else
4142 {
4143 slowdown_warnings = 0;
4144 }
4145 }
4146 }
4147 }
4148
4149 hc_thread_mutex_unlock (mux_adl);
4150 }
4151
4152 if (hwmon_check == 1)
4153 {
4154 hc_thread_mutex_lock (mux_adl);
4155
4156 time_t temp_check_time;
4157
4158 time (&temp_check_time);
4159
4160 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4161
4162 if (Ta == 0) Ta = 1;
4163
4164 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4165 {
4166 hc_device_param_t *device_param = &data.devices_param[device_id];
4167
4168 if (device_param->skipped) continue;
4169
4170 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4171
4172 const int temperature = hm_get_temperature_with_device_id (device_id);
4173
4174 if (temperature > (int) data.gpu_temp_abort)
4175 {
4176 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4177
4178 if (data.devices_status != STATUS_QUIT) myabort ();
4179
4180 break;
4181 }
4182
4183 const int gpu_temp_retain = data.gpu_temp_retain;
4184
4185 if (gpu_temp_retain)
4186 {
4187 if (data.hm_device[device_id].fan_set_supported == 1)
4188 {
4189 int temp_cur = temperature;
4190
4191 int temp_diff_new = gpu_temp_retain - temp_cur;
4192
4193 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4194
4195 // calculate Ta value (time difference in seconds between the last check and this check)
4196
4197 last_temp_check_time = temp_check_time;
4198
4199 float Kp = 1.8;
4200 float Ki = 0.005;
4201 float Kd = 6;
4202
4203 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4204
4205 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);
4206
4207 if (abs (fan_diff_required) >= temp_threshold)
4208 {
4209 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4210
4211 int fan_speed_level = fan_speed_cur;
4212
4213 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4214
4215 int fan_speed_new = fan_speed_level - fan_diff_required;
4216
4217 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4218 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4219
4220 if (fan_speed_new != fan_speed_cur)
4221 {
4222 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4223 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4224
4225 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4226 {
4227 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4228 {
4229 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4230 }
4231 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4232 {
4233
4234 }
4235
4236 fan_speed_chgd[device_id] = 1;
4237 }
4238
4239 temp_diff_old[device_id] = temp_diff_new;
4240 }
4241 }
4242 }
4243 }
4244 }
4245
4246 hc_thread_mutex_unlock (mux_adl);
4247 }
4248 #endif // HAVE_HWMON
4249
4250 if (restore_check == 1)
4251 {
4252 restore_left--;
4253
4254 if (restore_left == 0)
4255 {
4256 if (data.restore_disable == 0) cycle_restore ();
4257
4258 restore_left = data.restore_timer;
4259 }
4260 }
4261
4262 if ((runtime_check == 1) && (data.runtime_start > 0))
4263 {
4264 time_t runtime_cur;
4265
4266 time (&runtime_cur);
4267
4268 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4269
4270 if (runtime_left <= 0)
4271 {
4272 if (data.benchmark == 0)
4273 {
4274 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4275 }
4276
4277 if (data.devices_status != STATUS_QUIT) myabort ();
4278 }
4279 }
4280
4281 if (remove_check == 1)
4282 {
4283 remove_left--;
4284
4285 if (remove_left == 0)
4286 {
4287 if (data.digests_saved != data.digests_done)
4288 {
4289 data.digests_saved = data.digests_done;
4290
4291 save_hash ();
4292 }
4293
4294 remove_left = data.remove_timer;
4295 }
4296 }
4297
4298 if (status_check == 1)
4299 {
4300 status_left--;
4301
4302 if (status_left == 0)
4303 {
4304 //hc_thread_mutex_lock (mux_display);
4305
4306 if (data.quiet == 0) clear_prompt ();
4307
4308 if (data.quiet == 0) log_info ("");
4309
4310 status_display ();
4311
4312 if (data.quiet == 0) log_info ("");
4313
4314 //hc_thread_mutex_unlock (mux_display);
4315
4316 status_left = data.status_timer;
4317 }
4318 }
4319 }
4320
4321 #ifdef HAVE_HWMON
4322 myfree (fan_speed_chgd);
4323
4324 myfree (temp_diff_old);
4325 myfree (temp_diff_sum);
4326 #endif
4327
4328 p = NULL;
4329
4330 return (p);
4331 }
4332
4333 static void *thread_outfile_remove (void *p)
4334 {
4335 // some hash-dependent constants
4336 char *outfile_dir = data.outfile_check_directory;
4337 uint dgst_size = data.dgst_size;
4338 uint isSalted = data.isSalted;
4339 uint esalt_size = data.esalt_size;
4340 uint hash_mode = data.hash_mode;
4341
4342 uint outfile_check_timer = data.outfile_check_timer;
4343
4344 char separator = data.separator;
4345
4346 // some hash-dependent functions
4347 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4348 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4349
4350 // buffers
4351 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4352
4353 hash_buf.digest = mymalloc (dgst_size);
4354
4355 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4356
4357 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4358
4359 uint digest_buf[64] = { 0 };
4360
4361 outfile_data_t *out_info = NULL;
4362
4363 char **out_files = NULL;
4364
4365 time_t folder_mtime = 0;
4366
4367 int out_cnt = 0;
4368
4369 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4370
4371 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4372 {
4373 hc_sleep (1);
4374
4375 if (data.devices_status != STATUS_RUNNING) continue;
4376
4377 check_left--;
4378
4379 if (check_left == 0)
4380 {
4381 struct stat outfile_check_stat;
4382
4383 if (stat (outfile_dir, &outfile_check_stat) == 0)
4384 {
4385 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4386
4387 if (is_dir == 1)
4388 {
4389 if (outfile_check_stat.st_mtime > folder_mtime)
4390 {
4391 char **out_files_new = scan_directory (outfile_dir);
4392
4393 int out_cnt_new = count_dictionaries (out_files_new);
4394
4395 outfile_data_t *out_info_new = NULL;
4396
4397 if (out_cnt_new > 0)
4398 {
4399 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4400
4401 for (int i = 0; i < out_cnt_new; i++)
4402 {
4403 out_info_new[i].file_name = out_files_new[i];
4404
4405 // check if there are files that we have seen/checked before (and not changed)
4406
4407 for (int j = 0; j < out_cnt; j++)
4408 {
4409 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4410 {
4411 struct stat outfile_stat;
4412
4413 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4414 {
4415 if (outfile_stat.st_ctime == out_info[j].ctime)
4416 {
4417 out_info_new[i].ctime = out_info[j].ctime;
4418 out_info_new[i].seek = out_info[j].seek;
4419 }
4420 }
4421 }
4422 }
4423 }
4424 }
4425
4426 local_free (out_info);
4427 local_free (out_files);
4428
4429 out_files = out_files_new;
4430 out_cnt = out_cnt_new;
4431 out_info = out_info_new;
4432
4433 folder_mtime = outfile_check_stat.st_mtime;
4434 }
4435
4436 for (int j = 0; j < out_cnt; j++)
4437 {
4438 FILE *fp = fopen (out_info[j].file_name, "rb");
4439
4440 if (fp != NULL)
4441 {
4442 //hc_thread_mutex_lock (mux_display);
4443
4444 #ifdef _POSIX
4445 struct stat outfile_stat;
4446
4447 fstat (fileno (fp), &outfile_stat);
4448 #endif
4449
4450 #ifdef _WIN
4451 struct stat64 outfile_stat;
4452
4453 _fstat64 (fileno (fp), &outfile_stat);
4454 #endif
4455
4456 if (outfile_stat.st_ctime > out_info[j].ctime)
4457 {
4458 out_info[j].ctime = outfile_stat.st_ctime;
4459 out_info[j].seek = 0;
4460 }
4461
4462 fseek (fp, out_info[j].seek, SEEK_SET);
4463
4464 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4465
4466 while (!feof (fp))
4467 {
4468 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4469
4470 if (ptr == NULL) break;
4471
4472 int line_len = strlen (line_buf);
4473
4474 if (line_len <= 0) continue;
4475
4476 int iter = MAX_CUT_TRIES;
4477
4478 for (uint i = line_len - 1; i && iter; i--, line_len--)
4479 {
4480 if (line_buf[i] != separator) continue;
4481
4482 int parser_status = PARSER_OK;
4483
4484 if ((hash_mode != 2500) && (hash_mode != 6800))
4485 {
4486 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4487 }
4488
4489 uint found = 0;
4490
4491 if (parser_status == PARSER_OK)
4492 {
4493 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4494 {
4495 if (data.salts_shown[salt_pos] == 1) continue;
4496
4497 salt_t *salt_buf = &data.salts_buf[salt_pos];
4498
4499 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4500 {
4501 uint idx = salt_buf->digests_offset + digest_pos;
4502
4503 if (data.digests_shown[idx] == 1) continue;
4504
4505 uint cracked = 0;
4506
4507 if (hash_mode == 6800)
4508 {
4509 if (i == salt_buf->salt_len)
4510 {
4511 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4512 }
4513 }
4514 else if (hash_mode == 2500)
4515 {
4516 // BSSID : MAC1 : MAC2 (:plain)
4517 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4518 {
4519 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4520
4521 if (!cracked) continue;
4522
4523 // now compare MAC1 and MAC2 too, since we have this additional info
4524 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4525 char *mac2_pos = mac1_pos + 12 + 1;
4526
4527 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4528 wpa_t *wpa = &wpas[salt_pos];
4529
4530 // compare hex string(s) vs binary MAC address(es)
4531
4532 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4533 {
4534 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4535 {
4536 cracked = 0;
4537
4538 break;
4539 }
4540 }
4541
4542 // early skip ;)
4543 if (!cracked) continue;
4544
4545 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4546 {
4547 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4548 {
4549 cracked = 0;
4550
4551 break;
4552 }
4553 }
4554 }
4555 }
4556 else
4557 {
4558 char *digests_buf_ptr = (char *) data.digests_buf;
4559
4560 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4561
4562 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4563 }
4564
4565 if (cracked == 1)
4566 {
4567 found = 1;
4568
4569 data.digests_shown[idx] = 1;
4570
4571 data.digests_done++;
4572
4573 salt_buf->digests_done++;
4574
4575 if (salt_buf->digests_done == salt_buf->digests_cnt)
4576 {
4577 data.salts_shown[salt_pos] = 1;
4578
4579 data.salts_done++;
4580
4581 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4582 }
4583 }
4584 }
4585
4586 if (data.devices_status == STATUS_CRACKED) break;
4587 }
4588 }
4589
4590 if (found) break;
4591
4592 if (data.devices_status == STATUS_CRACKED) break;
4593
4594 iter--;
4595 }
4596
4597 if (data.devices_status == STATUS_CRACKED) break;
4598 }
4599
4600 myfree (line_buf);
4601
4602 out_info[j].seek = ftell (fp);
4603
4604 //hc_thread_mutex_unlock (mux_display);
4605
4606 fclose (fp);
4607 }
4608 }
4609 }
4610 }
4611
4612 check_left = outfile_check_timer;
4613 }
4614 }
4615
4616 if (esalt_size) local_free (hash_buf.esalt);
4617
4618 if (isSalted) local_free (hash_buf.salt);
4619
4620 local_free (hash_buf.digest);
4621
4622 local_free (out_info);
4623
4624 local_free (out_files);
4625
4626 p = NULL;
4627
4628 return (p);
4629 }
4630
4631 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4632 {
4633 //if (device_param->pws_cnt < device_param->kernel_power)
4634 //{
4635 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4636
4637 u8 *ptr = (u8 *) pw->i;
4638
4639 memcpy (ptr, pw_buf, pw_len);
4640
4641 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4642
4643 pw->pw_len = pw_len;
4644
4645 device_param->pws_cnt++;
4646 //}
4647 //else
4648 //{
4649 // fprintf (stderr, "BUG pw_add()!!\n");
4650 //
4651 // return;
4652 //}
4653 }
4654
4655 static void set_kernel_power_final (const u64 kernel_power_final)
4656 {
4657 if (data.quiet == 0)
4658 {
4659 clear_prompt ();
4660
4661 //log_info ("");
4662
4663 log_info ("INFO: approaching final keyspace, workload adjusted");
4664 log_info ("");
4665
4666 fprintf (stdout, "%s", PROMPT);
4667
4668 fflush (stdout);
4669 }
4670
4671 data.kernel_power_final = kernel_power_final;
4672 }
4673
4674 static u32 get_power (hc_device_param_t *device_param)
4675 {
4676 const u64 kernel_power_final = data.kernel_power_final;
4677
4678 if (kernel_power_final)
4679 {
4680 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4681
4682 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4683
4684 // work should be at least the hardware power available without any accelerator
4685
4686 const u64 work = MAX (words_left_device, device_param->hardware_power);
4687
4688 return work;
4689 }
4690
4691 return device_param->kernel_power;
4692 }
4693
4694 static uint get_work (hc_device_param_t *device_param, const u64 max)
4695 {
4696 hc_thread_mutex_lock (mux_dispatcher);
4697
4698 const u64 words_cur = data.words_cur;
4699 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4700
4701 device_param->words_off = words_cur;
4702
4703 const u64 kernel_power_all = data.kernel_power_all;
4704
4705 const u64 words_left = words_base - words_cur;
4706
4707 if (words_left < kernel_power_all)
4708 {
4709 if (data.kernel_power_final == 0)
4710 {
4711 set_kernel_power_final (words_left);
4712 }
4713 }
4714
4715 const u32 kernel_power = get_power (device_param);
4716
4717 uint work = MIN (words_left, kernel_power);
4718
4719 work = MIN (work, max);
4720
4721 data.words_cur += work;
4722
4723 hc_thread_mutex_unlock (mux_dispatcher);
4724
4725 return work;
4726 }
4727
4728 static void *thread_autotune (void *p)
4729 {
4730 hc_device_param_t *device_param = (hc_device_param_t *) p;
4731
4732 if (device_param->skipped) return NULL;
4733
4734 autotune (device_param);
4735
4736 return NULL;
4737 }
4738
4739 static void *thread_calc_stdin (void *p)
4740 {
4741 hc_device_param_t *device_param = (hc_device_param_t *) p;
4742
4743 if (device_param->skipped) return NULL;
4744
4745 char *buf = (char *) mymalloc (HCBUFSIZ);
4746
4747 const uint attack_kern = data.attack_kern;
4748
4749 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4750 {
4751 hc_thread_mutex_lock (mux_dispatcher);
4752
4753 if (feof (stdin) != 0)
4754 {
4755 hc_thread_mutex_unlock (mux_dispatcher);
4756
4757 break;
4758 }
4759
4760 uint words_cur = 0;
4761
4762 while (words_cur < device_param->kernel_power)
4763 {
4764 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4765
4766 if (line_buf == NULL) break;
4767
4768 uint line_len = in_superchop (line_buf);
4769
4770 line_len = convert_from_hex (line_buf, line_len);
4771
4772 // post-process rule engine
4773
4774 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4775 {
4776 char rule_buf_out[BLOCK_SIZE] = { 0 };
4777
4778 int rule_len_out = -1;
4779
4780 if (line_len < BLOCK_SIZE)
4781 {
4782 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4783 }
4784
4785 if (rule_len_out < 0) continue;
4786
4787 line_buf = rule_buf_out;
4788 line_len = rule_len_out;
4789 }
4790
4791 if (line_len > PW_MAX)
4792 {
4793 continue;
4794 }
4795
4796 // hmm that's always the case, or?
4797
4798 if (attack_kern == ATTACK_KERN_STRAIGHT)
4799 {
4800 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4801 {
4802 hc_thread_mutex_lock (mux_counter);
4803
4804 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4805 {
4806 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4807 }
4808
4809 hc_thread_mutex_unlock (mux_counter);
4810
4811 continue;
4812 }
4813 }
4814
4815 pw_add (device_param, (u8 *) line_buf, line_len);
4816
4817 words_cur++;
4818
4819 if (data.devices_status == STATUS_CRACKED) break;
4820 if (data.devices_status == STATUS_ABORTED) break;
4821 if (data.devices_status == STATUS_QUIT) break;
4822 if (data.devices_status == STATUS_BYPASS) break;
4823 }
4824
4825 hc_thread_mutex_unlock (mux_dispatcher);
4826
4827 if (data.devices_status == STATUS_CRACKED) break;
4828 if (data.devices_status == STATUS_ABORTED) break;
4829 if (data.devices_status == STATUS_QUIT) break;
4830 if (data.devices_status == STATUS_BYPASS) break;
4831
4832 // flush
4833
4834 const uint pws_cnt = device_param->pws_cnt;
4835
4836 if (pws_cnt)
4837 {
4838 run_copy (device_param, pws_cnt);
4839
4840 run_cracker (device_param, pws_cnt);
4841
4842 device_param->pws_cnt = 0;
4843
4844 /*
4845 still required?
4846 if (attack_kern == ATTACK_KERN_STRAIGHT)
4847 {
4848 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4849 }
4850 else if (attack_kern == ATTACK_KERN_COMBI)
4851 {
4852 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4853 }
4854 */
4855 }
4856 }
4857
4858 device_param->kernel_accel = 0;
4859 device_param->kernel_loops = 0;
4860
4861 myfree (buf);
4862
4863 return NULL;
4864 }
4865
4866 static void *thread_calc (void *p)
4867 {
4868 hc_device_param_t *device_param = (hc_device_param_t *) p;
4869
4870 if (device_param->skipped) return NULL;
4871
4872 const uint attack_mode = data.attack_mode;
4873 const uint attack_kern = data.attack_kern;
4874
4875 if (attack_mode == ATTACK_MODE_BF)
4876 {
4877 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4878 {
4879 const uint work = get_work (device_param, -1);
4880
4881 if (work == 0) break;
4882
4883 const u64 words_off = device_param->words_off;
4884 const u64 words_fin = words_off + work;
4885
4886 const uint pws_cnt = work;
4887
4888 device_param->pws_cnt = pws_cnt;
4889
4890 if (pws_cnt)
4891 {
4892 run_copy (device_param, pws_cnt);
4893
4894 run_cracker (device_param, pws_cnt);
4895
4896 device_param->pws_cnt = 0;
4897
4898 /*
4899 still required?
4900 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4901 */
4902 }
4903
4904 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4905
4906 if (data.devices_status == STATUS_CRACKED) break;
4907 if (data.devices_status == STATUS_ABORTED) break;
4908 if (data.devices_status == STATUS_QUIT) break;
4909 if (data.devices_status == STATUS_BYPASS) break;
4910
4911 if (data.benchmark == 1) break;
4912
4913 device_param->words_done = words_fin;
4914 }
4915 }
4916 else
4917 {
4918 const uint segment_size = data.segment_size;
4919
4920 char *dictfile = data.dictfile;
4921
4922 if (attack_mode == ATTACK_MODE_COMBI)
4923 {
4924 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4925 {
4926 dictfile = data.dictfile2;
4927 }
4928 }
4929
4930 FILE *fd = fopen (dictfile, "rb");
4931
4932 if (fd == NULL)
4933 {
4934 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4935
4936 return NULL;
4937 }
4938
4939 if (attack_mode == ATTACK_MODE_COMBI)
4940 {
4941 const uint combs_mode = data.combs_mode;
4942
4943 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4944 {
4945 const char *dictfilec = data.dictfile2;
4946
4947 FILE *combs_fp = fopen (dictfilec, "rb");
4948
4949 if (combs_fp == NULL)
4950 {
4951 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4952
4953 fclose (fd);
4954
4955 return NULL;
4956 }
4957
4958 device_param->combs_fp = combs_fp;
4959 }
4960 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4961 {
4962 const char *dictfilec = data.dictfile;
4963
4964 FILE *combs_fp = fopen (dictfilec, "rb");
4965
4966 if (combs_fp == NULL)
4967 {
4968 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4969
4970 fclose (fd);
4971
4972 return NULL;
4973 }
4974
4975 device_param->combs_fp = combs_fp;
4976 }
4977 }
4978
4979 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4980
4981 wl_data->buf = (char *) mymalloc (segment_size);
4982 wl_data->avail = segment_size;
4983 wl_data->incr = segment_size;
4984 wl_data->cnt = 0;
4985 wl_data->pos = 0;
4986
4987 u64 words_cur = 0;
4988
4989 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4990 {
4991 u64 words_off = 0;
4992 u64 words_fin = 0;
4993
4994 u64 max = -1;
4995
4996 while (max)
4997 {
4998 const uint work = get_work (device_param, max);
4999
5000 if (work == 0) break;
5001
5002 max = 0;
5003
5004 words_off = device_param->words_off;
5005 words_fin = words_off + work;
5006
5007 char *line_buf;
5008 uint line_len;
5009
5010 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5011
5012 for ( ; words_cur < words_fin; words_cur++)
5013 {
5014 get_next_word (wl_data, fd, &line_buf, &line_len);
5015
5016 line_len = convert_from_hex (line_buf, line_len);
5017
5018 // post-process rule engine
5019
5020 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5021 {
5022 char rule_buf_out[BLOCK_SIZE] = { 0 };
5023
5024 int rule_len_out = -1;
5025
5026 if (line_len < BLOCK_SIZE)
5027 {
5028 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5029 }
5030
5031 if (rule_len_out < 0) continue;
5032
5033 line_buf = rule_buf_out;
5034 line_len = rule_len_out;
5035 }
5036
5037 if (attack_kern == ATTACK_KERN_STRAIGHT)
5038 {
5039 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5040 {
5041 max++;
5042
5043 hc_thread_mutex_lock (mux_counter);
5044
5045 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5046 {
5047 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5048 }
5049
5050 hc_thread_mutex_unlock (mux_counter);
5051
5052 continue;
5053 }
5054 }
5055 else if (attack_kern == ATTACK_KERN_COMBI)
5056 {
5057 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5058 // since we still need to combine the plains
5059
5060 if (line_len > data.pw_max)
5061 {
5062 max++;
5063
5064 hc_thread_mutex_lock (mux_counter);
5065
5066 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5067 {
5068 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5069 }
5070
5071 hc_thread_mutex_unlock (mux_counter);
5072
5073 continue;
5074 }
5075 }
5076
5077 pw_add (device_param, (u8 *) line_buf, line_len);
5078
5079 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5080
5081 if (data.devices_status == STATUS_CRACKED) break;
5082 if (data.devices_status == STATUS_ABORTED) break;
5083 if (data.devices_status == STATUS_QUIT) break;
5084 if (data.devices_status == STATUS_BYPASS) break;
5085 }
5086
5087 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5088
5089 if (data.devices_status == STATUS_CRACKED) break;
5090 if (data.devices_status == STATUS_ABORTED) break;
5091 if (data.devices_status == STATUS_QUIT) break;
5092 if (data.devices_status == STATUS_BYPASS) break;
5093 }
5094
5095 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5096
5097 if (data.devices_status == STATUS_CRACKED) break;
5098 if (data.devices_status == STATUS_ABORTED) break;
5099 if (data.devices_status == STATUS_QUIT) break;
5100 if (data.devices_status == STATUS_BYPASS) break;
5101
5102 //
5103 // flush
5104 //
5105
5106 const uint pws_cnt = device_param->pws_cnt;
5107
5108 if (pws_cnt)
5109 {
5110 run_copy (device_param, pws_cnt);
5111
5112 run_cracker (device_param, pws_cnt);
5113
5114 device_param->pws_cnt = 0;
5115
5116 /*
5117 still required?
5118 if (attack_kern == ATTACK_KERN_STRAIGHT)
5119 {
5120 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5121 }
5122 else if (attack_kern == ATTACK_KERN_COMBI)
5123 {
5124 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5125 }
5126 */
5127 }
5128
5129 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5130
5131 if (data.devices_status == STATUS_CRACKED) break;
5132 if (data.devices_status == STATUS_ABORTED) break;
5133 if (data.devices_status == STATUS_QUIT) break;
5134 if (data.devices_status == STATUS_BYPASS) break;
5135
5136 if (words_fin == 0) break;
5137
5138 device_param->words_done = words_fin;
5139 }
5140
5141 if (attack_mode == ATTACK_MODE_COMBI)
5142 {
5143 fclose (device_param->combs_fp);
5144 }
5145
5146 free (wl_data->buf);
5147 free (wl_data);
5148
5149 fclose (fd);
5150 }
5151
5152 device_param->kernel_accel = 0;
5153 device_param->kernel_loops = 0;
5154
5155 return NULL;
5156 }
5157
5158 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5159 {
5160 if (!device_param)
5161 {
5162 log_error ("ERROR: %s : Invalid argument", __func__);
5163
5164 exit (-1);
5165 }
5166
5167 salt_t *salt_buf = &data.salts_buf[salt_pos];
5168
5169 device_param->kernel_params_buf32[24] = salt_pos;
5170 device_param->kernel_params_buf32[27] = 1;
5171 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5172 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5173 device_param->kernel_params_buf32[30] = 0;
5174 device_param->kernel_params_buf32[31] = 1;
5175
5176 char *dictfile_old = data.dictfile;
5177
5178 const char *weak_hash_check = "weak-hash-check";
5179
5180 data.dictfile = (char *) weak_hash_check;
5181
5182 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5183
5184 data.kernel_rules_buf[0].cmds[0] = 0;
5185
5186 /**
5187 * run the kernel
5188 */
5189
5190 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5191 {
5192 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5193 }
5194 else
5195 {
5196 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5197
5198 uint loop_step = 16;
5199
5200 const uint iter = salt_buf->salt_iter;
5201
5202 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5203 {
5204 uint loop_left = iter - loop_pos;
5205
5206 loop_left = MIN (loop_left, loop_step);
5207
5208 device_param->kernel_params_buf32[25] = loop_pos;
5209 device_param->kernel_params_buf32[26] = loop_left;
5210
5211 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5212 }
5213
5214 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5215 }
5216
5217 /**
5218 * result
5219 */
5220
5221 check_cracked (device_param, salt_pos);
5222
5223 /**
5224 * cleanup
5225 */
5226
5227 device_param->kernel_params_buf32[24] = 0;
5228 device_param->kernel_params_buf32[25] = 0;
5229 device_param->kernel_params_buf32[26] = 0;
5230 device_param->kernel_params_buf32[27] = 0;
5231 device_param->kernel_params_buf32[28] = 0;
5232 device_param->kernel_params_buf32[29] = 0;
5233 device_param->kernel_params_buf32[30] = 0;
5234 device_param->kernel_params_buf32[31] = 0;
5235
5236 data.dictfile = dictfile_old;
5237
5238 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5239 }
5240
5241 // hlfmt hashcat
5242
5243 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5244 {
5245 if (data.username == 0)
5246 {
5247 *hashbuf_pos = line_buf;
5248 *hashbuf_len = line_len;
5249 }
5250 else
5251 {
5252 char *pos = line_buf;
5253 int len = line_len;
5254
5255 for (int i = 0; i < line_len; i++, pos++, len--)
5256 {
5257 if (line_buf[i] == data.separator)
5258 {
5259 pos++;
5260
5261 len--;
5262
5263 break;
5264 }
5265 }
5266
5267 *hashbuf_pos = pos;
5268 *hashbuf_len = len;
5269 }
5270 }
5271
5272 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5273 {
5274 char *pos = NULL;
5275 int len = 0;
5276
5277 int sep_cnt = 0;
5278
5279 for (int i = 0; i < line_len; i++)
5280 {
5281 if (line_buf[i] == data.separator)
5282 {
5283 sep_cnt++;
5284
5285 continue;
5286 }
5287
5288 if (sep_cnt == 0)
5289 {
5290 if (pos == NULL) pos = line_buf + i;
5291
5292 len++;
5293 }
5294 }
5295
5296 *userbuf_pos = pos;
5297 *userbuf_len = len;
5298 }
5299
5300 // hlfmt pwdump
5301
5302 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5303 {
5304 int sep_cnt = 0;
5305
5306 int sep2_len = 0;
5307 int sep3_len = 0;
5308
5309 for (int i = 0; i < line_len; i++)
5310 {
5311 if (line_buf[i] == ':')
5312 {
5313 sep_cnt++;
5314
5315 continue;
5316 }
5317
5318 if (sep_cnt == 2) sep2_len++;
5319 if (sep_cnt == 3) sep3_len++;
5320 }
5321
5322 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5323
5324 return 0;
5325 }
5326
5327 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5328 {
5329 char *pos = NULL;
5330 int len = 0;
5331
5332 int sep_cnt = 0;
5333
5334 for (int i = 0; i < line_len; i++)
5335 {
5336 if (line_buf[i] == ':')
5337 {
5338 sep_cnt++;
5339
5340 continue;
5341 }
5342
5343 if (data.hash_mode == 1000)
5344 {
5345 if (sep_cnt == 3)
5346 {
5347 if (pos == NULL) pos = line_buf + i;
5348
5349 len++;
5350 }
5351 }
5352 else if (data.hash_mode == 3000)
5353 {
5354 if (sep_cnt == 2)
5355 {
5356 if (pos == NULL) pos = line_buf + i;
5357
5358 len++;
5359 }
5360 }
5361 }
5362
5363 *hashbuf_pos = pos;
5364 *hashbuf_len = len;
5365 }
5366
5367 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5368 {
5369 char *pos = NULL;
5370 int len = 0;
5371
5372 int sep_cnt = 0;
5373
5374 for (int i = 0; i < line_len; i++)
5375 {
5376 if (line_buf[i] == ':')
5377 {
5378 sep_cnt++;
5379
5380 continue;
5381 }
5382
5383 if (sep_cnt == 0)
5384 {
5385 if (pos == NULL) pos = line_buf + i;
5386
5387 len++;
5388 }
5389 }
5390
5391 *userbuf_pos = pos;
5392 *userbuf_len = len;
5393 }
5394
5395 // hlfmt passwd
5396
5397 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5398 {
5399 int sep_cnt = 0;
5400
5401 char sep5_first = 0;
5402 char sep6_first = 0;
5403
5404 for (int i = 0; i < line_len; i++)
5405 {
5406 if (line_buf[i] == ':')
5407 {
5408 sep_cnt++;
5409
5410 continue;
5411 }
5412
5413 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5414 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5415 }
5416
5417 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5418
5419 return 0;
5420 }
5421
5422 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5423 {
5424 char *pos = NULL;
5425 int len = 0;
5426
5427 int sep_cnt = 0;
5428
5429 for (int i = 0; i < line_len; i++)
5430 {
5431 if (line_buf[i] == ':')
5432 {
5433 sep_cnt++;
5434
5435 continue;
5436 }
5437
5438 if (sep_cnt == 1)
5439 {
5440 if (pos == NULL) pos = line_buf + i;
5441
5442 len++;
5443 }
5444 }
5445
5446 *hashbuf_pos = pos;
5447 *hashbuf_len = len;
5448 }
5449
5450 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5451 {
5452 char *pos = NULL;
5453 int len = 0;
5454
5455 int sep_cnt = 0;
5456
5457 for (int i = 0; i < line_len; i++)
5458 {
5459 if (line_buf[i] == ':')
5460 {
5461 sep_cnt++;
5462
5463 continue;
5464 }
5465
5466 if (sep_cnt == 0)
5467 {
5468 if (pos == NULL) pos = line_buf + i;
5469
5470 len++;
5471 }
5472 }
5473
5474 *userbuf_pos = pos;
5475 *userbuf_len = len;
5476 }
5477
5478 // hlfmt shadow
5479
5480 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5481 {
5482 int sep_cnt = 0;
5483
5484 for (int i = 0; i < line_len; i++)
5485 {
5486 if (line_buf[i] == ':') sep_cnt++;
5487 }
5488
5489 if (sep_cnt == 8) return 1;
5490
5491 return 0;
5492 }
5493
5494 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5495 {
5496 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5497 }
5498
5499 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5500 {
5501 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5502 }
5503
5504 // hlfmt main
5505
5506 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5507 {
5508 switch (hashfile_format)
5509 {
5510 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5511 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5512 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5513 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5514 }
5515 }
5516
5517 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5518 {
5519 switch (hashfile_format)
5520 {
5521 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5522 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5523 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5524 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5525 }
5526 }
5527
5528 char *strhlfmt (const uint hashfile_format)
5529 {
5530 switch (hashfile_format)
5531 {
5532 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5533 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5534 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5535 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5536 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5537 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5538 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5539 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5540 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5541 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5542 }
5543
5544 return ((char *) "Unknown");
5545 }
5546
5547 static uint hlfmt_detect (FILE *fp, uint max_check)
5548 {
5549 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5550
5551 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5552 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5553
5554 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5555
5556 uint num_check = 0;
5557
5558 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5559
5560 while (!feof (fp))
5561 {
5562 int line_len = fgetl (fp, line_buf);
5563
5564 if (line_len == 0) continue;
5565
5566 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5567 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5568 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5569
5570 if (num_check == max_check) break;
5571
5572 num_check++;
5573 }
5574
5575 myfree (line_buf);
5576
5577 uint hashlist_format = HLFMT_HASHCAT;
5578
5579 for (int i = 1; i < HLFMTS_CNT; i++)
5580 {
5581 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5582
5583 hashlist_format = i;
5584 }
5585
5586 free (formats_cnt);
5587
5588 return hashlist_format;
5589 }
5590
5591 /**
5592 * some further helper function
5593 */
5594
5595 // wrapper around mymalloc for ADL
5596
5597 #if defined(HAVE_HWMON)
5598 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5599 {
5600 return mymalloc (iSize);
5601 }
5602 #endif
5603
5604 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)
5605 {
5606 u64 collisions = 0;
5607
5608 const uint dgst_pos0 = data.dgst_pos0;
5609 const uint dgst_pos1 = data.dgst_pos1;
5610 const uint dgst_pos2 = data.dgst_pos2;
5611 const uint dgst_pos3 = data.dgst_pos3;
5612
5613 memset (bitmap_a, 0, bitmap_size);
5614 memset (bitmap_b, 0, bitmap_size);
5615 memset (bitmap_c, 0, bitmap_size);
5616 memset (bitmap_d, 0, bitmap_size);
5617
5618 for (uint i = 0; i < digests_cnt; i++)
5619 {
5620 uint *digest_ptr = (uint *) digests_buf_ptr;
5621
5622 digests_buf_ptr += dgst_size;
5623
5624 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5625 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5626 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5627 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5628
5629 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5630 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5631 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5632 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5633
5634 if (bitmap_a[idx0] & val0) collisions++;
5635 if (bitmap_b[idx1] & val1) collisions++;
5636 if (bitmap_c[idx2] & val2) collisions++;
5637 if (bitmap_d[idx3] & val3) collisions++;
5638
5639 bitmap_a[idx0] |= val0;
5640 bitmap_b[idx1] |= val1;
5641 bitmap_c[idx2] |= val2;
5642 bitmap_d[idx3] |= val3;
5643
5644 if (collisions >= collisions_max) return 0x7fffffff;
5645 }
5646
5647 return collisions;
5648 }
5649
5650 /**
5651 * main
5652 */
5653
5654 #ifdef WIN
5655 void SetConsoleWindowSize (const int x)
5656 {
5657 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5658
5659 if (h == INVALID_HANDLE_VALUE) return;
5660
5661 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5662
5663 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5664
5665 SMALL_RECT *sr = &bufferInfo.srWindow;
5666
5667 sr->Right = MAX (sr->Right, x - 1);
5668
5669 COORD co;
5670
5671 co.X = sr->Right + 1;
5672 co.Y = 9999;
5673
5674 if (!SetConsoleScreenBufferSize (h, co)) return;
5675
5676 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5677 }
5678 #endif
5679
5680 int main (int argc, char **argv)
5681 {
5682 #ifdef WIN
5683 SetConsoleWindowSize (132);
5684 #endif
5685
5686 /**
5687 * To help users a bit
5688 */
5689
5690 char *compute = getenv ("COMPUTE");
5691
5692 if (compute)
5693 {
5694 static char display[100];
5695
5696 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5697
5698 putenv (display);
5699 }
5700 else
5701 {
5702 if (getenv ("DISPLAY") == NULL)
5703 putenv ((char *) "DISPLAY=:0");
5704 }
5705
5706 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5707 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5708
5709 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5710 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5711
5712 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5713 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5714
5715 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5716 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5717
5718 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5719 putenv ((char *) "POCL_KERNEL_CACHE=0");
5720
5721 umask (077);
5722
5723 /**
5724 * Real init
5725 */
5726
5727 memset (&data, 0, sizeof (hc_global_data_t));
5728
5729 time_t proc_start;
5730
5731 time (&proc_start);
5732
5733 data.proc_start = proc_start;
5734
5735 int myargc = argc;
5736 char **myargv = argv;
5737
5738 hc_thread_mutex_init (mux_dispatcher);
5739 hc_thread_mutex_init (mux_counter);
5740 hc_thread_mutex_init (mux_display);
5741 hc_thread_mutex_init (mux_adl);
5742
5743 /**
5744 * commandline parameters
5745 */
5746
5747 uint usage = USAGE;
5748 uint version = VERSION;
5749 uint quiet = QUIET;
5750 uint benchmark = BENCHMARK;
5751 uint stdout_flag = STDOUT_FLAG;
5752 uint show = SHOW;
5753 uint left = LEFT;
5754 uint username = USERNAME;
5755 uint remove = REMOVE;
5756 uint remove_timer = REMOVE_TIMER;
5757 u64 skip = SKIP;
5758 u64 limit = LIMIT;
5759 uint keyspace = KEYSPACE;
5760 uint potfile_disable = POTFILE_DISABLE;
5761 char *potfile_path = NULL;
5762 uint debug_mode = DEBUG_MODE;
5763 char *debug_file = NULL;
5764 char *induction_dir = NULL;
5765 char *outfile_check_dir = NULL;
5766 uint force = FORCE;
5767 uint runtime = RUNTIME;
5768 uint hash_mode = HASH_MODE;
5769 uint attack_mode = ATTACK_MODE;
5770 uint markov_disable = MARKOV_DISABLE;
5771 uint markov_classic = MARKOV_CLASSIC;
5772 uint markov_threshold = MARKOV_THRESHOLD;
5773 char *markov_hcstat = NULL;
5774 char *outfile = NULL;
5775 uint outfile_format = OUTFILE_FORMAT;
5776 uint outfile_autohex = OUTFILE_AUTOHEX;
5777 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5778 uint restore = RESTORE;
5779 uint restore_timer = RESTORE_TIMER;
5780 uint restore_disable = RESTORE_DISABLE;
5781 uint status = STATUS;
5782 uint status_timer = STATUS_TIMER;
5783 uint machine_readable = MACHINE_READABLE;
5784 uint loopback = LOOPBACK;
5785 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5786 char *session = NULL;
5787 uint hex_charset = HEX_CHARSET;
5788 uint hex_salt = HEX_SALT;
5789 uint hex_wordlist = HEX_WORDLIST;
5790 uint rp_gen = RP_GEN;
5791 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5792 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5793 uint rp_gen_seed = RP_GEN_SEED;
5794 char *rule_buf_l = (char *) RULE_BUF_L;
5795 char *rule_buf_r = (char *) RULE_BUF_R;
5796 uint increment = INCREMENT;
5797 uint increment_min = INCREMENT_MIN;
5798 uint increment_max = INCREMENT_MAX;
5799 char *cpu_affinity = NULL;
5800 OCL_PTR *ocl = NULL;
5801 char *opencl_devices = NULL;
5802 char *opencl_platforms = NULL;
5803 char *opencl_device_types = NULL;
5804 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5805 char *truecrypt_keyfiles = NULL;
5806 char *veracrypt_keyfiles = NULL;
5807 uint veracrypt_pim = 0;
5808 uint workload_profile = WORKLOAD_PROFILE;
5809 uint kernel_accel = KERNEL_ACCEL;
5810 uint kernel_loops = KERNEL_LOOPS;
5811 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5812 #ifdef HAVE_HWMON
5813 uint gpu_temp_abort = GPU_TEMP_ABORT;
5814 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5815 uint powertune_enable = POWERTUNE_ENABLE;
5816 #endif
5817 uint logfile_disable = LOGFILE_DISABLE;
5818 uint segment_size = SEGMENT_SIZE;
5819 uint scrypt_tmto = SCRYPT_TMTO;
5820 char separator = SEPARATOR;
5821 uint bitmap_min = BITMAP_MIN;
5822 uint bitmap_max = BITMAP_MAX;
5823 char *custom_charset_1 = NULL;
5824 char *custom_charset_2 = NULL;
5825 char *custom_charset_3 = NULL;
5826 char *custom_charset_4 = NULL;
5827
5828 #define IDX_HELP 'h'
5829 #define IDX_VERSION 'V'
5830 #define IDX_VERSION_LOWER 'v'
5831 #define IDX_QUIET 0xff02
5832 #define IDX_SHOW 0xff03
5833 #define IDX_LEFT 0xff04
5834 #define IDX_REMOVE 0xff05
5835 #define IDX_REMOVE_TIMER 0xff37
5836 #define IDX_SKIP 's'
5837 #define IDX_LIMIT 'l'
5838 #define IDX_KEYSPACE 0xff35
5839 #define IDX_POTFILE_DISABLE 0xff06
5840 #define IDX_POTFILE_PATH 0xffe0
5841 #define IDX_DEBUG_MODE 0xff43
5842 #define IDX_DEBUG_FILE 0xff44
5843 #define IDX_INDUCTION_DIR 0xff46
5844 #define IDX_OUTFILE_CHECK_DIR 0xff47
5845 #define IDX_USERNAME 0xff07
5846 #define IDX_FORCE 0xff08
5847 #define IDX_RUNTIME 0xff09
5848 #define IDX_BENCHMARK 'b'
5849 #define IDX_STDOUT_FLAG 0xff77
5850 #define IDX_HASH_MODE 'm'
5851 #define IDX_ATTACK_MODE 'a'
5852 #define IDX_RP_FILE 'r'
5853 #define IDX_RP_GEN 'g'
5854 #define IDX_RP_GEN_FUNC_MIN 0xff10
5855 #define IDX_RP_GEN_FUNC_MAX 0xff11
5856 #define IDX_RP_GEN_SEED 0xff34
5857 #define IDX_RULE_BUF_L 'j'
5858 #define IDX_RULE_BUF_R 'k'
5859 #define IDX_INCREMENT 'i'
5860 #define IDX_INCREMENT_MIN 0xff12
5861 #define IDX_INCREMENT_MAX 0xff13
5862 #define IDX_OUTFILE 'o'
5863 #define IDX_OUTFILE_FORMAT 0xff14
5864 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5865 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5866 #define IDX_RESTORE 0xff15
5867 #define IDX_RESTORE_DISABLE 0xff27
5868 #define IDX_STATUS 0xff17
5869 #define IDX_STATUS_TIMER 0xff18
5870 #define IDX_MACHINE_READABLE 0xff50
5871 #define IDX_LOOPBACK 0xff38
5872 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5873 #define IDX_SESSION 0xff19
5874 #define IDX_HEX_CHARSET 0xff20
5875 #define IDX_HEX_SALT 0xff21
5876 #define IDX_HEX_WORDLIST 0xff40
5877 #define IDX_MARKOV_DISABLE 0xff22
5878 #define IDX_MARKOV_CLASSIC 0xff23
5879 #define IDX_MARKOV_THRESHOLD 't'
5880 #define IDX_MARKOV_HCSTAT 0xff24
5881 #define IDX_CPU_AFFINITY 0xff25
5882 #define IDX_OPENCL_DEVICES 'd'
5883 #define IDX_OPENCL_PLATFORMS 0xff72
5884 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5885 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5886 #define IDX_WORKLOAD_PROFILE 'w'
5887 #define IDX_KERNEL_ACCEL 'n'
5888 #define IDX_KERNEL_LOOPS 'u'
5889 #define IDX_GPU_TEMP_DISABLE 0xff29
5890 #define IDX_GPU_TEMP_ABORT 0xff30
5891 #define IDX_GPU_TEMP_RETAIN 0xff31
5892 #define IDX_POWERTUNE_ENABLE 0xff41
5893 #define IDX_LOGFILE_DISABLE 0xff51
5894 #define IDX_TRUECRYPT_KEYFILES 0xff52
5895 #define IDX_VERACRYPT_KEYFILES 0xff53
5896 #define IDX_VERACRYPT_PIM 0xff54
5897 #define IDX_SCRYPT_TMTO 0xff61
5898 #define IDX_SEGMENT_SIZE 'c'
5899 #define IDX_SEPARATOR 'p'
5900 #define IDX_BITMAP_MIN 0xff70
5901 #define IDX_BITMAP_MAX 0xff71
5902 #define IDX_CUSTOM_CHARSET_1 '1'
5903 #define IDX_CUSTOM_CHARSET_2 '2'
5904 #define IDX_CUSTOM_CHARSET_3 '3'
5905 #define IDX_CUSTOM_CHARSET_4 '4'
5906
5907 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5908
5909 struct option long_options[] =
5910 {
5911 {"help", no_argument, 0, IDX_HELP},
5912 {"version", no_argument, 0, IDX_VERSION},
5913 {"quiet", no_argument, 0, IDX_QUIET},
5914 {"show", no_argument, 0, IDX_SHOW},
5915 {"left", no_argument, 0, IDX_LEFT},
5916 {"username", no_argument, 0, IDX_USERNAME},
5917 {"remove", no_argument, 0, IDX_REMOVE},
5918 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5919 {"skip", required_argument, 0, IDX_SKIP},
5920 {"limit", required_argument, 0, IDX_LIMIT},
5921 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5922 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5923 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5924 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5925 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5926 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5927 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5928 {"force", no_argument, 0, IDX_FORCE},
5929 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5930 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5931 {"restore", no_argument, 0, IDX_RESTORE},
5932 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5933 {"status", no_argument, 0, IDX_STATUS},
5934 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5935 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5936 {"loopback", no_argument, 0, IDX_LOOPBACK},
5937 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5938 {"session", required_argument, 0, IDX_SESSION},
5939 {"runtime", required_argument, 0, IDX_RUNTIME},
5940 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5941 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5942 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5943 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5944 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5945 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5946 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5947 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5948 {"rules-file", required_argument, 0, IDX_RP_FILE},
5949 {"outfile", required_argument, 0, IDX_OUTFILE},
5950 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5951 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5952 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5953 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5954 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5955 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5956 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5957 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5958 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5959 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5960 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5961 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5962 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5963 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5964 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5965 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5966 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5967 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5968 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5969 #ifdef HAVE_HWMON
5970 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5971 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5972 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5973 #endif // HAVE_HWMON
5974 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5975 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5976 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5977 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5978 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5979 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5980 {"seperator", required_argument, 0, IDX_SEPARATOR},
5981 {"separator", required_argument, 0, IDX_SEPARATOR},
5982 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5983 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5984 {"increment", no_argument, 0, IDX_INCREMENT},
5985 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5986 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5987 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5988 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5989 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5990 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5991 {0, 0, 0, 0}
5992 };
5993
5994 uint rp_files_cnt = 0;
5995
5996 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5997
5998 int option_index = 0;
5999 int c = -1;
6000
6001 optind = 1;
6002 optopt = 0;
6003
6004 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6005 {
6006 switch (c)
6007 {
6008 case IDX_HELP: usage = 1; break;
6009 case IDX_VERSION:
6010 case IDX_VERSION_LOWER: version = 1; break;
6011 case IDX_RESTORE: restore = 1; break;
6012 case IDX_SESSION: session = optarg; break;
6013 case IDX_SHOW: show = 1; break;
6014 case IDX_LEFT: left = 1; break;
6015 case '?': return (-1);
6016 }
6017 }
6018
6019 if (optopt != 0)
6020 {
6021 log_error ("ERROR: Invalid argument specified");
6022
6023 return (-1);
6024 }
6025
6026 /**
6027 * exit functions
6028 */
6029
6030 if (version)
6031 {
6032 log_info ("%s", VERSION_TAG);
6033
6034 return (0);
6035 }
6036
6037 if (usage)
6038 {
6039 usage_big_print (PROGNAME);
6040
6041 return (0);
6042 }
6043
6044 /**
6045 * session needs to be set, always!
6046 */
6047
6048 if (session == NULL) session = (char *) PROGNAME;
6049
6050 /**
6051 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6052 */
6053
6054 char *exec_path = get_exec_path ();
6055
6056 #ifdef LINUX
6057
6058 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6059 char *resolved_exec_path = realpath (exec_path, NULL);
6060
6061 char *install_dir = get_install_dir (resolved_exec_path);
6062 char *profile_dir = NULL;
6063 char *session_dir = NULL;
6064 char *shared_dir = NULL;
6065
6066 if (strcmp (install_dir, resolved_install_folder) == 0)
6067 {
6068 struct passwd *pw = getpwuid (getuid ());
6069
6070 const char *homedir = pw->pw_dir;
6071
6072 profile_dir = get_profile_dir (homedir);
6073 session_dir = get_session_dir (profile_dir);
6074 shared_dir = strdup (SHARED_FOLDER);
6075
6076 mkdir (profile_dir, 0700);
6077 mkdir (session_dir, 0700);
6078 }
6079 else
6080 {
6081 profile_dir = install_dir;
6082 session_dir = install_dir;
6083 shared_dir = install_dir;
6084 }
6085
6086 myfree (resolved_install_folder);
6087 myfree (resolved_exec_path);
6088
6089 #else
6090
6091 char *install_dir = get_install_dir (exec_path);
6092 char *profile_dir = install_dir;
6093 char *session_dir = install_dir;
6094 char *shared_dir = install_dir;
6095
6096 #endif
6097
6098 data.install_dir = install_dir;
6099 data.profile_dir = profile_dir;
6100 data.session_dir = session_dir;
6101 data.shared_dir = shared_dir;
6102
6103 myfree (exec_path);
6104
6105 /**
6106 * kernel cache, we need to make sure folder exist
6107 */
6108
6109 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6110
6111 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6112
6113 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6114
6115 mkdir (kernels_folder, 0700);
6116
6117 myfree (kernels_folder);
6118
6119 /**
6120 * session
6121 */
6122
6123 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6124
6125 data.session = session;
6126
6127 char *eff_restore_file = (char *) mymalloc (session_size);
6128 char *new_restore_file = (char *) mymalloc (session_size);
6129
6130 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6131 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6132
6133 data.eff_restore_file = eff_restore_file;
6134 data.new_restore_file = new_restore_file;
6135
6136 if (((show == 1) || (left == 1)) && (restore == 1))
6137 {
6138 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6139 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6140
6141 return (-1);
6142 }
6143
6144 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6145 if ((show == 1) || (left == 1))
6146 {
6147 restore_disable = 1;
6148
6149 restore = 0;
6150 }
6151
6152 data.restore_disable = restore_disable;
6153
6154 restore_data_t *rd = init_restore (argc, argv);
6155
6156 data.rd = rd;
6157
6158 /**
6159 * restore file
6160 */
6161
6162 if (restore == 1)
6163 {
6164 read_restore (eff_restore_file, rd);
6165
6166 if (rd->version_bin < RESTORE_MIN)
6167 {
6168 log_error ("ERROR: Incompatible restore-file version");
6169
6170 return (-1);
6171 }
6172
6173 myargc = rd->argc;
6174 myargv = rd->argv;
6175
6176 #ifdef _POSIX
6177 rd->pid = getpid ();
6178 #elif _WIN
6179 rd->pid = GetCurrentProcessId ();
6180 #endif
6181 }
6182
6183 uint hash_mode_chgd = 0;
6184 uint runtime_chgd = 0;
6185 uint kernel_loops_chgd = 0;
6186 uint kernel_accel_chgd = 0;
6187 uint attack_mode_chgd = 0;
6188 uint outfile_format_chgd = 0;
6189 uint rp_gen_seed_chgd = 0;
6190 uint remove_timer_chgd = 0;
6191 uint increment_min_chgd = 0;
6192 uint increment_max_chgd = 0;
6193 uint workload_profile_chgd = 0;
6194 uint opencl_vector_width_chgd = 0;
6195
6196 optind = 1;
6197 optopt = 0;
6198 option_index = 0;
6199
6200 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6201 {
6202 switch (c)
6203 {
6204 //case IDX_HELP: usage = 1; break;
6205 //case IDX_VERSION: version = 1; break;
6206 //case IDX_RESTORE: restore = 1; break;
6207 case IDX_QUIET: quiet = 1; break;
6208 //case IDX_SHOW: show = 1; break;
6209 case IDX_SHOW: break;
6210 //case IDX_LEFT: left = 1; break;
6211 case IDX_LEFT: break;
6212 case IDX_USERNAME: username = 1; break;
6213 case IDX_REMOVE: remove = 1; break;
6214 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6215 remove_timer_chgd = 1; break;
6216 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6217 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6218 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6219 case IDX_DEBUG_FILE: debug_file = optarg; break;
6220 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6221 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6222 case IDX_FORCE: force = 1; break;
6223 case IDX_SKIP: skip = atoll (optarg); break;
6224 case IDX_LIMIT: limit = atoll (optarg); break;
6225 case IDX_KEYSPACE: keyspace = 1; break;
6226 case IDX_BENCHMARK: benchmark = 1; break;
6227 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6228 case IDX_RESTORE: break;
6229 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6230 case IDX_STATUS: status = 1; break;
6231 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6232 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6233 case IDX_LOOPBACK: loopback = 1; break;
6234 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6235 //case IDX_SESSION: session = optarg; break;
6236 case IDX_SESSION: break;
6237 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6238 hash_mode_chgd = 1; break;
6239 case IDX_RUNTIME: runtime = atoi (optarg);
6240 runtime_chgd = 1; break;
6241 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6242 attack_mode_chgd = 1; break;
6243 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6244 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6245 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6246 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6247 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6248 rp_gen_seed_chgd = 1; break;
6249 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6250 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6251 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6252 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6253 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6254 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6255 case IDX_OUTFILE: outfile = optarg; break;
6256 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6257 outfile_format_chgd = 1; break;
6258 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6259 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6260 case IDX_HEX_CHARSET: hex_charset = 1; break;
6261 case IDX_HEX_SALT: hex_salt = 1; break;
6262 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6263 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6264 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6265 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6266 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6267 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6268 opencl_vector_width_chgd = 1; break;
6269 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6270 workload_profile_chgd = 1; break;
6271 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6272 kernel_accel_chgd = 1; break;
6273 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6274 kernel_loops_chgd = 1; break;
6275 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6276 #ifdef HAVE_HWMON
6277 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6278 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6279 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6280 #endif // HAVE_HWMON
6281 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6282 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6283 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6284 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6285 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6286 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6287 case IDX_SEPARATOR: separator = optarg[0]; break;
6288 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6289 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6290 case IDX_INCREMENT: increment = 1; break;
6291 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6292 increment_min_chgd = 1; break;
6293 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6294 increment_max_chgd = 1; break;
6295 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6296 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6297 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6298 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6299
6300 default:
6301 log_error ("ERROR: Invalid argument specified");
6302 return (-1);
6303 }
6304 }
6305
6306 if (optopt != 0)
6307 {
6308 log_error ("ERROR: Invalid argument specified");
6309
6310 return (-1);
6311 }
6312
6313 /**
6314 * Inform user things getting started,
6315 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6316 * - we do not need to check algorithm_pos
6317 */
6318
6319 if (quiet == 0)
6320 {
6321 if (benchmark == 1)
6322 {
6323 if (machine_readable == 0)
6324 {
6325 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6326 log_info ("");
6327 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6328 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6329 log_info ("");
6330 }
6331 else
6332 {
6333 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6334 }
6335 }
6336 else if (restore == 1)
6337 {
6338 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6339 log_info ("");
6340 }
6341 else if (stdout_flag == 1)
6342 {
6343 // do nothing
6344 }
6345 else
6346 {
6347 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6348 log_info ("");
6349 }
6350 }
6351
6352 /**
6353 * sanity check
6354 */
6355
6356 if (attack_mode > 7)
6357 {
6358 log_error ("ERROR: Invalid attack-mode specified");
6359
6360 return (-1);
6361 }
6362
6363 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6364 {
6365 log_error ("ERROR: Invalid runtime specified");
6366
6367 return (-1);
6368 }
6369
6370 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6371 {
6372 log_error ("ERROR: Invalid hash-type specified");
6373
6374 return (-1);
6375 }
6376
6377 // renamed hash modes
6378
6379 if (hash_mode_chgd)
6380 {
6381 int n = -1;
6382
6383 switch (hash_mode)
6384 {
6385 case 123: n = 124;
6386 break;
6387 }
6388
6389 if (n >= 0)
6390 {
6391 log_error ("Old -m specified, use -m %d instead", n);
6392
6393 return (-1);
6394 }
6395 }
6396
6397 if (username == 1)
6398 {
6399 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6400 {
6401 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6402
6403 return (-1);
6404 }
6405 }
6406
6407 if (outfile_format > 16)
6408 {
6409 log_error ("ERROR: Invalid outfile-format specified");
6410
6411 return (-1);
6412 }
6413
6414 if (left == 1)
6415 {
6416 if (outfile_format_chgd == 1)
6417 {
6418 if (outfile_format > 1)
6419 {
6420 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6421
6422 return (-1);
6423 }
6424 }
6425 else
6426 {
6427 outfile_format = OUTFILE_FMT_HASH;
6428 }
6429 }
6430
6431 if (show == 1)
6432 {
6433 if (outfile_format_chgd == 1)
6434 {
6435 if ((outfile_format > 7) && (outfile_format < 16))
6436 {
6437 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6438
6439 return (-1);
6440 }
6441 }
6442 }
6443
6444 if (increment_min < INCREMENT_MIN)
6445 {
6446 log_error ("ERROR: Invalid increment-min specified");
6447
6448 return (-1);
6449 }
6450
6451 if (increment_max > INCREMENT_MAX)
6452 {
6453 log_error ("ERROR: Invalid increment-max specified");
6454
6455 return (-1);
6456 }
6457
6458 if (increment_min > increment_max)
6459 {
6460 log_error ("ERROR: Invalid increment-min specified");
6461
6462 return (-1);
6463 }
6464
6465 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6466 {
6467 log_error ("ERROR: increment is not allowed in attack-mode 0");
6468
6469 return (-1);
6470 }
6471
6472 if ((increment == 0) && (increment_min_chgd == 1))
6473 {
6474 log_error ("ERROR: increment-min is only supported together with increment switch");
6475
6476 return (-1);
6477 }
6478
6479 if ((increment == 0) && (increment_max_chgd == 1))
6480 {
6481 log_error ("ERROR: increment-max is only supported together with increment switch");
6482
6483 return (-1);
6484 }
6485
6486 if (rp_files_cnt && rp_gen)
6487 {
6488 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6489
6490 return (-1);
6491 }
6492
6493 if (rp_files_cnt || rp_gen)
6494 {
6495 if (attack_mode != ATTACK_MODE_STRAIGHT)
6496 {
6497 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6498
6499 return (-1);
6500 }
6501 }
6502
6503 if (rp_gen_func_min > rp_gen_func_max)
6504 {
6505 log_error ("ERROR: Invalid rp-gen-func-min specified");
6506
6507 return (-1);
6508 }
6509
6510 if (kernel_accel_chgd == 1)
6511 {
6512 if (force == 0)
6513 {
6514 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6515 log_info ("Please consider using the option -w instead");
6516 log_info ("You can use --force to override this but do not post error reports if you do so");
6517 log_info ("");
6518
6519 return (-1);
6520 }
6521
6522 if (kernel_accel < 1)
6523 {
6524 log_error ("ERROR: Invalid kernel-accel specified");
6525
6526 return (-1);
6527 }
6528
6529 if (kernel_accel > 1024)
6530 {
6531 log_error ("ERROR: Invalid kernel-accel specified");
6532
6533 return (-1);
6534 }
6535 }
6536
6537 if (kernel_loops_chgd == 1)
6538 {
6539 if (force == 0)
6540 {
6541 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6542 log_info ("Please consider using the option -w instead");
6543 log_info ("You can use --force to override this but do not post error reports if you do so");
6544 log_info ("");
6545
6546 return (-1);
6547 }
6548
6549 if (kernel_loops < 1)
6550 {
6551 log_error ("ERROR: Invalid kernel-loops specified");
6552
6553 return (-1);
6554 }
6555
6556 if (kernel_loops > 1024)
6557 {
6558 log_error ("ERROR: Invalid kernel-loops specified");
6559
6560 return (-1);
6561 }
6562 }
6563
6564 if ((workload_profile < 1) || (workload_profile > 4))
6565 {
6566 log_error ("ERROR: workload-profile %i not available", workload_profile);
6567
6568 return (-1);
6569 }
6570
6571 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6572 {
6573 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6574
6575 return (-1);
6576 }
6577
6578 if (show == 1 || left == 1)
6579 {
6580 attack_mode = ATTACK_MODE_NONE;
6581
6582 if (remove == 1)
6583 {
6584 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6585
6586 return (-1);
6587 }
6588
6589 if (potfile_disable == 1)
6590 {
6591 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6592
6593 return (-1);
6594 }
6595 }
6596
6597 uint attack_kern = ATTACK_KERN_NONE;
6598
6599 switch (attack_mode)
6600 {
6601 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6602 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6603 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6604 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6605 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6606 }
6607
6608 if (benchmark == 1)
6609 {
6610 if (myargv[optind] != 0)
6611 {
6612 log_error ("ERROR: Invalid argument for benchmark mode specified");
6613
6614 return (-1);
6615 }
6616
6617 if (attack_mode_chgd == 1)
6618 {
6619 if (attack_mode != ATTACK_MODE_BF)
6620 {
6621 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6622
6623 return (-1);
6624 }
6625 }
6626 }
6627 else
6628 {
6629 if (stdout_flag == 1) // no hash here
6630 {
6631 optind--;
6632 }
6633
6634 if (keyspace == 1)
6635 {
6636 int num_additional_params = 1;
6637
6638 if (attack_kern == ATTACK_KERN_COMBI)
6639 {
6640 num_additional_params = 2;
6641 }
6642
6643 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6644
6645 if (keyspace_wordlist_specified == 0) optind--;
6646 }
6647
6648 if (attack_kern == ATTACK_KERN_NONE)
6649 {
6650 if ((optind + 1) != myargc)
6651 {
6652 usage_mini_print (myargv[0]);
6653
6654 return (-1);
6655 }
6656 }
6657 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6658 {
6659 if ((optind + 1) > myargc)
6660 {
6661 usage_mini_print (myargv[0]);
6662
6663 return (-1);
6664 }
6665 }
6666 else if (attack_kern == ATTACK_KERN_COMBI)
6667 {
6668 if ((optind + 3) != myargc)
6669 {
6670 usage_mini_print (myargv[0]);
6671
6672 return (-1);
6673 }
6674 }
6675 else if (attack_kern == ATTACK_KERN_BF)
6676 {
6677 if ((optind + 1) > myargc)
6678 {
6679 usage_mini_print (myargv[0]);
6680
6681 return (-1);
6682 }
6683 }
6684 else
6685 {
6686 usage_mini_print (myargv[0]);
6687
6688 return (-1);
6689 }
6690 }
6691
6692 if (skip != 0 && limit != 0)
6693 {
6694 limit += skip;
6695 }
6696
6697 if (keyspace == 1)
6698 {
6699 if (show == 1)
6700 {
6701 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6702
6703 return (-1);
6704 }
6705 else if (left == 1)
6706 {
6707 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6708
6709 return (-1);
6710 }
6711
6712 potfile_disable = 1;
6713
6714 restore_disable = 1;
6715
6716 restore = 0;
6717
6718 weak_hash_threshold = 0;
6719
6720 quiet = 1;
6721 }
6722
6723 if (stdout_flag == 1)
6724 {
6725 status_timer = 0;
6726 restore_timer = 0;
6727 restore_disable = 1;
6728 restore = 0;
6729 potfile_disable = 1;
6730 weak_hash_threshold = 0;
6731 gpu_temp_disable = 1;
6732 hash_mode = 2000;
6733 quiet = 1;
6734 outfile_format = OUTFILE_FMT_PLAIN;
6735 kernel_accel = 1024;
6736 kernel_loops = 1024;
6737 force = 1;
6738 outfile_check_timer = 0;
6739 }
6740
6741 if (remove_timer_chgd == 1)
6742 {
6743 if (remove == 0)
6744 {
6745 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6746
6747 return (-1);
6748 }
6749
6750 if (remove_timer < 1)
6751 {
6752 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6753
6754 return (-1);
6755 }
6756 }
6757
6758 if (loopback == 1)
6759 {
6760 if (attack_mode == ATTACK_MODE_STRAIGHT)
6761 {
6762 if ((rp_files_cnt == 0) && (rp_gen == 0))
6763 {
6764 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6765
6766 return (-1);
6767 }
6768 }
6769 else
6770 {
6771 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6772
6773 return (-1);
6774 }
6775 }
6776
6777 if (debug_mode > 0)
6778 {
6779 if (attack_mode != ATTACK_MODE_STRAIGHT)
6780 {
6781 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6782
6783 return (-1);
6784 }
6785
6786 if ((rp_files_cnt == 0) && (rp_gen == 0))
6787 {
6788 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6789
6790 return (-1);
6791 }
6792 }
6793
6794 if (debug_mode > 4)
6795 {
6796 log_error ("ERROR: Invalid debug-mode specified");
6797
6798 return (-1);
6799 }
6800
6801 if (debug_file != NULL)
6802 {
6803 if (debug_mode < 1)
6804 {
6805 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6806
6807 return (-1);
6808 }
6809 }
6810
6811 if (induction_dir != NULL)
6812 {
6813 if (attack_mode == ATTACK_MODE_BF)
6814 {
6815 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6816
6817 return (-1);
6818 }
6819 }
6820
6821 if (attack_mode != ATTACK_MODE_STRAIGHT)
6822 {
6823 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6824 {
6825 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6826
6827 return (-1);
6828 }
6829
6830 weak_hash_threshold = 0;
6831 }
6832
6833 /**
6834 * induction directory
6835 */
6836
6837 char *induction_directory = NULL;
6838
6839 if (attack_mode != ATTACK_MODE_BF)
6840 {
6841 if (induction_dir == NULL)
6842 {
6843 induction_directory = (char *) mymalloc (session_size);
6844
6845 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6846
6847 // create induction folder if it does not already exist
6848
6849 if (keyspace == 0)
6850 {
6851 if (rmdir (induction_directory) == -1)
6852 {
6853 if (errno == ENOENT)
6854 {
6855 // good, we can ignore
6856 }
6857 else if (errno == ENOTEMPTY)
6858 {
6859 char *induction_directory_mv = (char *) mymalloc (session_size);
6860
6861 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6862
6863 if (rename (induction_directory, induction_directory_mv) != 0)
6864 {
6865 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6866
6867 return (-1);
6868 }
6869 }
6870 else
6871 {
6872 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6873
6874 return (-1);
6875 }
6876 }
6877
6878 if (mkdir (induction_directory, 0700) == -1)
6879 {
6880 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6881
6882 return (-1);
6883 }
6884 }
6885 }
6886 else
6887 {
6888 induction_directory = induction_dir;
6889 }
6890 }
6891
6892 data.induction_directory = induction_directory;
6893
6894 /**
6895 * loopback
6896 */
6897
6898 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6899
6900 char *loopback_file = (char *) mymalloc (loopback_size);
6901
6902 /**
6903 * tuning db
6904 */
6905
6906 char tuning_db_file[256] = { 0 };
6907
6908 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6909
6910 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6911
6912 /**
6913 * outfile-check directory
6914 */
6915
6916 char *outfile_check_directory = NULL;
6917
6918 if (outfile_check_dir == NULL)
6919 {
6920 outfile_check_directory = (char *) mymalloc (session_size);
6921
6922 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6923 }
6924 else
6925 {
6926 outfile_check_directory = outfile_check_dir;
6927 }
6928
6929 data.outfile_check_directory = outfile_check_directory;
6930
6931 if (keyspace == 0)
6932 {
6933 struct stat outfile_check_stat;
6934
6935 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6936 {
6937 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6938
6939 if (is_dir == 0)
6940 {
6941 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6942
6943 return (-1);
6944 }
6945 }
6946 else if (outfile_check_dir == NULL)
6947 {
6948 if (mkdir (outfile_check_directory, 0700) == -1)
6949 {
6950 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6951
6952 return (-1);
6953 }
6954 }
6955 }
6956
6957 /**
6958 * special other stuff
6959 */
6960
6961 if (hash_mode == 9710)
6962 {
6963 outfile_format = 5;
6964 outfile_format_chgd = 1;
6965 }
6966
6967 if (hash_mode == 9810)
6968 {
6969 outfile_format = 5;
6970 outfile_format_chgd = 1;
6971 }
6972
6973 if (hash_mode == 10410)
6974 {
6975 outfile_format = 5;
6976 outfile_format_chgd = 1;
6977 }
6978
6979 /**
6980 * store stuff
6981 */
6982
6983 data.hash_mode = hash_mode;
6984 data.restore = restore;
6985 data.restore_timer = restore_timer;
6986 data.restore_disable = restore_disable;
6987 data.status = status;
6988 data.status_timer = status_timer;
6989 data.machine_readable = machine_readable;
6990 data.loopback = loopback;
6991 data.runtime = runtime;
6992 data.remove = remove;
6993 data.remove_timer = remove_timer;
6994 data.debug_mode = debug_mode;
6995 data.debug_file = debug_file;
6996 data.username = username;
6997 data.quiet = quiet;
6998 data.outfile = outfile;
6999 data.outfile_format = outfile_format;
7000 data.outfile_autohex = outfile_autohex;
7001 data.hex_charset = hex_charset;
7002 data.hex_salt = hex_salt;
7003 data.hex_wordlist = hex_wordlist;
7004 data.separator = separator;
7005 data.rp_files = rp_files;
7006 data.rp_files_cnt = rp_files_cnt;
7007 data.rp_gen = rp_gen;
7008 data.rp_gen_seed = rp_gen_seed;
7009 data.force = force;
7010 data.benchmark = benchmark;
7011 data.skip = skip;
7012 data.limit = limit;
7013 #ifdef HAVE_HWMON
7014 data.powertune_enable = powertune_enable;
7015 #endif
7016 data.logfile_disable = logfile_disable;
7017 data.truecrypt_keyfiles = truecrypt_keyfiles;
7018 data.veracrypt_keyfiles = veracrypt_keyfiles;
7019 data.veracrypt_pim = veracrypt_pim;
7020 data.scrypt_tmto = scrypt_tmto;
7021 data.workload_profile = workload_profile;
7022
7023 /**
7024 * cpu affinity
7025 */
7026
7027 if (cpu_affinity)
7028 {
7029 set_cpu_affinity (cpu_affinity);
7030 }
7031
7032 if (rp_gen_seed_chgd == 0)
7033 {
7034 srand (proc_start);
7035 }
7036 else
7037 {
7038 srand (rp_gen_seed);
7039 }
7040
7041 /**
7042 * logfile init
7043 */
7044
7045 if (logfile_disable == 0)
7046 {
7047 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7048
7049 char *logfile = (char *) mymalloc (logfile_size);
7050
7051 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7052
7053 data.logfile = logfile;
7054
7055 char *topid = logfile_generate_topid ();
7056
7057 data.topid = topid;
7058 }
7059
7060 // logfile_append() checks for logfile_disable internally to make it easier from here
7061
7062 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7063 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7064 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7065 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7066 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7067 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7068 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7069 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7070 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7071 #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));
7072
7073 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7074 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7075 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7076 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7077 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7078 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7079 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7080 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7081
7082 logfile_top_msg ("START");
7083
7084 logfile_top_uint (attack_mode);
7085 logfile_top_uint (attack_kern);
7086 logfile_top_uint (benchmark);
7087 logfile_top_uint (stdout_flag);
7088 logfile_top_uint (bitmap_min);
7089 logfile_top_uint (bitmap_max);
7090 logfile_top_uint (debug_mode);
7091 logfile_top_uint (force);
7092 logfile_top_uint (kernel_accel);
7093 logfile_top_uint (kernel_loops);
7094 logfile_top_uint (gpu_temp_disable);
7095 #ifdef HAVE_HWMON
7096 logfile_top_uint (gpu_temp_abort);
7097 logfile_top_uint (gpu_temp_retain);
7098 #endif
7099 logfile_top_uint (hash_mode);
7100 logfile_top_uint (hex_charset);
7101 logfile_top_uint (hex_salt);
7102 logfile_top_uint (hex_wordlist);
7103 logfile_top_uint (increment);
7104 logfile_top_uint (increment_max);
7105 logfile_top_uint (increment_min);
7106 logfile_top_uint (keyspace);
7107 logfile_top_uint (left);
7108 logfile_top_uint (logfile_disable);
7109 logfile_top_uint (loopback);
7110 logfile_top_uint (markov_classic);
7111 logfile_top_uint (markov_disable);
7112 logfile_top_uint (markov_threshold);
7113 logfile_top_uint (outfile_autohex);
7114 logfile_top_uint (outfile_check_timer);
7115 logfile_top_uint (outfile_format);
7116 logfile_top_uint (potfile_disable);
7117 logfile_top_string (potfile_path);
7118 #if defined(HAVE_HWMON)
7119 logfile_top_uint (powertune_enable);
7120 #endif
7121 logfile_top_uint (scrypt_tmto);
7122 logfile_top_uint (quiet);
7123 logfile_top_uint (remove);
7124 logfile_top_uint (remove_timer);
7125 logfile_top_uint (restore);
7126 logfile_top_uint (restore_disable);
7127 logfile_top_uint (restore_timer);
7128 logfile_top_uint (rp_gen);
7129 logfile_top_uint (rp_gen_func_max);
7130 logfile_top_uint (rp_gen_func_min);
7131 logfile_top_uint (rp_gen_seed);
7132 logfile_top_uint (runtime);
7133 logfile_top_uint (segment_size);
7134 logfile_top_uint (show);
7135 logfile_top_uint (status);
7136 logfile_top_uint (machine_readable);
7137 logfile_top_uint (status_timer);
7138 logfile_top_uint (usage);
7139 logfile_top_uint (username);
7140 logfile_top_uint (version);
7141 logfile_top_uint (weak_hash_threshold);
7142 logfile_top_uint (workload_profile);
7143 logfile_top_uint64 (limit);
7144 logfile_top_uint64 (skip);
7145 logfile_top_char (separator);
7146 logfile_top_string (cpu_affinity);
7147 logfile_top_string (custom_charset_1);
7148 logfile_top_string (custom_charset_2);
7149 logfile_top_string (custom_charset_3);
7150 logfile_top_string (custom_charset_4);
7151 logfile_top_string (debug_file);
7152 logfile_top_string (opencl_devices);
7153 logfile_top_string (opencl_platforms);
7154 logfile_top_string (opencl_device_types);
7155 logfile_top_uint (opencl_vector_width);
7156 logfile_top_string (induction_dir);
7157 logfile_top_string (markov_hcstat);
7158 logfile_top_string (outfile);
7159 logfile_top_string (outfile_check_dir);
7160 logfile_top_string (rule_buf_l);
7161 logfile_top_string (rule_buf_r);
7162 logfile_top_string (session);
7163 logfile_top_string (truecrypt_keyfiles);
7164 logfile_top_string (veracrypt_keyfiles);
7165 logfile_top_uint (veracrypt_pim);
7166
7167 /**
7168 * Init OpenCL library loader
7169 */
7170
7171 if (keyspace == 0)
7172 {
7173 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7174
7175 ocl_init (ocl);
7176
7177 data.ocl = ocl;
7178 }
7179
7180 /**
7181 * OpenCL platform selection
7182 */
7183
7184 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7185
7186 /**
7187 * OpenCL device selection
7188 */
7189
7190 u32 devices_filter = setup_devices_filter (opencl_devices);
7191
7192 /**
7193 * OpenCL device type selection
7194 */
7195
7196 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7197
7198 /**
7199 * benchmark
7200 */
7201
7202 if (benchmark == 1)
7203 {
7204 /**
7205 * disable useless stuff for benchmark
7206 */
7207
7208 status_timer = 0;
7209 restore_timer = 0;
7210 restore_disable = 1;
7211 potfile_disable = 1;
7212 weak_hash_threshold = 0;
7213 gpu_temp_disable = 1;
7214 outfile_check_timer = 0;
7215
7216 #ifdef HAVE_HWMON
7217 if (powertune_enable == 1)
7218 {
7219 gpu_temp_disable = 0;
7220 }
7221 #endif
7222
7223 data.status_timer = status_timer;
7224 data.restore_timer = restore_timer;
7225 data.restore_disable = restore_disable;
7226 data.outfile_check_timer = outfile_check_timer;
7227
7228 /**
7229 * force attack mode to be bruteforce
7230 */
7231
7232 attack_mode = ATTACK_MODE_BF;
7233 attack_kern = ATTACK_KERN_BF;
7234
7235 if (workload_profile_chgd == 0)
7236 {
7237 workload_profile = 3;
7238
7239 data.workload_profile = workload_profile;
7240 }
7241 }
7242
7243 /**
7244 * config
7245 */
7246
7247 uint hash_type = 0;
7248 uint salt_type = 0;
7249 uint attack_exec = 0;
7250 uint opts_type = 0;
7251 uint kern_type = 0;
7252 uint dgst_size = 0;
7253 uint esalt_size = 0;
7254 uint opti_type = 0;
7255 uint dgst_pos0 = -1;
7256 uint dgst_pos1 = -1;
7257 uint dgst_pos2 = -1;
7258 uint dgst_pos3 = -1;
7259
7260 int (*parse_func) (char *, uint, hash_t *);
7261 int (*sort_by_digest) (const void *, const void *);
7262
7263 uint algorithm_pos = 0;
7264 uint algorithm_max = 1;
7265
7266 uint *algorithms = default_benchmark_algorithms;
7267
7268 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7269
7270 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7271 {
7272 /*
7273 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7274 * the following algos are skipped entirely
7275 */
7276
7277 if (algorithm_pos > 0)
7278 {
7279 local_free (rd);
7280
7281 rd = init_restore (argc, argv);
7282
7283 data.rd = rd;
7284 }
7285
7286 /**
7287 * update hash_mode in case of multihash benchmark
7288 */
7289
7290 if (benchmark == 1)
7291 {
7292 if (hash_mode_chgd == 0)
7293 {
7294 hash_mode = algorithms[algorithm_pos];
7295
7296 data.hash_mode = hash_mode;
7297 }
7298
7299 quiet = 1;
7300
7301 data.quiet = quiet;
7302 }
7303
7304 switch (hash_mode)
7305 {
7306 case 0: hash_type = HASH_TYPE_MD5;
7307 salt_type = SALT_TYPE_NONE;
7308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7309 opts_type = OPTS_TYPE_PT_GENERATE_LE
7310 | OPTS_TYPE_PT_ADD80
7311 | OPTS_TYPE_PT_ADDBITS14;
7312 kern_type = KERN_TYPE_MD5;
7313 dgst_size = DGST_SIZE_4_4;
7314 parse_func = md5_parse_hash;
7315 sort_by_digest = sort_by_digest_4_4;
7316 opti_type = OPTI_TYPE_ZERO_BYTE
7317 | OPTI_TYPE_PRECOMPUTE_INIT
7318 | OPTI_TYPE_PRECOMPUTE_MERKLE
7319 | OPTI_TYPE_MEET_IN_MIDDLE
7320 | OPTI_TYPE_EARLY_SKIP
7321 | OPTI_TYPE_NOT_ITERATED
7322 | OPTI_TYPE_NOT_SALTED
7323 | OPTI_TYPE_RAW_HASH;
7324 dgst_pos0 = 0;
7325 dgst_pos1 = 3;
7326 dgst_pos2 = 2;
7327 dgst_pos3 = 1;
7328 break;
7329
7330 case 10: hash_type = HASH_TYPE_MD5;
7331 salt_type = SALT_TYPE_INTERN;
7332 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7333 opts_type = OPTS_TYPE_PT_GENERATE_LE
7334 | OPTS_TYPE_ST_ADD80
7335 | OPTS_TYPE_ST_ADDBITS14;
7336 kern_type = KERN_TYPE_MD5_PWSLT;
7337 dgst_size = DGST_SIZE_4_4;
7338 parse_func = md5s_parse_hash;
7339 sort_by_digest = sort_by_digest_4_4;
7340 opti_type = OPTI_TYPE_ZERO_BYTE
7341 | OPTI_TYPE_PRECOMPUTE_INIT
7342 | OPTI_TYPE_PRECOMPUTE_MERKLE
7343 | OPTI_TYPE_MEET_IN_MIDDLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_APPENDED_SALT
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 0;
7349 dgst_pos1 = 3;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 11: hash_type = HASH_TYPE_MD5;
7355 salt_type = SALT_TYPE_INTERN;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_LE
7358 | OPTS_TYPE_ST_ADD80
7359 | OPTS_TYPE_ST_ADDBITS14;
7360 kern_type = KERN_TYPE_MD5_PWSLT;
7361 dgst_size = DGST_SIZE_4_4;
7362 parse_func = joomla_parse_hash;
7363 sort_by_digest = sort_by_digest_4_4;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_MEET_IN_MIDDLE
7368 | OPTI_TYPE_EARLY_SKIP
7369 | OPTI_TYPE_NOT_ITERATED
7370 | OPTI_TYPE_APPENDED_SALT
7371 | OPTI_TYPE_RAW_HASH;
7372 dgst_pos0 = 0;
7373 dgst_pos1 = 3;
7374 dgst_pos2 = 2;
7375 dgst_pos3 = 1;
7376 break;
7377
7378 case 12: hash_type = HASH_TYPE_MD5;
7379 salt_type = SALT_TYPE_INTERN;
7380 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7381 opts_type = OPTS_TYPE_PT_GENERATE_LE
7382 | OPTS_TYPE_ST_ADD80
7383 | OPTS_TYPE_ST_ADDBITS14;
7384 kern_type = KERN_TYPE_MD5_PWSLT;
7385 dgst_size = DGST_SIZE_4_4;
7386 parse_func = postgresql_parse_hash;
7387 sort_by_digest = sort_by_digest_4_4;
7388 opti_type = OPTI_TYPE_ZERO_BYTE
7389 | OPTI_TYPE_PRECOMPUTE_INIT
7390 | OPTI_TYPE_PRECOMPUTE_MERKLE
7391 | OPTI_TYPE_MEET_IN_MIDDLE
7392 | OPTI_TYPE_EARLY_SKIP
7393 | OPTI_TYPE_NOT_ITERATED
7394 | OPTI_TYPE_APPENDED_SALT
7395 | OPTI_TYPE_RAW_HASH;
7396 dgst_pos0 = 0;
7397 dgst_pos1 = 3;
7398 dgst_pos2 = 2;
7399 dgst_pos3 = 1;
7400 break;
7401
7402 case 20: hash_type = HASH_TYPE_MD5;
7403 salt_type = SALT_TYPE_INTERN;
7404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7405 opts_type = OPTS_TYPE_PT_GENERATE_LE
7406 | OPTS_TYPE_PT_ADD80
7407 | OPTS_TYPE_PT_ADDBITS14;
7408 kern_type = KERN_TYPE_MD5_SLTPW;
7409 dgst_size = DGST_SIZE_4_4;
7410 parse_func = md5s_parse_hash;
7411 sort_by_digest = sort_by_digest_4_4;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_PREPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 0;
7420 dgst_pos1 = 3;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 21: hash_type = HASH_TYPE_MD5;
7426 salt_type = SALT_TYPE_INTERN;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_LE
7429 | OPTS_TYPE_PT_ADD80
7430 | OPTS_TYPE_PT_ADDBITS14;
7431 kern_type = KERN_TYPE_MD5_SLTPW;
7432 dgst_size = DGST_SIZE_4_4;
7433 parse_func = osc_parse_hash;
7434 sort_by_digest = sort_by_digest_4_4;
7435 opti_type = OPTI_TYPE_ZERO_BYTE
7436 | OPTI_TYPE_PRECOMPUTE_INIT
7437 | OPTI_TYPE_PRECOMPUTE_MERKLE
7438 | OPTI_TYPE_EARLY_SKIP
7439 | OPTI_TYPE_NOT_ITERATED
7440 | OPTI_TYPE_PREPENDED_SALT
7441 | OPTI_TYPE_RAW_HASH;
7442 dgst_pos0 = 0;
7443 dgst_pos1 = 3;
7444 dgst_pos2 = 2;
7445 dgst_pos3 = 1;
7446 break;
7447
7448 case 22: hash_type = HASH_TYPE_MD5;
7449 salt_type = SALT_TYPE_EMBEDDED;
7450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7451 opts_type = OPTS_TYPE_PT_GENERATE_LE
7452 | OPTS_TYPE_PT_ADD80
7453 | OPTS_TYPE_PT_ADDBITS14;
7454 kern_type = KERN_TYPE_MD5_SLTPW;
7455 dgst_size = DGST_SIZE_4_4;
7456 parse_func = netscreen_parse_hash;
7457 sort_by_digest = sort_by_digest_4_4;
7458 opti_type = OPTI_TYPE_ZERO_BYTE
7459 | OPTI_TYPE_PRECOMPUTE_INIT
7460 | OPTI_TYPE_PRECOMPUTE_MERKLE
7461 | OPTI_TYPE_EARLY_SKIP
7462 | OPTI_TYPE_NOT_ITERATED
7463 | OPTI_TYPE_PREPENDED_SALT
7464 | OPTI_TYPE_RAW_HASH;
7465 dgst_pos0 = 0;
7466 dgst_pos1 = 3;
7467 dgst_pos2 = 2;
7468 dgst_pos3 = 1;
7469 break;
7470
7471 case 23: hash_type = HASH_TYPE_MD5;
7472 salt_type = SALT_TYPE_EMBEDDED;
7473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7474 opts_type = OPTS_TYPE_PT_GENERATE_LE
7475 | OPTS_TYPE_PT_ADD80
7476 | OPTS_TYPE_PT_ADDBITS14;
7477 kern_type = KERN_TYPE_MD5_SLTPW;
7478 dgst_size = DGST_SIZE_4_4;
7479 parse_func = skype_parse_hash;
7480 sort_by_digest = sort_by_digest_4_4;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 0;
7489 dgst_pos1 = 3;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 30: hash_type = HASH_TYPE_MD5;
7495 salt_type = SALT_TYPE_INTERN;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_LE
7498 | OPTS_TYPE_PT_UNICODE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_ADDBITS14;
7501 kern_type = KERN_TYPE_MD5_PWUSLT;
7502 dgst_size = DGST_SIZE_4_4;
7503 parse_func = md5s_parse_hash;
7504 sort_by_digest = sort_by_digest_4_4;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_MEET_IN_MIDDLE
7509 | OPTI_TYPE_EARLY_SKIP
7510 | OPTI_TYPE_NOT_ITERATED
7511 | OPTI_TYPE_APPENDED_SALT
7512 | OPTI_TYPE_RAW_HASH;
7513 dgst_pos0 = 0;
7514 dgst_pos1 = 3;
7515 dgst_pos2 = 2;
7516 dgst_pos3 = 1;
7517 break;
7518
7519 case 40: hash_type = HASH_TYPE_MD5;
7520 salt_type = SALT_TYPE_INTERN;
7521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7522 opts_type = OPTS_TYPE_PT_GENERATE_LE
7523 | OPTS_TYPE_PT_ADD80
7524 | OPTS_TYPE_PT_ADDBITS14
7525 | OPTS_TYPE_PT_UNICODE;
7526 kern_type = KERN_TYPE_MD5_SLTPWU;
7527 dgst_size = DGST_SIZE_4_4;
7528 parse_func = md5s_parse_hash;
7529 sort_by_digest = sort_by_digest_4_4;
7530 opti_type = OPTI_TYPE_ZERO_BYTE
7531 | OPTI_TYPE_PRECOMPUTE_INIT
7532 | OPTI_TYPE_PRECOMPUTE_MERKLE
7533 | OPTI_TYPE_EARLY_SKIP
7534 | OPTI_TYPE_NOT_ITERATED
7535 | OPTI_TYPE_PREPENDED_SALT
7536 | OPTI_TYPE_RAW_HASH;
7537 dgst_pos0 = 0;
7538 dgst_pos1 = 3;
7539 dgst_pos2 = 2;
7540 dgst_pos3 = 1;
7541 break;
7542
7543 case 50: hash_type = HASH_TYPE_MD5;
7544 salt_type = SALT_TYPE_INTERN;
7545 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7546 opts_type = OPTS_TYPE_PT_GENERATE_LE
7547 | OPTS_TYPE_ST_ADD80
7548 | OPTS_TYPE_ST_ADDBITS14;
7549 kern_type = KERN_TYPE_HMACMD5_PW;
7550 dgst_size = DGST_SIZE_4_4;
7551 parse_func = hmacmd5_parse_hash;
7552 sort_by_digest = sort_by_digest_4_4;
7553 opti_type = OPTI_TYPE_ZERO_BYTE
7554 | OPTI_TYPE_NOT_ITERATED;
7555 dgst_pos0 = 0;
7556 dgst_pos1 = 3;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 1;
7559 break;
7560
7561 case 60: hash_type = HASH_TYPE_MD5;
7562 salt_type = SALT_TYPE_INTERN;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_LE
7565 | OPTS_TYPE_PT_ADD80
7566 | OPTS_TYPE_PT_ADDBITS14;
7567 kern_type = KERN_TYPE_HMACMD5_SLT;
7568 dgst_size = DGST_SIZE_4_4;
7569 parse_func = hmacmd5_parse_hash;
7570 sort_by_digest = sort_by_digest_4_4;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_NOT_ITERATED;
7573 dgst_pos0 = 0;
7574 dgst_pos1 = 3;
7575 dgst_pos2 = 2;
7576 dgst_pos3 = 1;
7577 break;
7578
7579 case 100: hash_type = HASH_TYPE_SHA1;
7580 salt_type = SALT_TYPE_NONE;
7581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7582 opts_type = OPTS_TYPE_PT_GENERATE_BE
7583 | OPTS_TYPE_PT_ADD80
7584 | OPTS_TYPE_PT_ADDBITS15;
7585 kern_type = KERN_TYPE_SHA1;
7586 dgst_size = DGST_SIZE_4_5;
7587 parse_func = sha1_parse_hash;
7588 sort_by_digest = sort_by_digest_4_5;
7589 opti_type = OPTI_TYPE_ZERO_BYTE
7590 | OPTI_TYPE_PRECOMPUTE_INIT
7591 | OPTI_TYPE_PRECOMPUTE_MERKLE
7592 | OPTI_TYPE_EARLY_SKIP
7593 | OPTI_TYPE_NOT_ITERATED
7594 | OPTI_TYPE_NOT_SALTED
7595 | OPTI_TYPE_RAW_HASH;
7596 dgst_pos0 = 3;
7597 dgst_pos1 = 4;
7598 dgst_pos2 = 2;
7599 dgst_pos3 = 1;
7600 break;
7601
7602 case 101: hash_type = HASH_TYPE_SHA1;
7603 salt_type = SALT_TYPE_NONE;
7604 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7605 opts_type = OPTS_TYPE_PT_GENERATE_BE
7606 | OPTS_TYPE_PT_ADD80
7607 | OPTS_TYPE_PT_ADDBITS15;
7608 kern_type = KERN_TYPE_SHA1;
7609 dgst_size = DGST_SIZE_4_5;
7610 parse_func = sha1b64_parse_hash;
7611 sort_by_digest = sort_by_digest_4_5;
7612 opti_type = OPTI_TYPE_ZERO_BYTE
7613 | OPTI_TYPE_PRECOMPUTE_INIT
7614 | OPTI_TYPE_PRECOMPUTE_MERKLE
7615 | OPTI_TYPE_EARLY_SKIP
7616 | OPTI_TYPE_NOT_ITERATED
7617 | OPTI_TYPE_NOT_SALTED
7618 | OPTI_TYPE_RAW_HASH;
7619 dgst_pos0 = 3;
7620 dgst_pos1 = 4;
7621 dgst_pos2 = 2;
7622 dgst_pos3 = 1;
7623 break;
7624
7625 case 110: hash_type = HASH_TYPE_SHA1;
7626 salt_type = SALT_TYPE_INTERN;
7627 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7628 opts_type = OPTS_TYPE_PT_GENERATE_BE
7629 | OPTS_TYPE_ST_ADD80
7630 | OPTS_TYPE_ST_ADDBITS15;
7631 kern_type = KERN_TYPE_SHA1_PWSLT;
7632 dgst_size = DGST_SIZE_4_5;
7633 parse_func = sha1s_parse_hash;
7634 sort_by_digest = sort_by_digest_4_5;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_PRECOMPUTE_INIT
7637 | OPTI_TYPE_PRECOMPUTE_MERKLE
7638 | OPTI_TYPE_EARLY_SKIP
7639 | OPTI_TYPE_NOT_ITERATED
7640 | OPTI_TYPE_APPENDED_SALT
7641 | OPTI_TYPE_RAW_HASH;
7642 dgst_pos0 = 3;
7643 dgst_pos1 = 4;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 1;
7646 break;
7647
7648 case 111: hash_type = HASH_TYPE_SHA1;
7649 salt_type = SALT_TYPE_EMBEDDED;
7650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_BE
7652 | OPTS_TYPE_ST_ADD80
7653 | OPTS_TYPE_ST_ADDBITS15;
7654 kern_type = KERN_TYPE_SHA1_PWSLT;
7655 dgst_size = DGST_SIZE_4_5;
7656 parse_func = sha1b64s_parse_hash;
7657 sort_by_digest = sort_by_digest_4_5;
7658 opti_type = OPTI_TYPE_ZERO_BYTE
7659 | OPTI_TYPE_PRECOMPUTE_INIT
7660 | OPTI_TYPE_PRECOMPUTE_MERKLE
7661 | OPTI_TYPE_EARLY_SKIP
7662 | OPTI_TYPE_NOT_ITERATED
7663 | OPTI_TYPE_APPENDED_SALT
7664 | OPTI_TYPE_RAW_HASH;
7665 dgst_pos0 = 3;
7666 dgst_pos1 = 4;
7667 dgst_pos2 = 2;
7668 dgst_pos3 = 1;
7669 break;
7670
7671 case 112: hash_type = HASH_TYPE_SHA1;
7672 salt_type = SALT_TYPE_INTERN;
7673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7674 opts_type = OPTS_TYPE_PT_GENERATE_BE
7675 | OPTS_TYPE_ST_ADD80
7676 | OPTS_TYPE_ST_ADDBITS15
7677 | OPTS_TYPE_ST_HEX;
7678 kern_type = KERN_TYPE_SHA1_PWSLT;
7679 dgst_size = DGST_SIZE_4_5;
7680 parse_func = oracles_parse_hash;
7681 sort_by_digest = sort_by_digest_4_5;
7682 opti_type = OPTI_TYPE_ZERO_BYTE
7683 | OPTI_TYPE_PRECOMPUTE_INIT
7684 | OPTI_TYPE_PRECOMPUTE_MERKLE
7685 | OPTI_TYPE_EARLY_SKIP
7686 | OPTI_TYPE_NOT_ITERATED
7687 | OPTI_TYPE_APPENDED_SALT
7688 | OPTI_TYPE_RAW_HASH;
7689 dgst_pos0 = 3;
7690 dgst_pos1 = 4;
7691 dgst_pos2 = 2;
7692 dgst_pos3 = 1;
7693 break;
7694
7695 case 120: 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_SHA1_SLTPW;
7702 dgst_size = DGST_SIZE_4_5;
7703 parse_func = sha1s_parse_hash;
7704 sort_by_digest = sort_by_digest_4_5;
7705 opti_type = OPTI_TYPE_ZERO_BYTE
7706 | OPTI_TYPE_PRECOMPUTE_INIT
7707 | OPTI_TYPE_PRECOMPUTE_MERKLE
7708 | OPTI_TYPE_EARLY_SKIP
7709 | OPTI_TYPE_NOT_ITERATED
7710 | OPTI_TYPE_PREPENDED_SALT
7711 | OPTI_TYPE_RAW_HASH;
7712 dgst_pos0 = 3;
7713 dgst_pos1 = 4;
7714 dgst_pos2 = 2;
7715 dgst_pos3 = 1;
7716 break;
7717
7718 case 121: hash_type = HASH_TYPE_SHA1;
7719 salt_type = SALT_TYPE_INTERN;
7720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7721 opts_type = OPTS_TYPE_PT_GENERATE_BE
7722 | OPTS_TYPE_PT_ADD80
7723 | OPTS_TYPE_PT_ADDBITS15
7724 | OPTS_TYPE_ST_LOWER;
7725 kern_type = KERN_TYPE_SHA1_SLTPW;
7726 dgst_size = DGST_SIZE_4_5;
7727 parse_func = smf_parse_hash;
7728 sort_by_digest = sort_by_digest_4_5;
7729 opti_type = OPTI_TYPE_ZERO_BYTE
7730 | OPTI_TYPE_PRECOMPUTE_INIT
7731 | OPTI_TYPE_PRECOMPUTE_MERKLE
7732 | OPTI_TYPE_EARLY_SKIP
7733 | OPTI_TYPE_NOT_ITERATED
7734 | OPTI_TYPE_PREPENDED_SALT
7735 | OPTI_TYPE_RAW_HASH;
7736 dgst_pos0 = 3;
7737 dgst_pos1 = 4;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 122: hash_type = HASH_TYPE_SHA1;
7743 salt_type = SALT_TYPE_EMBEDDED;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15
7748 | OPTS_TYPE_ST_HEX;
7749 kern_type = KERN_TYPE_SHA1_SLTPW;
7750 dgst_size = DGST_SIZE_4_5;
7751 parse_func = osx1_parse_hash;
7752 sort_by_digest = sort_by_digest_4_5;
7753 opti_type = OPTI_TYPE_ZERO_BYTE
7754 | OPTI_TYPE_PRECOMPUTE_INIT
7755 | OPTI_TYPE_PRECOMPUTE_MERKLE
7756 | OPTI_TYPE_EARLY_SKIP
7757 | OPTI_TYPE_NOT_ITERATED
7758 | OPTI_TYPE_PREPENDED_SALT
7759 | OPTI_TYPE_RAW_HASH;
7760 dgst_pos0 = 3;
7761 dgst_pos1 = 4;
7762 dgst_pos2 = 2;
7763 dgst_pos3 = 1;
7764 break;
7765
7766 case 124: hash_type = HASH_TYPE_SHA1;
7767 salt_type = SALT_TYPE_EMBEDDED;
7768 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7769 opts_type = OPTS_TYPE_PT_GENERATE_BE
7770 | OPTS_TYPE_PT_ADD80
7771 | OPTS_TYPE_PT_ADDBITS15;
7772 kern_type = KERN_TYPE_SHA1_SLTPW;
7773 dgst_size = DGST_SIZE_4_5;
7774 parse_func = djangosha1_parse_hash;
7775 sort_by_digest = sort_by_digest_4_5;
7776 opti_type = OPTI_TYPE_ZERO_BYTE
7777 | OPTI_TYPE_PRECOMPUTE_INIT
7778 | OPTI_TYPE_PRECOMPUTE_MERKLE
7779 | OPTI_TYPE_EARLY_SKIP
7780 | OPTI_TYPE_NOT_ITERATED
7781 | OPTI_TYPE_PREPENDED_SALT
7782 | OPTI_TYPE_RAW_HASH;
7783 dgst_pos0 = 3;
7784 dgst_pos1 = 4;
7785 dgst_pos2 = 2;
7786 dgst_pos3 = 1;
7787 break;
7788
7789 case 125: hash_type = HASH_TYPE_SHA1;
7790 salt_type = SALT_TYPE_EMBEDDED;
7791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7792 opts_type = OPTS_TYPE_PT_GENERATE_BE
7793 | OPTS_TYPE_PT_ADD80
7794 | OPTS_TYPE_PT_ADDBITS15
7795 | OPTS_TYPE_ST_HEX;
7796 kern_type = KERN_TYPE_SHA1_SLTPW;
7797 dgst_size = DGST_SIZE_4_5;
7798 parse_func = arubaos_parse_hash;
7799 sort_by_digest = sort_by_digest_4_5;
7800 opti_type = OPTI_TYPE_ZERO_BYTE
7801 | OPTI_TYPE_PRECOMPUTE_INIT
7802 | OPTI_TYPE_PRECOMPUTE_MERKLE
7803 | OPTI_TYPE_EARLY_SKIP
7804 | OPTI_TYPE_NOT_ITERATED
7805 | OPTI_TYPE_PREPENDED_SALT
7806 | OPTI_TYPE_RAW_HASH;
7807 dgst_pos0 = 3;
7808 dgst_pos1 = 4;
7809 dgst_pos2 = 2;
7810 dgst_pos3 = 1;
7811 break;
7812
7813 case 130: hash_type = HASH_TYPE_SHA1;
7814 salt_type = SALT_TYPE_INTERN;
7815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7816 opts_type = OPTS_TYPE_PT_GENERATE_BE
7817 | OPTS_TYPE_PT_UNICODE
7818 | OPTS_TYPE_ST_ADD80
7819 | OPTS_TYPE_ST_ADDBITS15;
7820 kern_type = KERN_TYPE_SHA1_PWUSLT;
7821 dgst_size = DGST_SIZE_4_5;
7822 parse_func = sha1s_parse_hash;
7823 sort_by_digest = sort_by_digest_4_5;
7824 opti_type = OPTI_TYPE_ZERO_BYTE
7825 | OPTI_TYPE_PRECOMPUTE_INIT
7826 | OPTI_TYPE_PRECOMPUTE_MERKLE
7827 | OPTI_TYPE_EARLY_SKIP
7828 | OPTI_TYPE_NOT_ITERATED
7829 | OPTI_TYPE_APPENDED_SALT
7830 | OPTI_TYPE_RAW_HASH;
7831 dgst_pos0 = 3;
7832 dgst_pos1 = 4;
7833 dgst_pos2 = 2;
7834 dgst_pos3 = 1;
7835 break;
7836
7837 case 131: hash_type = HASH_TYPE_SHA1;
7838 salt_type = SALT_TYPE_EMBEDDED;
7839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7840 opts_type = OPTS_TYPE_PT_GENERATE_BE
7841 | OPTS_TYPE_PT_UNICODE
7842 | OPTS_TYPE_PT_UPPER
7843 | OPTS_TYPE_ST_ADD80
7844 | OPTS_TYPE_ST_ADDBITS15
7845 | OPTS_TYPE_ST_HEX;
7846 kern_type = KERN_TYPE_SHA1_PWUSLT;
7847 dgst_size = DGST_SIZE_4_5;
7848 parse_func = mssql2000_parse_hash;
7849 sort_by_digest = sort_by_digest_4_5;
7850 opti_type = OPTI_TYPE_ZERO_BYTE
7851 | OPTI_TYPE_PRECOMPUTE_INIT
7852 | OPTI_TYPE_PRECOMPUTE_MERKLE
7853 | OPTI_TYPE_EARLY_SKIP
7854 | OPTI_TYPE_NOT_ITERATED
7855 | OPTI_TYPE_APPENDED_SALT
7856 | OPTI_TYPE_RAW_HASH;
7857 dgst_pos0 = 3;
7858 dgst_pos1 = 4;
7859 dgst_pos2 = 2;
7860 dgst_pos3 = 1;
7861 break;
7862
7863 case 132: hash_type = HASH_TYPE_SHA1;
7864 salt_type = SALT_TYPE_EMBEDDED;
7865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7866 opts_type = OPTS_TYPE_PT_GENERATE_BE
7867 | OPTS_TYPE_PT_UNICODE
7868 | OPTS_TYPE_ST_ADD80
7869 | OPTS_TYPE_ST_ADDBITS15
7870 | OPTS_TYPE_ST_HEX;
7871 kern_type = KERN_TYPE_SHA1_PWUSLT;
7872 dgst_size = DGST_SIZE_4_5;
7873 parse_func = mssql2005_parse_hash;
7874 sort_by_digest = sort_by_digest_4_5;
7875 opti_type = OPTI_TYPE_ZERO_BYTE
7876 | OPTI_TYPE_PRECOMPUTE_INIT
7877 | OPTI_TYPE_PRECOMPUTE_MERKLE
7878 | OPTI_TYPE_EARLY_SKIP
7879 | OPTI_TYPE_NOT_ITERATED
7880 | OPTI_TYPE_APPENDED_SALT
7881 | OPTI_TYPE_RAW_HASH;
7882 dgst_pos0 = 3;
7883 dgst_pos1 = 4;
7884 dgst_pos2 = 2;
7885 dgst_pos3 = 1;
7886 break;
7887
7888 case 133: hash_type = HASH_TYPE_SHA1;
7889 salt_type = SALT_TYPE_EMBEDDED;
7890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7891 opts_type = OPTS_TYPE_PT_GENERATE_BE
7892 | OPTS_TYPE_PT_UNICODE
7893 | OPTS_TYPE_ST_ADD80
7894 | OPTS_TYPE_ST_ADDBITS15;
7895 kern_type = KERN_TYPE_SHA1_PWUSLT;
7896 dgst_size = DGST_SIZE_4_5;
7897 parse_func = peoplesoft_parse_hash;
7898 sort_by_digest = sort_by_digest_4_5;
7899 opti_type = OPTI_TYPE_ZERO_BYTE
7900 | OPTI_TYPE_PRECOMPUTE_INIT
7901 | OPTI_TYPE_PRECOMPUTE_MERKLE
7902 | OPTI_TYPE_EARLY_SKIP
7903 | OPTI_TYPE_NOT_ITERATED
7904 | OPTI_TYPE_APPENDED_SALT
7905 | OPTI_TYPE_RAW_HASH;
7906 dgst_pos0 = 3;
7907 dgst_pos1 = 4;
7908 dgst_pos2 = 2;
7909 dgst_pos3 = 1;
7910 break;
7911
7912 case 140: hash_type = HASH_TYPE_SHA1;
7913 salt_type = SALT_TYPE_INTERN;
7914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7915 opts_type = OPTS_TYPE_PT_GENERATE_BE
7916 | OPTS_TYPE_PT_ADD80
7917 | OPTS_TYPE_PT_ADDBITS15
7918 | OPTS_TYPE_PT_UNICODE;
7919 kern_type = KERN_TYPE_SHA1_SLTPWU;
7920 dgst_size = DGST_SIZE_4_5;
7921 parse_func = sha1s_parse_hash;
7922 sort_by_digest = sort_by_digest_4_5;
7923 opti_type = OPTI_TYPE_ZERO_BYTE
7924 | OPTI_TYPE_PRECOMPUTE_INIT
7925 | OPTI_TYPE_PRECOMPUTE_MERKLE
7926 | OPTI_TYPE_EARLY_SKIP
7927 | OPTI_TYPE_NOT_ITERATED
7928 | OPTI_TYPE_PREPENDED_SALT
7929 | OPTI_TYPE_RAW_HASH;
7930 dgst_pos0 = 3;
7931 dgst_pos1 = 4;
7932 dgst_pos2 = 2;
7933 dgst_pos3 = 1;
7934 break;
7935
7936 case 141: hash_type = HASH_TYPE_SHA1;
7937 salt_type = SALT_TYPE_EMBEDDED;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_ADD80
7941 | OPTS_TYPE_PT_ADDBITS15
7942 | OPTS_TYPE_PT_UNICODE
7943 | OPTS_TYPE_ST_BASE64;
7944 kern_type = KERN_TYPE_SHA1_SLTPWU;
7945 dgst_size = DGST_SIZE_4_5;
7946 parse_func = episerver_parse_hash;
7947 sort_by_digest = sort_by_digest_4_5;
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 = 4;
7957 dgst_pos2 = 2;
7958 dgst_pos3 = 1;
7959 break;
7960
7961 case 150: hash_type = HASH_TYPE_SHA1;
7962 salt_type = SALT_TYPE_INTERN;
7963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7964 opts_type = OPTS_TYPE_PT_GENERATE_BE
7965 | OPTS_TYPE_ST_ADD80
7966 | OPTS_TYPE_ST_ADDBITS15;
7967 kern_type = KERN_TYPE_HMACSHA1_PW;
7968 dgst_size = DGST_SIZE_4_5;
7969 parse_func = hmacsha1_parse_hash;
7970 sort_by_digest = sort_by_digest_4_5;
7971 opti_type = OPTI_TYPE_ZERO_BYTE
7972 | OPTI_TYPE_NOT_ITERATED;
7973 dgst_pos0 = 3;
7974 dgst_pos1 = 4;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 1;
7977 break;
7978
7979 case 160: hash_type = HASH_TYPE_SHA1;
7980 salt_type = SALT_TYPE_INTERN;
7981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982 opts_type = OPTS_TYPE_PT_GENERATE_BE
7983 | OPTS_TYPE_PT_ADD80
7984 | OPTS_TYPE_PT_ADDBITS15;
7985 kern_type = KERN_TYPE_HMACSHA1_SLT;
7986 dgst_size = DGST_SIZE_4_5;
7987 parse_func = hmacsha1_parse_hash;
7988 sort_by_digest = sort_by_digest_4_5;
7989 opti_type = OPTI_TYPE_ZERO_BYTE
7990 | OPTI_TYPE_NOT_ITERATED;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 4;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 1;
7995 break;
7996
7997 case 190: hash_type = HASH_TYPE_SHA1;
7998 salt_type = SALT_TYPE_NONE;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8004 dgst_size = DGST_SIZE_4_5;
8005 parse_func = sha1linkedin_parse_hash;
8006 sort_by_digest = sort_by_digest_4_5;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_EARLY_SKIP
8010 | OPTI_TYPE_NOT_ITERATED
8011 | OPTI_TYPE_NOT_SALTED;
8012 dgst_pos0 = 0;
8013 dgst_pos1 = 4;
8014 dgst_pos2 = 3;
8015 dgst_pos3 = 2;
8016 break;
8017
8018 case 200: hash_type = HASH_TYPE_MYSQL;
8019 salt_type = SALT_TYPE_NONE;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = 0;
8022 kern_type = KERN_TYPE_MYSQL;
8023 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8024 parse_func = mysql323_parse_hash;
8025 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8026 opti_type = OPTI_TYPE_ZERO_BYTE;
8027 dgst_pos0 = 0;
8028 dgst_pos1 = 1;
8029 dgst_pos2 = 2;
8030 dgst_pos3 = 3;
8031 break;
8032
8033 case 300: hash_type = HASH_TYPE_SHA1;
8034 salt_type = SALT_TYPE_NONE;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_PT_ADD80
8038 | OPTS_TYPE_PT_ADDBITS15;
8039 kern_type = KERN_TYPE_MYSQL41;
8040 dgst_size = DGST_SIZE_4_5;
8041 parse_func = sha1_parse_hash;
8042 sort_by_digest = sort_by_digest_4_5;
8043 opti_type = OPTI_TYPE_ZERO_BYTE
8044 | OPTI_TYPE_PRECOMPUTE_INIT
8045 | OPTI_TYPE_PRECOMPUTE_MERKLE
8046 | OPTI_TYPE_EARLY_SKIP
8047 | OPTI_TYPE_NOT_ITERATED
8048 | OPTI_TYPE_NOT_SALTED;
8049 dgst_pos0 = 3;
8050 dgst_pos1 = 4;
8051 dgst_pos2 = 2;
8052 dgst_pos3 = 1;
8053 break;
8054
8055 case 400: hash_type = HASH_TYPE_MD5;
8056 salt_type = SALT_TYPE_EMBEDDED;
8057 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8058 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8059 kern_type = KERN_TYPE_PHPASS;
8060 dgst_size = DGST_SIZE_4_4;
8061 parse_func = phpass_parse_hash;
8062 sort_by_digest = sort_by_digest_4_4;
8063 opti_type = OPTI_TYPE_ZERO_BYTE
8064 | OPTI_TYPE_SLOW_HASH_SIMD;
8065 dgst_pos0 = 0;
8066 dgst_pos1 = 1;
8067 dgst_pos2 = 2;
8068 dgst_pos3 = 3;
8069 break;
8070
8071 case 500: hash_type = HASH_TYPE_MD5;
8072 salt_type = SALT_TYPE_EMBEDDED;
8073 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8074 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8075 kern_type = KERN_TYPE_MD5CRYPT;
8076 dgst_size = DGST_SIZE_4_4;
8077 parse_func = md5crypt_parse_hash;
8078 sort_by_digest = sort_by_digest_4_4;
8079 opti_type = OPTI_TYPE_ZERO_BYTE;
8080 dgst_pos0 = 0;
8081 dgst_pos1 = 1;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 3;
8084 break;
8085
8086 case 501: hash_type = HASH_TYPE_MD5;
8087 salt_type = SALT_TYPE_EMBEDDED;
8088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_LE
8090 | OPTS_TYPE_HASH_COPY;
8091 kern_type = KERN_TYPE_MD5CRYPT;
8092 dgst_size = DGST_SIZE_4_4;
8093 parse_func = juniper_parse_hash;
8094 sort_by_digest = sort_by_digest_4_4;
8095 opti_type = OPTI_TYPE_ZERO_BYTE;
8096 dgst_pos0 = 0;
8097 dgst_pos1 = 1;
8098 dgst_pos2 = 2;
8099 dgst_pos3 = 3;
8100 break;
8101
8102 case 900: hash_type = HASH_TYPE_MD4;
8103 salt_type = SALT_TYPE_NONE;
8104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8105 opts_type = OPTS_TYPE_PT_GENERATE_LE
8106 | OPTS_TYPE_PT_ADD80
8107 | OPTS_TYPE_PT_ADDBITS14;
8108 kern_type = KERN_TYPE_MD4;
8109 dgst_size = DGST_SIZE_4_4;
8110 parse_func = md4_parse_hash;
8111 sort_by_digest = sort_by_digest_4_4;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_INIT
8114 | OPTI_TYPE_PRECOMPUTE_MERKLE
8115 | OPTI_TYPE_MEET_IN_MIDDLE
8116 | OPTI_TYPE_EARLY_SKIP
8117 | OPTI_TYPE_NOT_ITERATED
8118 | OPTI_TYPE_NOT_SALTED
8119 | OPTI_TYPE_RAW_HASH;
8120 dgst_pos0 = 0;
8121 dgst_pos1 = 3;
8122 dgst_pos2 = 2;
8123 dgst_pos3 = 1;
8124 break;
8125
8126 case 1000: hash_type = HASH_TYPE_MD4;
8127 salt_type = SALT_TYPE_NONE;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_LE
8130 | OPTS_TYPE_PT_ADD80
8131 | OPTS_TYPE_PT_ADDBITS14
8132 | OPTS_TYPE_PT_UNICODE;
8133 kern_type = KERN_TYPE_MD4_PWU;
8134 dgst_size = DGST_SIZE_4_4;
8135 parse_func = md4_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4;
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_INIT
8139 | OPTI_TYPE_PRECOMPUTE_MERKLE
8140 | OPTI_TYPE_MEET_IN_MIDDLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_ITERATED
8143 | OPTI_TYPE_NOT_SALTED
8144 | OPTI_TYPE_RAW_HASH;
8145 dgst_pos0 = 0;
8146 dgst_pos1 = 3;
8147 dgst_pos2 = 2;
8148 dgst_pos3 = 1;
8149 break;
8150
8151 case 1100: hash_type = HASH_TYPE_MD4;
8152 salt_type = SALT_TYPE_INTERN;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_LE
8155 | OPTS_TYPE_PT_ADD80
8156 | OPTS_TYPE_PT_ADDBITS14
8157 | OPTS_TYPE_PT_UNICODE
8158 | OPTS_TYPE_ST_ADD80
8159 | OPTS_TYPE_ST_UNICODE
8160 | OPTS_TYPE_ST_LOWER;
8161 kern_type = KERN_TYPE_MD44_PWUSLT;
8162 dgst_size = DGST_SIZE_4_4;
8163 parse_func = dcc_parse_hash;
8164 sort_by_digest = sort_by_digest_4_4;
8165 opti_type = OPTI_TYPE_ZERO_BYTE
8166 | OPTI_TYPE_PRECOMPUTE_INIT
8167 | OPTI_TYPE_PRECOMPUTE_MERKLE
8168 | OPTI_TYPE_EARLY_SKIP
8169 | OPTI_TYPE_NOT_ITERATED;
8170 dgst_pos0 = 0;
8171 dgst_pos1 = 3;
8172 dgst_pos2 = 2;
8173 dgst_pos3 = 1;
8174 break;
8175
8176 case 1400: hash_type = HASH_TYPE_SHA256;
8177 salt_type = SALT_TYPE_NONE;
8178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_BE
8180 | OPTS_TYPE_PT_ADD80
8181 | OPTS_TYPE_PT_ADDBITS15;
8182 kern_type = KERN_TYPE_SHA256;
8183 dgst_size = DGST_SIZE_4_8;
8184 parse_func = sha256_parse_hash;
8185 sort_by_digest = sort_by_digest_4_8;
8186 opti_type = OPTI_TYPE_ZERO_BYTE
8187 | OPTI_TYPE_PRECOMPUTE_INIT
8188 | OPTI_TYPE_PRECOMPUTE_MERKLE
8189 | OPTI_TYPE_EARLY_SKIP
8190 | OPTI_TYPE_NOT_ITERATED
8191 | OPTI_TYPE_NOT_SALTED
8192 | OPTI_TYPE_RAW_HASH;
8193 dgst_pos0 = 3;
8194 dgst_pos1 = 7;
8195 dgst_pos2 = 2;
8196 dgst_pos3 = 6;
8197 break;
8198
8199 case 1410: hash_type = HASH_TYPE_SHA256;
8200 salt_type = SALT_TYPE_INTERN;
8201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8202 opts_type = OPTS_TYPE_PT_GENERATE_BE
8203 | OPTS_TYPE_ST_ADD80
8204 | OPTS_TYPE_ST_ADDBITS15;
8205 kern_type = KERN_TYPE_SHA256_PWSLT;
8206 dgst_size = DGST_SIZE_4_8;
8207 parse_func = sha256s_parse_hash;
8208 sort_by_digest = sort_by_digest_4_8;
8209 opti_type = OPTI_TYPE_ZERO_BYTE
8210 | OPTI_TYPE_PRECOMPUTE_INIT
8211 | OPTI_TYPE_PRECOMPUTE_MERKLE
8212 | OPTI_TYPE_EARLY_SKIP
8213 | OPTI_TYPE_NOT_ITERATED
8214 | OPTI_TYPE_APPENDED_SALT
8215 | OPTI_TYPE_RAW_HASH;
8216 dgst_pos0 = 3;
8217 dgst_pos1 = 7;
8218 dgst_pos2 = 2;
8219 dgst_pos3 = 6;
8220 break;
8221
8222 case 1420: hash_type = HASH_TYPE_SHA256;
8223 salt_type = SALT_TYPE_INTERN;
8224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8225 opts_type = OPTS_TYPE_PT_GENERATE_BE
8226 | OPTS_TYPE_PT_ADD80
8227 | OPTS_TYPE_PT_ADDBITS15;
8228 kern_type = KERN_TYPE_SHA256_SLTPW;
8229 dgst_size = DGST_SIZE_4_8;
8230 parse_func = sha256s_parse_hash;
8231 sort_by_digest = sort_by_digest_4_8;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_INIT
8234 | OPTI_TYPE_PRECOMPUTE_MERKLE
8235 | OPTI_TYPE_EARLY_SKIP
8236 | OPTI_TYPE_NOT_ITERATED
8237 | OPTI_TYPE_PREPENDED_SALT
8238 | OPTI_TYPE_RAW_HASH;
8239 dgst_pos0 = 3;
8240 dgst_pos1 = 7;
8241 dgst_pos2 = 2;
8242 dgst_pos3 = 6;
8243 break;
8244
8245 case 1421: hash_type = HASH_TYPE_SHA256;
8246 salt_type = SALT_TYPE_EMBEDDED;
8247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8248 opts_type = OPTS_TYPE_PT_GENERATE_BE
8249 | OPTS_TYPE_PT_ADD80
8250 | OPTS_TYPE_PT_ADDBITS15;
8251 kern_type = KERN_TYPE_SHA256_SLTPW;
8252 dgst_size = DGST_SIZE_4_8;
8253 parse_func = hmailserver_parse_hash;
8254 sort_by_digest = sort_by_digest_4_8;
8255 opti_type = OPTI_TYPE_ZERO_BYTE
8256 | OPTI_TYPE_PRECOMPUTE_INIT
8257 | OPTI_TYPE_PRECOMPUTE_MERKLE
8258 | OPTI_TYPE_EARLY_SKIP
8259 | OPTI_TYPE_NOT_ITERATED
8260 | OPTI_TYPE_PREPENDED_SALT
8261 | OPTI_TYPE_RAW_HASH;
8262 dgst_pos0 = 3;
8263 dgst_pos1 = 7;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 6;
8266 break;
8267
8268 case 1430: hash_type = HASH_TYPE_SHA256;
8269 salt_type = SALT_TYPE_INTERN;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_BE
8272 | OPTS_TYPE_PT_UNICODE
8273 | OPTS_TYPE_ST_ADD80
8274 | OPTS_TYPE_ST_ADDBITS15;
8275 kern_type = KERN_TYPE_SHA256_PWUSLT;
8276 dgst_size = DGST_SIZE_4_8;
8277 parse_func = sha256s_parse_hash;
8278 sort_by_digest = sort_by_digest_4_8;
8279 opti_type = OPTI_TYPE_ZERO_BYTE
8280 | OPTI_TYPE_PRECOMPUTE_INIT
8281 | OPTI_TYPE_PRECOMPUTE_MERKLE
8282 | OPTI_TYPE_EARLY_SKIP
8283 | OPTI_TYPE_NOT_ITERATED
8284 | OPTI_TYPE_APPENDED_SALT
8285 | OPTI_TYPE_RAW_HASH;
8286 dgst_pos0 = 3;
8287 dgst_pos1 = 7;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 6;
8290 break;
8291
8292 case 1440: hash_type = HASH_TYPE_SHA256;
8293 salt_type = SALT_TYPE_INTERN;
8294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_BE
8296 | OPTS_TYPE_PT_ADD80
8297 | OPTS_TYPE_PT_ADDBITS15
8298 | OPTS_TYPE_PT_UNICODE;
8299 kern_type = KERN_TYPE_SHA256_SLTPWU;
8300 dgst_size = DGST_SIZE_4_8;
8301 parse_func = sha256s_parse_hash;
8302 sort_by_digest = sort_by_digest_4_8;
8303 opti_type = OPTI_TYPE_ZERO_BYTE
8304 | OPTI_TYPE_PRECOMPUTE_INIT
8305 | OPTI_TYPE_PRECOMPUTE_MERKLE
8306 | OPTI_TYPE_EARLY_SKIP
8307 | OPTI_TYPE_NOT_ITERATED
8308 | OPTI_TYPE_PREPENDED_SALT
8309 | OPTI_TYPE_RAW_HASH;
8310 dgst_pos0 = 3;
8311 dgst_pos1 = 7;
8312 dgst_pos2 = 2;
8313 dgst_pos3 = 6;
8314 break;
8315
8316 case 1441: hash_type = HASH_TYPE_SHA256;
8317 salt_type = SALT_TYPE_EMBEDDED;
8318 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8319 opts_type = OPTS_TYPE_PT_GENERATE_BE
8320 | OPTS_TYPE_PT_ADD80
8321 | OPTS_TYPE_PT_ADDBITS15
8322 | OPTS_TYPE_PT_UNICODE
8323 | OPTS_TYPE_ST_BASE64;
8324 kern_type = KERN_TYPE_SHA256_SLTPWU;
8325 dgst_size = DGST_SIZE_4_8;
8326 parse_func = episerver4_parse_hash;
8327 sort_by_digest = sort_by_digest_4_8;
8328 opti_type = OPTI_TYPE_ZERO_BYTE
8329 | OPTI_TYPE_PRECOMPUTE_INIT
8330 | OPTI_TYPE_PRECOMPUTE_MERKLE
8331 | OPTI_TYPE_EARLY_SKIP
8332 | OPTI_TYPE_NOT_ITERATED
8333 | OPTI_TYPE_PREPENDED_SALT
8334 | OPTI_TYPE_RAW_HASH;
8335 dgst_pos0 = 3;
8336 dgst_pos1 = 7;
8337 dgst_pos2 = 2;
8338 dgst_pos3 = 6;
8339 break;
8340
8341 case 1450: hash_type = HASH_TYPE_SHA256;
8342 salt_type = SALT_TYPE_INTERN;
8343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8344 opts_type = OPTS_TYPE_PT_GENERATE_BE
8345 | OPTS_TYPE_ST_ADD80;
8346 kern_type = KERN_TYPE_HMACSHA256_PW;
8347 dgst_size = DGST_SIZE_4_8;
8348 parse_func = hmacsha256_parse_hash;
8349 sort_by_digest = sort_by_digest_4_8;
8350 opti_type = OPTI_TYPE_ZERO_BYTE
8351 | OPTI_TYPE_NOT_ITERATED;
8352 dgst_pos0 = 3;
8353 dgst_pos1 = 7;
8354 dgst_pos2 = 2;
8355 dgst_pos3 = 6;
8356 break;
8357
8358 case 1460: hash_type = HASH_TYPE_SHA256;
8359 salt_type = SALT_TYPE_INTERN;
8360 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8361 opts_type = OPTS_TYPE_PT_GENERATE_BE
8362 | OPTS_TYPE_PT_ADD80
8363 | OPTS_TYPE_PT_ADDBITS15;
8364 kern_type = KERN_TYPE_HMACSHA256_SLT;
8365 dgst_size = DGST_SIZE_4_8;
8366 parse_func = hmacsha256_parse_hash;
8367 sort_by_digest = sort_by_digest_4_8;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_NOT_ITERATED;
8370 dgst_pos0 = 3;
8371 dgst_pos1 = 7;
8372 dgst_pos2 = 2;
8373 dgst_pos3 = 6;
8374 break;
8375
8376 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8377 salt_type = SALT_TYPE_EMBEDDED;
8378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8379 opts_type = OPTS_TYPE_PT_GENERATE_LE
8380 | OPTS_TYPE_PT_BITSLICE;
8381 kern_type = KERN_TYPE_DESCRYPT;
8382 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8383 parse_func = descrypt_parse_hash;
8384 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8387 dgst_pos0 = 0;
8388 dgst_pos1 = 1;
8389 dgst_pos2 = 2;
8390 dgst_pos3 = 3;
8391 break;
8392
8393 case 1600: hash_type = HASH_TYPE_MD5;
8394 salt_type = SALT_TYPE_EMBEDDED;
8395 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8396 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8397 kern_type = KERN_TYPE_APR1CRYPT;
8398 dgst_size = DGST_SIZE_4_4;
8399 parse_func = md5apr1_parse_hash;
8400 sort_by_digest = sort_by_digest_4_4;
8401 opti_type = OPTI_TYPE_ZERO_BYTE;
8402 dgst_pos0 = 0;
8403 dgst_pos1 = 1;
8404 dgst_pos2 = 2;
8405 dgst_pos3 = 3;
8406 break;
8407
8408 case 1700: hash_type = HASH_TYPE_SHA512;
8409 salt_type = SALT_TYPE_NONE;
8410 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8411 opts_type = OPTS_TYPE_PT_GENERATE_BE
8412 | OPTS_TYPE_PT_ADD80
8413 | OPTS_TYPE_PT_ADDBITS15;
8414 kern_type = KERN_TYPE_SHA512;
8415 dgst_size = DGST_SIZE_8_8;
8416 parse_func = sha512_parse_hash;
8417 sort_by_digest = sort_by_digest_8_8;
8418 opti_type = OPTI_TYPE_ZERO_BYTE
8419 | OPTI_TYPE_PRECOMPUTE_INIT
8420 | OPTI_TYPE_PRECOMPUTE_MERKLE
8421 | OPTI_TYPE_EARLY_SKIP
8422 | OPTI_TYPE_NOT_ITERATED
8423 | OPTI_TYPE_NOT_SALTED
8424 | OPTI_TYPE_USES_BITS_64
8425 | OPTI_TYPE_RAW_HASH;
8426 dgst_pos0 = 14;
8427 dgst_pos1 = 15;
8428 dgst_pos2 = 6;
8429 dgst_pos3 = 7;
8430 break;
8431
8432 case 1710: hash_type = HASH_TYPE_SHA512;
8433 salt_type = SALT_TYPE_INTERN;
8434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8435 opts_type = OPTS_TYPE_PT_GENERATE_BE
8436 | OPTS_TYPE_ST_ADD80
8437 | OPTS_TYPE_ST_ADDBITS15;
8438 kern_type = KERN_TYPE_SHA512_PWSLT;
8439 dgst_size = DGST_SIZE_8_8;
8440 parse_func = sha512s_parse_hash;
8441 sort_by_digest = sort_by_digest_8_8;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_PRECOMPUTE_INIT
8444 | OPTI_TYPE_PRECOMPUTE_MERKLE
8445 | OPTI_TYPE_EARLY_SKIP
8446 | OPTI_TYPE_NOT_ITERATED
8447 | OPTI_TYPE_APPENDED_SALT
8448 | OPTI_TYPE_USES_BITS_64
8449 | OPTI_TYPE_RAW_HASH;
8450 dgst_pos0 = 14;
8451 dgst_pos1 = 15;
8452 dgst_pos2 = 6;
8453 dgst_pos3 = 7;
8454 break;
8455
8456 case 1711: hash_type = HASH_TYPE_SHA512;
8457 salt_type = SALT_TYPE_EMBEDDED;
8458 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8459 opts_type = OPTS_TYPE_PT_GENERATE_BE
8460 | OPTS_TYPE_ST_ADD80
8461 | OPTS_TYPE_ST_ADDBITS15;
8462 kern_type = KERN_TYPE_SHA512_PWSLT;
8463 dgst_size = DGST_SIZE_8_8;
8464 parse_func = sha512b64s_parse_hash;
8465 sort_by_digest = sort_by_digest_8_8;
8466 opti_type = OPTI_TYPE_ZERO_BYTE
8467 | OPTI_TYPE_PRECOMPUTE_INIT
8468 | OPTI_TYPE_PRECOMPUTE_MERKLE
8469 | OPTI_TYPE_EARLY_SKIP
8470 | OPTI_TYPE_NOT_ITERATED
8471 | OPTI_TYPE_APPENDED_SALT
8472 | OPTI_TYPE_USES_BITS_64
8473 | OPTI_TYPE_RAW_HASH;
8474 dgst_pos0 = 14;
8475 dgst_pos1 = 15;
8476 dgst_pos2 = 6;
8477 dgst_pos3 = 7;
8478 break;
8479
8480 case 1720: hash_type = HASH_TYPE_SHA512;
8481 salt_type = SALT_TYPE_INTERN;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_BE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS15;
8486 kern_type = KERN_TYPE_SHA512_SLTPW;
8487 dgst_size = DGST_SIZE_8_8;
8488 parse_func = sha512s_parse_hash;
8489 sort_by_digest = sort_by_digest_8_8;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_ITERATED
8495 | OPTI_TYPE_PREPENDED_SALT
8496 | OPTI_TYPE_USES_BITS_64
8497 | OPTI_TYPE_RAW_HASH;
8498 dgst_pos0 = 14;
8499 dgst_pos1 = 15;
8500 dgst_pos2 = 6;
8501 dgst_pos3 = 7;
8502 break;
8503
8504 case 1722: hash_type = HASH_TYPE_SHA512;
8505 salt_type = SALT_TYPE_EMBEDDED;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_BE
8508 | OPTS_TYPE_PT_ADD80
8509 | OPTS_TYPE_PT_ADDBITS15
8510 | OPTS_TYPE_ST_HEX;
8511 kern_type = KERN_TYPE_SHA512_SLTPW;
8512 dgst_size = DGST_SIZE_8_8;
8513 parse_func = osx512_parse_hash;
8514 sort_by_digest = sort_by_digest_8_8;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP
8519 | OPTI_TYPE_NOT_ITERATED
8520 | OPTI_TYPE_PREPENDED_SALT
8521 | OPTI_TYPE_USES_BITS_64
8522 | OPTI_TYPE_RAW_HASH;
8523 dgst_pos0 = 14;
8524 dgst_pos1 = 15;
8525 dgst_pos2 = 6;
8526 dgst_pos3 = 7;
8527 break;
8528
8529 case 1730: hash_type = HASH_TYPE_SHA512;
8530 salt_type = SALT_TYPE_INTERN;
8531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8532 opts_type = OPTS_TYPE_PT_GENERATE_BE
8533 | OPTS_TYPE_PT_UNICODE
8534 | OPTS_TYPE_ST_ADD80
8535 | OPTS_TYPE_ST_ADDBITS15;
8536 kern_type = KERN_TYPE_SHA512_PWSLTU;
8537 dgst_size = DGST_SIZE_8_8;
8538 parse_func = sha512s_parse_hash;
8539 sort_by_digest = sort_by_digest_8_8;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_ITERATED
8545 | OPTI_TYPE_APPENDED_SALT
8546 | OPTI_TYPE_USES_BITS_64
8547 | OPTI_TYPE_RAW_HASH;
8548 dgst_pos0 = 14;
8549 dgst_pos1 = 15;
8550 dgst_pos2 = 6;
8551 dgst_pos3 = 7;
8552 break;
8553
8554 case 1731: hash_type = HASH_TYPE_SHA512;
8555 salt_type = SALT_TYPE_EMBEDDED;
8556 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8557 opts_type = OPTS_TYPE_PT_GENERATE_BE
8558 | OPTS_TYPE_PT_UNICODE
8559 | OPTS_TYPE_ST_ADD80
8560 | OPTS_TYPE_ST_ADDBITS15
8561 | OPTS_TYPE_ST_HEX;
8562 kern_type = KERN_TYPE_SHA512_PWSLTU;
8563 dgst_size = DGST_SIZE_8_8;
8564 parse_func = mssql2012_parse_hash;
8565 sort_by_digest = sort_by_digest_8_8;
8566 opti_type = OPTI_TYPE_ZERO_BYTE
8567 | OPTI_TYPE_PRECOMPUTE_INIT
8568 | OPTI_TYPE_PRECOMPUTE_MERKLE
8569 | OPTI_TYPE_EARLY_SKIP
8570 | OPTI_TYPE_NOT_ITERATED
8571 | OPTI_TYPE_APPENDED_SALT
8572 | OPTI_TYPE_USES_BITS_64
8573 | OPTI_TYPE_RAW_HASH;
8574 dgst_pos0 = 14;
8575 dgst_pos1 = 15;
8576 dgst_pos2 = 6;
8577 dgst_pos3 = 7;
8578 break;
8579
8580 case 1740: hash_type = HASH_TYPE_SHA512;
8581 salt_type = SALT_TYPE_INTERN;
8582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8583 opts_type = OPTS_TYPE_PT_GENERATE_BE
8584 | OPTS_TYPE_PT_ADD80
8585 | OPTS_TYPE_PT_ADDBITS15
8586 | OPTS_TYPE_PT_UNICODE;
8587 kern_type = KERN_TYPE_SHA512_SLTPWU;
8588 dgst_size = DGST_SIZE_8_8;
8589 parse_func = sha512s_parse_hash;
8590 sort_by_digest = sort_by_digest_8_8;
8591 opti_type = OPTI_TYPE_ZERO_BYTE
8592 | OPTI_TYPE_PRECOMPUTE_INIT
8593 | OPTI_TYPE_PRECOMPUTE_MERKLE
8594 | OPTI_TYPE_EARLY_SKIP
8595 | OPTI_TYPE_NOT_ITERATED
8596 | OPTI_TYPE_PREPENDED_SALT
8597 | OPTI_TYPE_USES_BITS_64
8598 | OPTI_TYPE_RAW_HASH;
8599 dgst_pos0 = 14;
8600 dgst_pos1 = 15;
8601 dgst_pos2 = 6;
8602 dgst_pos3 = 7;
8603 break;
8604
8605 case 1750: hash_type = HASH_TYPE_SHA512;
8606 salt_type = SALT_TYPE_INTERN;
8607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8608 opts_type = OPTS_TYPE_PT_GENERATE_BE
8609 | OPTS_TYPE_ST_ADD80;
8610 kern_type = KERN_TYPE_HMACSHA512_PW;
8611 dgst_size = DGST_SIZE_8_8;
8612 parse_func = hmacsha512_parse_hash;
8613 sort_by_digest = sort_by_digest_8_8;
8614 opti_type = OPTI_TYPE_ZERO_BYTE
8615 | OPTI_TYPE_USES_BITS_64
8616 | OPTI_TYPE_NOT_ITERATED;
8617 dgst_pos0 = 14;
8618 dgst_pos1 = 15;
8619 dgst_pos2 = 6;
8620 dgst_pos3 = 7;
8621 break;
8622
8623 case 1760: hash_type = HASH_TYPE_SHA512;
8624 salt_type = SALT_TYPE_INTERN;
8625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_BE
8627 | OPTS_TYPE_PT_ADD80
8628 | OPTS_TYPE_PT_ADDBITS15;
8629 kern_type = KERN_TYPE_HMACSHA512_SLT;
8630 dgst_size = DGST_SIZE_8_8;
8631 parse_func = hmacsha512_parse_hash;
8632 sort_by_digest = sort_by_digest_8_8;
8633 opti_type = OPTI_TYPE_ZERO_BYTE
8634 | OPTI_TYPE_USES_BITS_64
8635 | OPTI_TYPE_NOT_ITERATED;
8636 dgst_pos0 = 14;
8637 dgst_pos1 = 15;
8638 dgst_pos2 = 6;
8639 dgst_pos3 = 7;
8640 break;
8641
8642 case 1800: hash_type = HASH_TYPE_SHA512;
8643 salt_type = SALT_TYPE_EMBEDDED;
8644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8645 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8646 kern_type = KERN_TYPE_SHA512CRYPT;
8647 dgst_size = DGST_SIZE_8_8;
8648 parse_func = sha512crypt_parse_hash;
8649 sort_by_digest = sort_by_digest_8_8;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_USES_BITS_64;
8652 dgst_pos0 = 0;
8653 dgst_pos1 = 1;
8654 dgst_pos2 = 2;
8655 dgst_pos3 = 3;
8656 break;
8657
8658 case 2000: hash_type = HASH_TYPE_STDOUT;
8659 salt_type = SALT_TYPE_NONE;
8660 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8662 kern_type = 0;
8663 dgst_size = DGST_SIZE_4_4;
8664 parse_func = NULL;
8665 sort_by_digest = NULL;
8666 opti_type = 0;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 0;
8669 dgst_pos2 = 0;
8670 dgst_pos3 = 0;
8671 break;
8672
8673 case 2100: hash_type = HASH_TYPE_DCC2;
8674 salt_type = SALT_TYPE_EMBEDDED;
8675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8677 | OPTS_TYPE_ST_LOWER
8678 | OPTS_TYPE_ST_UNICODE;
8679 kern_type = KERN_TYPE_DCC2;
8680 dgst_size = DGST_SIZE_4_4;
8681 parse_func = dcc2_parse_hash;
8682 sort_by_digest = sort_by_digest_4_4;
8683 opti_type = OPTI_TYPE_ZERO_BYTE
8684 | OPTI_TYPE_SLOW_HASH_SIMD;
8685 dgst_pos0 = 0;
8686 dgst_pos1 = 1;
8687 dgst_pos2 = 2;
8688 dgst_pos3 = 3;
8689 break;
8690
8691 case 2400: hash_type = HASH_TYPE_MD5;
8692 salt_type = SALT_TYPE_NONE;
8693 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8694 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8695 kern_type = KERN_TYPE_MD5PIX;
8696 dgst_size = DGST_SIZE_4_4;
8697 parse_func = md5pix_parse_hash;
8698 sort_by_digest = sort_by_digest_4_4;
8699 opti_type = OPTI_TYPE_ZERO_BYTE
8700 | OPTI_TYPE_PRECOMPUTE_INIT
8701 | OPTI_TYPE_PRECOMPUTE_MERKLE
8702 | OPTI_TYPE_EARLY_SKIP
8703 | OPTI_TYPE_NOT_ITERATED
8704 | OPTI_TYPE_NOT_SALTED;
8705 dgst_pos0 = 0;
8706 dgst_pos1 = 3;
8707 dgst_pos2 = 2;
8708 dgst_pos3 = 1;
8709 break;
8710
8711 case 2410: hash_type = HASH_TYPE_MD5;
8712 salt_type = SALT_TYPE_INTERN;
8713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8715 kern_type = KERN_TYPE_MD5ASA;
8716 dgst_size = DGST_SIZE_4_4;
8717 parse_func = md5asa_parse_hash;
8718 sort_by_digest = sort_by_digest_4_4;
8719 opti_type = OPTI_TYPE_ZERO_BYTE
8720 | OPTI_TYPE_PRECOMPUTE_INIT
8721 | OPTI_TYPE_PRECOMPUTE_MERKLE
8722 | OPTI_TYPE_EARLY_SKIP
8723 | OPTI_TYPE_NOT_ITERATED;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 3;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 1;
8728 break;
8729
8730 case 2500: hash_type = HASH_TYPE_WPA;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8734 kern_type = KERN_TYPE_WPA;
8735 dgst_size = DGST_SIZE_4_4;
8736 parse_func = wpa_parse_hash;
8737 sort_by_digest = sort_by_digest_4_4;
8738 opti_type = OPTI_TYPE_ZERO_BYTE
8739 | OPTI_TYPE_SLOW_HASH_SIMD;
8740 dgst_pos0 = 0;
8741 dgst_pos1 = 1;
8742 dgst_pos2 = 2;
8743 dgst_pos3 = 3;
8744 break;
8745
8746 case 2600: hash_type = HASH_TYPE_MD5;
8747 salt_type = SALT_TYPE_VIRTUAL;
8748 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8749 opts_type = OPTS_TYPE_PT_GENERATE_LE
8750 | OPTS_TYPE_PT_ADD80
8751 | OPTS_TYPE_PT_ADDBITS14
8752 | OPTS_TYPE_ST_ADD80;
8753 kern_type = KERN_TYPE_MD55_PWSLT1;
8754 dgst_size = DGST_SIZE_4_4;
8755 parse_func = md5md5_parse_hash;
8756 sort_by_digest = sort_by_digest_4_4;
8757 opti_type = OPTI_TYPE_ZERO_BYTE
8758 | OPTI_TYPE_PRECOMPUTE_INIT
8759 | OPTI_TYPE_PRECOMPUTE_MERKLE
8760 | OPTI_TYPE_EARLY_SKIP;
8761 dgst_pos0 = 0;
8762 dgst_pos1 = 3;
8763 dgst_pos2 = 2;
8764 dgst_pos3 = 1;
8765 break;
8766
8767 case 2611: hash_type = HASH_TYPE_MD5;
8768 salt_type = SALT_TYPE_INTERN;
8769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8770 opts_type = OPTS_TYPE_PT_GENERATE_LE
8771 | OPTS_TYPE_PT_ADD80
8772 | OPTS_TYPE_PT_ADDBITS14
8773 | OPTS_TYPE_ST_ADD80;
8774 kern_type = KERN_TYPE_MD55_PWSLT1;
8775 dgst_size = DGST_SIZE_4_4;
8776 parse_func = vb3_parse_hash;
8777 sort_by_digest = sort_by_digest_4_4;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_PRECOMPUTE_MERKLE
8781 | OPTI_TYPE_EARLY_SKIP;
8782 dgst_pos0 = 0;
8783 dgst_pos1 = 3;
8784 dgst_pos2 = 2;
8785 dgst_pos3 = 1;
8786 break;
8787
8788 case 2612: hash_type = HASH_TYPE_MD5;
8789 salt_type = SALT_TYPE_EMBEDDED;
8790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8791 opts_type = OPTS_TYPE_PT_GENERATE_LE
8792 | OPTS_TYPE_PT_ADD80
8793 | OPTS_TYPE_PT_ADDBITS14
8794 | OPTS_TYPE_ST_ADD80
8795 | OPTS_TYPE_ST_HEX;
8796 kern_type = KERN_TYPE_MD55_PWSLT1;
8797 dgst_size = DGST_SIZE_4_4;
8798 parse_func = phps_parse_hash;
8799 sort_by_digest = sort_by_digest_4_4;
8800 opti_type = OPTI_TYPE_ZERO_BYTE
8801 | OPTI_TYPE_PRECOMPUTE_INIT
8802 | OPTI_TYPE_PRECOMPUTE_MERKLE
8803 | OPTI_TYPE_EARLY_SKIP;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 3;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 1;
8808 break;
8809
8810 case 2711: hash_type = HASH_TYPE_MD5;
8811 salt_type = SALT_TYPE_INTERN;
8812 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE
8814 | OPTS_TYPE_PT_ADD80
8815 | OPTS_TYPE_PT_ADDBITS14
8816 | OPTS_TYPE_ST_ADD80;
8817 kern_type = KERN_TYPE_MD55_PWSLT2;
8818 dgst_size = DGST_SIZE_4_4;
8819 parse_func = vb30_parse_hash;
8820 sort_by_digest = sort_by_digest_4_4;
8821 opti_type = OPTI_TYPE_ZERO_BYTE
8822 | OPTI_TYPE_PRECOMPUTE_INIT
8823 | OPTI_TYPE_EARLY_SKIP;
8824 dgst_pos0 = 0;
8825 dgst_pos1 = 3;
8826 dgst_pos2 = 2;
8827 dgst_pos3 = 1;
8828 break;
8829
8830 case 2811: hash_type = HASH_TYPE_MD5;
8831 salt_type = SALT_TYPE_INTERN;
8832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8833 opts_type = OPTS_TYPE_PT_GENERATE_LE
8834 | OPTS_TYPE_PT_ADD80
8835 | OPTS_TYPE_PT_ADDBITS14;
8836 kern_type = KERN_TYPE_MD55_SLTPW;
8837 dgst_size = DGST_SIZE_4_4;
8838 parse_func = ipb2_parse_hash;
8839 sort_by_digest = sort_by_digest_4_4;
8840 opti_type = OPTI_TYPE_ZERO_BYTE
8841 | OPTI_TYPE_PRECOMPUTE_INIT
8842 | OPTI_TYPE_EARLY_SKIP;
8843 dgst_pos0 = 0;
8844 dgst_pos1 = 3;
8845 dgst_pos2 = 2;
8846 dgst_pos3 = 1;
8847 break;
8848
8849 case 3000: hash_type = HASH_TYPE_LM;
8850 salt_type = SALT_TYPE_NONE;
8851 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8852 opts_type = OPTS_TYPE_PT_GENERATE_LE
8853 | OPTS_TYPE_PT_UPPER
8854 | OPTS_TYPE_PT_BITSLICE;
8855 kern_type = KERN_TYPE_LM;
8856 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8857 parse_func = lm_parse_hash;
8858 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8859 opti_type = OPTI_TYPE_ZERO_BYTE
8860 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8861 dgst_pos0 = 0;
8862 dgst_pos1 = 1;
8863 dgst_pos2 = 2;
8864 dgst_pos3 = 3;
8865 break;
8866
8867 case 3100: hash_type = HASH_TYPE_ORACLEH;
8868 salt_type = SALT_TYPE_INTERN;
8869 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8870 opts_type = OPTS_TYPE_PT_GENERATE_LE
8871 | OPTS_TYPE_PT_UPPER
8872 | OPTS_TYPE_ST_UPPER;
8873 kern_type = KERN_TYPE_ORACLEH;
8874 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8875 parse_func = oracleh_parse_hash;
8876 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8877 opti_type = OPTI_TYPE_ZERO_BYTE;
8878 dgst_pos0 = 0;
8879 dgst_pos1 = 1;
8880 dgst_pos2 = 2;
8881 dgst_pos3 = 3;
8882 break;
8883
8884 case 3200: hash_type = HASH_TYPE_BCRYPT;
8885 salt_type = SALT_TYPE_EMBEDDED;
8886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8887 opts_type = OPTS_TYPE_PT_GENERATE_LE
8888 | OPTS_TYPE_ST_GENERATE_LE;
8889 kern_type = KERN_TYPE_BCRYPT;
8890 dgst_size = DGST_SIZE_4_6;
8891 parse_func = bcrypt_parse_hash;
8892 sort_by_digest = sort_by_digest_4_6;
8893 opti_type = OPTI_TYPE_ZERO_BYTE;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 3710: hash_type = HASH_TYPE_MD5;
8901 salt_type = SALT_TYPE_INTERN;
8902 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE
8904 | OPTS_TYPE_PT_ADD80
8905 | OPTS_TYPE_PT_ADDBITS14;
8906 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8907 dgst_size = DGST_SIZE_4_4;
8908 parse_func = md5s_parse_hash;
8909 sort_by_digest = sort_by_digest_4_4;
8910 opti_type = OPTI_TYPE_ZERO_BYTE
8911 | OPTI_TYPE_PRECOMPUTE_INIT
8912 | OPTI_TYPE_PRECOMPUTE_MERKLE
8913 | OPTI_TYPE_EARLY_SKIP;
8914 dgst_pos0 = 0;
8915 dgst_pos1 = 3;
8916 dgst_pos2 = 2;
8917 dgst_pos3 = 1;
8918 break;
8919
8920 case 3711: hash_type = HASH_TYPE_MD5;
8921 salt_type = SALT_TYPE_EMBEDDED;
8922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8923 opts_type = OPTS_TYPE_PT_GENERATE_LE
8924 | OPTS_TYPE_PT_ADD80
8925 | OPTS_TYPE_PT_ADDBITS14;
8926 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8927 dgst_size = DGST_SIZE_4_4;
8928 parse_func = mediawiki_b_parse_hash;
8929 sort_by_digest = sort_by_digest_4_4;
8930 opti_type = OPTI_TYPE_ZERO_BYTE
8931 | OPTI_TYPE_PRECOMPUTE_INIT
8932 | OPTI_TYPE_PRECOMPUTE_MERKLE
8933 | OPTI_TYPE_EARLY_SKIP;
8934 dgst_pos0 = 0;
8935 dgst_pos1 = 3;
8936 dgst_pos2 = 2;
8937 dgst_pos3 = 1;
8938 break;
8939
8940 case 3800: hash_type = HASH_TYPE_MD5;
8941 salt_type = SALT_TYPE_INTERN;
8942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8943 opts_type = OPTS_TYPE_PT_GENERATE_LE
8944 | OPTS_TYPE_ST_ADDBITS14;
8945 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8946 dgst_size = DGST_SIZE_4_4;
8947 parse_func = md5s_parse_hash;
8948 sort_by_digest = sort_by_digest_4_4;
8949 opti_type = OPTI_TYPE_ZERO_BYTE
8950 | OPTI_TYPE_PRECOMPUTE_INIT
8951 | OPTI_TYPE_PRECOMPUTE_MERKLE
8952 | OPTI_TYPE_EARLY_SKIP
8953 | OPTI_TYPE_NOT_ITERATED
8954 | OPTI_TYPE_RAW_HASH;
8955 dgst_pos0 = 0;
8956 dgst_pos1 = 3;
8957 dgst_pos2 = 2;
8958 dgst_pos3 = 1;
8959 break;
8960
8961 case 4300: hash_type = HASH_TYPE_MD5;
8962 salt_type = SALT_TYPE_VIRTUAL;
8963 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8964 opts_type = OPTS_TYPE_PT_GENERATE_LE
8965 | OPTS_TYPE_PT_ADD80
8966 | OPTS_TYPE_PT_ADDBITS14
8967 | OPTS_TYPE_ST_ADD80;
8968 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8969 dgst_size = DGST_SIZE_4_4;
8970 parse_func = md5md5_parse_hash;
8971 sort_by_digest = sort_by_digest_4_4;
8972 opti_type = OPTI_TYPE_ZERO_BYTE
8973 | OPTI_TYPE_PRECOMPUTE_INIT
8974 | OPTI_TYPE_PRECOMPUTE_MERKLE
8975 | OPTI_TYPE_EARLY_SKIP;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 3;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 1;
8980 break;
8981
8982
8983 case 4400: hash_type = HASH_TYPE_MD5;
8984 salt_type = SALT_TYPE_NONE;
8985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8986 opts_type = OPTS_TYPE_PT_GENERATE_BE
8987 | OPTS_TYPE_PT_ADD80
8988 | OPTS_TYPE_PT_ADDBITS15;
8989 kern_type = KERN_TYPE_MD5_SHA1;
8990 dgst_size = DGST_SIZE_4_4;
8991 parse_func = md5_parse_hash;
8992 sort_by_digest = sort_by_digest_4_4;
8993 opti_type = OPTI_TYPE_ZERO_BYTE
8994 | OPTI_TYPE_PRECOMPUTE_INIT
8995 | OPTI_TYPE_PRECOMPUTE_MERKLE
8996 | OPTI_TYPE_EARLY_SKIP
8997 | OPTI_TYPE_NOT_ITERATED
8998 | OPTI_TYPE_NOT_SALTED
8999 | OPTI_TYPE_RAW_HASH;
9000 dgst_pos0 = 0;
9001 dgst_pos1 = 3;
9002 dgst_pos2 = 2;
9003 dgst_pos3 = 1;
9004 break;
9005
9006 case 4500: hash_type = HASH_TYPE_SHA1;
9007 salt_type = SALT_TYPE_NONE;
9008 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9009 opts_type = OPTS_TYPE_PT_GENERATE_BE
9010 | OPTS_TYPE_PT_ADD80
9011 | OPTS_TYPE_PT_ADDBITS15;
9012 kern_type = KERN_TYPE_SHA11;
9013 dgst_size = DGST_SIZE_4_5;
9014 parse_func = sha1_parse_hash;
9015 sort_by_digest = sort_by_digest_4_5;
9016 opti_type = OPTI_TYPE_ZERO_BYTE
9017 | OPTI_TYPE_PRECOMPUTE_INIT
9018 | OPTI_TYPE_PRECOMPUTE_MERKLE
9019 | OPTI_TYPE_EARLY_SKIP
9020 | OPTI_TYPE_NOT_SALTED;
9021 dgst_pos0 = 3;
9022 dgst_pos1 = 4;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 1;
9025 break;
9026
9027 case 4700: hash_type = HASH_TYPE_SHA1;
9028 salt_type = SALT_TYPE_NONE;
9029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE
9031 | OPTS_TYPE_PT_ADD80
9032 | OPTS_TYPE_PT_ADDBITS14;
9033 kern_type = KERN_TYPE_SHA1_MD5;
9034 dgst_size = DGST_SIZE_4_5;
9035 parse_func = sha1_parse_hash;
9036 sort_by_digest = sort_by_digest_4_5;
9037 opti_type = OPTI_TYPE_ZERO_BYTE
9038 | OPTI_TYPE_PRECOMPUTE_INIT
9039 | OPTI_TYPE_PRECOMPUTE_MERKLE
9040 | OPTI_TYPE_EARLY_SKIP
9041 | OPTI_TYPE_NOT_ITERATED
9042 | OPTI_TYPE_NOT_SALTED
9043 | OPTI_TYPE_RAW_HASH;
9044 dgst_pos0 = 3;
9045 dgst_pos1 = 4;
9046 dgst_pos2 = 2;
9047 dgst_pos3 = 1;
9048 break;
9049
9050 case 4800: hash_type = HASH_TYPE_MD5;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_LE
9054 | OPTS_TYPE_PT_ADDBITS14;
9055 kern_type = KERN_TYPE_MD5_CHAP;
9056 dgst_size = DGST_SIZE_4_4;
9057 parse_func = chap_parse_hash;
9058 sort_by_digest = sort_by_digest_4_4;
9059 opti_type = OPTI_TYPE_ZERO_BYTE
9060 | OPTI_TYPE_PRECOMPUTE_INIT
9061 | OPTI_TYPE_PRECOMPUTE_MERKLE
9062 | OPTI_TYPE_MEET_IN_MIDDLE
9063 | OPTI_TYPE_EARLY_SKIP
9064 | OPTI_TYPE_NOT_ITERATED
9065 | OPTI_TYPE_RAW_HASH;
9066 dgst_pos0 = 0;
9067 dgst_pos1 = 3;
9068 dgst_pos2 = 2;
9069 dgst_pos3 = 1;
9070 break;
9071
9072 case 4900: hash_type = HASH_TYPE_SHA1;
9073 salt_type = SALT_TYPE_INTERN;
9074 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9075 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9076 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9077 dgst_size = DGST_SIZE_4_5;
9078 parse_func = sha1s_parse_hash;
9079 sort_by_digest = sort_by_digest_4_5;
9080 opti_type = OPTI_TYPE_ZERO_BYTE
9081 | OPTI_TYPE_PRECOMPUTE_INIT
9082 | OPTI_TYPE_PRECOMPUTE_MERKLE
9083 | OPTI_TYPE_EARLY_SKIP;
9084 dgst_pos0 = 3;
9085 dgst_pos1 = 4;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 1;
9088 break;
9089
9090 case 5000: hash_type = HASH_TYPE_KECCAK;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE
9094 | OPTS_TYPE_PT_ADD01;
9095 kern_type = KERN_TYPE_KECCAK;
9096 dgst_size = DGST_SIZE_8_25;
9097 parse_func = keccak_parse_hash;
9098 sort_by_digest = sort_by_digest_8_25;
9099 opti_type = OPTI_TYPE_ZERO_BYTE
9100 | OPTI_TYPE_USES_BITS_64
9101 | OPTI_TYPE_RAW_HASH;
9102 dgst_pos0 = 2;
9103 dgst_pos1 = 3;
9104 dgst_pos2 = 4;
9105 dgst_pos3 = 5;
9106 break;
9107
9108 case 5100: hash_type = HASH_TYPE_MD5H;
9109 salt_type = SALT_TYPE_NONE;
9110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9111 opts_type = OPTS_TYPE_PT_GENERATE_LE
9112 | OPTS_TYPE_PT_ADD80
9113 | OPTS_TYPE_PT_ADDBITS14;
9114 kern_type = KERN_TYPE_MD5H;
9115 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9116 parse_func = md5half_parse_hash;
9117 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9118 opti_type = OPTI_TYPE_ZERO_BYTE
9119 | OPTI_TYPE_RAW_HASH;
9120 dgst_pos0 = 0;
9121 dgst_pos1 = 1;
9122 dgst_pos2 = 2;
9123 dgst_pos3 = 3;
9124 break;
9125
9126 case 5200: hash_type = HASH_TYPE_SHA256;
9127 salt_type = SALT_TYPE_EMBEDDED;
9128 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9130 kern_type = KERN_TYPE_PSAFE3;
9131 dgst_size = DGST_SIZE_4_8;
9132 parse_func = psafe3_parse_hash;
9133 sort_by_digest = sort_by_digest_4_8;
9134 opti_type = OPTI_TYPE_ZERO_BYTE;
9135 dgst_pos0 = 0;
9136 dgst_pos1 = 1;
9137 dgst_pos2 = 2;
9138 dgst_pos3 = 3;
9139 break;
9140
9141 case 5300: hash_type = HASH_TYPE_MD5;
9142 salt_type = SALT_TYPE_EMBEDDED;
9143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9144 opts_type = OPTS_TYPE_PT_GENERATE_LE
9145 | OPTS_TYPE_ST_ADD80;
9146 kern_type = KERN_TYPE_IKEPSK_MD5;
9147 dgst_size = DGST_SIZE_4_4;
9148 parse_func = ikepsk_md5_parse_hash;
9149 sort_by_digest = sort_by_digest_4_4;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 3;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 1;
9155 break;
9156
9157 case 5400: hash_type = HASH_TYPE_SHA1;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_BE
9161 | OPTS_TYPE_ST_ADD80;
9162 kern_type = KERN_TYPE_IKEPSK_SHA1;
9163 dgst_size = DGST_SIZE_4_5;
9164 parse_func = ikepsk_sha1_parse_hash;
9165 sort_by_digest = sort_by_digest_4_5;
9166 opti_type = OPTI_TYPE_ZERO_BYTE;
9167 dgst_pos0 = 3;
9168 dgst_pos1 = 4;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 1;
9171 break;
9172
9173 case 5500: hash_type = HASH_TYPE_NETNTLM;
9174 salt_type = SALT_TYPE_EMBEDDED;
9175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_LE
9177 | OPTS_TYPE_PT_ADD80
9178 | OPTS_TYPE_PT_ADDBITS14
9179 | OPTS_TYPE_PT_UNICODE
9180 | OPTS_TYPE_ST_HEX;
9181 kern_type = KERN_TYPE_NETNTLMv1;
9182 dgst_size = DGST_SIZE_4_4;
9183 parse_func = netntlmv1_parse_hash;
9184 sort_by_digest = sort_by_digest_4_4;
9185 opti_type = OPTI_TYPE_ZERO_BYTE
9186 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9187 dgst_pos0 = 0;
9188 dgst_pos1 = 1;
9189 dgst_pos2 = 2;
9190 dgst_pos3 = 3;
9191 break;
9192
9193 case 5600: hash_type = HASH_TYPE_MD5;
9194 salt_type = SALT_TYPE_EMBEDDED;
9195 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9196 opts_type = OPTS_TYPE_PT_GENERATE_LE
9197 | OPTS_TYPE_PT_ADD80
9198 | OPTS_TYPE_PT_ADDBITS14
9199 | OPTS_TYPE_PT_UNICODE;
9200 kern_type = KERN_TYPE_NETNTLMv2;
9201 dgst_size = DGST_SIZE_4_4;
9202 parse_func = netntlmv2_parse_hash;
9203 sort_by_digest = sort_by_digest_4_4;
9204 opti_type = OPTI_TYPE_ZERO_BYTE;
9205 dgst_pos0 = 0;
9206 dgst_pos1 = 3;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 1;
9209 break;
9210
9211 case 5700: hash_type = HASH_TYPE_SHA256;
9212 salt_type = SALT_TYPE_NONE;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_BE
9215 | OPTS_TYPE_PT_ADD80
9216 | OPTS_TYPE_PT_ADDBITS15;
9217 kern_type = KERN_TYPE_SHA256;
9218 dgst_size = DGST_SIZE_4_8;
9219 parse_func = cisco4_parse_hash;
9220 sort_by_digest = sort_by_digest_4_8;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_PRECOMPUTE_MERKLE
9224 | OPTI_TYPE_EARLY_SKIP
9225 | OPTI_TYPE_NOT_ITERATED
9226 | OPTI_TYPE_NOT_SALTED
9227 | OPTI_TYPE_RAW_HASH;
9228 dgst_pos0 = 3;
9229 dgst_pos1 = 7;
9230 dgst_pos2 = 2;
9231 dgst_pos3 = 6;
9232 break;
9233
9234 case 5800: hash_type = HASH_TYPE_SHA1;
9235 salt_type = SALT_TYPE_INTERN;
9236 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9237 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9238 | OPTS_TYPE_ST_ADD80;
9239 kern_type = KERN_TYPE_ANDROIDPIN;
9240 dgst_size = DGST_SIZE_4_5;
9241 parse_func = androidpin_parse_hash;
9242 sort_by_digest = sort_by_digest_4_5;
9243 opti_type = OPTI_TYPE_ZERO_BYTE;
9244 dgst_pos0 = 0;
9245 dgst_pos1 = 1;
9246 dgst_pos2 = 2;
9247 dgst_pos3 = 3;
9248 break;
9249
9250 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9251 salt_type = SALT_TYPE_NONE;
9252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9253 opts_type = OPTS_TYPE_PT_GENERATE_LE
9254 | OPTS_TYPE_PT_ADD80;
9255 kern_type = KERN_TYPE_RIPEMD160;
9256 dgst_size = DGST_SIZE_4_5;
9257 parse_func = ripemd160_parse_hash;
9258 sort_by_digest = sort_by_digest_4_5;
9259 opti_type = OPTI_TYPE_ZERO_BYTE;
9260 dgst_pos0 = 0;
9261 dgst_pos1 = 1;
9262 dgst_pos2 = 2;
9263 dgst_pos3 = 3;
9264 break;
9265
9266 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9267 salt_type = SALT_TYPE_NONE;
9268 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9269 opts_type = OPTS_TYPE_PT_GENERATE_BE
9270 | OPTS_TYPE_PT_ADD80;
9271 kern_type = KERN_TYPE_WHIRLPOOL;
9272 dgst_size = DGST_SIZE_4_16;
9273 parse_func = whirlpool_parse_hash;
9274 sort_by_digest = sort_by_digest_4_16;
9275 opti_type = OPTI_TYPE_ZERO_BYTE;
9276 dgst_pos0 = 0;
9277 dgst_pos1 = 1;
9278 dgst_pos2 = 2;
9279 dgst_pos3 = 3;
9280 break;
9281
9282 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9283 salt_type = SALT_TYPE_EMBEDDED;
9284 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9285 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9286 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9287 dgst_size = DGST_SIZE_4_5;
9288 parse_func = truecrypt_parse_hash_2k;
9289 sort_by_digest = sort_by_digest_4_5;
9290 opti_type = OPTI_TYPE_ZERO_BYTE;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 1;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 3;
9295 break;
9296
9297 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9298 salt_type = SALT_TYPE_EMBEDDED;
9299 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9301 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9302 dgst_size = DGST_SIZE_4_5;
9303 parse_func = truecrypt_parse_hash_2k;
9304 sort_by_digest = sort_by_digest_4_5;
9305 opti_type = OPTI_TYPE_ZERO_BYTE;
9306 dgst_pos0 = 0;
9307 dgst_pos1 = 1;
9308 dgst_pos2 = 2;
9309 dgst_pos3 = 3;
9310 break;
9311
9312 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9313 salt_type = SALT_TYPE_EMBEDDED;
9314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9315 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9316 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9317 dgst_size = DGST_SIZE_4_5;
9318 parse_func = truecrypt_parse_hash_2k;
9319 sort_by_digest = sort_by_digest_4_5;
9320 opti_type = OPTI_TYPE_ZERO_BYTE;
9321 dgst_pos0 = 0;
9322 dgst_pos1 = 1;
9323 dgst_pos2 = 2;
9324 dgst_pos3 = 3;
9325 break;
9326
9327 case 6221: hash_type = HASH_TYPE_SHA512;
9328 salt_type = SALT_TYPE_EMBEDDED;
9329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9330 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9331 kern_type = KERN_TYPE_TCSHA512_XTS512;
9332 dgst_size = DGST_SIZE_8_8;
9333 parse_func = truecrypt_parse_hash_1k;
9334 sort_by_digest = sort_by_digest_8_8;
9335 opti_type = OPTI_TYPE_ZERO_BYTE
9336 | OPTI_TYPE_USES_BITS_64;
9337 dgst_pos0 = 0;
9338 dgst_pos1 = 1;
9339 dgst_pos2 = 2;
9340 dgst_pos3 = 3;
9341 break;
9342
9343 case 6222: hash_type = HASH_TYPE_SHA512;
9344 salt_type = SALT_TYPE_EMBEDDED;
9345 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9346 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9347 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9348 dgst_size = DGST_SIZE_8_8;
9349 parse_func = truecrypt_parse_hash_1k;
9350 sort_by_digest = sort_by_digest_8_8;
9351 opti_type = OPTI_TYPE_ZERO_BYTE
9352 | OPTI_TYPE_USES_BITS_64;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 6223: hash_type = HASH_TYPE_SHA512;
9360 salt_type = SALT_TYPE_EMBEDDED;
9361 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9363 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9364 dgst_size = DGST_SIZE_8_8;
9365 parse_func = truecrypt_parse_hash_1k;
9366 sort_by_digest = sort_by_digest_8_8;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_USES_BITS_64;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9380 dgst_size = DGST_SIZE_4_8;
9381 parse_func = truecrypt_parse_hash_1k;
9382 sort_by_digest = sort_by_digest_4_8;
9383 opti_type = OPTI_TYPE_ZERO_BYTE;
9384 dgst_pos0 = 0;
9385 dgst_pos1 = 1;
9386 dgst_pos2 = 2;
9387 dgst_pos3 = 3;
9388 break;
9389
9390 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9391 salt_type = SALT_TYPE_EMBEDDED;
9392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9394 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9395 dgst_size = DGST_SIZE_4_8;
9396 parse_func = truecrypt_parse_hash_1k;
9397 sort_by_digest = sort_by_digest_4_8;
9398 opti_type = OPTI_TYPE_ZERO_BYTE;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9410 dgst_size = DGST_SIZE_4_8;
9411 parse_func = truecrypt_parse_hash_1k;
9412 sort_by_digest = sort_by_digest_4_8;
9413 opti_type = OPTI_TYPE_ZERO_BYTE;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9425 dgst_size = DGST_SIZE_4_5;
9426 parse_func = truecrypt_parse_hash_1k;
9427 sort_by_digest = sort_by_digest_4_5;
9428 opti_type = OPTI_TYPE_ZERO_BYTE;
9429 dgst_pos0 = 0;
9430 dgst_pos1 = 1;
9431 dgst_pos2 = 2;
9432 dgst_pos3 = 3;
9433 break;
9434
9435 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9436 salt_type = SALT_TYPE_EMBEDDED;
9437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9439 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9440 dgst_size = DGST_SIZE_4_5;
9441 parse_func = truecrypt_parse_hash_1k;
9442 sort_by_digest = sort_by_digest_4_5;
9443 opti_type = OPTI_TYPE_ZERO_BYTE;
9444 dgst_pos0 = 0;
9445 dgst_pos1 = 1;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 3;
9448 break;
9449
9450 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9454 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9455 dgst_size = DGST_SIZE_4_5;
9456 parse_func = truecrypt_parse_hash_1k;
9457 sort_by_digest = sort_by_digest_4_5;
9458 opti_type = OPTI_TYPE_ZERO_BYTE;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 6300: hash_type = HASH_TYPE_MD5;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_MD5AIX;
9470 dgst_size = DGST_SIZE_4_4;
9471 parse_func = md5aix_parse_hash;
9472 sort_by_digest = sort_by_digest_4_4;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 6400: hash_type = HASH_TYPE_SHA256;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9484 kern_type = KERN_TYPE_SHA256AIX;
9485 dgst_size = DGST_SIZE_4_8;
9486 parse_func = sha256aix_parse_hash;
9487 sort_by_digest = sort_by_digest_4_8;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 6500: hash_type = HASH_TYPE_SHA512;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9499 kern_type = KERN_TYPE_SHA512AIX;
9500 dgst_size = DGST_SIZE_8_8;
9501 parse_func = sha512aix_parse_hash;
9502 sort_by_digest = sort_by_digest_8_8;
9503 opti_type = OPTI_TYPE_ZERO_BYTE
9504 | OPTI_TYPE_USES_BITS_64;
9505 dgst_pos0 = 0;
9506 dgst_pos1 = 1;
9507 dgst_pos2 = 2;
9508 dgst_pos3 = 3;
9509 break;
9510
9511 case 6600: hash_type = HASH_TYPE_AES;
9512 salt_type = SALT_TYPE_EMBEDDED;
9513 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9514 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9515 kern_type = KERN_TYPE_AGILEKEY;
9516 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9517 parse_func = agilekey_parse_hash;
9518 sort_by_digest = sort_by_digest_4_5;
9519 opti_type = OPTI_TYPE_ZERO_BYTE;
9520 dgst_pos0 = 0;
9521 dgst_pos1 = 1;
9522 dgst_pos2 = 2;
9523 dgst_pos3 = 3;
9524 break;
9525
9526 case 6700: hash_type = HASH_TYPE_SHA1;
9527 salt_type = SALT_TYPE_EMBEDDED;
9528 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9529 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9530 kern_type = KERN_TYPE_SHA1AIX;
9531 dgst_size = DGST_SIZE_4_5;
9532 parse_func = sha1aix_parse_hash;
9533 sort_by_digest = sort_by_digest_4_5;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 0;
9536 dgst_pos1 = 1;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 3;
9539 break;
9540
9541 case 6800: hash_type = HASH_TYPE_AES;
9542 salt_type = SALT_TYPE_EMBEDDED;
9543 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9545 kern_type = KERN_TYPE_LASTPASS;
9546 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9547 parse_func = lastpass_parse_hash;
9548 sort_by_digest = sort_by_digest_4_8;
9549 opti_type = OPTI_TYPE_ZERO_BYTE;
9550 dgst_pos0 = 0;
9551 dgst_pos1 = 1;
9552 dgst_pos2 = 2;
9553 dgst_pos3 = 3;
9554 break;
9555
9556 case 6900: hash_type = HASH_TYPE_GOST;
9557 salt_type = SALT_TYPE_NONE;
9558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9559 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9560 kern_type = KERN_TYPE_GOST;
9561 dgst_size = DGST_SIZE_4_8;
9562 parse_func = gost_parse_hash;
9563 sort_by_digest = sort_by_digest_4_8;
9564 opti_type = OPTI_TYPE_ZERO_BYTE;
9565 dgst_pos0 = 0;
9566 dgst_pos1 = 1;
9567 dgst_pos2 = 2;
9568 dgst_pos3 = 3;
9569 break;
9570
9571 case 7100: hash_type = HASH_TYPE_SHA512;
9572 salt_type = SALT_TYPE_EMBEDDED;
9573 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9574 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9575 kern_type = KERN_TYPE_PBKDF2_SHA512;
9576 dgst_size = DGST_SIZE_8_16;
9577 parse_func = sha512osx_parse_hash;
9578 sort_by_digest = sort_by_digest_8_16;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_USES_BITS_64
9581 | OPTI_TYPE_SLOW_HASH_SIMD;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 7200: hash_type = HASH_TYPE_SHA512;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9592 kern_type = KERN_TYPE_PBKDF2_SHA512;
9593 dgst_size = DGST_SIZE_8_16;
9594 parse_func = sha512grub_parse_hash;
9595 sort_by_digest = sort_by_digest_8_16;
9596 opti_type = OPTI_TYPE_ZERO_BYTE
9597 | OPTI_TYPE_USES_BITS_64
9598 | OPTI_TYPE_SLOW_HASH_SIMD;
9599 dgst_pos0 = 0;
9600 dgst_pos1 = 1;
9601 dgst_pos2 = 2;
9602 dgst_pos3 = 3;
9603 break;
9604
9605 case 7300: hash_type = HASH_TYPE_SHA1;
9606 salt_type = SALT_TYPE_EMBEDDED;
9607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9608 opts_type = OPTS_TYPE_PT_GENERATE_BE
9609 | OPTS_TYPE_ST_ADD80
9610 | OPTS_TYPE_ST_ADDBITS15;
9611 kern_type = KERN_TYPE_RAKP;
9612 dgst_size = DGST_SIZE_4_5;
9613 parse_func = rakp_parse_hash;
9614 sort_by_digest = sort_by_digest_4_5;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_NOT_ITERATED;
9617 dgst_pos0 = 3;
9618 dgst_pos1 = 4;
9619 dgst_pos2 = 2;
9620 dgst_pos3 = 1;
9621 break;
9622
9623 case 7400: hash_type = HASH_TYPE_SHA256;
9624 salt_type = SALT_TYPE_EMBEDDED;
9625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9626 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9627 kern_type = KERN_TYPE_SHA256CRYPT;
9628 dgst_size = DGST_SIZE_4_8;
9629 parse_func = sha256crypt_parse_hash;
9630 sort_by_digest = sort_by_digest_4_8;
9631 opti_type = OPTI_TYPE_ZERO_BYTE;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 7500: hash_type = HASH_TYPE_KRB5PA;
9639 salt_type = SALT_TYPE_EMBEDDED;
9640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_KRB5PA;
9643 dgst_size = DGST_SIZE_4_4;
9644 parse_func = krb5pa_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4;
9646 opti_type = OPTI_TYPE_ZERO_BYTE
9647 | OPTI_TYPE_NOT_ITERATED;
9648 dgst_pos0 = 0;
9649 dgst_pos1 = 1;
9650 dgst_pos2 = 2;
9651 dgst_pos3 = 3;
9652 break;
9653
9654 case 7600: hash_type = HASH_TYPE_SHA1;
9655 salt_type = SALT_TYPE_INTERN;
9656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_BE
9658 | OPTS_TYPE_PT_ADD80
9659 | OPTS_TYPE_PT_ADDBITS15;
9660 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9661 dgst_size = DGST_SIZE_4_5;
9662 parse_func = redmine_parse_hash;
9663 sort_by_digest = sort_by_digest_4_5;
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_PRECOMPUTE_INIT
9666 | OPTI_TYPE_EARLY_SKIP
9667 | OPTI_TYPE_NOT_ITERATED
9668 | OPTI_TYPE_PREPENDED_SALT;
9669 dgst_pos0 = 3;
9670 dgst_pos1 = 4;
9671 dgst_pos2 = 2;
9672 dgst_pos3 = 1;
9673 break;
9674
9675 case 7700: hash_type = HASH_TYPE_SAPB;
9676 salt_type = SALT_TYPE_EMBEDDED;
9677 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9678 opts_type = OPTS_TYPE_PT_GENERATE_LE
9679 | OPTS_TYPE_PT_UPPER
9680 | OPTS_TYPE_ST_UPPER;
9681 kern_type = KERN_TYPE_SAPB;
9682 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9683 parse_func = sapb_parse_hash;
9684 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9685 opti_type = OPTI_TYPE_ZERO_BYTE
9686 | OPTI_TYPE_PRECOMPUTE_INIT
9687 | OPTI_TYPE_NOT_ITERATED;
9688 dgst_pos0 = 0;
9689 dgst_pos1 = 1;
9690 dgst_pos2 = 2;
9691 dgst_pos3 = 3;
9692 break;
9693
9694 case 7800: hash_type = HASH_TYPE_SAPG;
9695 salt_type = SALT_TYPE_EMBEDDED;
9696 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9697 opts_type = OPTS_TYPE_PT_GENERATE_BE
9698 | OPTS_TYPE_ST_ADD80
9699 | OPTS_TYPE_ST_UPPER;
9700 kern_type = KERN_TYPE_SAPG;
9701 dgst_size = DGST_SIZE_4_5;
9702 parse_func = sapg_parse_hash;
9703 sort_by_digest = sort_by_digest_4_5;
9704 opti_type = OPTI_TYPE_ZERO_BYTE
9705 | OPTI_TYPE_PRECOMPUTE_INIT
9706 | OPTI_TYPE_NOT_ITERATED;
9707 dgst_pos0 = 3;
9708 dgst_pos1 = 4;
9709 dgst_pos2 = 2;
9710 dgst_pos3 = 1;
9711 break;
9712
9713 case 7900: hash_type = HASH_TYPE_SHA512;
9714 salt_type = SALT_TYPE_EMBEDDED;
9715 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9716 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9717 kern_type = KERN_TYPE_DRUPAL7;
9718 dgst_size = DGST_SIZE_8_8;
9719 parse_func = drupal7_parse_hash;
9720 sort_by_digest = sort_by_digest_8_8;
9721 opti_type = OPTI_TYPE_ZERO_BYTE
9722 | OPTI_TYPE_USES_BITS_64;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 8000: hash_type = HASH_TYPE_SHA256;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_BE
9733 | OPTS_TYPE_PT_UNICODE
9734 | OPTS_TYPE_ST_ADD80
9735 | OPTS_TYPE_ST_HEX;
9736 kern_type = KERN_TYPE_SYBASEASE;
9737 dgst_size = DGST_SIZE_4_8;
9738 parse_func = sybasease_parse_hash;
9739 sort_by_digest = sort_by_digest_4_8;
9740 opti_type = OPTI_TYPE_ZERO_BYTE
9741 | OPTI_TYPE_PRECOMPUTE_INIT
9742 | OPTI_TYPE_EARLY_SKIP
9743 | OPTI_TYPE_NOT_ITERATED
9744 | OPTI_TYPE_RAW_HASH;
9745 dgst_pos0 = 3;
9746 dgst_pos1 = 7;
9747 dgst_pos2 = 2;
9748 dgst_pos3 = 6;
9749 break;
9750
9751 case 8100: hash_type = HASH_TYPE_SHA1;
9752 salt_type = SALT_TYPE_EMBEDDED;
9753 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9754 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9755 kern_type = KERN_TYPE_NETSCALER;
9756 dgst_size = DGST_SIZE_4_5;
9757 parse_func = netscaler_parse_hash;
9758 sort_by_digest = sort_by_digest_4_5;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_PRECOMPUTE_MERKLE
9762 | OPTI_TYPE_EARLY_SKIP
9763 | OPTI_TYPE_NOT_ITERATED
9764 | OPTI_TYPE_PREPENDED_SALT
9765 | OPTI_TYPE_RAW_HASH;
9766 dgst_pos0 = 3;
9767 dgst_pos1 = 4;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 1;
9770 break;
9771
9772 case 8200: hash_type = HASH_TYPE_SHA256;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9776 kern_type = KERN_TYPE_CLOUDKEY;
9777 dgst_size = DGST_SIZE_4_8;
9778 parse_func = cloudkey_parse_hash;
9779 sort_by_digest = sort_by_digest_4_8;
9780 opti_type = OPTI_TYPE_ZERO_BYTE;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 8300: hash_type = HASH_TYPE_SHA1;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_ST_HEX
9792 | OPTS_TYPE_ST_ADD80;
9793 kern_type = KERN_TYPE_NSEC3;
9794 dgst_size = DGST_SIZE_4_5;
9795 parse_func = nsec3_parse_hash;
9796 sort_by_digest = sort_by_digest_4_5;
9797 opti_type = OPTI_TYPE_ZERO_BYTE;
9798 dgst_pos0 = 3;
9799 dgst_pos1 = 4;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 1;
9802 break;
9803
9804 case 8400: hash_type = HASH_TYPE_SHA1;
9805 salt_type = SALT_TYPE_INTERN;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_BE
9808 | OPTS_TYPE_PT_ADD80
9809 | OPTS_TYPE_PT_ADDBITS15;
9810 kern_type = KERN_TYPE_WBB3;
9811 dgst_size = DGST_SIZE_4_5;
9812 parse_func = wbb3_parse_hash;
9813 sort_by_digest = sort_by_digest_4_5;
9814 opti_type = OPTI_TYPE_ZERO_BYTE
9815 | OPTI_TYPE_PRECOMPUTE_INIT
9816 | OPTI_TYPE_NOT_ITERATED;
9817 dgst_pos0 = 3;
9818 dgst_pos1 = 4;
9819 dgst_pos2 = 2;
9820 dgst_pos3 = 1;
9821 break;
9822
9823 case 8500: hash_type = HASH_TYPE_DESRACF;
9824 salt_type = SALT_TYPE_EMBEDDED;
9825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9826 opts_type = OPTS_TYPE_PT_GENERATE_LE
9827 | OPTS_TYPE_ST_UPPER;
9828 kern_type = KERN_TYPE_RACF;
9829 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9830 parse_func = racf_parse_hash;
9831 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9832 opti_type = OPTI_TYPE_ZERO_BYTE
9833 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9834 dgst_pos0 = 0;
9835 dgst_pos1 = 1;
9836 dgst_pos2 = 2;
9837 dgst_pos3 = 3;
9838 break;
9839
9840 case 8600: hash_type = HASH_TYPE_LOTUS5;
9841 salt_type = SALT_TYPE_NONE;
9842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9843 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9844 kern_type = KERN_TYPE_LOTUS5;
9845 dgst_size = DGST_SIZE_4_4;
9846 parse_func = lotus5_parse_hash;
9847 sort_by_digest = sort_by_digest_4_4;
9848 opti_type = OPTI_TYPE_EARLY_SKIP
9849 | OPTI_TYPE_NOT_ITERATED
9850 | OPTI_TYPE_NOT_SALTED
9851 | OPTI_TYPE_RAW_HASH;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 8700: hash_type = HASH_TYPE_LOTUS6;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9862 kern_type = KERN_TYPE_LOTUS6;
9863 dgst_size = DGST_SIZE_4_4;
9864 parse_func = lotus6_parse_hash;
9865 sort_by_digest = sort_by_digest_4_4;
9866 opti_type = OPTI_TYPE_EARLY_SKIP
9867 | OPTI_TYPE_NOT_ITERATED
9868 | OPTI_TYPE_RAW_HASH;
9869 dgst_pos0 = 0;
9870 dgst_pos1 = 1;
9871 dgst_pos2 = 2;
9872 dgst_pos3 = 3;
9873 break;
9874
9875 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9876 salt_type = SALT_TYPE_EMBEDDED;
9877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9878 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9879 kern_type = KERN_TYPE_ANDROIDFDE;
9880 dgst_size = DGST_SIZE_4_4;
9881 parse_func = androidfde_parse_hash;
9882 sort_by_digest = sort_by_digest_4_4;
9883 opti_type = OPTI_TYPE_ZERO_BYTE;
9884 dgst_pos0 = 0;
9885 dgst_pos1 = 1;
9886 dgst_pos2 = 2;
9887 dgst_pos3 = 3;
9888 break;
9889
9890 case 8900: hash_type = HASH_TYPE_SCRYPT;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9894 kern_type = KERN_TYPE_SCRYPT;
9895 dgst_size = DGST_SIZE_4_8;
9896 parse_func = scrypt_parse_hash;
9897 sort_by_digest = sort_by_digest_4_8;
9898 opti_type = OPTI_TYPE_ZERO_BYTE;
9899 dgst_pos0 = 0;
9900 dgst_pos1 = 1;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 3;
9903 break;
9904
9905 case 9000: hash_type = HASH_TYPE_SHA1;
9906 salt_type = SALT_TYPE_EMBEDDED;
9907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9908 opts_type = OPTS_TYPE_PT_GENERATE_LE
9909 | OPTS_TYPE_ST_GENERATE_LE;
9910 kern_type = KERN_TYPE_PSAFE2;
9911 dgst_size = DGST_SIZE_4_5;
9912 parse_func = psafe2_parse_hash;
9913 sort_by_digest = sort_by_digest_4_5;
9914 opti_type = OPTI_TYPE_ZERO_BYTE;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 9100: hash_type = HASH_TYPE_LOTUS8;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9925 kern_type = KERN_TYPE_LOTUS8;
9926 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9927 parse_func = lotus8_parse_hash;
9928 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 9200: hash_type = HASH_TYPE_SHA256;
9937 salt_type = SALT_TYPE_EMBEDDED;
9938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9940 kern_type = KERN_TYPE_PBKDF2_SHA256;
9941 dgst_size = DGST_SIZE_4_32;
9942 parse_func = cisco8_parse_hash;
9943 sort_by_digest = sort_by_digest_4_32;
9944 opti_type = OPTI_TYPE_ZERO_BYTE
9945 | OPTI_TYPE_SLOW_HASH_SIMD;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 9300: hash_type = HASH_TYPE_SCRYPT;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9956 kern_type = KERN_TYPE_SCRYPT;
9957 dgst_size = DGST_SIZE_4_8;
9958 parse_func = cisco9_parse_hash;
9959 sort_by_digest = sort_by_digest_4_8;
9960 opti_type = OPTI_TYPE_ZERO_BYTE;
9961 dgst_pos0 = 0;
9962 dgst_pos1 = 1;
9963 dgst_pos2 = 2;
9964 dgst_pos3 = 3;
9965 break;
9966
9967 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9968 salt_type = SALT_TYPE_EMBEDDED;
9969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9971 kern_type = KERN_TYPE_OFFICE2007;
9972 dgst_size = DGST_SIZE_4_4;
9973 parse_func = office2007_parse_hash;
9974 sort_by_digest = sort_by_digest_4_4;
9975 opti_type = OPTI_TYPE_ZERO_BYTE;
9976 dgst_pos0 = 0;
9977 dgst_pos1 = 1;
9978 dgst_pos2 = 2;
9979 dgst_pos3 = 3;
9980 break;
9981
9982 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9986 kern_type = KERN_TYPE_OFFICE2010;
9987 dgst_size = DGST_SIZE_4_4;
9988 parse_func = office2010_parse_hash;
9989 sort_by_digest = sort_by_digest_4_4;
9990 opti_type = OPTI_TYPE_ZERO_BYTE;
9991 dgst_pos0 = 0;
9992 dgst_pos1 = 1;
9993 dgst_pos2 = 2;
9994 dgst_pos3 = 3;
9995 break;
9996
9997 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9998 salt_type = SALT_TYPE_EMBEDDED;
9999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10001 kern_type = KERN_TYPE_OFFICE2013;
10002 dgst_size = DGST_SIZE_4_4;
10003 parse_func = office2013_parse_hash;
10004 sort_by_digest = sort_by_digest_4_4;
10005 opti_type = OPTI_TYPE_ZERO_BYTE;
10006 dgst_pos0 = 0;
10007 dgst_pos1 = 1;
10008 dgst_pos2 = 2;
10009 dgst_pos3 = 3;
10010 break;
10011
10012 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10013 salt_type = SALT_TYPE_EMBEDDED;
10014 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10015 opts_type = OPTS_TYPE_PT_GENERATE_LE
10016 | OPTS_TYPE_PT_ADD80
10017 | OPTS_TYPE_PT_UNICODE;
10018 kern_type = KERN_TYPE_OLDOFFICE01;
10019 dgst_size = DGST_SIZE_4_4;
10020 parse_func = oldoffice01_parse_hash;
10021 sort_by_digest = sort_by_digest_4_4;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_PRECOMPUTE_INIT
10024 | OPTI_TYPE_NOT_ITERATED;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_PT_ADD80;
10036 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10037 dgst_size = DGST_SIZE_4_4;
10038 parse_func = oldoffice01cm1_parse_hash;
10039 sort_by_digest = sort_by_digest_4_4;
10040 opti_type = OPTI_TYPE_ZERO_BYTE
10041 | OPTI_TYPE_PRECOMPUTE_INIT
10042 | OPTI_TYPE_NOT_ITERATED;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 1;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 3;
10047 break;
10048
10049 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE
10053 | OPTS_TYPE_PT_ADD80
10054 | OPTS_TYPE_PT_UNICODE
10055 | OPTS_TYPE_PT_NEVERCRACK;
10056 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10057 dgst_size = DGST_SIZE_4_4;
10058 parse_func = oldoffice01cm2_parse_hash;
10059 sort_by_digest = sort_by_digest_4_4;
10060 opti_type = OPTI_TYPE_ZERO_BYTE
10061 | OPTI_TYPE_PRECOMPUTE_INIT
10062 | OPTI_TYPE_NOT_ITERATED;
10063 dgst_pos0 = 0;
10064 dgst_pos1 = 1;
10065 dgst_pos2 = 2;
10066 dgst_pos3 = 3;
10067 break;
10068
10069 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10070 salt_type = SALT_TYPE_EMBEDDED;
10071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_BE
10073 | OPTS_TYPE_PT_ADD80
10074 | OPTS_TYPE_PT_UNICODE;
10075 kern_type = KERN_TYPE_OLDOFFICE34;
10076 dgst_size = DGST_SIZE_4_4;
10077 parse_func = oldoffice34_parse_hash;
10078 sort_by_digest = sort_by_digest_4_4;
10079 opti_type = OPTI_TYPE_ZERO_BYTE
10080 | OPTI_TYPE_PRECOMPUTE_INIT
10081 | OPTI_TYPE_NOT_ITERATED;
10082 dgst_pos0 = 0;
10083 dgst_pos1 = 1;
10084 dgst_pos2 = 2;
10085 dgst_pos3 = 3;
10086 break;
10087
10088 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10089 salt_type = SALT_TYPE_EMBEDDED;
10090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10092 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10093 dgst_size = DGST_SIZE_4_4;
10094 parse_func = oldoffice34cm1_parse_hash;
10095 sort_by_digest = sort_by_digest_4_4;
10096 opti_type = OPTI_TYPE_ZERO_BYTE
10097 | OPTI_TYPE_PRECOMPUTE_INIT
10098 | OPTI_TYPE_NOT_ITERATED;
10099 dgst_pos0 = 0;
10100 dgst_pos1 = 1;
10101 dgst_pos2 = 2;
10102 dgst_pos3 = 3;
10103 break;
10104
10105 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10106 salt_type = SALT_TYPE_EMBEDDED;
10107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10108 opts_type = OPTS_TYPE_PT_GENERATE_BE
10109 | OPTS_TYPE_PT_ADD80
10110 | OPTS_TYPE_PT_UNICODE
10111 | OPTS_TYPE_PT_NEVERCRACK;
10112 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10113 dgst_size = DGST_SIZE_4_4;
10114 parse_func = oldoffice34cm2_parse_hash;
10115 sort_by_digest = sort_by_digest_4_4;
10116 opti_type = OPTI_TYPE_ZERO_BYTE
10117 | OPTI_TYPE_PRECOMPUTE_INIT
10118 | OPTI_TYPE_NOT_ITERATED;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 9900: hash_type = HASH_TYPE_MD5;
10126 salt_type = SALT_TYPE_NONE;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_RADMIN2;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = radmin2_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_PRECOMPUTE_INIT
10135 | OPTI_TYPE_EARLY_SKIP
10136 | OPTI_TYPE_NOT_ITERATED
10137 | OPTI_TYPE_NOT_SALTED;
10138 dgst_pos0 = 0;
10139 dgst_pos1 = 3;
10140 dgst_pos2 = 2;
10141 dgst_pos3 = 1;
10142 break;
10143
10144 case 10000: hash_type = HASH_TYPE_SHA256;
10145 salt_type = SALT_TYPE_EMBEDDED;
10146 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10147 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10148 kern_type = KERN_TYPE_PBKDF2_SHA256;
10149 dgst_size = DGST_SIZE_4_32;
10150 parse_func = djangopbkdf2_parse_hash;
10151 sort_by_digest = sort_by_digest_4_32;
10152 opti_type = OPTI_TYPE_ZERO_BYTE
10153 | OPTI_TYPE_SLOW_HASH_SIMD;
10154 dgst_pos0 = 0;
10155 dgst_pos1 = 1;
10156 dgst_pos2 = 2;
10157 dgst_pos3 = 3;
10158 break;
10159
10160 case 10100: hash_type = HASH_TYPE_SIPHASH;
10161 salt_type = SALT_TYPE_EMBEDDED;
10162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10163 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10164 kern_type = KERN_TYPE_SIPHASH;
10165 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10166 parse_func = siphash_parse_hash;
10167 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10168 opti_type = OPTI_TYPE_ZERO_BYTE
10169 | OPTI_TYPE_NOT_ITERATED
10170 | OPTI_TYPE_RAW_HASH;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 10200: hash_type = HASH_TYPE_MD5;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE
10181 | OPTS_TYPE_ST_ADD80
10182 | OPTS_TYPE_ST_ADDBITS14;
10183 kern_type = KERN_TYPE_HMACMD5_PW;
10184 dgst_size = DGST_SIZE_4_4;
10185 parse_func = crammd5_parse_hash;
10186 sort_by_digest = sort_by_digest_4_4;
10187 opti_type = OPTI_TYPE_ZERO_BYTE
10188 | OPTI_TYPE_NOT_ITERATED;
10189 dgst_pos0 = 0;
10190 dgst_pos1 = 3;
10191 dgst_pos2 = 2;
10192 dgst_pos3 = 1;
10193 break;
10194
10195 case 10300: hash_type = HASH_TYPE_SHA1;
10196 salt_type = SALT_TYPE_EMBEDDED;
10197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10198 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10199 kern_type = KERN_TYPE_SAPH_SHA1;
10200 dgst_size = DGST_SIZE_4_5;
10201 parse_func = saph_sha1_parse_hash;
10202 sort_by_digest = sort_by_digest_4_5;
10203 opti_type = OPTI_TYPE_ZERO_BYTE;
10204 dgst_pos0 = 0;
10205 dgst_pos1 = 1;
10206 dgst_pos2 = 2;
10207 dgst_pos3 = 3;
10208 break;
10209
10210 case 10400: hash_type = HASH_TYPE_PDFU16;
10211 salt_type = SALT_TYPE_EMBEDDED;
10212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10213 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10214 kern_type = KERN_TYPE_PDF11;
10215 dgst_size = DGST_SIZE_4_4;
10216 parse_func = pdf11_parse_hash;
10217 sort_by_digest = sort_by_digest_4_4;
10218 opti_type = OPTI_TYPE_ZERO_BYTE
10219 | OPTI_TYPE_NOT_ITERATED;
10220 dgst_pos0 = 0;
10221 dgst_pos1 = 1;
10222 dgst_pos2 = 2;
10223 dgst_pos3 = 3;
10224 break;
10225
10226 case 10410: hash_type = HASH_TYPE_PDFU16;
10227 salt_type = SALT_TYPE_EMBEDDED;
10228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10230 kern_type = KERN_TYPE_PDF11CM1;
10231 dgst_size = DGST_SIZE_4_4;
10232 parse_func = pdf11cm1_parse_hash;
10233 sort_by_digest = sort_by_digest_4_4;
10234 opti_type = OPTI_TYPE_ZERO_BYTE
10235 | OPTI_TYPE_NOT_ITERATED;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 10420: hash_type = HASH_TYPE_PDFU16;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_PDF11CM2;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = pdf11cm2_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE
10251 | OPTI_TYPE_NOT_ITERATED;
10252 dgst_pos0 = 0;
10253 dgst_pos1 = 1;
10254 dgst_pos2 = 2;
10255 dgst_pos3 = 3;
10256 break;
10257
10258 case 10500: hash_type = HASH_TYPE_PDFU16;
10259 salt_type = SALT_TYPE_EMBEDDED;
10260 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10262 kern_type = KERN_TYPE_PDF14;
10263 dgst_size = DGST_SIZE_4_4;
10264 parse_func = pdf14_parse_hash;
10265 sort_by_digest = sort_by_digest_4_4;
10266 opti_type = OPTI_TYPE_ZERO_BYTE
10267 | OPTI_TYPE_NOT_ITERATED;
10268 dgst_pos0 = 0;
10269 dgst_pos1 = 1;
10270 dgst_pos2 = 2;
10271 dgst_pos3 = 3;
10272 break;
10273
10274 case 10600: hash_type = HASH_TYPE_SHA256;
10275 salt_type = SALT_TYPE_EMBEDDED;
10276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10277 opts_type = OPTS_TYPE_PT_GENERATE_BE
10278 | OPTS_TYPE_ST_ADD80
10279 | OPTS_TYPE_ST_ADDBITS15
10280 | OPTS_TYPE_HASH_COPY;
10281 kern_type = KERN_TYPE_SHA256_PWSLT;
10282 dgst_size = DGST_SIZE_4_8;
10283 parse_func = pdf17l3_parse_hash;
10284 sort_by_digest = sort_by_digest_4_8;
10285 opti_type = OPTI_TYPE_ZERO_BYTE
10286 | OPTI_TYPE_PRECOMPUTE_INIT
10287 | OPTI_TYPE_PRECOMPUTE_MERKLE
10288 | OPTI_TYPE_EARLY_SKIP
10289 | OPTI_TYPE_NOT_ITERATED
10290 | OPTI_TYPE_APPENDED_SALT
10291 | OPTI_TYPE_RAW_HASH;
10292 dgst_pos0 = 3;
10293 dgst_pos1 = 7;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 6;
10296 break;
10297
10298 case 10700: hash_type = HASH_TYPE_PDFU32;
10299 salt_type = SALT_TYPE_EMBEDDED;
10300 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_LE
10302 | OPTS_TYPE_HASH_COPY;
10303 kern_type = KERN_TYPE_PDF17L8;
10304 dgst_size = DGST_SIZE_4_8;
10305 parse_func = pdf17l8_parse_hash;
10306 sort_by_digest = sort_by_digest_4_8;
10307 opti_type = OPTI_TYPE_ZERO_BYTE
10308 | OPTI_TYPE_NOT_ITERATED;
10309 dgst_pos0 = 0;
10310 dgst_pos1 = 1;
10311 dgst_pos2 = 2;
10312 dgst_pos3 = 3;
10313 break;
10314
10315 case 10800: hash_type = HASH_TYPE_SHA384;
10316 salt_type = SALT_TYPE_NONE;
10317 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10318 opts_type = OPTS_TYPE_PT_GENERATE_BE
10319 | OPTS_TYPE_PT_ADD80
10320 | OPTS_TYPE_PT_ADDBITS15;
10321 kern_type = KERN_TYPE_SHA384;
10322 dgst_size = DGST_SIZE_8_8;
10323 parse_func = sha384_parse_hash;
10324 sort_by_digest = sort_by_digest_8_8;
10325 opti_type = OPTI_TYPE_ZERO_BYTE
10326 | OPTI_TYPE_PRECOMPUTE_INIT
10327 | OPTI_TYPE_PRECOMPUTE_MERKLE
10328 | OPTI_TYPE_EARLY_SKIP
10329 | OPTI_TYPE_NOT_ITERATED
10330 | OPTI_TYPE_NOT_SALTED
10331 | OPTI_TYPE_USES_BITS_64
10332 | OPTI_TYPE_RAW_HASH;
10333 dgst_pos0 = 6;
10334 dgst_pos1 = 7;
10335 dgst_pos2 = 4;
10336 dgst_pos3 = 5;
10337 break;
10338
10339 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_LE
10343 | OPTS_TYPE_ST_BASE64
10344 | OPTS_TYPE_HASH_COPY;
10345 kern_type = KERN_TYPE_PBKDF2_SHA256;
10346 dgst_size = DGST_SIZE_4_32;
10347 parse_func = pbkdf2_sha256_parse_hash;
10348 sort_by_digest = sort_by_digest_4_32;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_SLOW_HASH_SIMD;
10351 dgst_pos0 = 0;
10352 dgst_pos1 = 1;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 3;
10355 break;
10356
10357 case 11000: hash_type = HASH_TYPE_MD5;
10358 salt_type = SALT_TYPE_INTERN;
10359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10360 opts_type = OPTS_TYPE_PT_GENERATE_LE
10361 | OPTS_TYPE_PT_ADD80;
10362 kern_type = KERN_TYPE_PRESTASHOP;
10363 dgst_size = DGST_SIZE_4_4;
10364 parse_func = prestashop_parse_hash;
10365 sort_by_digest = sort_by_digest_4_4;
10366 opti_type = OPTI_TYPE_ZERO_BYTE
10367 | OPTI_TYPE_PRECOMPUTE_INIT
10368 | OPTI_TYPE_NOT_ITERATED
10369 | OPTI_TYPE_PREPENDED_SALT;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 3;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 1;
10374 break;
10375
10376 case 11100: hash_type = HASH_TYPE_MD5;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE
10380 | OPTS_TYPE_ST_ADD80;
10381 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10382 dgst_size = DGST_SIZE_4_4;
10383 parse_func = postgresql_auth_parse_hash;
10384 sort_by_digest = sort_by_digest_4_4;
10385 opti_type = OPTI_TYPE_ZERO_BYTE
10386 | OPTI_TYPE_PRECOMPUTE_INIT
10387 | OPTI_TYPE_PRECOMPUTE_MERKLE
10388 | OPTI_TYPE_EARLY_SKIP;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 3;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 1;
10393 break;
10394
10395 case 11200: hash_type = HASH_TYPE_SHA1;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_BE
10399 | OPTS_TYPE_PT_ADD80
10400 | OPTS_TYPE_ST_HEX;
10401 kern_type = KERN_TYPE_MYSQL_AUTH;
10402 dgst_size = DGST_SIZE_4_5;
10403 parse_func = mysql_auth_parse_hash;
10404 sort_by_digest = sort_by_digest_4_5;
10405 opti_type = OPTI_TYPE_ZERO_BYTE
10406 | OPTI_TYPE_EARLY_SKIP;
10407 dgst_pos0 = 3;
10408 dgst_pos1 = 4;
10409 dgst_pos2 = 2;
10410 dgst_pos3 = 1;
10411 break;
10412
10413 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10414 salt_type = SALT_TYPE_EMBEDDED;
10415 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10416 opts_type = OPTS_TYPE_PT_GENERATE_LE
10417 | OPTS_TYPE_ST_HEX
10418 | OPTS_TYPE_ST_ADD80;
10419 kern_type = KERN_TYPE_BITCOIN_WALLET;
10420 dgst_size = DGST_SIZE_4_4;
10421 parse_func = bitcoin_wallet_parse_hash;
10422 sort_by_digest = sort_by_digest_4_4;
10423 opti_type = OPTI_TYPE_ZERO_BYTE;
10424 dgst_pos0 = 0;
10425 dgst_pos1 = 1;
10426 dgst_pos2 = 2;
10427 dgst_pos3 = 3;
10428 break;
10429
10430 case 11400: hash_type = HASH_TYPE_MD5;
10431 salt_type = SALT_TYPE_EMBEDDED;
10432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10433 opts_type = OPTS_TYPE_PT_GENERATE_LE
10434 | OPTS_TYPE_PT_ADD80
10435 | OPTS_TYPE_HASH_COPY;
10436 kern_type = KERN_TYPE_SIP_AUTH;
10437 dgst_size = DGST_SIZE_4_4;
10438 parse_func = sip_auth_parse_hash;
10439 sort_by_digest = sort_by_digest_4_4;
10440 opti_type = OPTI_TYPE_ZERO_BYTE;
10441 dgst_pos0 = 0;
10442 dgst_pos1 = 3;
10443 dgst_pos2 = 2;
10444 dgst_pos3 = 1;
10445 break;
10446
10447 case 11500: hash_type = HASH_TYPE_CRC32;
10448 salt_type = SALT_TYPE_INTERN;
10449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10450 opts_type = OPTS_TYPE_PT_GENERATE_LE
10451 | OPTS_TYPE_ST_GENERATE_LE
10452 | OPTS_TYPE_ST_HEX;
10453 kern_type = KERN_TYPE_CRC32;
10454 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10455 parse_func = crc32_parse_hash;
10456 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10457 opti_type = OPTI_TYPE_ZERO_BYTE;
10458 dgst_pos0 = 0;
10459 dgst_pos1 = 1;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 3;
10462 break;
10463
10464 case 11600: hash_type = HASH_TYPE_AES;
10465 salt_type = SALT_TYPE_EMBEDDED;
10466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE
10468 | OPTS_TYPE_PT_NEVERCRACK;
10469 kern_type = KERN_TYPE_SEVEN_ZIP;
10470 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10471 parse_func = seven_zip_parse_hash;
10472 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10473 opti_type = OPTI_TYPE_ZERO_BYTE;
10474 dgst_pos0 = 0;
10475 dgst_pos1 = 1;
10476 dgst_pos2 = 2;
10477 dgst_pos3 = 3;
10478 break;
10479
10480 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10481 salt_type = SALT_TYPE_NONE;
10482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10483 opts_type = OPTS_TYPE_PT_GENERATE_LE
10484 | OPTS_TYPE_PT_ADD01;
10485 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10486 dgst_size = DGST_SIZE_4_8;
10487 parse_func = gost2012sbog_256_parse_hash;
10488 sort_by_digest = sort_by_digest_4_8;
10489 opti_type = OPTI_TYPE_ZERO_BYTE;
10490 dgst_pos0 = 0;
10491 dgst_pos1 = 1;
10492 dgst_pos2 = 2;
10493 dgst_pos3 = 3;
10494 break;
10495
10496 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10497 salt_type = SALT_TYPE_NONE;
10498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10499 opts_type = OPTS_TYPE_PT_GENERATE_LE
10500 | OPTS_TYPE_PT_ADD01;
10501 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10502 dgst_size = DGST_SIZE_4_16;
10503 parse_func = gost2012sbog_512_parse_hash;
10504 sort_by_digest = sort_by_digest_4_16;
10505 opti_type = OPTI_TYPE_ZERO_BYTE;
10506 dgst_pos0 = 0;
10507 dgst_pos1 = 1;
10508 dgst_pos2 = 2;
10509 dgst_pos3 = 3;
10510 break;
10511
10512 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10513 salt_type = SALT_TYPE_EMBEDDED;
10514 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10515 opts_type = OPTS_TYPE_PT_GENERATE_LE
10516 | OPTS_TYPE_ST_BASE64
10517 | OPTS_TYPE_HASH_COPY;
10518 kern_type = KERN_TYPE_PBKDF2_MD5;
10519 dgst_size = DGST_SIZE_4_32;
10520 parse_func = pbkdf2_md5_parse_hash;
10521 sort_by_digest = sort_by_digest_4_32;
10522 opti_type = OPTI_TYPE_ZERO_BYTE
10523 | OPTI_TYPE_SLOW_HASH_SIMD;
10524 dgst_pos0 = 0;
10525 dgst_pos1 = 1;
10526 dgst_pos2 = 2;
10527 dgst_pos3 = 3;
10528 break;
10529
10530 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10531 salt_type = SALT_TYPE_EMBEDDED;
10532 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10533 opts_type = OPTS_TYPE_PT_GENERATE_LE
10534 | OPTS_TYPE_ST_BASE64
10535 | OPTS_TYPE_HASH_COPY;
10536 kern_type = KERN_TYPE_PBKDF2_SHA1;
10537 dgst_size = DGST_SIZE_4_32;
10538 parse_func = pbkdf2_sha1_parse_hash;
10539 sort_by_digest = sort_by_digest_4_32;
10540 opti_type = OPTI_TYPE_ZERO_BYTE
10541 | OPTI_TYPE_SLOW_HASH_SIMD;
10542 dgst_pos0 = 0;
10543 dgst_pos1 = 1;
10544 dgst_pos2 = 2;
10545 dgst_pos3 = 3;
10546 break;
10547
10548 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10549 salt_type = SALT_TYPE_EMBEDDED;
10550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10551 opts_type = OPTS_TYPE_PT_GENERATE_LE
10552 | OPTS_TYPE_ST_BASE64
10553 | OPTS_TYPE_HASH_COPY;
10554 kern_type = KERN_TYPE_PBKDF2_SHA512;
10555 dgst_size = DGST_SIZE_8_16;
10556 parse_func = pbkdf2_sha512_parse_hash;
10557 sort_by_digest = sort_by_digest_8_16;
10558 opti_type = OPTI_TYPE_ZERO_BYTE
10559 | OPTI_TYPE_USES_BITS_64
10560 | OPTI_TYPE_SLOW_HASH_SIMD;
10561 dgst_pos0 = 0;
10562 dgst_pos1 = 1;
10563 dgst_pos2 = 2;
10564 dgst_pos3 = 3;
10565 break;
10566
10567 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10568 salt_type = SALT_TYPE_EMBEDDED;
10569 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10570 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10571 kern_type = KERN_TYPE_ECRYPTFS;
10572 dgst_size = DGST_SIZE_8_8;
10573 parse_func = ecryptfs_parse_hash;
10574 sort_by_digest = sort_by_digest_8_8;
10575 opti_type = OPTI_TYPE_ZERO_BYTE
10576 | OPTI_TYPE_USES_BITS_64;
10577 dgst_pos0 = 0;
10578 dgst_pos1 = 1;
10579 dgst_pos2 = 2;
10580 dgst_pos3 = 3;
10581 break;
10582
10583 case 12300: hash_type = HASH_TYPE_ORACLET;
10584 salt_type = SALT_TYPE_EMBEDDED;
10585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10586 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10587 kern_type = KERN_TYPE_ORACLET;
10588 dgst_size = DGST_SIZE_8_16;
10589 parse_func = oraclet_parse_hash;
10590 sort_by_digest = sort_by_digest_8_16;
10591 opti_type = OPTI_TYPE_ZERO_BYTE
10592 | OPTI_TYPE_USES_BITS_64;
10593 dgst_pos0 = 0;
10594 dgst_pos1 = 1;
10595 dgst_pos2 = 2;
10596 dgst_pos3 = 3;
10597 break;
10598
10599 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10600 salt_type = SALT_TYPE_EMBEDDED;
10601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10603 kern_type = KERN_TYPE_BSDICRYPT;
10604 dgst_size = DGST_SIZE_4_4;
10605 parse_func = bsdicrypt_parse_hash;
10606 sort_by_digest = sort_by_digest_4_4;
10607 opti_type = OPTI_TYPE_ZERO_BYTE
10608 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10609 dgst_pos0 = 0;
10610 dgst_pos1 = 1;
10611 dgst_pos2 = 2;
10612 dgst_pos3 = 3;
10613 break;
10614
10615 case 12500: hash_type = HASH_TYPE_RAR3HP;
10616 salt_type = SALT_TYPE_EMBEDDED;
10617 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10618 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10619 kern_type = KERN_TYPE_RAR3;
10620 dgst_size = DGST_SIZE_4_4;
10621 parse_func = rar3hp_parse_hash;
10622 sort_by_digest = sort_by_digest_4_4;
10623 opti_type = OPTI_TYPE_ZERO_BYTE;
10624 dgst_pos0 = 0;
10625 dgst_pos1 = 1;
10626 dgst_pos2 = 2;
10627 dgst_pos3 = 3;
10628 break;
10629
10630 case 12600: hash_type = HASH_TYPE_SHA256;
10631 salt_type = SALT_TYPE_INTERN;
10632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10633 opts_type = OPTS_TYPE_PT_GENERATE_BE
10634 | OPTS_TYPE_PT_ADD80;
10635 kern_type = KERN_TYPE_CF10;
10636 dgst_size = DGST_SIZE_4_8;
10637 parse_func = cf10_parse_hash;
10638 sort_by_digest = sort_by_digest_4_8;
10639 opti_type = OPTI_TYPE_ZERO_BYTE
10640 | OPTI_TYPE_PRECOMPUTE_INIT
10641 | OPTI_TYPE_EARLY_SKIP
10642 | OPTI_TYPE_NOT_ITERATED;
10643 dgst_pos0 = 3;
10644 dgst_pos1 = 7;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 6;
10647 break;
10648
10649 case 12700: hash_type = HASH_TYPE_AES;
10650 salt_type = SALT_TYPE_EMBEDDED;
10651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10652 opts_type = OPTS_TYPE_PT_GENERATE_LE
10653 | OPTS_TYPE_HASH_COPY;
10654 kern_type = KERN_TYPE_MYWALLET;
10655 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10656 parse_func = mywallet_parse_hash;
10657 sort_by_digest = sort_by_digest_4_5;
10658 opti_type = OPTI_TYPE_ZERO_BYTE;
10659 dgst_pos0 = 0;
10660 dgst_pos1 = 1;
10661 dgst_pos2 = 2;
10662 dgst_pos3 = 3;
10663 break;
10664
10665 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10666 salt_type = SALT_TYPE_EMBEDDED;
10667 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10669 kern_type = KERN_TYPE_MS_DRSR;
10670 dgst_size = DGST_SIZE_4_8;
10671 parse_func = ms_drsr_parse_hash;
10672 sort_by_digest = sort_by_digest_4_8;
10673 opti_type = OPTI_TYPE_ZERO_BYTE;
10674 dgst_pos0 = 0;
10675 dgst_pos1 = 1;
10676 dgst_pos2 = 2;
10677 dgst_pos3 = 3;
10678 break;
10679
10680 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10681 salt_type = SALT_TYPE_EMBEDDED;
10682 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10683 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10684 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10685 dgst_size = DGST_SIZE_4_8;
10686 parse_func = androidfde_samsung_parse_hash;
10687 sort_by_digest = sort_by_digest_4_8;
10688 opti_type = OPTI_TYPE_ZERO_BYTE;
10689 dgst_pos0 = 0;
10690 dgst_pos1 = 1;
10691 dgst_pos2 = 2;
10692 dgst_pos3 = 3;
10693 break;
10694
10695 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10696 salt_type = SALT_TYPE_EMBEDDED;
10697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10698 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10699 kern_type = KERN_TYPE_RAR5;
10700 dgst_size = DGST_SIZE_4_4;
10701 parse_func = rar5_parse_hash;
10702 sort_by_digest = sort_by_digest_4_4;
10703 opti_type = OPTI_TYPE_ZERO_BYTE;
10704 dgst_pos0 = 0;
10705 dgst_pos1 = 1;
10706 dgst_pos2 = 2;
10707 dgst_pos3 = 3;
10708 break;
10709
10710 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10711 salt_type = SALT_TYPE_EMBEDDED;
10712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10713 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10714 kern_type = KERN_TYPE_KRB5TGS;
10715 dgst_size = DGST_SIZE_4_4;
10716 parse_func = krb5tgs_parse_hash;
10717 sort_by_digest = sort_by_digest_4_4;
10718 opti_type = OPTI_TYPE_ZERO_BYTE
10719 | OPTI_TYPE_NOT_ITERATED;
10720 dgst_pos0 = 0;
10721 dgst_pos1 = 1;
10722 dgst_pos2 = 2;
10723 dgst_pos3 = 3;
10724 break;
10725
10726 case 13200: hash_type = HASH_TYPE_AES;
10727 salt_type = SALT_TYPE_EMBEDDED;
10728 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10729 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10730 kern_type = KERN_TYPE_AXCRYPT;
10731 dgst_size = DGST_SIZE_4_4;
10732 parse_func = axcrypt_parse_hash;
10733 sort_by_digest = sort_by_digest_4_4;
10734 opti_type = OPTI_TYPE_ZERO_BYTE;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 1;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 3;
10739 break;
10740
10741 case 13300: hash_type = HASH_TYPE_SHA1;
10742 salt_type = SALT_TYPE_NONE;
10743 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_BE
10745 | OPTS_TYPE_PT_ADD80
10746 | OPTS_TYPE_PT_ADDBITS15;
10747 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10748 dgst_size = DGST_SIZE_4_5;
10749 parse_func = sha1axcrypt_parse_hash;
10750 sort_by_digest = sort_by_digest_4_5;
10751 opti_type = OPTI_TYPE_ZERO_BYTE
10752 | OPTI_TYPE_PRECOMPUTE_INIT
10753 | OPTI_TYPE_EARLY_SKIP
10754 | OPTI_TYPE_NOT_ITERATED
10755 | OPTI_TYPE_NOT_SALTED;
10756 dgst_pos0 = 0;
10757 dgst_pos1 = 4;
10758 dgst_pos2 = 3;
10759 dgst_pos3 = 2;
10760 break;
10761
10762 case 13400: hash_type = HASH_TYPE_AES;
10763 salt_type = SALT_TYPE_EMBEDDED;
10764 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10765 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10766 kern_type = KERN_TYPE_KEEPASS;
10767 dgst_size = DGST_SIZE_4_4;
10768 parse_func = keepass_parse_hash;
10769 sort_by_digest = sort_by_digest_4_4;
10770 opti_type = OPTI_TYPE_ZERO_BYTE;
10771 dgst_pos0 = 0;
10772 dgst_pos1 = 1;
10773 dgst_pos2 = 2;
10774 dgst_pos3 = 3;
10775 break;
10776
10777 case 13500: hash_type = HASH_TYPE_SHA1;
10778 salt_type = SALT_TYPE_EMBEDDED;
10779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10780 opts_type = OPTS_TYPE_PT_GENERATE_BE
10781 | OPTS_TYPE_PT_UNICODE
10782 | OPTS_TYPE_PT_ADD80;
10783 kern_type = KERN_TYPE_PSTOKEN;
10784 dgst_size = DGST_SIZE_4_5;
10785 parse_func = pstoken_parse_hash;
10786 sort_by_digest = sort_by_digest_4_5;
10787 opti_type = OPTI_TYPE_ZERO_BYTE
10788 | OPTI_TYPE_PRECOMPUTE_INIT
10789 | OPTI_TYPE_EARLY_SKIP
10790 | OPTI_TYPE_NOT_ITERATED
10791 | OPTI_TYPE_PREPENDED_SALT
10792 | OPTI_TYPE_RAW_HASH;
10793 dgst_pos0 = 3;
10794 dgst_pos1 = 4;
10795 dgst_pos2 = 2;
10796 dgst_pos3 = 1;
10797 break;
10798
10799 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10800 salt_type = SALT_TYPE_EMBEDDED;
10801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10803 kern_type = KERN_TYPE_ZIP2;
10804 dgst_size = DGST_SIZE_4_4;
10805 parse_func = zip2_parse_hash;
10806 sort_by_digest = sort_by_digest_4_4;
10807 opti_type = OPTI_TYPE_ZERO_BYTE;
10808 dgst_pos0 = 0;
10809 dgst_pos1 = 1;
10810 dgst_pos2 = 2;
10811 dgst_pos3 = 3;
10812 break;
10813
10814 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10815 salt_type = SALT_TYPE_EMBEDDED;
10816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10817 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10818 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10819 dgst_size = DGST_SIZE_4_5;
10820 parse_func = veracrypt_parse_hash_655331;
10821 sort_by_digest = sort_by_digest_4_5;
10822 opti_type = OPTI_TYPE_ZERO_BYTE;
10823 dgst_pos0 = 0;
10824 dgst_pos1 = 1;
10825 dgst_pos2 = 2;
10826 dgst_pos3 = 3;
10827 break;
10828
10829 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10830 salt_type = SALT_TYPE_EMBEDDED;
10831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10832 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10833 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10834 dgst_size = DGST_SIZE_4_5;
10835 parse_func = veracrypt_parse_hash_655331;
10836 sort_by_digest = sort_by_digest_4_5;
10837 opti_type = OPTI_TYPE_ZERO_BYTE;
10838 dgst_pos0 = 0;
10839 dgst_pos1 = 1;
10840 dgst_pos2 = 2;
10841 dgst_pos3 = 3;
10842 break;
10843
10844 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10845 salt_type = SALT_TYPE_EMBEDDED;
10846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10848 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10849 dgst_size = DGST_SIZE_4_5;
10850 parse_func = veracrypt_parse_hash_655331;
10851 sort_by_digest = sort_by_digest_4_5;
10852 opti_type = OPTI_TYPE_ZERO_BYTE;
10853 dgst_pos0 = 0;
10854 dgst_pos1 = 1;
10855 dgst_pos2 = 2;
10856 dgst_pos3 = 3;
10857 break;
10858
10859 case 13721: hash_type = HASH_TYPE_SHA512;
10860 salt_type = SALT_TYPE_EMBEDDED;
10861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10862 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10863 kern_type = KERN_TYPE_TCSHA512_XTS512;
10864 dgst_size = DGST_SIZE_8_8;
10865 parse_func = veracrypt_parse_hash_500000;
10866 sort_by_digest = sort_by_digest_8_8;
10867 opti_type = OPTI_TYPE_ZERO_BYTE
10868 | OPTI_TYPE_USES_BITS_64;
10869 dgst_pos0 = 0;
10870 dgst_pos1 = 1;
10871 dgst_pos2 = 2;
10872 dgst_pos3 = 3;
10873 break;
10874
10875 case 13722: hash_type = HASH_TYPE_SHA512;
10876 salt_type = SALT_TYPE_EMBEDDED;
10877 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10878 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10879 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10880 dgst_size = DGST_SIZE_8_8;
10881 parse_func = veracrypt_parse_hash_500000;
10882 sort_by_digest = sort_by_digest_8_8;
10883 opti_type = OPTI_TYPE_ZERO_BYTE
10884 | OPTI_TYPE_USES_BITS_64;
10885 dgst_pos0 = 0;
10886 dgst_pos1 = 1;
10887 dgst_pos2 = 2;
10888 dgst_pos3 = 3;
10889 break;
10890
10891 case 13723: hash_type = HASH_TYPE_SHA512;
10892 salt_type = SALT_TYPE_EMBEDDED;
10893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10894 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10895 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10896 dgst_size = DGST_SIZE_8_8;
10897 parse_func = veracrypt_parse_hash_500000;
10898 sort_by_digest = sort_by_digest_8_8;
10899 opti_type = OPTI_TYPE_ZERO_BYTE
10900 | OPTI_TYPE_USES_BITS_64;
10901 dgst_pos0 = 0;
10902 dgst_pos1 = 1;
10903 dgst_pos2 = 2;
10904 dgst_pos3 = 3;
10905 break;
10906
10907 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10908 salt_type = SALT_TYPE_EMBEDDED;
10909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10911 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10912 dgst_size = DGST_SIZE_4_8;
10913 parse_func = veracrypt_parse_hash_500000;
10914 sort_by_digest = sort_by_digest_4_8;
10915 opti_type = OPTI_TYPE_ZERO_BYTE;
10916 dgst_pos0 = 0;
10917 dgst_pos1 = 1;
10918 dgst_pos2 = 2;
10919 dgst_pos3 = 3;
10920 break;
10921
10922 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10923 salt_type = SALT_TYPE_EMBEDDED;
10924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10926 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10927 dgst_size = DGST_SIZE_4_8;
10928 parse_func = veracrypt_parse_hash_500000;
10929 sort_by_digest = sort_by_digest_4_8;
10930 opti_type = OPTI_TYPE_ZERO_BYTE;
10931 dgst_pos0 = 0;
10932 dgst_pos1 = 1;
10933 dgst_pos2 = 2;
10934 dgst_pos3 = 3;
10935 break;
10936
10937 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10938 salt_type = SALT_TYPE_EMBEDDED;
10939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10941 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10942 dgst_size = DGST_SIZE_4_8;
10943 parse_func = veracrypt_parse_hash_500000;
10944 sort_by_digest = sort_by_digest_4_8;
10945 opti_type = OPTI_TYPE_ZERO_BYTE;
10946 dgst_pos0 = 0;
10947 dgst_pos1 = 1;
10948 dgst_pos2 = 2;
10949 dgst_pos3 = 3;
10950 break;
10951
10952 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10953 salt_type = SALT_TYPE_EMBEDDED;
10954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10956 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10957 dgst_size = DGST_SIZE_4_5;
10958 parse_func = veracrypt_parse_hash_327661;
10959 sort_by_digest = sort_by_digest_4_5;
10960 opti_type = OPTI_TYPE_ZERO_BYTE;
10961 dgst_pos0 = 0;
10962 dgst_pos1 = 1;
10963 dgst_pos2 = 2;
10964 dgst_pos3 = 3;
10965 break;
10966
10967 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10968 salt_type = SALT_TYPE_EMBEDDED;
10969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10971 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10972 dgst_size = DGST_SIZE_4_5;
10973 parse_func = veracrypt_parse_hash_327661;
10974 sort_by_digest = sort_by_digest_4_5;
10975 opti_type = OPTI_TYPE_ZERO_BYTE;
10976 dgst_pos0 = 0;
10977 dgst_pos1 = 1;
10978 dgst_pos2 = 2;
10979 dgst_pos3 = 3;
10980 break;
10981
10982 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10983 salt_type = SALT_TYPE_EMBEDDED;
10984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10986 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10987 dgst_size = DGST_SIZE_4_5;
10988 parse_func = veracrypt_parse_hash_327661;
10989 sort_by_digest = sort_by_digest_4_5;
10990 opti_type = OPTI_TYPE_ZERO_BYTE;
10991 dgst_pos0 = 0;
10992 dgst_pos1 = 1;
10993 dgst_pos2 = 2;
10994 dgst_pos3 = 3;
10995 break;
10996
10997 case 13751: hash_type = HASH_TYPE_SHA256;
10998 salt_type = SALT_TYPE_EMBEDDED;
10999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11000 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11001 kern_type = KERN_TYPE_VCSHA256_XTS512;
11002 dgst_size = DGST_SIZE_4_8;
11003 parse_func = veracrypt_parse_hash_500000;
11004 sort_by_digest = sort_by_digest_4_8;
11005 opti_type = OPTI_TYPE_ZERO_BYTE;
11006 dgst_pos0 = 0;
11007 dgst_pos1 = 1;
11008 dgst_pos2 = 2;
11009 dgst_pos3 = 3;
11010 break;
11011
11012 case 13752: hash_type = HASH_TYPE_SHA256;
11013 salt_type = SALT_TYPE_EMBEDDED;
11014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11015 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11016 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11017 dgst_size = DGST_SIZE_4_8;
11018 parse_func = veracrypt_parse_hash_500000;
11019 sort_by_digest = sort_by_digest_4_8;
11020 opti_type = OPTI_TYPE_ZERO_BYTE;
11021 dgst_pos0 = 0;
11022 dgst_pos1 = 1;
11023 dgst_pos2 = 2;
11024 dgst_pos3 = 3;
11025 break;
11026
11027 case 13753: hash_type = HASH_TYPE_SHA256;
11028 salt_type = SALT_TYPE_EMBEDDED;
11029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11031 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11032 dgst_size = DGST_SIZE_4_8;
11033 parse_func = veracrypt_parse_hash_500000;
11034 sort_by_digest = sort_by_digest_4_8;
11035 opti_type = OPTI_TYPE_ZERO_BYTE;
11036 dgst_pos0 = 0;
11037 dgst_pos1 = 1;
11038 dgst_pos2 = 2;
11039 dgst_pos3 = 3;
11040 break;
11041
11042 case 13761: hash_type = HASH_TYPE_SHA256;
11043 salt_type = SALT_TYPE_EMBEDDED;
11044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11046 kern_type = KERN_TYPE_VCSHA256_XTS512;
11047 dgst_size = DGST_SIZE_4_8;
11048 parse_func = veracrypt_parse_hash_200000;
11049 sort_by_digest = sort_by_digest_4_8;
11050 opti_type = OPTI_TYPE_ZERO_BYTE;
11051 dgst_pos0 = 0;
11052 dgst_pos1 = 1;
11053 dgst_pos2 = 2;
11054 dgst_pos3 = 3;
11055 break;
11056
11057 case 13762: hash_type = HASH_TYPE_SHA256;
11058 salt_type = SALT_TYPE_EMBEDDED;
11059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11061 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11062 dgst_size = DGST_SIZE_4_8;
11063 parse_func = veracrypt_parse_hash_200000;
11064 sort_by_digest = sort_by_digest_4_8;
11065 opti_type = OPTI_TYPE_ZERO_BYTE;
11066 dgst_pos0 = 0;
11067 dgst_pos1 = 1;
11068 dgst_pos2 = 2;
11069 dgst_pos3 = 3;
11070 break;
11071
11072 case 13763: hash_type = HASH_TYPE_SHA256;
11073 salt_type = SALT_TYPE_EMBEDDED;
11074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11076 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11077 dgst_size = DGST_SIZE_4_8;
11078 parse_func = veracrypt_parse_hash_200000;
11079 sort_by_digest = sort_by_digest_4_8;
11080 opti_type = OPTI_TYPE_ZERO_BYTE;
11081 dgst_pos0 = 0;
11082 dgst_pos1 = 1;
11083 dgst_pos2 = 2;
11084 dgst_pos3 = 3;
11085 break;
11086
11087 case 13800: hash_type = HASH_TYPE_SHA256;
11088 salt_type = SALT_TYPE_EMBEDDED;
11089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11090 opts_type = OPTS_TYPE_PT_GENERATE_BE
11091 | OPTS_TYPE_PT_UNICODE;
11092 kern_type = KERN_TYPE_WIN8PHONE;
11093 dgst_size = DGST_SIZE_4_8;
11094 parse_func = win8phone_parse_hash;
11095 sort_by_digest = sort_by_digest_4_8;
11096 opti_type = OPTI_TYPE_ZERO_BYTE
11097 | OPTI_TYPE_PRECOMPUTE_INIT
11098 | OPTI_TYPE_EARLY_SKIP
11099 | OPTI_TYPE_NOT_ITERATED
11100 | OPTI_TYPE_RAW_HASH;
11101 dgst_pos0 = 3;
11102 dgst_pos1 = 7;
11103 dgst_pos2 = 2;
11104 dgst_pos3 = 6;
11105 break;
11106
11107 default: usage_mini_print (PROGNAME); return (-1);
11108 }
11109
11110 /**
11111 * parser
11112 */
11113
11114 data.parse_func = parse_func;
11115
11116 /**
11117 * misc stuff
11118 */
11119
11120 if (hex_salt)
11121 {
11122 if (salt_type == SALT_TYPE_INTERN)
11123 {
11124 opts_type |= OPTS_TYPE_ST_HEX;
11125 }
11126 else
11127 {
11128 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11129
11130 return (-1);
11131 }
11132 }
11133
11134 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11135 | (salt_type == SALT_TYPE_EXTERN)
11136 | (salt_type == SALT_TYPE_EMBEDDED)
11137 | (salt_type == SALT_TYPE_VIRTUAL));
11138
11139 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11140
11141 data.hash_type = hash_type;
11142 data.attack_mode = attack_mode;
11143 data.attack_kern = attack_kern;
11144 data.attack_exec = attack_exec;
11145 data.kern_type = kern_type;
11146 data.opts_type = opts_type;
11147 data.dgst_size = dgst_size;
11148 data.salt_type = salt_type;
11149 data.isSalted = isSalted;
11150 data.sort_by_digest = sort_by_digest;
11151 data.dgst_pos0 = dgst_pos0;
11152 data.dgst_pos1 = dgst_pos1;
11153 data.dgst_pos2 = dgst_pos2;
11154 data.dgst_pos3 = dgst_pos3;
11155
11156 esalt_size = 0;
11157
11158 switch (hash_mode)
11159 {
11160 case 2500: esalt_size = sizeof (wpa_t); break;
11161 case 5300: esalt_size = sizeof (ikepsk_t); break;
11162 case 5400: esalt_size = sizeof (ikepsk_t); break;
11163 case 5500: esalt_size = sizeof (netntlm_t); break;
11164 case 5600: esalt_size = sizeof (netntlm_t); break;
11165 case 6211: esalt_size = sizeof (tc_t); break;
11166 case 6212: esalt_size = sizeof (tc_t); break;
11167 case 6213: esalt_size = sizeof (tc_t); break;
11168 case 6221: esalt_size = sizeof (tc_t); break;
11169 case 6222: esalt_size = sizeof (tc_t); break;
11170 case 6223: esalt_size = sizeof (tc_t); break;
11171 case 6231: esalt_size = sizeof (tc_t); break;
11172 case 6232: esalt_size = sizeof (tc_t); break;
11173 case 6233: esalt_size = sizeof (tc_t); break;
11174 case 6241: esalt_size = sizeof (tc_t); break;
11175 case 6242: esalt_size = sizeof (tc_t); break;
11176 case 6243: esalt_size = sizeof (tc_t); break;
11177 case 6600: esalt_size = sizeof (agilekey_t); break;
11178 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11179 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11180 case 7300: esalt_size = sizeof (rakp_t); break;
11181 case 7500: esalt_size = sizeof (krb5pa_t); break;
11182 case 8200: esalt_size = sizeof (cloudkey_t); break;
11183 case 8800: esalt_size = sizeof (androidfde_t); break;
11184 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11185 case 9400: esalt_size = sizeof (office2007_t); break;
11186 case 9500: esalt_size = sizeof (office2010_t); break;
11187 case 9600: esalt_size = sizeof (office2013_t); break;
11188 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11189 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11190 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11191 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11192 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11193 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11194 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11195 case 10200: esalt_size = sizeof (cram_md5_t); break;
11196 case 10400: esalt_size = sizeof (pdf_t); break;
11197 case 10410: esalt_size = sizeof (pdf_t); break;
11198 case 10420: esalt_size = sizeof (pdf_t); break;
11199 case 10500: esalt_size = sizeof (pdf_t); break;
11200 case 10600: esalt_size = sizeof (pdf_t); break;
11201 case 10700: esalt_size = sizeof (pdf_t); break;
11202 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11203 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11204 case 11400: esalt_size = sizeof (sip_t); break;
11205 case 11600: esalt_size = sizeof (seven_zip_t); break;
11206 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11207 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11208 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11209 case 13000: esalt_size = sizeof (rar5_t); break;
11210 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11211 case 13400: esalt_size = sizeof (keepass_t); break;
11212 case 13500: esalt_size = sizeof (pstoken_t); break;
11213 case 13600: esalt_size = sizeof (zip2_t); break;
11214 case 13711: esalt_size = sizeof (tc_t); break;
11215 case 13712: esalt_size = sizeof (tc_t); break;
11216 case 13713: esalt_size = sizeof (tc_t); break;
11217 case 13721: esalt_size = sizeof (tc_t); break;
11218 case 13722: esalt_size = sizeof (tc_t); break;
11219 case 13723: esalt_size = sizeof (tc_t); break;
11220 case 13731: esalt_size = sizeof (tc_t); break;
11221 case 13732: esalt_size = sizeof (tc_t); break;
11222 case 13733: esalt_size = sizeof (tc_t); break;
11223 case 13741: esalt_size = sizeof (tc_t); break;
11224 case 13742: esalt_size = sizeof (tc_t); break;
11225 case 13743: esalt_size = sizeof (tc_t); break;
11226 case 13751: esalt_size = sizeof (tc_t); break;
11227 case 13752: esalt_size = sizeof (tc_t); break;
11228 case 13753: esalt_size = sizeof (tc_t); break;
11229 case 13761: esalt_size = sizeof (tc_t); break;
11230 case 13762: esalt_size = sizeof (tc_t); break;
11231 case 13763: esalt_size = sizeof (tc_t); break;
11232 case 13800: esalt_size = sizeof (win8phone_t); break;
11233 }
11234
11235 data.esalt_size = esalt_size;
11236
11237 /**
11238 * choose dictionary parser
11239 */
11240
11241 if (hash_type == HASH_TYPE_LM)
11242 {
11243 get_next_word_func = get_next_word_lm;
11244 }
11245 else if (opts_type & OPTS_TYPE_PT_UPPER)
11246 {
11247 get_next_word_func = get_next_word_uc;
11248 }
11249 else
11250 {
11251 get_next_word_func = get_next_word_std;
11252 }
11253
11254 /**
11255 * dictstat
11256 */
11257
11258 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11259
11260 #ifdef _POSIX
11261 size_t dictstat_nmemb = 0;
11262 #endif
11263
11264 #ifdef _WIN
11265 uint dictstat_nmemb = 0;
11266 #endif
11267
11268 char dictstat[256] = { 0 };
11269
11270 FILE *dictstat_fp = NULL;
11271
11272 if (keyspace == 0)
11273 {
11274 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11275
11276 dictstat_fp = fopen (dictstat, "rb");
11277
11278 if (dictstat_fp)
11279 {
11280 #ifdef _POSIX
11281 struct stat tmpstat;
11282
11283 fstat (fileno (dictstat_fp), &tmpstat);
11284 #endif
11285
11286 #ifdef _WIN
11287 struct stat64 tmpstat;
11288
11289 _fstat64 (fileno (dictstat_fp), &tmpstat);
11290 #endif
11291
11292 if (tmpstat.st_mtime < COMPTIME)
11293 {
11294 /* with v0.15 the format changed so we have to ensure user is using a good version
11295 since there is no version-header in the dictstat file */
11296
11297 fclose (dictstat_fp);
11298
11299 unlink (dictstat);
11300 }
11301 else
11302 {
11303 while (!feof (dictstat_fp))
11304 {
11305 dictstat_t d;
11306
11307 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11308
11309 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11310
11311 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11312 {
11313 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11314
11315 return -1;
11316 }
11317 }
11318
11319 fclose (dictstat_fp);
11320 }
11321 }
11322 }
11323
11324 /**
11325 * potfile
11326 */
11327
11328 char potfile[256] = { 0 };
11329
11330 if (potfile_path == NULL)
11331 {
11332 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11333 }
11334 else
11335 {
11336 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11337 }
11338
11339 data.pot_fp = NULL;
11340
11341 FILE *out_fp = NULL;
11342 FILE *pot_fp = NULL;
11343
11344 if (show == 1 || left == 1)
11345 {
11346 pot_fp = fopen (potfile, "rb");
11347
11348 if (pot_fp == NULL)
11349 {
11350 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11351
11352 return (-1);
11353 }
11354
11355 if (outfile != NULL)
11356 {
11357 if ((out_fp = fopen (outfile, "ab")) == NULL)
11358 {
11359 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11360
11361 fclose (pot_fp);
11362
11363 return (-1);
11364 }
11365 }
11366 else
11367 {
11368 out_fp = stdout;
11369 }
11370 }
11371 else
11372 {
11373 if (potfile_disable == 0)
11374 {
11375 pot_fp = fopen (potfile, "ab");
11376
11377 if (pot_fp == NULL)
11378 {
11379 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11380
11381 return (-1);
11382 }
11383
11384 data.pot_fp = pot_fp;
11385 }
11386 }
11387
11388 pot_t *pot = NULL;
11389
11390 uint pot_cnt = 0;
11391 uint pot_avail = 0;
11392
11393 if (show == 1 || left == 1)
11394 {
11395 SUPPRESS_OUTPUT = 1;
11396
11397 pot_avail = count_lines (pot_fp);
11398
11399 rewind (pot_fp);
11400
11401 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11402
11403 uint pot_hashes_avail = 0;
11404
11405 uint line_num = 0;
11406
11407 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11408
11409 while (!feof (pot_fp))
11410 {
11411 line_num++;
11412
11413 int line_len = fgetl (pot_fp, line_buf);
11414
11415 if (line_len == 0) continue;
11416
11417 char *plain_buf = line_buf + line_len;
11418
11419 pot_t *pot_ptr = &pot[pot_cnt];
11420
11421 hash_t *hashes_buf = &pot_ptr->hash;
11422
11423 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11424 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11425
11426 if (pot_cnt == pot_hashes_avail)
11427 {
11428 uint pos = 0;
11429
11430 for (pos = 0; pos < INCR_POT; pos++)
11431 {
11432 if ((pot_cnt + pos) >= pot_avail) break;
11433
11434 pot_t *tmp_pot = &pot[pot_cnt + pos];
11435
11436 hash_t *tmp_hash = &tmp_pot->hash;
11437
11438 tmp_hash->digest = mymalloc (dgst_size);
11439
11440 if (isSalted)
11441 {
11442 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11443 }
11444
11445 if (esalt_size)
11446 {
11447 tmp_hash->esalt = mymalloc (esalt_size);
11448 }
11449
11450 pot_hashes_avail++;
11451 }
11452 }
11453
11454 int plain_len = 0;
11455
11456 int parser_status;
11457
11458 int iter = MAX_CUT_TRIES;
11459
11460 do
11461 {
11462 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11463 {
11464 if (line_buf[i] == ':')
11465 {
11466 line_len--;
11467
11468 break;
11469 }
11470 }
11471
11472 if (data.hash_mode != 2500)
11473 {
11474 parser_status = parse_func (line_buf, line_len, hashes_buf);
11475 }
11476 else
11477 {
11478 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11479
11480 if (line_len > max_salt_size)
11481 {
11482 parser_status = PARSER_GLOBAL_LENGTH;
11483 }
11484 else
11485 {
11486 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11487
11488 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11489
11490 hashes_buf->salt->salt_len = line_len;
11491
11492 parser_status = PARSER_OK;
11493 }
11494 }
11495
11496 // if NOT parsed without error, we add the ":" to the plain
11497
11498 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11499 {
11500 plain_len++;
11501 plain_buf--;
11502 }
11503
11504 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11505
11506 if (parser_status < PARSER_GLOBAL_ZERO)
11507 {
11508 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11509
11510 continue;
11511 }
11512
11513 if (plain_len >= 255) continue;
11514
11515 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11516
11517 pot_ptr->plain_len = plain_len;
11518
11519 pot_cnt++;
11520 }
11521
11522 myfree (line_buf);
11523
11524 fclose (pot_fp);
11525
11526 SUPPRESS_OUTPUT = 0;
11527
11528 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11529 }
11530
11531 /**
11532 * word len
11533 */
11534
11535 uint pw_min = PW_MIN;
11536 uint pw_max = PW_MAX;
11537
11538 switch (hash_mode)
11539 {
11540 case 125: if (pw_max > 32) pw_max = 32;
11541 break;
11542 case 400: if (pw_max > 40) pw_max = 40;
11543 break;
11544 case 500: if (pw_max > 16) pw_max = 16;
11545 break;
11546 case 1500: if (pw_max > 8) pw_max = 8;
11547 break;
11548 case 1600: if (pw_max > 16) pw_max = 16;
11549 break;
11550 case 1800: if (pw_max > 16) pw_max = 16;
11551 break;
11552 case 2100: if (pw_max > 16) pw_max = 16;
11553 break;
11554 case 2500: if (pw_min < 8) pw_min = 8;
11555 break;
11556 case 3000: if (pw_max > 7) pw_max = 7;
11557 break;
11558 case 5200: if (pw_max > 24) pw_max = 24;
11559 break;
11560 case 5800: if (pw_max > 16) pw_max = 16;
11561 break;
11562 case 6300: if (pw_max > 16) pw_max = 16;
11563 break;
11564 case 7400: if (pw_max > 16) pw_max = 16;
11565 break;
11566 case 7700: if (pw_max > 8) pw_max = 8;
11567 break;
11568 case 7900: if (pw_max > 48) pw_max = 48;
11569 break;
11570 case 8500: if (pw_max > 8) pw_max = 8;
11571 break;
11572 case 8600: if (pw_max > 16) pw_max = 16;
11573 break;
11574 case 9710: pw_min = 5;
11575 pw_max = 5;
11576 break;
11577 case 9810: pw_min = 5;
11578 pw_max = 5;
11579 break;
11580 case 10410: pw_min = 5;
11581 pw_max = 5;
11582 break;
11583 case 10300: if (pw_max < 3) pw_min = 3;
11584 if (pw_max > 40) pw_max = 40;
11585 break;
11586 case 10500: if (pw_max < 3) pw_min = 3;
11587 if (pw_max > 40) pw_max = 40;
11588 break;
11589 case 10700: if (pw_max > 16) pw_max = 16;
11590 break;
11591 case 11300: if (pw_max > 40) pw_max = 40;
11592 break;
11593 case 11600: if (pw_max > 32) pw_max = 32;
11594 break;
11595 case 12500: if (pw_max > 20) pw_max = 20;
11596 break;
11597 case 12800: if (pw_max > 24) pw_max = 24;
11598 break;
11599 }
11600
11601 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11602 {
11603 switch (attack_kern)
11604 {
11605 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11606 break;
11607 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11608 break;
11609 }
11610 }
11611
11612 /**
11613 * charsets : keep them together for more easy maintainnce
11614 */
11615
11616 cs_t mp_sys[6] = { { { 0 }, 0 } };
11617 cs_t mp_usr[4] = { { { 0 }, 0 } };
11618
11619 mp_setup_sys (mp_sys);
11620
11621 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11622 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11623 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11624 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11625
11626 /**
11627 * load hashes, part I: find input mode, count hashes
11628 */
11629
11630 uint hashlist_mode = 0;
11631 uint hashlist_format = HLFMT_HASHCAT;
11632
11633 uint hashes_avail = 0;
11634
11635 if ((benchmark == 0) && (stdout_flag == 0))
11636 {
11637 struct stat f;
11638
11639 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11640
11641 if ((hash_mode == 2500) ||
11642 (hash_mode == 5200) ||
11643 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11644 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11645 (hash_mode == 9000))
11646 {
11647 hashlist_mode = HL_MODE_ARG;
11648
11649 char *hashfile = myargv[optind];
11650
11651 data.hashfile = hashfile;
11652
11653 logfile_top_var_string ("target", hashfile);
11654 }
11655
11656 if (hashlist_mode == HL_MODE_ARG)
11657 {
11658 if (hash_mode == 2500)
11659 {
11660 struct stat st;
11661
11662 if (stat (data.hashfile, &st) == -1)
11663 {
11664 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11665
11666 return (-1);
11667 }
11668
11669 hashes_avail = st.st_size / sizeof (hccap_t);
11670 }
11671 else
11672 {
11673 hashes_avail = 1;
11674 }
11675 }
11676 else if (hashlist_mode == HL_MODE_FILE)
11677 {
11678 char *hashfile = myargv[optind];
11679
11680 data.hashfile = hashfile;
11681
11682 logfile_top_var_string ("target", hashfile);
11683
11684 FILE *fp = NULL;
11685
11686 if ((fp = fopen (hashfile, "rb")) == NULL)
11687 {
11688 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11689
11690 return (-1);
11691 }
11692
11693 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11694
11695 hashes_avail = count_lines (fp);
11696
11697 rewind (fp);
11698
11699 if (hashes_avail == 0)
11700 {
11701 log_error ("ERROR: hashfile is empty or corrupt");
11702
11703 fclose (fp);
11704
11705 return (-1);
11706 }
11707
11708 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11709
11710 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11711 {
11712 log_error ("ERROR: remove not supported in native hashfile-format mode");
11713
11714 fclose (fp);
11715
11716 return (-1);
11717 }
11718
11719 fclose (fp);
11720 }
11721 }
11722 else
11723 {
11724 hashlist_mode = HL_MODE_ARG;
11725
11726 hashes_avail = 1;
11727 }
11728
11729 if (hash_mode == 3000) hashes_avail *= 2;
11730
11731 data.hashlist_mode = hashlist_mode;
11732 data.hashlist_format = hashlist_format;
11733
11734 logfile_top_uint (hashlist_mode);
11735 logfile_top_uint (hashlist_format);
11736
11737 /**
11738 * load hashes, part II: allocate required memory, set pointers
11739 */
11740
11741 hash_t *hashes_buf = NULL;
11742 void *digests_buf = NULL;
11743 salt_t *salts_buf = NULL;
11744 void *esalts_buf = NULL;
11745
11746 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11747
11748 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11749
11750 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11751 {
11752 u32 hash_pos;
11753
11754 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11755 {
11756 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11757
11758 hashes_buf[hash_pos].hash_info = hash_info;
11759
11760 if (username && (remove || show || left))
11761 {
11762 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11763 }
11764
11765 if (benchmark)
11766 {
11767 hash_info->orighash = (char *) mymalloc (256);
11768 }
11769 }
11770 }
11771
11772 if (isSalted)
11773 {
11774 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11775
11776 if (esalt_size)
11777 {
11778 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11779 }
11780 }
11781 else
11782 {
11783 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11784 }
11785
11786 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11787 {
11788 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11789
11790 if (isSalted)
11791 {
11792 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11793
11794 if (esalt_size)
11795 {
11796 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11797 }
11798 }
11799 else
11800 {
11801 hashes_buf[hash_pos].salt = &salts_buf[0];
11802 }
11803 }
11804
11805 /**
11806 * load hashes, part III: parse hashes or generate them if benchmark
11807 */
11808
11809 uint hashes_cnt = 0;
11810
11811 if (benchmark == 0)
11812 {
11813 if (keyspace == 1)
11814 {
11815 // useless to read hash file for keyspace, cheat a little bit w/ optind
11816 }
11817 else if (stdout_flag == 1)
11818 {
11819 // useless to read hash file for stdout, cheat a little bit w/ optind
11820 }
11821 else if (hashes_avail == 0)
11822 {
11823 }
11824 else if (hashlist_mode == HL_MODE_ARG)
11825 {
11826 char *input_buf = myargv[optind];
11827
11828 uint input_len = strlen (input_buf);
11829
11830 logfile_top_var_string ("target", input_buf);
11831
11832 char *hash_buf = NULL;
11833 int hash_len = 0;
11834
11835 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11836
11837 bool hash_fmt_error = 0;
11838
11839 if (hash_len < 1) hash_fmt_error = 1;
11840 if (hash_buf == NULL) hash_fmt_error = 1;
11841
11842 if (hash_fmt_error)
11843 {
11844 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11845 }
11846 else
11847 {
11848 if (opts_type & OPTS_TYPE_HASH_COPY)
11849 {
11850 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11851
11852 hash_info_tmp->orighash = mystrdup (hash_buf);
11853 }
11854
11855 if (isSalted)
11856 {
11857 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11858 }
11859
11860 int parser_status = PARSER_OK;
11861
11862 if (hash_mode == 2500)
11863 {
11864 if (hash_len == 0)
11865 {
11866 log_error ("ERROR: hccap file not specified");
11867
11868 return (-1);
11869 }
11870
11871 hashlist_mode = HL_MODE_FILE;
11872
11873 data.hashlist_mode = hashlist_mode;
11874
11875 FILE *fp = fopen (hash_buf, "rb");
11876
11877 if (fp == NULL)
11878 {
11879 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11880
11881 return (-1);
11882 }
11883
11884 if (hashes_avail < 1)
11885 {
11886 log_error ("ERROR: hccap file is empty or corrupt");
11887
11888 fclose (fp);
11889
11890 return (-1);
11891 }
11892
11893 uint hccap_size = sizeof (hccap_t);
11894
11895 char *in = (char *) mymalloc (hccap_size);
11896
11897 while (!feof (fp))
11898 {
11899 int n = fread (in, hccap_size, 1, fp);
11900
11901 if (n != 1)
11902 {
11903 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11904
11905 break;
11906 }
11907
11908 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11909
11910 if (parser_status != PARSER_OK)
11911 {
11912 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11913
11914 continue;
11915 }
11916
11917 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11918
11919 if ((show == 1) || (left == 1))
11920 {
11921 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11922
11923 char *salt_ptr = (char *) tmp_salt->salt_buf;
11924
11925 int cur_pos = tmp_salt->salt_len;
11926 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11927
11928 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11929
11930 // do the appending task
11931
11932 snprintf (salt_ptr + cur_pos,
11933 rem_len,
11934 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11935 wpa->orig_mac1[0],
11936 wpa->orig_mac1[1],
11937 wpa->orig_mac1[2],
11938 wpa->orig_mac1[3],
11939 wpa->orig_mac1[4],
11940 wpa->orig_mac1[5],
11941 wpa->orig_mac2[0],
11942 wpa->orig_mac2[1],
11943 wpa->orig_mac2[2],
11944 wpa->orig_mac2[3],
11945 wpa->orig_mac2[4],
11946 wpa->orig_mac2[5]);
11947
11948 // memset () the remaining part of the salt
11949
11950 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11951 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11952
11953 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11954
11955 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11956 }
11957
11958 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);
11959 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);
11960
11961 hashes_cnt++;
11962 }
11963
11964 fclose (fp);
11965
11966 myfree (in);
11967 }
11968 else if (hash_mode == 3000)
11969 {
11970 if (hash_len == 32)
11971 {
11972 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11973
11974 hash_t *lm_hash_left = NULL;
11975
11976 if (parser_status == PARSER_OK)
11977 {
11978 lm_hash_left = &hashes_buf[hashes_cnt];
11979
11980 hashes_cnt++;
11981 }
11982 else
11983 {
11984 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11985 }
11986
11987 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11988
11989 hash_t *lm_hash_right = NULL;
11990
11991 if (parser_status == PARSER_OK)
11992 {
11993 lm_hash_right = &hashes_buf[hashes_cnt];
11994
11995 hashes_cnt++;
11996 }
11997 else
11998 {
11999 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12000 }
12001
12002 // show / left
12003
12004 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12005 {
12006 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);
12007 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);
12008 }
12009 }
12010 else
12011 {
12012 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12013
12014 if (parser_status == PARSER_OK)
12015 {
12016 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12017 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12018 }
12019
12020 if (parser_status == PARSER_OK)
12021 {
12022 hashes_cnt++;
12023 }
12024 else
12025 {
12026 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12027 }
12028 }
12029 }
12030 else
12031 {
12032 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12033
12034 if (parser_status == PARSER_OK)
12035 {
12036 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12037 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12038 }
12039
12040 if (parser_status == PARSER_OK)
12041 {
12042 hashes_cnt++;
12043 }
12044 else
12045 {
12046 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12047 }
12048 }
12049 }
12050 }
12051 else if (hashlist_mode == HL_MODE_FILE)
12052 {
12053 char *hashfile = data.hashfile;
12054
12055 FILE *fp;
12056
12057 if ((fp = fopen (hashfile, "rb")) == NULL)
12058 {
12059 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12060
12061 return (-1);
12062 }
12063
12064 uint line_num = 0;
12065
12066 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12067
12068 while (!feof (fp))
12069 {
12070 line_num++;
12071
12072 int line_len = fgetl (fp, line_buf);
12073
12074 if (line_len == 0) continue;
12075
12076 char *hash_buf = NULL;
12077 int hash_len = 0;
12078
12079 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12080
12081 bool hash_fmt_error = 0;
12082
12083 if (hash_len < 1) hash_fmt_error = 1;
12084 if (hash_buf == NULL) hash_fmt_error = 1;
12085
12086 if (hash_fmt_error)
12087 {
12088 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12089
12090 continue;
12091 }
12092
12093 if (username)
12094 {
12095 char *user_buf = NULL;
12096 int user_len = 0;
12097
12098 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12099
12100 if (remove || show)
12101 {
12102 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12103
12104 *user = (user_t *) mymalloc (sizeof (user_t));
12105
12106 user_t *user_ptr = *user;
12107
12108 if (user_buf != NULL)
12109 {
12110 user_ptr->user_name = mystrdup (user_buf);
12111 }
12112 else
12113 {
12114 user_ptr->user_name = mystrdup ("");
12115 }
12116
12117 user_ptr->user_len = user_len;
12118 }
12119 }
12120
12121 if (opts_type & OPTS_TYPE_HASH_COPY)
12122 {
12123 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12124
12125 hash_info_tmp->orighash = mystrdup (hash_buf);
12126 }
12127
12128 if (isSalted)
12129 {
12130 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12131 }
12132
12133 if (hash_mode == 3000)
12134 {
12135 if (hash_len == 32)
12136 {
12137 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12138
12139 if (parser_status < PARSER_GLOBAL_ZERO)
12140 {
12141 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12142
12143 continue;
12144 }
12145
12146 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12147
12148 hashes_cnt++;
12149
12150 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12151
12152 if (parser_status < PARSER_GLOBAL_ZERO)
12153 {
12154 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12155
12156 continue;
12157 }
12158
12159 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12160
12161 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);
12162
12163 hashes_cnt++;
12164
12165 // show / left
12166
12167 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);
12168 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);
12169 }
12170 else
12171 {
12172 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12173
12174 if (parser_status < PARSER_GLOBAL_ZERO)
12175 {
12176 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12177
12178 continue;
12179 }
12180
12181 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);
12182
12183 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12184 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12185
12186 hashes_cnt++;
12187 }
12188 }
12189 else
12190 {
12191 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12192
12193 if (parser_status < PARSER_GLOBAL_ZERO)
12194 {
12195 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12196
12197 continue;
12198 }
12199
12200 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);
12201
12202 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12203 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12204
12205 hashes_cnt++;
12206 }
12207 }
12208
12209 myfree (line_buf);
12210
12211 fclose (fp);
12212
12213 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12214
12215 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12216 }
12217 }
12218 else
12219 {
12220 if (isSalted)
12221 {
12222 hashes_buf[0].salt->salt_len = 8;
12223
12224 // special salt handling
12225
12226 switch (hash_mode)
12227 {
12228 case 1500: hashes_buf[0].salt->salt_len = 2;
12229 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12230 break;
12231 case 1731: hashes_buf[0].salt->salt_len = 4;
12232 break;
12233 case 2410: hashes_buf[0].salt->salt_len = 4;
12234 break;
12235 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12236 break;
12237 case 3100: hashes_buf[0].salt->salt_len = 1;
12238 break;
12239 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12240 break;
12241 case 5800: hashes_buf[0].salt->salt_len = 16;
12242 break;
12243 case 6800: hashes_buf[0].salt->salt_len = 32;
12244 break;
12245 case 8400: hashes_buf[0].salt->salt_len = 40;
12246 break;
12247 case 8800: hashes_buf[0].salt->salt_len = 16;
12248 break;
12249 case 8900: hashes_buf[0].salt->salt_len = 16;
12250 hashes_buf[0].salt->scrypt_N = 1024;
12251 hashes_buf[0].salt->scrypt_r = 1;
12252 hashes_buf[0].salt->scrypt_p = 1;
12253 break;
12254 case 9100: hashes_buf[0].salt->salt_len = 16;
12255 break;
12256 case 9300: hashes_buf[0].salt->salt_len = 14;
12257 hashes_buf[0].salt->scrypt_N = 16384;
12258 hashes_buf[0].salt->scrypt_r = 1;
12259 hashes_buf[0].salt->scrypt_p = 1;
12260 break;
12261 case 9400: hashes_buf[0].salt->salt_len = 16;
12262 break;
12263 case 9500: hashes_buf[0].salt->salt_len = 16;
12264 break;
12265 case 9600: hashes_buf[0].salt->salt_len = 16;
12266 break;
12267 case 9700: hashes_buf[0].salt->salt_len = 16;
12268 break;
12269 case 9710: hashes_buf[0].salt->salt_len = 16;
12270 break;
12271 case 9720: hashes_buf[0].salt->salt_len = 16;
12272 break;
12273 case 9800: hashes_buf[0].salt->salt_len = 16;
12274 break;
12275 case 9810: hashes_buf[0].salt->salt_len = 16;
12276 break;
12277 case 9820: hashes_buf[0].salt->salt_len = 16;
12278 break;
12279 case 10300: hashes_buf[0].salt->salt_len = 12;
12280 break;
12281 case 11500: hashes_buf[0].salt->salt_len = 4;
12282 break;
12283 case 11600: hashes_buf[0].salt->salt_len = 4;
12284 break;
12285 case 12400: hashes_buf[0].salt->salt_len = 4;
12286 break;
12287 case 12500: hashes_buf[0].salt->salt_len = 8;
12288 break;
12289 case 12600: hashes_buf[0].salt->salt_len = 64;
12290 break;
12291 }
12292
12293 // special esalt handling
12294
12295 switch (hash_mode)
12296 {
12297 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12298 break;
12299 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12300 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12301 break;
12302 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12303 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12304 break;
12305 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12306 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12307 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12308 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12309 break;
12310 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12311 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12312 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12313 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12314 break;
12315 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12316 break;
12317 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12318 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12319 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12320 break;
12321 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12322 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12323 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12324 break;
12325 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12326 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12327 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12328 break;
12329 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12330 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12331 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12332 break;
12333 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12334 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12335 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12336 break;
12337 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12338 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12339 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12340 break;
12341 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12342 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12343 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12344 break;
12345 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12346 break;
12347 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12348 break;
12349 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12350 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12351 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12352 break;
12353 }
12354 }
12355
12356 // set hashfile
12357
12358 switch (hash_mode)
12359 {
12360 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12361 break;
12362 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12363 break;
12364 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12365 break;
12366 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12367 break;
12368 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12369 break;
12370 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12371 break;
12372 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12373 break;
12374 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12375 break;
12376 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12377 break;
12378 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12379 break;
12380 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12381 break;
12382 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12383 break;
12384 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12385 break;
12386 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12387 break;
12388 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12389 break;
12390 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12391 break;
12392 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12393 break;
12394 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12395 break;
12396 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12397 break;
12398 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12399 break;
12400 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12401 break;
12402 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12403 break;
12404 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12405 break;
12406 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12407 break;
12408 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12409 break;
12410 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12411 break;
12412 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12413 break;
12414 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12415 break;
12416 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12417 break;
12418 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12419 break;
12420 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12421 break;
12422 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12423 break;
12424 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12425 break;
12426 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12427 break;
12428 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12429 break;
12430 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12431 break;
12432 }
12433
12434 // set default iterations
12435
12436 switch (hash_mode)
12437 {
12438 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12439 break;
12440 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12441 break;
12442 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12443 break;
12444 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12445 break;
12446 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12447 break;
12448 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12449 break;
12450 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12451 break;
12452 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12453 break;
12454 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12455 break;
12456 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12457 break;
12458 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12459 break;
12460 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12461 break;
12462 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12463 break;
12464 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12465 break;
12466 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12467 break;
12468 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12469 break;
12470 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12471 break;
12472 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12473 break;
12474 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12475 break;
12476 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12477 break;
12478 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12479 break;
12480 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12481 break;
12482 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12483 break;
12484 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12485 break;
12486 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12487 break;
12488 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12489 break;
12490 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12491 break;
12492 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12493 break;
12494 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12495 break;
12496 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12497 break;
12498 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12499 break;
12500 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12501 break;
12502 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12503 break;
12504 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12505 break;
12506 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12507 break;
12508 case 8900: hashes_buf[0].salt->salt_iter = 1;
12509 break;
12510 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12511 break;
12512 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12513 break;
12514 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12515 break;
12516 case 9300: hashes_buf[0].salt->salt_iter = 1;
12517 break;
12518 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12519 break;
12520 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12521 break;
12522 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12523 break;
12524 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12525 break;
12526 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12527 break;
12528 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12529 break;
12530 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12531 break;
12532 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12533 break;
12534 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12535 break;
12536 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12537 break;
12538 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12539 break;
12540 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12541 break;
12542 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12543 break;
12544 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12545 break;
12546 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12547 break;
12548 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12549 break;
12550 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12551 break;
12552 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12553 break;
12554 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12555 break;
12556 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12557 break;
12558 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12559 break;
12560 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12561 break;
12562 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12563 break;
12564 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12565 break;
12566 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12567 break;
12568 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12569 break;
12570 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12571 break;
12572 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12573 break;
12574 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12575 break;
12576 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12577 break;
12578 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12579 break;
12580 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12581 break;
12582 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12583 break;
12584 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12585 break;
12586 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12587 break;
12588 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12589 break;
12590 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12591 break;
12592 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12593 break;
12594 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12595 break;
12596 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12597 break;
12598 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12599 break;
12600 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12601 break;
12602 }
12603
12604 hashes_cnt = 1;
12605 }
12606
12607 if (show == 1 || left == 1)
12608 {
12609 for (uint i = 0; i < pot_cnt; i++)
12610 {
12611 pot_t *pot_ptr = &pot[i];
12612
12613 hash_t *hashes_buf = &pot_ptr->hash;
12614
12615 local_free (hashes_buf->digest);
12616
12617 if (isSalted)
12618 {
12619 local_free (hashes_buf->salt);
12620 }
12621 }
12622
12623 local_free (pot);
12624
12625 if (data.quiet == 0) log_info_nn ("");
12626
12627 return (0);
12628 }
12629
12630 if ((keyspace == 0) && (stdout_flag == 0))
12631 {
12632 if (hashes_cnt == 0)
12633 {
12634 log_error ("ERROR: No hashes loaded");
12635
12636 return (-1);
12637 }
12638 }
12639
12640 /**
12641 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12642 */
12643
12644 if (data.outfile != NULL)
12645 {
12646 if (data.hashfile != NULL)
12647 {
12648 #ifdef _POSIX
12649 struct stat tmpstat_outfile;
12650 struct stat tmpstat_hashfile;
12651 #endif
12652
12653 #ifdef _WIN
12654 struct stat64 tmpstat_outfile;
12655 struct stat64 tmpstat_hashfile;
12656 #endif
12657
12658 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12659
12660 if (tmp_outfile_fp)
12661 {
12662 #ifdef _POSIX
12663 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12664 #endif
12665
12666 #ifdef _WIN
12667 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12668 #endif
12669
12670 fclose (tmp_outfile_fp);
12671 }
12672
12673 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12674
12675 if (tmp_hashfile_fp)
12676 {
12677 #ifdef _POSIX
12678 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12679 #endif
12680
12681 #ifdef _WIN
12682 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12683 #endif
12684
12685 fclose (tmp_hashfile_fp);
12686 }
12687
12688 if (tmp_outfile_fp && tmp_outfile_fp)
12689 {
12690 tmpstat_outfile.st_mode = 0;
12691 tmpstat_outfile.st_nlink = 0;
12692 tmpstat_outfile.st_uid = 0;
12693 tmpstat_outfile.st_gid = 0;
12694 tmpstat_outfile.st_rdev = 0;
12695 tmpstat_outfile.st_atime = 0;
12696
12697 tmpstat_hashfile.st_mode = 0;
12698 tmpstat_hashfile.st_nlink = 0;
12699 tmpstat_hashfile.st_uid = 0;
12700 tmpstat_hashfile.st_gid = 0;
12701 tmpstat_hashfile.st_rdev = 0;
12702 tmpstat_hashfile.st_atime = 0;
12703
12704 #ifdef _POSIX
12705 tmpstat_outfile.st_blksize = 0;
12706 tmpstat_outfile.st_blocks = 0;
12707
12708 tmpstat_hashfile.st_blksize = 0;
12709 tmpstat_hashfile.st_blocks = 0;
12710 #endif
12711
12712 #ifdef _POSIX
12713 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12714 {
12715 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12716
12717 return (-1);
12718 }
12719 #endif
12720
12721 #ifdef _WIN
12722 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12723 {
12724 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12725
12726 return (-1);
12727 }
12728 #endif
12729 }
12730 }
12731 }
12732
12733 /**
12734 * Remove duplicates
12735 */
12736
12737 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12738
12739 if (isSalted)
12740 {
12741 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12742 }
12743 else
12744 {
12745 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12746 }
12747
12748 uint hashes_cnt_orig = hashes_cnt;
12749
12750 hashes_cnt = 1;
12751
12752 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12753 {
12754 if (isSalted)
12755 {
12756 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12757 {
12758 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12759 }
12760 }
12761 else
12762 {
12763 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12764 }
12765
12766 if (hashes_pos > hashes_cnt)
12767 {
12768 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12769 }
12770
12771 hashes_cnt++;
12772 }
12773
12774 /**
12775 * Potfile removes
12776 */
12777
12778 uint potfile_remove_cracks = 0;
12779
12780 if (potfile_disable == 0)
12781 {
12782 hash_t hash_buf;
12783
12784 hash_buf.digest = mymalloc (dgst_size);
12785 hash_buf.salt = NULL;
12786 hash_buf.esalt = NULL;
12787 hash_buf.hash_info = NULL;
12788 hash_buf.cracked = 0;
12789
12790 if (isSalted)
12791 {
12792 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12793 }
12794
12795 if (esalt_size)
12796 {
12797 hash_buf.esalt = mymalloc (esalt_size);
12798 }
12799
12800 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12801
12802 // no solution for these special hash types (for instane because they use hashfile in output etc)
12803 if ((hash_mode != 5200) &&
12804 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12805 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12806 (hash_mode != 9000))
12807 {
12808 FILE *fp = fopen (potfile, "rb");
12809
12810 if (fp != NULL)
12811 {
12812 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12813
12814 // to be safe work with a copy (because of line_len loop, i etc)
12815 // moved up here because it's easier to handle continue case
12816 // it's just 64kb
12817
12818 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12819
12820 while (!feof (fp))
12821 {
12822 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12823
12824 if (ptr == NULL) break;
12825
12826 int line_len = strlen (line_buf);
12827
12828 if (line_len == 0) continue;
12829
12830 int iter = MAX_CUT_TRIES;
12831
12832 for (int i = line_len - 1; i && iter; i--, line_len--)
12833 {
12834 if (line_buf[i] != ':') continue;
12835
12836 if (isSalted)
12837 {
12838 memset (hash_buf.salt, 0, sizeof (salt_t));
12839 }
12840
12841 hash_t *found = NULL;
12842
12843 if (hash_mode == 6800)
12844 {
12845 if (i < 64) // 64 = 16 * uint in salt_buf[]
12846 {
12847 // manipulate salt_buf
12848 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12849
12850 hash_buf.salt->salt_len = i;
12851
12852 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12853 }
12854 }
12855 else if (hash_mode == 2500)
12856 {
12857 if (i < 64) // 64 = 16 * uint in salt_buf[]
12858 {
12859 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12860 // manipulate salt_buf
12861
12862 memcpy (line_buf_cpy, line_buf, i);
12863
12864 char *mac2_pos = strrchr (line_buf_cpy, ':');
12865
12866 if (mac2_pos == NULL) continue;
12867
12868 mac2_pos[0] = 0;
12869 mac2_pos++;
12870
12871 if (strlen (mac2_pos) != 12) continue;
12872
12873 char *mac1_pos = strrchr (line_buf_cpy, ':');
12874
12875 if (mac1_pos == NULL) continue;
12876
12877 mac1_pos[0] = 0;
12878 mac1_pos++;
12879
12880 if (strlen (mac1_pos) != 12) continue;
12881
12882 uint essid_length = mac1_pos - line_buf_cpy - 1;
12883
12884 // here we need the ESSID
12885 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12886
12887 hash_buf.salt->salt_len = essid_length;
12888
12889 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12890
12891 if (found)
12892 {
12893 wpa_t *wpa = (wpa_t *) found->esalt;
12894
12895 // compare hex string(s) vs binary MAC address(es)
12896
12897 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12898 {
12899 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12900 {
12901 found = NULL;
12902
12903 break;
12904 }
12905 }
12906
12907 // early skip ;)
12908 if (!found) continue;
12909
12910 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12911 {
12912 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12913 {
12914 found = NULL;
12915
12916 break;
12917 }
12918 }
12919 }
12920 }
12921 }
12922 else
12923 {
12924 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12925
12926 if (parser_status == PARSER_OK)
12927 {
12928 if (isSalted)
12929 {
12930 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12931 }
12932 else
12933 {
12934 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12935 }
12936 }
12937 }
12938
12939 if (found == NULL) continue;
12940
12941 if (!found->cracked) potfile_remove_cracks++;
12942
12943 found->cracked = 1;
12944
12945 if (found) break;
12946
12947 iter--;
12948 }
12949 }
12950
12951 myfree (line_buf_cpy);
12952
12953 myfree (line_buf);
12954
12955 fclose (fp);
12956 }
12957 }
12958
12959 if (esalt_size)
12960 {
12961 local_free (hash_buf.esalt);
12962 }
12963
12964 if (isSalted)
12965 {
12966 local_free (hash_buf.salt);
12967 }
12968
12969 local_free (hash_buf.digest);
12970 }
12971
12972 /**
12973 * Now generate all the buffers required for later
12974 */
12975
12976 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12977
12978 salt_t *salts_buf_new = NULL;
12979 void *esalts_buf_new = NULL;
12980
12981 if (isSalted)
12982 {
12983 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12984
12985 if (esalt_size)
12986 {
12987 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12988 }
12989 }
12990 else
12991 {
12992 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12993 }
12994
12995 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12996
12997 uint digests_cnt = hashes_cnt;
12998 uint digests_done = 0;
12999
13000 size_t size_digests = digests_cnt * dgst_size;
13001 size_t size_shown = digests_cnt * sizeof (uint);
13002
13003 uint *digests_shown = (uint *) mymalloc (size_shown);
13004 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13005
13006 uint salts_cnt = 0;
13007 uint salts_done = 0;
13008
13009 hashinfo_t **hash_info = NULL;
13010
13011 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13012 {
13013 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13014
13015 if (username && (remove || show))
13016 {
13017 uint user_pos;
13018
13019 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13020 {
13021 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13022
13023 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13024 }
13025 }
13026 }
13027
13028 uint *salts_shown = (uint *) mymalloc (size_shown);
13029
13030 salt_t *salt_buf;
13031
13032 {
13033 // copied from inner loop
13034
13035 salt_buf = &salts_buf_new[salts_cnt];
13036
13037 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13038
13039 if (esalt_size)
13040 {
13041 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13042 }
13043
13044 salt_buf->digests_cnt = 0;
13045 salt_buf->digests_done = 0;
13046 salt_buf->digests_offset = 0;
13047
13048 salts_cnt++;
13049 }
13050
13051 if (hashes_buf[0].cracked == 1)
13052 {
13053 digests_shown[0] = 1;
13054
13055 digests_done++;
13056
13057 salt_buf->digests_done++;
13058 }
13059
13060 salt_buf->digests_cnt++;
13061
13062 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13063
13064 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13065 {
13066 hash_info[0] = hashes_buf[0].hash_info;
13067 }
13068
13069 // copy from inner loop
13070
13071 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13072 {
13073 if (isSalted)
13074 {
13075 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13076 {
13077 salt_buf = &salts_buf_new[salts_cnt];
13078
13079 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13080
13081 if (esalt_size)
13082 {
13083 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13084 }
13085
13086 salt_buf->digests_cnt = 0;
13087 salt_buf->digests_done = 0;
13088 salt_buf->digests_offset = hashes_pos;
13089
13090 salts_cnt++;
13091 }
13092 }
13093
13094 if (hashes_buf[hashes_pos].cracked == 1)
13095 {
13096 digests_shown[hashes_pos] = 1;
13097
13098 digests_done++;
13099
13100 salt_buf->digests_done++;
13101 }
13102
13103 salt_buf->digests_cnt++;
13104
13105 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13106
13107 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13108 {
13109 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13110 }
13111 }
13112
13113 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13114 {
13115 salt_t *salt_buf = &salts_buf_new[salt_pos];
13116
13117 if (salt_buf->digests_done == salt_buf->digests_cnt)
13118 {
13119 salts_shown[salt_pos] = 1;
13120
13121 salts_done++;
13122 }
13123
13124 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13125 }
13126
13127 local_free (digests_buf);
13128 local_free (salts_buf);
13129 local_free (esalts_buf);
13130
13131 digests_buf = digests_buf_new;
13132 salts_buf = salts_buf_new;
13133 esalts_buf = esalts_buf_new;
13134
13135 local_free (hashes_buf);
13136
13137 /**
13138 * special modification not set from parser
13139 */
13140
13141 switch (hash_mode)
13142 {
13143 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13144 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13145 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13146 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13147 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13148 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13149 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13150 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13151 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13152 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13153 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13154 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13155 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13156 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13157 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13158 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13159 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13160 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13161 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13162 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13163 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13164 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13165 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13166 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13167 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13168 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13169 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13170 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13171 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13172 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13173 }
13174
13175 if (truecrypt_keyfiles)
13176 {
13177 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13178
13179 char *keyfiles = strdup (truecrypt_keyfiles);
13180
13181 char *keyfile = strtok (keyfiles, ",");
13182
13183 do
13184 {
13185 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13186
13187 } while ((keyfile = strtok (NULL, ",")) != NULL);
13188
13189 free (keyfiles);
13190 }
13191
13192 if (veracrypt_keyfiles)
13193 {
13194 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13195
13196 char *keyfiles = strdup (veracrypt_keyfiles);
13197
13198 char *keyfile = strtok (keyfiles, ",");
13199
13200 do
13201 {
13202 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13203
13204 } while ((keyfile = strtok (NULL, ",")) != NULL);
13205
13206 free (keyfiles);
13207 }
13208
13209 data.digests_cnt = digests_cnt;
13210 data.digests_done = digests_done;
13211 data.digests_buf = digests_buf;
13212 data.digests_shown = digests_shown;
13213 data.digests_shown_tmp = digests_shown_tmp;
13214
13215 data.salts_cnt = salts_cnt;
13216 data.salts_done = salts_done;
13217 data.salts_buf = salts_buf;
13218 data.salts_shown = salts_shown;
13219
13220 data.esalts_buf = esalts_buf;
13221 data.hash_info = hash_info;
13222
13223 /**
13224 * Automatic Optimizers
13225 */
13226
13227 if (salts_cnt == 1)
13228 opti_type |= OPTI_TYPE_SINGLE_SALT;
13229
13230 if (digests_cnt == 1)
13231 opti_type |= OPTI_TYPE_SINGLE_HASH;
13232
13233 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13234 opti_type |= OPTI_TYPE_NOT_ITERATED;
13235
13236 if (attack_mode == ATTACK_MODE_BF)
13237 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13238
13239 data.opti_type = opti_type;
13240
13241 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13242 {
13243 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13244 {
13245 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13246 {
13247 if (opts_type & OPTS_TYPE_ST_ADD80)
13248 {
13249 opts_type &= ~OPTS_TYPE_ST_ADD80;
13250 opts_type |= OPTS_TYPE_PT_ADD80;
13251 }
13252
13253 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13254 {
13255 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13256 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13257 }
13258
13259 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13260 {
13261 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13262 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13263 }
13264 }
13265 }
13266 }
13267
13268 /**
13269 * Some algorithm, like descrypt, can benefit from JIT compilation
13270 */
13271
13272 int force_jit_compilation = -1;
13273
13274 if (hash_mode == 8900)
13275 {
13276 force_jit_compilation = 8900;
13277 }
13278 else if (hash_mode == 9300)
13279 {
13280 force_jit_compilation = 8900;
13281 }
13282 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13283 {
13284 force_jit_compilation = 1500;
13285 }
13286
13287 /**
13288 * generate bitmap tables
13289 */
13290
13291 const uint bitmap_shift1 = 5;
13292 const uint bitmap_shift2 = 13;
13293
13294 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13295
13296 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13297 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13298 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13299 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13300 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13301 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13302 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13303 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13304
13305 uint bitmap_bits;
13306 uint bitmap_nums;
13307 uint bitmap_mask;
13308 uint bitmap_size;
13309
13310 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13311 {
13312 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13313
13314 bitmap_nums = 1 << bitmap_bits;
13315
13316 bitmap_mask = bitmap_nums - 1;
13317
13318 bitmap_size = bitmap_nums * sizeof (uint);
13319
13320 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13321
13322 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;
13323 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;
13324
13325 break;
13326 }
13327
13328 bitmap_nums = 1 << bitmap_bits;
13329
13330 bitmap_mask = bitmap_nums - 1;
13331
13332 bitmap_size = bitmap_nums * sizeof (uint);
13333
13334 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);
13335 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);
13336
13337 /**
13338 * prepare quick rule
13339 */
13340
13341 data.rule_buf_l = rule_buf_l;
13342 data.rule_buf_r = rule_buf_r;
13343
13344 int rule_len_l = (int) strlen (rule_buf_l);
13345 int rule_len_r = (int) strlen (rule_buf_r);
13346
13347 data.rule_len_l = rule_len_l;
13348 data.rule_len_r = rule_len_r;
13349
13350 /**
13351 * load rules
13352 */
13353
13354 uint *all_kernel_rules_cnt = NULL;
13355
13356 kernel_rule_t **all_kernel_rules_buf = NULL;
13357
13358 if (rp_files_cnt)
13359 {
13360 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13361
13362 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13363 }
13364
13365 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13366
13367 int rule_len = 0;
13368
13369 for (uint i = 0; i < rp_files_cnt; i++)
13370 {
13371 uint kernel_rules_avail = 0;
13372
13373 uint kernel_rules_cnt = 0;
13374
13375 kernel_rule_t *kernel_rules_buf = NULL;
13376
13377 char *rp_file = rp_files[i];
13378
13379 char in[BLOCK_SIZE] = { 0 };
13380 char out[BLOCK_SIZE] = { 0 };
13381
13382 FILE *fp = NULL;
13383
13384 uint rule_line = 0;
13385
13386 if ((fp = fopen (rp_file, "rb")) == NULL)
13387 {
13388 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13389
13390 return (-1);
13391 }
13392
13393 while (!feof (fp))
13394 {
13395 memset (rule_buf, 0, HCBUFSIZ);
13396
13397 rule_len = fgetl (fp, rule_buf);
13398
13399 rule_line++;
13400
13401 if (rule_len == 0) continue;
13402
13403 if (rule_buf[0] == '#') continue;
13404
13405 if (kernel_rules_avail == kernel_rules_cnt)
13406 {
13407 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13408
13409 kernel_rules_avail += INCR_RULES;
13410 }
13411
13412 memset (in, 0, BLOCK_SIZE);
13413 memset (out, 0, BLOCK_SIZE);
13414
13415 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13416
13417 if (result == -1)
13418 {
13419 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13420
13421 continue;
13422 }
13423
13424 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13425 {
13426 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13427
13428 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13429
13430 continue;
13431 }
13432
13433 /* its so slow
13434 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13435 {
13436 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13437
13438 continue;
13439 }
13440 */
13441
13442 kernel_rules_cnt++;
13443 }
13444
13445 fclose (fp);
13446
13447 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13448
13449 all_kernel_rules_buf[i] = kernel_rules_buf;
13450 }
13451
13452 /**
13453 * merge rules or automatic rule generator
13454 */
13455
13456 uint kernel_rules_cnt = 0;
13457
13458 kernel_rule_t *kernel_rules_buf = NULL;
13459
13460 if (attack_mode == ATTACK_MODE_STRAIGHT)
13461 {
13462 if (rp_files_cnt)
13463 {
13464 kernel_rules_cnt = 1;
13465
13466 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13467
13468 repeats[0] = kernel_rules_cnt;
13469
13470 for (uint i = 0; i < rp_files_cnt; i++)
13471 {
13472 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13473
13474 repeats[i + 1] = kernel_rules_cnt;
13475 }
13476
13477 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13478
13479 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13480
13481 for (uint i = 0; i < kernel_rules_cnt; i++)
13482 {
13483 uint out_pos = 0;
13484
13485 kernel_rule_t *out = &kernel_rules_buf[i];
13486
13487 for (uint j = 0; j < rp_files_cnt; j++)
13488 {
13489 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13490 uint in_pos;
13491
13492 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13493
13494 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13495 {
13496 if (out_pos == RULES_MAX - 1)
13497 {
13498 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13499
13500 break;
13501 }
13502
13503 out->cmds[out_pos] = in->cmds[in_pos];
13504 }
13505 }
13506 }
13507
13508 local_free (repeats);
13509 }
13510 else if (rp_gen)
13511 {
13512 uint kernel_rules_avail = 0;
13513
13514 while (kernel_rules_cnt < rp_gen)
13515 {
13516 if (kernel_rules_avail == kernel_rules_cnt)
13517 {
13518 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13519
13520 kernel_rules_avail += INCR_RULES;
13521 }
13522
13523 memset (rule_buf, 0, HCBUFSIZ);
13524
13525 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13526
13527 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13528
13529 kernel_rules_cnt++;
13530 }
13531 }
13532 }
13533
13534 myfree (rule_buf);
13535
13536 /**
13537 * generate NOP rules
13538 */
13539
13540 if (kernel_rules_cnt == 0)
13541 {
13542 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13543
13544 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13545
13546 kernel_rules_cnt++;
13547 }
13548
13549 data.kernel_rules_cnt = kernel_rules_cnt;
13550 data.kernel_rules_buf = kernel_rules_buf;
13551
13552 /**
13553 * OpenCL platforms: detect
13554 */
13555
13556 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13557 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13558
13559 cl_uint platforms_cnt = 0;
13560 cl_uint platform_devices_cnt = 0;
13561
13562 if (keyspace == 0)
13563 {
13564 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13565
13566 if (platforms_cnt == 0)
13567 {
13568 log_info ("");
13569 log_info ("ATTENTION! No OpenCL compatible platform found");
13570 log_info ("");
13571 log_info ("You're probably missing the OpenCL runtime installation");
13572 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13573 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13574 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13575 log_info ("");
13576
13577 return (-1);
13578 }
13579
13580 if (opencl_platforms_filter != (uint) -1)
13581 {
13582 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13583
13584 if (opencl_platforms_filter > platform_cnt_mask)
13585 {
13586 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13587
13588 return (-1);
13589 }
13590 }
13591 }
13592
13593 /**
13594 * OpenCL device types:
13595 * 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.
13596 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13597 */
13598
13599 if (opencl_device_types == NULL)
13600 {
13601 cl_device_type device_types_all = 0;
13602
13603 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13604 {
13605 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13606
13607 cl_platform_id platform = platforms[platform_id];
13608
13609 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13610
13611 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13612 {
13613 cl_device_id device = platform_devices[platform_devices_id];
13614
13615 cl_device_type device_type;
13616
13617 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13618
13619 device_types_all |= device_type;
13620 }
13621 }
13622
13623 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13624 {
13625 device_types_filter |= CL_DEVICE_TYPE_CPU;
13626 }
13627 }
13628
13629 /**
13630 * OpenCL devices: simply push all devices from all platforms into the same device array
13631 */
13632
13633 int need_adl = 0;
13634 int need_nvapi = 0;
13635 int need_nvml = 0;
13636
13637 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13638
13639 data.devices_param = devices_param;
13640
13641 uint devices_cnt = 0;
13642
13643 uint devices_active = 0;
13644
13645 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13646 {
13647 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13648
13649 cl_platform_id platform = platforms[platform_id];
13650
13651 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13652
13653 char platform_vendor[INFOSZ] = { 0 };
13654
13655 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13656
13657 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13658 // this causes trouble with vendor id based macros
13659 // we'll assign generic to those without special optimization available
13660
13661 cl_uint platform_vendor_id = 0;
13662
13663 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13664 {
13665 platform_vendor_id = VENDOR_ID_AMD;
13666 }
13667 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13668 {
13669 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13670 }
13671 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13672 {
13673 platform_vendor_id = VENDOR_ID_APPLE;
13674 }
13675 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13676 {
13677 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13678 }
13679 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13680 {
13681 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13682 }
13683 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13684 {
13685 platform_vendor_id = VENDOR_ID_MESA;
13686 }
13687 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13688 {
13689 platform_vendor_id = VENDOR_ID_NV;
13690 }
13691 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13692 {
13693 platform_vendor_id = VENDOR_ID_POCL;
13694 }
13695 else
13696 {
13697 platform_vendor_id = VENDOR_ID_GENERIC;
13698 }
13699
13700 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13701 {
13702 size_t param_value_size = 0;
13703
13704 const uint device_id = devices_cnt;
13705
13706 hc_device_param_t *device_param = &data.devices_param[device_id];
13707
13708 device_param->platform_vendor_id = platform_vendor_id;
13709
13710 device_param->device = platform_devices[platform_devices_id];
13711
13712 device_param->device_id = device_id;
13713
13714 device_param->platform_devices_id = platform_devices_id;
13715
13716 // device_type
13717
13718 cl_device_type device_type;
13719
13720 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13721
13722 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13723
13724 device_param->device_type = device_type;
13725
13726 // device_name
13727
13728 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13729
13730 char *device_name = (char *) mymalloc (param_value_size);
13731
13732 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13733
13734 device_param->device_name = device_name;
13735
13736 // device_vendor
13737
13738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13739
13740 char *device_vendor = (char *) mymalloc (param_value_size);
13741
13742 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13743
13744 device_param->device_vendor = device_vendor;
13745
13746 cl_uint device_vendor_id = 0;
13747
13748 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13749 {
13750 device_vendor_id = VENDOR_ID_AMD;
13751 }
13752 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13753 {
13754 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13755 }
13756 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13757 {
13758 device_vendor_id = VENDOR_ID_APPLE;
13759 }
13760 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13761 {
13762 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13763 }
13764 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13765 {
13766 device_vendor_id = VENDOR_ID_INTEL_SDK;
13767 }
13768 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13769 {
13770 device_vendor_id = VENDOR_ID_MESA;
13771 }
13772 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13773 {
13774 device_vendor_id = VENDOR_ID_NV;
13775 }
13776 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13777 {
13778 device_vendor_id = VENDOR_ID_POCL;
13779 }
13780 else
13781 {
13782 device_vendor_id = VENDOR_ID_GENERIC;
13783 }
13784
13785 device_param->device_vendor_id = device_vendor_id;
13786
13787 // tuning db
13788
13789 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13790
13791 // device_version
13792
13793 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13794
13795 char *device_version = (char *) mymalloc (param_value_size);
13796
13797 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13798
13799 device_param->device_version = device_version;
13800
13801 // device_opencl_version
13802
13803 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13804
13805 char *device_opencl_version = (char *) mymalloc (param_value_size);
13806
13807 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13808
13809 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13810
13811 myfree (device_opencl_version);
13812
13813 // vector_width
13814
13815 cl_uint vector_width;
13816
13817 if (opencl_vector_width_chgd == 0)
13818 {
13819 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13820 {
13821 if (opti_type & OPTI_TYPE_USES_BITS_64)
13822 {
13823 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13824 }
13825 else
13826 {
13827 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13828 }
13829 }
13830 else
13831 {
13832 vector_width = (cl_uint) tuningdb_entry->vector_width;
13833 }
13834 }
13835 else
13836 {
13837 vector_width = opencl_vector_width;
13838 }
13839
13840 if (vector_width > 16) vector_width = 16;
13841
13842 device_param->vector_width = vector_width;
13843
13844 // max_compute_units
13845
13846 cl_uint device_processors;
13847
13848 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13849
13850 device_param->device_processors = device_processors;
13851
13852 // device_maxmem_alloc
13853 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13854
13855 cl_ulong device_maxmem_alloc;
13856
13857 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13858
13859 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13860
13861 // device_global_mem
13862
13863 cl_ulong device_global_mem;
13864
13865 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13866
13867 device_param->device_global_mem = device_global_mem;
13868
13869 // max_work_group_size
13870
13871 size_t device_maxworkgroup_size;
13872
13873 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13874
13875 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13876
13877 // max_clock_frequency
13878
13879 cl_uint device_maxclock_frequency;
13880
13881 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13882
13883 device_param->device_maxclock_frequency = device_maxclock_frequency;
13884
13885 // device_endian_little
13886
13887 cl_bool device_endian_little;
13888
13889 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13890
13891 if (device_endian_little == CL_FALSE)
13892 {
13893 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13894
13895 device_param->skipped = 1;
13896 }
13897
13898 // device_available
13899
13900 cl_bool device_available;
13901
13902 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13903
13904 if (device_available == CL_FALSE)
13905 {
13906 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13907
13908 device_param->skipped = 1;
13909 }
13910
13911 // device_compiler_available
13912
13913 cl_bool device_compiler_available;
13914
13915 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13916
13917 if (device_compiler_available == CL_FALSE)
13918 {
13919 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13920
13921 device_param->skipped = 1;
13922 }
13923
13924 // device_execution_capabilities
13925
13926 cl_device_exec_capabilities device_execution_capabilities;
13927
13928 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13929
13930 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13931 {
13932 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13933
13934 device_param->skipped = 1;
13935 }
13936
13937 // device_extensions
13938
13939 size_t device_extensions_size;
13940
13941 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13942
13943 char *device_extensions = mymalloc (device_extensions_size + 1);
13944
13945 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13946
13947 if (strstr (device_extensions, "base_atomics") == 0)
13948 {
13949 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13950
13951 device_param->skipped = 1;
13952 }
13953
13954 if (strstr (device_extensions, "byte_addressable_store") == 0)
13955 {
13956 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13957
13958 device_param->skipped = 1;
13959 }
13960
13961 myfree (device_extensions);
13962
13963 // device_local_mem_size
13964
13965 cl_ulong device_local_mem_size;
13966
13967 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13968
13969 if (device_local_mem_size < 32768)
13970 {
13971 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13972
13973 device_param->skipped = 1;
13974 }
13975
13976 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13977 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13978 // This results in both utilizing it for 50%
13979 // However, Intel has much better SIMD control over their own hardware
13980 // It makes sense to give them full control over their own hardware
13981
13982 if (device_type & CL_DEVICE_TYPE_CPU)
13983 {
13984 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13985 {
13986 if (data.force == 0)
13987 {
13988 if (algorithm_pos == 0)
13989 {
13990 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13991 log_info (" You can use --force to override this but do not post error reports if you do so");
13992 }
13993
13994 device_param->skipped = 1;
13995 }
13996 }
13997 }
13998
13999 // skipped
14000
14001 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14002 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14003
14004 // driver_version
14005
14006 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14007
14008 char *driver_version = (char *) mymalloc (param_value_size);
14009
14010 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14011
14012 device_param->driver_version = driver_version;
14013
14014 // device_name_chksum
14015
14016 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14017
14018 #if __x86_64__
14019 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);
14020 #else
14021 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);
14022 #endif
14023
14024 uint device_name_digest[4] = { 0 };
14025
14026 md5_64 ((uint *) device_name_chksum, device_name_digest);
14027
14028 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14029
14030 device_param->device_name_chksum = device_name_chksum;
14031
14032 // device_processor_cores
14033
14034 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14035 {
14036 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14037 {
14038 need_adl = 1;
14039 }
14040
14041 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14042 {
14043 need_nvml = 1;
14044
14045 #ifdef _WIN
14046 need_nvapi = 1;
14047 #endif
14048 }
14049 }
14050
14051 // device_processor_cores
14052
14053 if (device_type & CL_DEVICE_TYPE_CPU)
14054 {
14055 cl_uint device_processor_cores = 1;
14056
14057 device_param->device_processor_cores = device_processor_cores;
14058 }
14059
14060 if (device_type & CL_DEVICE_TYPE_GPU)
14061 {
14062 if (device_vendor_id == VENDOR_ID_AMD)
14063 {
14064 cl_uint device_processor_cores = 0;
14065
14066 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14067
14068 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14069
14070 device_param->device_processor_cores = device_processor_cores;
14071 }
14072 else if (device_vendor_id == VENDOR_ID_NV)
14073 {
14074 cl_uint kernel_exec_timeout = 0;
14075
14076 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14077
14078 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14079
14080 device_param->kernel_exec_timeout = kernel_exec_timeout;
14081
14082 cl_uint device_processor_cores = 0;
14083
14084 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14085
14086 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14087
14088 device_param->device_processor_cores = device_processor_cores;
14089
14090 cl_uint sm_minor = 0;
14091 cl_uint sm_major = 0;
14092
14093 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14094 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14095
14096 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14097 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14098
14099 device_param->sm_minor = sm_minor;
14100 device_param->sm_major = sm_major;
14101 }
14102 else
14103 {
14104 cl_uint device_processor_cores = 1;
14105
14106 device_param->device_processor_cores = device_processor_cores;
14107 }
14108 }
14109
14110 // display results
14111
14112 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14113 {
14114 if (machine_readable == 0)
14115 {
14116 if (device_param->skipped == 0)
14117 {
14118 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14119 device_id + 1,
14120 device_name,
14121 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14122 (unsigned int) (device_global_mem / 1024 / 1024),
14123 (unsigned int) device_processors);
14124 }
14125 else
14126 {
14127 log_info ("Device #%u: %s, skipped",
14128 device_id + 1,
14129 device_name);
14130 }
14131 }
14132 }
14133
14134 // common driver check
14135
14136 if (device_param->skipped == 0)
14137 {
14138 if (device_type & CL_DEVICE_TYPE_GPU)
14139 {
14140 if (platform_vendor_id == VENDOR_ID_AMD)
14141 {
14142 int catalyst_check = (force == 1) ? 0 : 1;
14143
14144 int catalyst_warn = 0;
14145
14146 int catalyst_broken = 0;
14147
14148 if (catalyst_check == 1)
14149 {
14150 catalyst_warn = 1;
14151
14152 // v14.9 and higher
14153 if (atoi (device_param->driver_version) >= 1573)
14154 {
14155 catalyst_warn = 0;
14156 }
14157
14158 catalyst_check = 0;
14159 }
14160
14161 if (catalyst_broken == 1)
14162 {
14163 log_info ("");
14164 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14165 log_info ("It will pass over cracked hashes and does not report them as cracked");
14166 log_info ("You are STRONGLY encouraged not to use it");
14167 log_info ("You can use --force to override this but do not post error reports if you do so");
14168 log_info ("");
14169
14170 return (-1);
14171 }
14172
14173 if (catalyst_warn == 1)
14174 {
14175 log_info ("");
14176 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14177 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14178 log_info ("See hashcat's homepage for official supported catalyst drivers");
14179 #ifdef _WIN
14180 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14181 #endif
14182 log_info ("You can use --force to override this but do not post error reports if you do so");
14183 log_info ("");
14184
14185 return (-1);
14186 }
14187 }
14188 else if (platform_vendor_id == VENDOR_ID_NV)
14189 {
14190 if (device_param->kernel_exec_timeout != 0)
14191 {
14192 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);
14193 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14194 }
14195 }
14196 }
14197
14198 /* turns out pocl still creates segfaults (because of llvm)
14199 if (device_type & CL_DEVICE_TYPE_CPU)
14200 {
14201 if (platform_vendor_id == VENDOR_ID_AMD)
14202 {
14203 if (force == 0)
14204 {
14205 log_info ("");
14206 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14207 log_info ("You are STRONGLY encouraged not to use it");
14208 log_info ("You can use --force to override this but do not post error reports if you do so");
14209 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14210 log_info ("");
14211
14212 return (-1);
14213 }
14214 }
14215 }
14216 */
14217
14218 /**
14219 * kernel accel and loops tuning db adjustment
14220 */
14221
14222 device_param->kernel_accel_min = 1;
14223 device_param->kernel_accel_max = 1024;
14224
14225 device_param->kernel_loops_min = 1;
14226 device_param->kernel_loops_max = 1024;
14227
14228 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14229
14230 if (tuningdb_entry)
14231 {
14232 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14233 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14234
14235 if (_kernel_accel)
14236 {
14237 device_param->kernel_accel_min = _kernel_accel;
14238 device_param->kernel_accel_max = _kernel_accel;
14239 }
14240
14241 if (_kernel_loops)
14242 {
14243 if (workload_profile == 1)
14244 {
14245 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14246 }
14247 else if (workload_profile == 2)
14248 {
14249 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14250 }
14251
14252 device_param->kernel_loops_min = _kernel_loops;
14253 device_param->kernel_loops_max = _kernel_loops;
14254 }
14255 }
14256
14257 // commandline parameters overwrite tuningdb entries
14258
14259 if (kernel_accel)
14260 {
14261 device_param->kernel_accel_min = kernel_accel;
14262 device_param->kernel_accel_max = kernel_accel;
14263 }
14264
14265 if (kernel_loops)
14266 {
14267 device_param->kernel_loops_min = kernel_loops;
14268 device_param->kernel_loops_max = kernel_loops;
14269 }
14270
14271 /**
14272 * activate device
14273 */
14274
14275 devices_active++;
14276 }
14277
14278 // next please
14279
14280 devices_cnt++;
14281 }
14282 }
14283
14284 if (keyspace == 0 && devices_active == 0)
14285 {
14286 log_error ("ERROR: No devices found/left");
14287
14288 return (-1);
14289 }
14290
14291 // 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)
14292
14293 if (devices_filter != (uint) -1)
14294 {
14295 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14296
14297 if (devices_filter > devices_cnt_mask)
14298 {
14299 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14300
14301 return (-1);
14302 }
14303 }
14304
14305 data.devices_cnt = devices_cnt;
14306
14307 data.devices_active = devices_active;
14308
14309 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14310 {
14311 if (machine_readable == 0)
14312 {
14313 log_info ("");
14314 }
14315 }
14316
14317 /**
14318 * HM devices: init
14319 */
14320
14321 #ifdef HAVE_HWMON
14322 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14323 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14324 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14325
14326 if (gpu_temp_disable == 0)
14327 {
14328 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14329 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14330 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14331
14332 data.hm_adl = NULL;
14333 data.hm_nvapi = NULL;
14334 data.hm_nvml = NULL;
14335
14336 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14337 {
14338 data.hm_nvml = nvml;
14339 }
14340
14341 if (data.hm_nvml)
14342 {
14343 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14344 {
14345 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14346
14347 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14348
14349 int tmp_out = 0;
14350
14351 for (int i = 0; i < tmp_in; i++)
14352 {
14353 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14354 }
14355
14356 for (int i = 0; i < tmp_out; i++)
14357 {
14358 unsigned int speed;
14359
14360 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14361
14362 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14363
14364 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14365 }
14366 }
14367 }
14368
14369 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14370 {
14371 data.hm_nvapi = nvapi;
14372 }
14373
14374 if (data.hm_nvapi)
14375 {
14376 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14377 {
14378 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14379
14380 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14381
14382 int tmp_out = 0;
14383
14384 for (int i = 0; i < tmp_in; i++)
14385 {
14386 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14387 }
14388 }
14389 }
14390
14391 if ((need_adl == 1) && (adl_init (adl) == 0))
14392 {
14393 data.hm_adl = adl;
14394 }
14395
14396 if (data.hm_adl)
14397 {
14398 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14399 {
14400 // total number of adapters
14401
14402 int hm_adapters_num;
14403
14404 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14405
14406 // adapter info
14407
14408 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14409
14410 if (lpAdapterInfo == NULL) return (-1);
14411
14412 // get a list (of ids of) valid/usable adapters
14413
14414 int num_adl_adapters = 0;
14415
14416 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14417
14418 if (num_adl_adapters > 0)
14419 {
14420 hc_thread_mutex_lock (mux_adl);
14421
14422 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14423
14424 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14425
14426 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14427 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14428
14429 hc_thread_mutex_unlock (mux_adl);
14430 }
14431
14432 myfree (valid_adl_device_list);
14433 myfree (lpAdapterInfo);
14434 }
14435 }
14436
14437 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14438 {
14439 gpu_temp_disable = 1;
14440 }
14441 }
14442
14443 /**
14444 * OpenCL devices: allocate buffer for device specific information
14445 */
14446
14447 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14448 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14449
14450 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14451
14452 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14453
14454 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14455
14456 /**
14457 * User-defined GPU temp handling
14458 */
14459
14460 if (gpu_temp_disable == 1)
14461 {
14462 gpu_temp_abort = 0;
14463 gpu_temp_retain = 0;
14464 }
14465
14466 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14467 {
14468 if (gpu_temp_abort < gpu_temp_retain)
14469 {
14470 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14471
14472 return (-1);
14473 }
14474 }
14475
14476 data.gpu_temp_disable = gpu_temp_disable;
14477 data.gpu_temp_abort = gpu_temp_abort;
14478 data.gpu_temp_retain = gpu_temp_retain;
14479 #endif
14480
14481 /**
14482 * enable custom signal handler(s)
14483 */
14484
14485 if (benchmark == 0)
14486 {
14487 hc_signal (sigHandler_default);
14488 }
14489 else
14490 {
14491 hc_signal (sigHandler_benchmark);
14492 }
14493
14494 /**
14495 * inform the user
14496 */
14497
14498 if (data.quiet == 0)
14499 {
14500 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14501
14502 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);
14503
14504 if (attack_mode == ATTACK_MODE_STRAIGHT)
14505 {
14506 log_info ("Rules: %u", kernel_rules_cnt);
14507 }
14508
14509 if (opti_type)
14510 {
14511 log_info ("Applicable Optimizers:");
14512
14513 for (uint i = 0; i < 32; i++)
14514 {
14515 const uint opti_bit = 1u << i;
14516
14517 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14518 }
14519 }
14520
14521 /**
14522 * Watchdog and Temperature balance
14523 */
14524
14525 #ifdef HAVE_HWMON
14526 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14527 {
14528 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14529 }
14530
14531 if (gpu_temp_abort == 0)
14532 {
14533 log_info ("Watchdog: Temperature abort trigger disabled");
14534 }
14535 else
14536 {
14537 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14538 }
14539
14540 if (gpu_temp_retain == 0)
14541 {
14542 log_info ("Watchdog: Temperature retain trigger disabled");
14543 }
14544 else
14545 {
14546 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14547 }
14548
14549 if (data.quiet == 0) log_info ("");
14550 #endif
14551 }
14552
14553 #ifdef HAVE_HWMON
14554
14555 /**
14556 * HM devices: copy
14557 */
14558
14559 if (gpu_temp_disable == 0)
14560 {
14561 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14562 {
14563 hc_device_param_t *device_param = &data.devices_param[device_id];
14564
14565 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14566
14567 if (device_param->skipped) continue;
14568
14569 const uint platform_devices_id = device_param->platform_devices_id;
14570
14571 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14572 {
14573 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14574 data.hm_device[device_id].nvapi = 0;
14575 data.hm_device[device_id].nvml = 0;
14576 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14577 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14578 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14579 }
14580
14581 if (device_param->device_vendor_id == VENDOR_ID_NV)
14582 {
14583 data.hm_device[device_id].adl = 0;
14584 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14585 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14586 data.hm_device[device_id].od_version = 0;
14587 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14588 data.hm_device[device_id].fan_set_supported = 0;
14589 }
14590 }
14591 }
14592
14593 /**
14594 * powertune on user request
14595 */
14596
14597 if (powertune_enable == 1)
14598 {
14599 hc_thread_mutex_lock (mux_adl);
14600
14601 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14602 {
14603 hc_device_param_t *device_param = &data.devices_param[device_id];
14604
14605 if (device_param->skipped) continue;
14606
14607 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14608 {
14609 /**
14610 * Temporary fix:
14611 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14612 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14613 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14614 * Driver / ADL bug?
14615 */
14616
14617 if (data.hm_device[device_id].od_version == 6)
14618 {
14619 int ADL_rc;
14620
14621 // check powertune capabilities first, if not available then skip device
14622
14623 int powertune_supported = 0;
14624
14625 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14626 {
14627 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14628
14629 return (-1);
14630 }
14631
14632 // first backup current value, we will restore it later
14633
14634 if (powertune_supported != 0)
14635 {
14636 // powercontrol settings
14637
14638 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14639
14640 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14641 {
14642 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14643 }
14644
14645 if (ADL_rc != ADL_OK)
14646 {
14647 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14648
14649 return (-1);
14650 }
14651
14652 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14653 {
14654 log_error ("ERROR: Failed to set new ADL PowerControl values");
14655
14656 return (-1);
14657 }
14658
14659 // clocks
14660
14661 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14662
14663 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14664
14665 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
14666 {
14667 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14668
14669 return (-1);
14670 }
14671
14672 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14673
14674 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14675
14676 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14677 {
14678 log_error ("ERROR: Failed to get ADL device capabilities");
14679
14680 return (-1);
14681 }
14682
14683 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14684 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14685
14686 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14687 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14688
14689 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14690 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14691
14692 // warning if profile has too low max values
14693
14694 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14695 {
14696 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14697 }
14698
14699 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14700 {
14701 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14702 }
14703
14704 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14705
14706 performance_state->iNumberOfPerformanceLevels = 2;
14707
14708 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14709 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14710 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14711 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14712
14713 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
14714 {
14715 log_info ("ERROR: Failed to set ADL performance state");
14716
14717 return (-1);
14718 }
14719
14720 local_free (performance_state);
14721 }
14722
14723 // set powertune value only
14724
14725 if (powertune_supported != 0)
14726 {
14727 // powertune set
14728 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14729
14730 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14731 {
14732 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14733
14734 return (-1);
14735 }
14736
14737 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14738 {
14739 log_error ("ERROR: Failed to set new ADL PowerControl values");
14740
14741 return (-1);
14742 }
14743 }
14744 }
14745 }
14746
14747 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14748 {
14749 // first backup current value, we will restore it later
14750
14751 unsigned int limit;
14752
14753 int powertune_supported = 0;
14754
14755 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14756 {
14757 powertune_supported = 1;
14758 }
14759
14760 // if backup worked, activate the maximum allowed
14761
14762 if (powertune_supported != 0)
14763 {
14764 unsigned int minLimit;
14765 unsigned int maxLimit;
14766
14767 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14768 {
14769 if (maxLimit > 0)
14770 {
14771 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14772 {
14773 // now we can be sure we need to reset later
14774
14775 nvml_power_limit[device_id] = limit;
14776 }
14777 }
14778 }
14779 }
14780 }
14781 }
14782
14783 hc_thread_mutex_unlock (mux_adl);
14784 }
14785
14786 #endif // HAVE_HWMON
14787
14788 #ifdef DEBUG
14789 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14790 #endif
14791
14792 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14793
14794 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14795 {
14796 /**
14797 * host buffer
14798 */
14799
14800 hc_device_param_t *device_param = &data.devices_param[device_id];
14801
14802 if (device_param->skipped) continue;
14803
14804 /**
14805 * device properties
14806 */
14807
14808 const char *device_name_chksum = device_param->device_name_chksum;
14809 const u32 device_processors = device_param->device_processors;
14810 const u32 device_processor_cores = device_param->device_processor_cores;
14811
14812 /**
14813 * create context for each device
14814 */
14815
14816 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14817
14818 /**
14819 * create command-queue
14820 */
14821
14822 // not supported with NV
14823 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14824
14825 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14826
14827 /**
14828 * kernel threads: some algorithms need a fixed kernel-threads count
14829 * because of shared memory usage or bitslice
14830 * there needs to be some upper limit, otherwise there's too much overhead
14831 */
14832
14833 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14834
14835 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14836 {
14837 kernel_threads = KERNEL_THREADS_MAX_CPU;
14838 }
14839
14840 if (hash_mode == 1500) kernel_threads = 64; // DES
14841 if (hash_mode == 3000) kernel_threads = 64; // DES
14842 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14843 if (hash_mode == 7500) kernel_threads = 64; // RC4
14844 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14845 if (hash_mode == 9700) kernel_threads = 64; // RC4
14846 if (hash_mode == 9710) kernel_threads = 64; // RC4
14847 if (hash_mode == 9800) kernel_threads = 64; // RC4
14848 if (hash_mode == 9810) kernel_threads = 64; // RC4
14849 if (hash_mode == 10400) kernel_threads = 64; // RC4
14850 if (hash_mode == 10410) kernel_threads = 64; // RC4
14851 if (hash_mode == 10500) kernel_threads = 64; // RC4
14852 if (hash_mode == 13100) kernel_threads = 64; // RC4
14853
14854 device_param->kernel_threads = kernel_threads;
14855
14856 device_param->hardware_power = device_processors * kernel_threads;
14857
14858 /**
14859 * create input buffers on device : calculate size of fixed memory buffers
14860 */
14861
14862 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14863 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14864
14865 device_param->size_root_css = size_root_css;
14866 device_param->size_markov_css = size_markov_css;
14867
14868 size_t size_results = sizeof (uint);
14869
14870 device_param->size_results = size_results;
14871
14872 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14873 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14874
14875 size_t size_plains = digests_cnt * sizeof (plain_t);
14876 size_t size_salts = salts_cnt * sizeof (salt_t);
14877 size_t size_esalts = salts_cnt * esalt_size;
14878
14879 device_param->size_plains = size_plains;
14880 device_param->size_digests = size_digests;
14881 device_param->size_shown = size_shown;
14882 device_param->size_salts = size_salts;
14883
14884 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14885 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14886 size_t size_tm = 32 * sizeof (bs_word_t);
14887
14888 // scryptV stuff
14889
14890 size_t size_scryptV = 1;
14891
14892 if ((hash_mode == 8900) || (hash_mode == 9300))
14893 {
14894 uint tmto_start = 0;
14895 uint tmto_stop = 10;
14896
14897 if (scrypt_tmto)
14898 {
14899 tmto_start = scrypt_tmto;
14900 }
14901 else
14902 {
14903 // in case the user did not specify the tmto manually
14904 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14905 // but set the lower end only in case the user has a device with too less memory
14906
14907 if (hash_mode == 8900)
14908 {
14909 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14910 {
14911 tmto_start = 1;
14912 }
14913 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14914 {
14915 tmto_start = 2;
14916 }
14917 }
14918 else if (hash_mode == 9300)
14919 {
14920 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14921 {
14922 tmto_start = 2;
14923 }
14924 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14925 {
14926 tmto_start = 2;
14927 }
14928 }
14929 }
14930
14931 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14932 {
14933 // TODO: in theory the following calculation needs to be done per salt, not global
14934 // we assume all hashes have the same scrypt settings
14935
14936 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14937
14938 size_scryptV /= 1 << tmto;
14939
14940 size_scryptV *= device_processors * device_processor_cores;
14941
14942 if (size_scryptV > device_param->device_maxmem_alloc)
14943 {
14944 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14945
14946 continue;
14947 }
14948
14949 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14950 {
14951 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14952 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14953 }
14954
14955 break;
14956 }
14957
14958 if (data.salts_buf[0].scrypt_phy == 0)
14959 {
14960 log_error ("ERROR: can't allocate enough device memory");
14961
14962 return -1;
14963 }
14964
14965 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14966 }
14967
14968 /**
14969 * some algorithms need a fixed kernel-loops count
14970 */
14971
14972 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14973 {
14974 const u32 kernel_loops_fixed = 1024;
14975
14976 device_param->kernel_loops_min = kernel_loops_fixed;
14977 device_param->kernel_loops_max = kernel_loops_fixed;
14978 }
14979
14980 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14981 {
14982 const u32 kernel_loops_fixed = 1024;
14983
14984 device_param->kernel_loops_min = kernel_loops_fixed;
14985 device_param->kernel_loops_max = kernel_loops_fixed;
14986 }
14987
14988 if (hash_mode == 8900)
14989 {
14990 const u32 kernel_loops_fixed = 1;
14991
14992 device_param->kernel_loops_min = kernel_loops_fixed;
14993 device_param->kernel_loops_max = kernel_loops_fixed;
14994 }
14995
14996 if (hash_mode == 9300)
14997 {
14998 const u32 kernel_loops_fixed = 1;
14999
15000 device_param->kernel_loops_min = kernel_loops_fixed;
15001 device_param->kernel_loops_max = kernel_loops_fixed;
15002 }
15003
15004 if (hash_mode == 12500)
15005 {
15006 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15007
15008 device_param->kernel_loops_min = kernel_loops_fixed;
15009 device_param->kernel_loops_max = kernel_loops_fixed;
15010 }
15011
15012 /**
15013 * some algorithms have a maximum kernel-loops count
15014 */
15015
15016 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15017 {
15018 u32 innerloop_cnt = 0;
15019
15020 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15021 {
15022 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15023 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15024 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15025 }
15026 else
15027 {
15028 innerloop_cnt = data.salts_buf[0].salt_iter;
15029 }
15030
15031 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15032 (innerloop_cnt <= device_param->kernel_loops_max))
15033 {
15034 device_param->kernel_loops_max = innerloop_cnt;
15035 }
15036 }
15037
15038 u32 kernel_accel_min = device_param->kernel_accel_min;
15039 u32 kernel_accel_max = device_param->kernel_accel_max;
15040
15041 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15042
15043 size_t size_pws = 4;
15044 size_t size_tmps = 4;
15045 size_t size_hooks = 4;
15046
15047 while (kernel_accel_max >= kernel_accel_min)
15048 {
15049 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15050
15051 // size_pws
15052
15053 size_pws = kernel_power_max * sizeof (pw_t);
15054
15055 // size_tmps
15056
15057 switch (hash_mode)
15058 {
15059 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15060 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15061 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15062 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15063 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15064 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15065 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15066 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15067 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15068 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15069 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15070 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15071 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15072 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15073 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15074 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15075 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15076 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15077 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15078 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15079 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15080 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15081 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15082 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15083 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15084 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15085 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15086 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15087 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15088 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15089 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15090 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15091 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15092 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15093 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15094 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15095 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15096 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15097 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15098 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15099 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15100 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15101 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15102 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15103 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15104 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15105 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15106 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15107 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15108 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15109 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15110 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15111 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15112 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15113 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15114 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15115 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15116 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15117 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15118 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15119 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15120 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15121 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15122 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15123 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15124 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15125 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15126 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15127 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15128 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15129 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15130 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15131 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15132 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15133 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15134 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15135 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15136 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15137 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15138 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15139 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15140 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15141 };
15142
15143 // size_hooks
15144
15145 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15146 {
15147 switch (hash_mode)
15148 {
15149 }
15150 }
15151
15152 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15153 // if not, decrease amplifier and try again
15154
15155 int skip = 0;
15156
15157 const u64 size_total
15158 = bitmap_size
15159 + bitmap_size
15160 + bitmap_size
15161 + bitmap_size
15162 + bitmap_size
15163 + bitmap_size
15164 + bitmap_size
15165 + bitmap_size
15166 + size_bfs
15167 + size_combs
15168 + size_digests
15169 + size_esalts
15170 + size_hooks
15171 + size_markov_css
15172 + size_plains
15173 + size_pws
15174 + size_pws // not a bug
15175 + size_results
15176 + size_root_css
15177 + size_rules
15178 + size_rules_c
15179 + size_salts
15180 + size_scryptV
15181 + size_shown
15182 + size_tm
15183 + size_tmps;
15184
15185 // Don't ask me, ask AMD!
15186
15187 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15188 if (size_total > device_param->device_global_mem) skip = 1;
15189
15190 if (skip == 1)
15191 {
15192 kernel_accel_max--;
15193
15194 continue;
15195 }
15196
15197 break;
15198 }
15199
15200 /*
15201 if (kernel_accel_max == 0)
15202 {
15203 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15204
15205 return -1;
15206 }
15207 */
15208
15209 device_param->kernel_accel_min = kernel_accel_min;
15210 device_param->kernel_accel_max = kernel_accel_max;
15211
15212 /*
15213 if (kernel_accel_max < kernel_accel)
15214 {
15215 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15216
15217 device_param->kernel_accel = kernel_accel_max;
15218 }
15219 */
15220
15221 device_param->size_bfs = size_bfs;
15222 device_param->size_combs = size_combs;
15223 device_param->size_rules = size_rules;
15224 device_param->size_rules_c = size_rules_c;
15225 device_param->size_pws = size_pws;
15226 device_param->size_tmps = size_tmps;
15227 device_param->size_hooks = size_hooks;
15228
15229 /**
15230 * default building options
15231 */
15232
15233 char build_opts[1024] = { 0 };
15234
15235 // we don't have sm_* on vendors not NV but it doesn't matter
15236
15237 #if _WIN
15238 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);
15239 #else
15240 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);
15241 #endif
15242
15243 char build_opts_new[1024] = { 0 };
15244
15245 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);
15246
15247 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15248
15249 /*
15250 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15251 {
15252 // we do vectorizing much better than the auto-vectorizer
15253
15254 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15255
15256 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15257 }
15258 */
15259
15260 #ifdef DEBUG
15261 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15262 #endif
15263
15264 /**
15265 * main kernel
15266 */
15267
15268 {
15269 /**
15270 * kernel source filename
15271 */
15272
15273 char source_file[256] = { 0 };
15274
15275 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15276
15277 struct stat sst;
15278
15279 if (stat (source_file, &sst) == -1)
15280 {
15281 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15282
15283 return -1;
15284 }
15285
15286 /**
15287 * kernel cached filename
15288 */
15289
15290 char cached_file[256] = { 0 };
15291
15292 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15293
15294 int cached = 1;
15295
15296 struct stat cst;
15297
15298 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15299 {
15300 cached = 0;
15301 }
15302
15303 /**
15304 * kernel compile or load
15305 */
15306
15307 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15308
15309 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15310
15311 if (force_jit_compilation == -1)
15312 {
15313 if (cached == 0)
15314 {
15315 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15316
15317 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15318
15319 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15320
15321 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15322
15323 #ifdef DEBUG
15324 size_t build_log_size = 0;
15325
15326 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15327
15328 if (build_log_size > 1)
15329 {
15330 char *build_log = (char *) malloc (build_log_size + 1);
15331
15332 memset (build_log, 0, build_log_size + 1);
15333
15334 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15335
15336 puts (build_log);
15337
15338 free (build_log);
15339 }
15340 #endif
15341
15342 if (rc != 0)
15343 {
15344 device_param->skipped = true;
15345
15346 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15347
15348 continue;
15349 }
15350
15351 size_t binary_size;
15352
15353 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15354
15355 u8 *binary = (u8 *) mymalloc (binary_size);
15356
15357 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15358
15359 writeProgramBin (cached_file, binary, binary_size);
15360
15361 local_free (binary);
15362 }
15363 else
15364 {
15365 #ifdef DEBUG
15366 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15367 #endif
15368
15369 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15370
15371 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15372
15373 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15374 }
15375 }
15376 else
15377 {
15378 #ifdef DEBUG
15379 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15380 #endif
15381
15382 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15383
15384 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15385
15386 char build_opts_update[1024] = { 0 };
15387
15388 if (force_jit_compilation == 1500)
15389 {
15390 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15391 }
15392 else if (force_jit_compilation == 8900)
15393 {
15394 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);
15395 }
15396 else
15397 {
15398 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15399 }
15400
15401 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15402
15403 #ifdef DEBUG
15404 size_t build_log_size = 0;
15405
15406 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15407
15408 if (build_log_size > 1)
15409 {
15410 char *build_log = (char *) malloc (build_log_size + 1);
15411
15412 memset (build_log, 0, build_log_size + 1);
15413
15414 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15415
15416 puts (build_log);
15417
15418 free (build_log);
15419 }
15420 #endif
15421
15422 if (rc != 0)
15423 {
15424 device_param->skipped = true;
15425
15426 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15427 }
15428 }
15429
15430 local_free (kernel_lengths);
15431 local_free (kernel_sources[0]);
15432 local_free (kernel_sources);
15433 }
15434
15435 /**
15436 * word generator kernel
15437 */
15438
15439 if (attack_mode != ATTACK_MODE_STRAIGHT)
15440 {
15441 /**
15442 * kernel mp source filename
15443 */
15444
15445 char source_file[256] = { 0 };
15446
15447 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15448
15449 struct stat sst;
15450
15451 if (stat (source_file, &sst) == -1)
15452 {
15453 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15454
15455 return -1;
15456 }
15457
15458 /**
15459 * kernel mp cached filename
15460 */
15461
15462 char cached_file[256] = { 0 };
15463
15464 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15465
15466 int cached = 1;
15467
15468 struct stat cst;
15469
15470 if (stat (cached_file, &cst) == -1)
15471 {
15472 cached = 0;
15473 }
15474
15475 /**
15476 * kernel compile or load
15477 */
15478
15479 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15480
15481 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15482
15483 if (cached == 0)
15484 {
15485 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15486 if (quiet == 0) log_info ("");
15487
15488 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15489
15490 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15491
15492 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15493
15494 if (rc != 0)
15495 {
15496 device_param->skipped = true;
15497
15498 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15499
15500 continue;
15501 }
15502
15503 size_t binary_size;
15504
15505 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15506
15507 u8 *binary = (u8 *) mymalloc (binary_size);
15508
15509 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15510
15511 writeProgramBin (cached_file, binary, binary_size);
15512
15513 local_free (binary);
15514 }
15515 else
15516 {
15517 #ifdef DEBUG
15518 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15519 #endif
15520
15521 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15522
15523 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15524
15525 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15526 }
15527
15528 local_free (kernel_lengths);
15529 local_free (kernel_sources[0]);
15530 local_free (kernel_sources);
15531 }
15532
15533 /**
15534 * amplifier kernel
15535 */
15536
15537 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15538 {
15539
15540 }
15541 else
15542 {
15543 /**
15544 * kernel amp source filename
15545 */
15546
15547 char source_file[256] = { 0 };
15548
15549 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15550
15551 struct stat sst;
15552
15553 if (stat (source_file, &sst) == -1)
15554 {
15555 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15556
15557 return -1;
15558 }
15559
15560 /**
15561 * kernel amp cached filename
15562 */
15563
15564 char cached_file[256] = { 0 };
15565
15566 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15567
15568 int cached = 1;
15569
15570 struct stat cst;
15571
15572 if (stat (cached_file, &cst) == -1)
15573 {
15574 cached = 0;
15575 }
15576
15577 /**
15578 * kernel compile or load
15579 */
15580
15581 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15582
15583 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15584
15585 if (cached == 0)
15586 {
15587 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15588 if (quiet == 0) log_info ("");
15589
15590 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15591
15592 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15593
15594 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15595
15596 if (rc != 0)
15597 {
15598 device_param->skipped = true;
15599
15600 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15601
15602 continue;
15603 }
15604
15605 size_t binary_size;
15606
15607 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15608
15609 u8 *binary = (u8 *) mymalloc (binary_size);
15610
15611 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15612
15613 writeProgramBin (cached_file, binary, binary_size);
15614
15615 local_free (binary);
15616 }
15617 else
15618 {
15619 #ifdef DEBUG
15620 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15621 #endif
15622
15623 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15624
15625 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15626
15627 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15628 }
15629
15630 local_free (kernel_lengths);
15631 local_free (kernel_sources[0]);
15632 local_free (kernel_sources);
15633 }
15634
15635 // some algorithm collide too fast, make that impossible
15636
15637 if (benchmark == 1)
15638 {
15639 ((uint *) digests_buf)[0] = -1;
15640 ((uint *) digests_buf)[1] = -1;
15641 ((uint *) digests_buf)[2] = -1;
15642 ((uint *) digests_buf)[3] = -1;
15643 }
15644
15645 /**
15646 * global buffers
15647 */
15648
15649 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15650 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15651 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15652 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15653 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15654 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15655 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15656 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15657 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15658 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15659 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15660 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15661 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15662 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15663 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15664 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15665 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15666 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15667
15668 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);
15669 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);
15670 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);
15671 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);
15672 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);
15673 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);
15674 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);
15675 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);
15676 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15677 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15678 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15679
15680 /**
15681 * special buffers
15682 */
15683
15684 if (attack_kern == ATTACK_KERN_STRAIGHT)
15685 {
15686 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15687 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15688
15689 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15690 }
15691 else if (attack_kern == ATTACK_KERN_COMBI)
15692 {
15693 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15694 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15695 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15696 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15697 }
15698 else if (attack_kern == ATTACK_KERN_BF)
15699 {
15700 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15701 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15702 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15703 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15704 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15705 }
15706
15707 if (size_esalts)
15708 {
15709 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15710
15711 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15712 }
15713
15714 /**
15715 * main host data
15716 */
15717
15718 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15719
15720 device_param->pws_buf = pws_buf;
15721
15722 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15723
15724 device_param->combs_buf = combs_buf;
15725
15726 void *hooks_buf = mymalloc (size_hooks);
15727
15728 device_param->hooks_buf = hooks_buf;
15729
15730 /**
15731 * kernel args
15732 */
15733
15734 device_param->kernel_params_buf32[21] = bitmap_mask;
15735 device_param->kernel_params_buf32[22] = bitmap_shift1;
15736 device_param->kernel_params_buf32[23] = bitmap_shift2;
15737 device_param->kernel_params_buf32[24] = 0; // salt_pos
15738 device_param->kernel_params_buf32[25] = 0; // loop_pos
15739 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15740 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15741 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15742 device_param->kernel_params_buf32[29] = 0; // digests_offset
15743 device_param->kernel_params_buf32[30] = 0; // combs_mode
15744 device_param->kernel_params_buf32[31] = 0; // gid_max
15745
15746 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15747 ? &device_param->d_pws_buf
15748 : &device_param->d_pws_amp_buf;
15749 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15750 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15751 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15752 device_param->kernel_params[ 4] = &device_param->d_tmps;
15753 device_param->kernel_params[ 5] = &device_param->d_hooks;
15754 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15755 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15756 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15757 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15758 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15759 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15760 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15761 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15762 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15763 device_param->kernel_params[15] = &device_param->d_digests_buf;
15764 device_param->kernel_params[16] = &device_param->d_digests_shown;
15765 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15766 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15767 device_param->kernel_params[19] = &device_param->d_result;
15768 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15769 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15770 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15771 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15772 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15773 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15774 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15775 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15776 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15777 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15778 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15779 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15780
15781 device_param->kernel_params_mp_buf64[3] = 0;
15782 device_param->kernel_params_mp_buf32[4] = 0;
15783 device_param->kernel_params_mp_buf32[5] = 0;
15784 device_param->kernel_params_mp_buf32[6] = 0;
15785 device_param->kernel_params_mp_buf32[7] = 0;
15786 device_param->kernel_params_mp_buf32[8] = 0;
15787
15788 device_param->kernel_params_mp[0] = NULL;
15789 device_param->kernel_params_mp[1] = NULL;
15790 device_param->kernel_params_mp[2] = NULL;
15791 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15792 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15793 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15794 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15795 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15796 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15797
15798 device_param->kernel_params_mp_l_buf64[3] = 0;
15799 device_param->kernel_params_mp_l_buf32[4] = 0;
15800 device_param->kernel_params_mp_l_buf32[5] = 0;
15801 device_param->kernel_params_mp_l_buf32[6] = 0;
15802 device_param->kernel_params_mp_l_buf32[7] = 0;
15803 device_param->kernel_params_mp_l_buf32[8] = 0;
15804 device_param->kernel_params_mp_l_buf32[9] = 0;
15805
15806 device_param->kernel_params_mp_l[0] = NULL;
15807 device_param->kernel_params_mp_l[1] = NULL;
15808 device_param->kernel_params_mp_l[2] = NULL;
15809 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15810 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15811 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15812 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15813 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15814 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15815 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15816
15817 device_param->kernel_params_mp_r_buf64[3] = 0;
15818 device_param->kernel_params_mp_r_buf32[4] = 0;
15819 device_param->kernel_params_mp_r_buf32[5] = 0;
15820 device_param->kernel_params_mp_r_buf32[6] = 0;
15821 device_param->kernel_params_mp_r_buf32[7] = 0;
15822 device_param->kernel_params_mp_r_buf32[8] = 0;
15823
15824 device_param->kernel_params_mp_r[0] = NULL;
15825 device_param->kernel_params_mp_r[1] = NULL;
15826 device_param->kernel_params_mp_r[2] = NULL;
15827 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15828 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15829 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15830 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15831 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15832 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15833
15834 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15835 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15836
15837 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15838 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15839 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15840 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15841 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15842 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15843 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15844
15845 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15846 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15847
15848 device_param->kernel_params_memset_buf32[1] = 0; // value
15849 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15850
15851 device_param->kernel_params_memset[0] = NULL;
15852 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15853 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15854
15855 /**
15856 * kernel name
15857 */
15858
15859 size_t kernel_wgs_tmp;
15860
15861 char kernel_name[64] = { 0 };
15862
15863 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15864 {
15865 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15866 {
15867 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15868
15869 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15870
15871 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15872
15873 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15874
15875 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15876
15877 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15878 }
15879 else
15880 {
15881 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15882
15883 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15884
15885 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15886
15887 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15888
15889 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15890
15891 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15892 }
15893
15894 if (data.attack_mode == ATTACK_MODE_BF)
15895 {
15896 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15897 {
15898 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15899
15900 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15901
15902 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);
15903 }
15904 }
15905 }
15906 else
15907 {
15908 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15909
15910 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15911
15912 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15913
15914 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15915
15916 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15917
15918 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15919
15920 if (opts_type & OPTS_TYPE_HOOK12)
15921 {
15922 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15923
15924 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15925
15926 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);
15927 }
15928
15929 if (opts_type & OPTS_TYPE_HOOK23)
15930 {
15931 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15932
15933 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15934
15935 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);
15936 }
15937 }
15938
15939 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);
15940 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);
15941 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);
15942
15943 for (uint i = 0; i <= 20; i++)
15944 {
15945 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15946 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15947 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15948
15949 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15950 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15951 }
15952
15953 for (uint i = 21; i <= 31; i++)
15954 {
15955 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15956 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15957 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15958
15959 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15960 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15961 }
15962
15963 // GPU memset
15964
15965 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15966
15967 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);
15968
15969 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15970 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15971 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15972
15973 // MP start
15974
15975 if (attack_mode == ATTACK_MODE_BF)
15976 {
15977 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15978 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15979
15980 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);
15981 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);
15982
15983 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15984 {
15985 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15986 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15987 }
15988 }
15989 else if (attack_mode == ATTACK_MODE_HYBRID1)
15990 {
15991 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15992
15993 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);
15994 }
15995 else if (attack_mode == ATTACK_MODE_HYBRID2)
15996 {
15997 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15998
15999 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);
16000 }
16001
16002 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16003 {
16004 // nothing to do
16005 }
16006 else
16007 {
16008 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16009
16010 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);
16011 }
16012
16013 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16014 {
16015 // nothing to do
16016 }
16017 else
16018 {
16019 for (uint i = 0; i < 5; i++)
16020 {
16021 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16022 }
16023
16024 for (uint i = 5; i < 7; i++)
16025 {
16026 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16027 }
16028 }
16029
16030 // maybe this has been updated by clGetKernelWorkGroupInfo()
16031 // value can only be decreased, so we don't need to reallocate buffers
16032
16033 device_param->kernel_threads = kernel_threads;
16034
16035 // zero some data buffers
16036
16037 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16038 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16039 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16040 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16041 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16042 run_kernel_bzero (device_param, device_param->d_result, size_results);
16043
16044 /**
16045 * special buffers
16046 */
16047
16048 if (attack_kern == ATTACK_KERN_STRAIGHT)
16049 {
16050 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16051 }
16052 else if (attack_kern == ATTACK_KERN_COMBI)
16053 {
16054 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16055 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16056 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16057 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16058 }
16059 else if (attack_kern == ATTACK_KERN_BF)
16060 {
16061 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16062 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16063 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16064 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16065 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16066 }
16067
16068 #if defined(HAVE_HWMON)
16069
16070 /**
16071 * Store initial fanspeed if gpu_temp_retain is enabled
16072 */
16073
16074 if (gpu_temp_disable == 0)
16075 {
16076 if (gpu_temp_retain != 0)
16077 {
16078 hc_thread_mutex_lock (mux_adl);
16079
16080 if (data.hm_device[device_id].fan_get_supported == 1)
16081 {
16082 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16083 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16084
16085 temp_retain_fanspeed_value[device_id] = fanspeed;
16086 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16087
16088 // we also set it to tell the OS we take control over the fan and it's automatic controller
16089 // if it was set to automatic. we do not control user-defined fanspeeds.
16090
16091 if (fanpolicy == 1)
16092 {
16093 data.hm_device[device_id].fan_set_supported = 1;
16094
16095 int rc = -1;
16096
16097 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16098 {
16099 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16100 }
16101 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16102 {
16103
16104 }
16105
16106 if (rc == 0)
16107 {
16108 data.hm_device[device_id].fan_set_supported = 1;
16109 }
16110 else
16111 {
16112 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16113
16114 data.hm_device[device_id].fan_set_supported = 0;
16115 }
16116 }
16117 else
16118 {
16119 data.hm_device[device_id].fan_set_supported = 0;
16120 }
16121 }
16122
16123 hc_thread_mutex_unlock (mux_adl);
16124 }
16125 }
16126
16127 #endif // HAVE_HWMON
16128 }
16129
16130 if (data.quiet == 0) log_info_nn ("");
16131
16132 /**
16133 * In benchmark-mode, inform user which algorithm is checked
16134 */
16135
16136 if (benchmark == 1)
16137 {
16138 if (machine_readable == 0)
16139 {
16140 quiet = 0;
16141
16142 data.quiet = quiet;
16143
16144 char *hash_type = strhashtype (data.hash_mode); // not a bug
16145
16146 log_info ("Hashtype: %s", hash_type);
16147 log_info ("");
16148 }
16149 }
16150
16151 /**
16152 * keep track of the progress
16153 */
16154
16155 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16156 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16157 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16158
16159 /**
16160 * open filehandles
16161 */
16162
16163 #if _WIN
16164 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16165 {
16166 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16167
16168 return (-1);
16169 }
16170
16171 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16172 {
16173 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16174
16175 return (-1);
16176 }
16177
16178 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16179 {
16180 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16181
16182 return (-1);
16183 }
16184 #endif
16185
16186 /**
16187 * dictionary pad
16188 */
16189
16190 segment_size *= (1024 * 1024);
16191
16192 data.segment_size = segment_size;
16193
16194 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16195
16196 wl_data->buf = (char *) mymalloc (segment_size);
16197 wl_data->avail = segment_size;
16198 wl_data->incr = segment_size;
16199 wl_data->cnt = 0;
16200 wl_data->pos = 0;
16201
16202 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16203
16204 data.wordlist_mode = wordlist_mode;
16205
16206 cs_t *css_buf = NULL;
16207 uint css_cnt = 0;
16208 uint dictcnt = 0;
16209 uint maskcnt = 1;
16210 char **masks = NULL;
16211 char **dictfiles = NULL;
16212
16213 uint mask_from_file = 0;
16214
16215 if (attack_mode == ATTACK_MODE_STRAIGHT)
16216 {
16217 if (wordlist_mode == WL_MODE_FILE)
16218 {
16219 int wls_left = myargc - (optind + 1);
16220
16221 for (int i = 0; i < wls_left; i++)
16222 {
16223 char *l0_filename = myargv[optind + 1 + i];
16224
16225 struct stat l0_stat;
16226
16227 if (stat (l0_filename, &l0_stat) == -1)
16228 {
16229 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16230
16231 return (-1);
16232 }
16233
16234 uint is_dir = S_ISDIR (l0_stat.st_mode);
16235
16236 if (is_dir == 0)
16237 {
16238 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16239
16240 dictcnt++;
16241
16242 dictfiles[dictcnt - 1] = l0_filename;
16243 }
16244 else
16245 {
16246 // do not allow --keyspace w/ a directory
16247
16248 if (keyspace == 1)
16249 {
16250 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16251
16252 return (-1);
16253 }
16254
16255 char **dictionary_files = NULL;
16256
16257 dictionary_files = scan_directory (l0_filename);
16258
16259 if (dictionary_files != NULL)
16260 {
16261 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16262
16263 for (int d = 0; dictionary_files[d] != NULL; d++)
16264 {
16265 char *l1_filename = dictionary_files[d];
16266
16267 struct stat l1_stat;
16268
16269 if (stat (l1_filename, &l1_stat) == -1)
16270 {
16271 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16272
16273 return (-1);
16274 }
16275
16276 if (S_ISREG (l1_stat.st_mode))
16277 {
16278 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16279
16280 dictcnt++;
16281
16282 dictfiles[dictcnt - 1] = strdup (l1_filename);
16283 }
16284 }
16285 }
16286
16287 local_free (dictionary_files);
16288 }
16289 }
16290
16291 if (dictcnt < 1)
16292 {
16293 log_error ("ERROR: No usable dictionary file found.");
16294
16295 return (-1);
16296 }
16297 }
16298 else if (wordlist_mode == WL_MODE_STDIN)
16299 {
16300 dictcnt = 1;
16301 }
16302 }
16303 else if (attack_mode == ATTACK_MODE_COMBI)
16304 {
16305 // display
16306
16307 char *dictfile1 = myargv[optind + 1 + 0];
16308 char *dictfile2 = myargv[optind + 1 + 1];
16309
16310 // find the bigger dictionary and use as base
16311
16312 FILE *fp1 = NULL;
16313 FILE *fp2 = NULL;
16314
16315 struct stat tmp_stat;
16316
16317 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16318 {
16319 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16320
16321 return (-1);
16322 }
16323
16324 if (stat (dictfile1, &tmp_stat) == -1)
16325 {
16326 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16327
16328 fclose (fp1);
16329
16330 return (-1);
16331 }
16332
16333 if (S_ISDIR (tmp_stat.st_mode))
16334 {
16335 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16336
16337 fclose (fp1);
16338
16339 return (-1);
16340 }
16341
16342 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16343 {
16344 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16345
16346 fclose (fp1);
16347
16348 return (-1);
16349 }
16350
16351 if (stat (dictfile2, &tmp_stat) == -1)
16352 {
16353 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16354
16355 fclose (fp1);
16356 fclose (fp2);
16357
16358 return (-1);
16359 }
16360
16361 if (S_ISDIR (tmp_stat.st_mode))
16362 {
16363 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16364
16365 fclose (fp1);
16366 fclose (fp2);
16367
16368 return (-1);
16369 }
16370
16371 data.combs_cnt = 1;
16372
16373 data.quiet = 1;
16374
16375 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16376
16377 data.quiet = quiet;
16378
16379 if (words1_cnt == 0)
16380 {
16381 log_error ("ERROR: %s: empty file", dictfile1);
16382
16383 fclose (fp1);
16384 fclose (fp2);
16385
16386 return (-1);
16387 }
16388
16389 data.combs_cnt = 1;
16390
16391 data.quiet = 1;
16392
16393 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16394
16395 data.quiet = quiet;
16396
16397 if (words2_cnt == 0)
16398 {
16399 log_error ("ERROR: %s: empty file", dictfile2);
16400
16401 fclose (fp1);
16402 fclose (fp2);
16403
16404 return (-1);
16405 }
16406
16407 fclose (fp1);
16408 fclose (fp2);
16409
16410 data.dictfile = dictfile1;
16411 data.dictfile2 = dictfile2;
16412
16413 if (words1_cnt >= words2_cnt)
16414 {
16415 data.combs_cnt = words2_cnt;
16416 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16417
16418 dictfiles = &data.dictfile;
16419
16420 dictcnt = 1;
16421 }
16422 else
16423 {
16424 data.combs_cnt = words1_cnt;
16425 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16426
16427 dictfiles = &data.dictfile2;
16428
16429 dictcnt = 1;
16430
16431 // we also have to switch wordlist related rules!
16432
16433 char *tmpc = data.rule_buf_l;
16434
16435 data.rule_buf_l = data.rule_buf_r;
16436 data.rule_buf_r = tmpc;
16437
16438 int tmpi = data.rule_len_l;
16439
16440 data.rule_len_l = data.rule_len_r;
16441 data.rule_len_r = tmpi;
16442 }
16443 }
16444 else if (attack_mode == ATTACK_MODE_BF)
16445 {
16446 char *mask = NULL;
16447
16448 maskcnt = 0;
16449
16450 if (benchmark == 0)
16451 {
16452 mask = myargv[optind + 1];
16453
16454 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16455
16456 if ((optind + 2) <= myargc)
16457 {
16458 struct stat file_stat;
16459
16460 if (stat (mask, &file_stat) == -1)
16461 {
16462 maskcnt = 1;
16463
16464 masks[maskcnt - 1] = mystrdup (mask);
16465 }
16466 else
16467 {
16468 int wls_left = myargc - (optind + 1);
16469
16470 uint masks_avail = INCR_MASKS;
16471
16472 for (int i = 0; i < wls_left; i++)
16473 {
16474 if (i != 0)
16475 {
16476 mask = myargv[optind + 1 + i];
16477
16478 if (stat (mask, &file_stat) == -1)
16479 {
16480 log_error ("ERROR: %s: %s", mask, strerror (errno));
16481
16482 return (-1);
16483 }
16484 }
16485
16486 uint is_file = S_ISREG (file_stat.st_mode);
16487
16488 if (is_file == 1)
16489 {
16490 FILE *mask_fp;
16491
16492 if ((mask_fp = fopen (mask, "r")) == NULL)
16493 {
16494 log_error ("ERROR: %s: %s", mask, strerror (errno));
16495
16496 return (-1);
16497 }
16498
16499 char *line_buf = (char *) mymalloc (HCBUFSIZ);
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 else
16528 {
16529 log_error ("ERROR: %s: unsupported file-type", mask);
16530
16531 return (-1);
16532 }
16533 }
16534
16535 mask_from_file = 1;
16536 }
16537 }
16538 else
16539 {
16540 custom_charset_1 = (char *) "?l?d?u";
16541 custom_charset_2 = (char *) "?l?d";
16542 custom_charset_3 = (char *) "?l?d*!$@_";
16543
16544 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16545 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16546 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16547
16548 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16549
16550 wordlist_mode = WL_MODE_MASK;
16551
16552 data.wordlist_mode = wordlist_mode;
16553
16554 increment = 1;
16555
16556 maskcnt = 1;
16557 }
16558 }
16559 else
16560 {
16561 /**
16562 * generate full masks and charsets
16563 */
16564
16565 masks = (char **) mymalloc (sizeof (char *));
16566
16567 switch (hash_mode)
16568 {
16569 case 1731: pw_min = 5;
16570 pw_max = 5;
16571 mask = mystrdup ("?b?b?b?b?b");
16572 break;
16573 case 12500: pw_min = 5;
16574 pw_max = 5;
16575 mask = mystrdup ("?b?b?b?b?b");
16576 break;
16577 default: pw_min = 7;
16578 pw_max = 7;
16579 mask = mystrdup ("?b?b?b?b?b?b?b");
16580 break;
16581 }
16582
16583 maskcnt = 1;
16584
16585 masks[maskcnt - 1] = mystrdup (mask);
16586
16587 wordlist_mode = WL_MODE_MASK;
16588
16589 data.wordlist_mode = wordlist_mode;
16590
16591 increment = 1;
16592 }
16593
16594 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16595
16596 if (increment)
16597 {
16598 if (increment_min > pw_min) pw_min = increment_min;
16599
16600 if (increment_max < pw_max) pw_max = increment_max;
16601 }
16602 }
16603 else if (attack_mode == ATTACK_MODE_HYBRID1)
16604 {
16605 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16606
16607 // display
16608
16609 char *mask = myargv[myargc - 1];
16610
16611 maskcnt = 0;
16612
16613 masks = (char **) mymalloc (1 * sizeof (char *));
16614
16615 // mod
16616
16617 struct stat file_stat;
16618
16619 if (stat (mask, &file_stat) == -1)
16620 {
16621 maskcnt = 1;
16622
16623 masks[maskcnt - 1] = mystrdup (mask);
16624 }
16625 else
16626 {
16627 uint is_file = S_ISREG (file_stat.st_mode);
16628
16629 if (is_file == 1)
16630 {
16631 FILE *mask_fp;
16632
16633 if ((mask_fp = fopen (mask, "r")) == NULL)
16634 {
16635 log_error ("ERROR: %s: %s", mask, strerror (errno));
16636
16637 return (-1);
16638 }
16639
16640 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16641
16642 uint masks_avail = 1;
16643
16644 while (!feof (mask_fp))
16645 {
16646 memset (line_buf, 0, HCBUFSIZ);
16647
16648 int line_len = fgetl (mask_fp, line_buf);
16649
16650 if (line_len == 0) continue;
16651
16652 if (line_buf[0] == '#') continue;
16653
16654 if (masks_avail == maskcnt)
16655 {
16656 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16657
16658 masks_avail += INCR_MASKS;
16659 }
16660
16661 masks[maskcnt] = mystrdup (line_buf);
16662
16663 maskcnt++;
16664 }
16665
16666 myfree (line_buf);
16667
16668 fclose (mask_fp);
16669
16670 mask_from_file = 1;
16671 }
16672 else
16673 {
16674 maskcnt = 1;
16675
16676 masks[maskcnt - 1] = mystrdup (mask);
16677 }
16678 }
16679
16680 // base
16681
16682 int wls_left = myargc - (optind + 2);
16683
16684 for (int i = 0; i < wls_left; i++)
16685 {
16686 char *filename = myargv[optind + 1 + i];
16687
16688 struct stat file_stat;
16689
16690 if (stat (filename, &file_stat) == -1)
16691 {
16692 log_error ("ERROR: %s: %s", filename, strerror (errno));
16693
16694 return (-1);
16695 }
16696
16697 uint is_dir = S_ISDIR (file_stat.st_mode);
16698
16699 if (is_dir == 0)
16700 {
16701 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16702
16703 dictcnt++;
16704
16705 dictfiles[dictcnt - 1] = filename;
16706 }
16707 else
16708 {
16709 // do not allow --keyspace w/ a directory
16710
16711 if (keyspace == 1)
16712 {
16713 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16714
16715 return (-1);
16716 }
16717
16718 char **dictionary_files = NULL;
16719
16720 dictionary_files = scan_directory (filename);
16721
16722 if (dictionary_files != NULL)
16723 {
16724 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16725
16726 for (int d = 0; dictionary_files[d] != NULL; d++)
16727 {
16728 char *l1_filename = dictionary_files[d];
16729
16730 struct stat l1_stat;
16731
16732 if (stat (l1_filename, &l1_stat) == -1)
16733 {
16734 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16735
16736 return (-1);
16737 }
16738
16739 if (S_ISREG (l1_stat.st_mode))
16740 {
16741 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16742
16743 dictcnt++;
16744
16745 dictfiles[dictcnt - 1] = strdup (l1_filename);
16746 }
16747 }
16748 }
16749
16750 local_free (dictionary_files);
16751 }
16752 }
16753
16754 if (dictcnt < 1)
16755 {
16756 log_error ("ERROR: No usable dictionary file found.");
16757
16758 return (-1);
16759 }
16760
16761 if (increment)
16762 {
16763 maskcnt = 0;
16764
16765 uint mask_min = increment_min; // we can't reject smaller masks here
16766 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16767
16768 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16769 {
16770 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16771
16772 if (cur_mask == NULL) break;
16773
16774 masks[maskcnt] = cur_mask;
16775
16776 maskcnt++;
16777
16778 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16779 }
16780 }
16781 }
16782 else if (attack_mode == ATTACK_MODE_HYBRID2)
16783 {
16784 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16785
16786 // display
16787
16788 char *mask = myargv[optind + 1 + 0];
16789
16790 maskcnt = 0;
16791
16792 masks = (char **) mymalloc (1 * sizeof (char *));
16793
16794 // mod
16795
16796 struct stat file_stat;
16797
16798 if (stat (mask, &file_stat) == -1)
16799 {
16800 maskcnt = 1;
16801
16802 masks[maskcnt - 1] = mystrdup (mask);
16803 }
16804 else
16805 {
16806 uint is_file = S_ISREG (file_stat.st_mode);
16807
16808 if (is_file == 1)
16809 {
16810 FILE *mask_fp;
16811
16812 if ((mask_fp = fopen (mask, "r")) == NULL)
16813 {
16814 log_error ("ERROR: %s: %s", mask, strerror (errno));
16815
16816 return (-1);
16817 }
16818
16819 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16820
16821 uint masks_avail = 1;
16822
16823 while (!feof (mask_fp))
16824 {
16825 memset (line_buf, 0, HCBUFSIZ);
16826
16827 int line_len = fgetl (mask_fp, line_buf);
16828
16829 if (line_len == 0) continue;
16830
16831 if (line_buf[0] == '#') continue;
16832
16833 if (masks_avail == maskcnt)
16834 {
16835 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16836
16837 masks_avail += INCR_MASKS;
16838 }
16839
16840 masks[maskcnt] = mystrdup (line_buf);
16841
16842 maskcnt++;
16843 }
16844
16845 myfree (line_buf);
16846
16847 fclose (mask_fp);
16848
16849 mask_from_file = 1;
16850 }
16851 else
16852 {
16853 maskcnt = 1;
16854
16855 masks[maskcnt - 1] = mystrdup (mask);
16856 }
16857 }
16858
16859 // base
16860
16861 int wls_left = myargc - (optind + 2);
16862
16863 for (int i = 0; i < wls_left; i++)
16864 {
16865 char *filename = myargv[optind + 2 + i];
16866
16867 struct stat file_stat;
16868
16869 if (stat (filename, &file_stat) == -1)
16870 {
16871 log_error ("ERROR: %s: %s", filename, strerror (errno));
16872
16873 return (-1);
16874 }
16875
16876 uint is_dir = S_ISDIR (file_stat.st_mode);
16877
16878 if (is_dir == 0)
16879 {
16880 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16881
16882 dictcnt++;
16883
16884 dictfiles[dictcnt - 1] = filename;
16885 }
16886 else
16887 {
16888 // do not allow --keyspace w/ a directory
16889
16890 if (keyspace == 1)
16891 {
16892 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16893
16894 return (-1);
16895 }
16896
16897 char **dictionary_files = NULL;
16898
16899 dictionary_files = scan_directory (filename);
16900
16901 if (dictionary_files != NULL)
16902 {
16903 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16904
16905 for (int d = 0; dictionary_files[d] != NULL; d++)
16906 {
16907 char *l1_filename = dictionary_files[d];
16908
16909 struct stat l1_stat;
16910
16911 if (stat (l1_filename, &l1_stat) == -1)
16912 {
16913 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16914
16915 return (-1);
16916 }
16917
16918 if (S_ISREG (l1_stat.st_mode))
16919 {
16920 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16921
16922 dictcnt++;
16923
16924 dictfiles[dictcnt - 1] = strdup (l1_filename);
16925 }
16926 }
16927 }
16928
16929 local_free (dictionary_files);
16930 }
16931 }
16932
16933 if (dictcnt < 1)
16934 {
16935 log_error ("ERROR: No usable dictionary file found.");
16936
16937 return (-1);
16938 }
16939
16940 if (increment)
16941 {
16942 maskcnt = 0;
16943
16944 uint mask_min = increment_min; // we can't reject smaller masks here
16945 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16946
16947 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16948 {
16949 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16950
16951 if (cur_mask == NULL) break;
16952
16953 masks[maskcnt] = cur_mask;
16954
16955 maskcnt++;
16956
16957 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16958 }
16959 }
16960 }
16961
16962 data.pw_min = pw_min;
16963 data.pw_max = pw_max;
16964
16965 /**
16966 * weak hash check
16967 */
16968
16969 if (weak_hash_threshold >= salts_cnt)
16970 {
16971 hc_device_param_t *device_param = NULL;
16972
16973 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16974 {
16975 device_param = &data.devices_param[device_id];
16976
16977 if (device_param->skipped) continue;
16978
16979 break;
16980 }
16981
16982 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16983
16984 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16985 {
16986 weak_hash_check (device_param, salt_pos);
16987 }
16988
16989 // Display hack, guarantee that there is at least one \r before real start
16990
16991 //if (data.quiet == 0) log_info ("");
16992 }
16993
16994 /**
16995 * status and monitor threads
16996 */
16997
16998 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16999
17000 uint i_threads_cnt = 0;
17001
17002 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17003
17004 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17005 {
17006 if (stdout_flag == 0)
17007 {
17008 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17009
17010 i_threads_cnt++;
17011 }
17012 }
17013
17014 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17015
17016 uint ni_threads_cnt = 0;
17017
17018 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17019
17020 if (stdout_flag == 0)
17021 {
17022 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17023
17024 ni_threads_cnt++;
17025 }
17026
17027 /**
17028 * Outfile remove
17029 */
17030
17031 if (keyspace == 0)
17032 {
17033 if (outfile_check_timer != 0)
17034 {
17035 if (data.outfile_check_directory != NULL)
17036 {
17037 if ((hash_mode != 5200) &&
17038 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17039 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17040 (hash_mode != 9000))
17041 {
17042 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17043
17044 ni_threads_cnt++;
17045 }
17046 else
17047 {
17048 outfile_check_timer = 0;
17049 }
17050 }
17051 else
17052 {
17053 outfile_check_timer = 0;
17054 }
17055 }
17056 }
17057
17058 /**
17059 * Inform the user if we got some hashes remove because of the pot file remove feature
17060 */
17061
17062 if (data.quiet == 0)
17063 {
17064 if (potfile_remove_cracks > 0)
17065 {
17066 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17067 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17068 }
17069 }
17070
17071 data.outfile_check_timer = outfile_check_timer;
17072
17073 /**
17074 * main loop
17075 */
17076
17077 char **induction_dictionaries = NULL;
17078
17079 int induction_dictionaries_cnt = 0;
17080
17081 hcstat_table_t *root_table_buf = NULL;
17082 hcstat_table_t *markov_table_buf = NULL;
17083
17084 uint initial_restore_done = 0;
17085
17086 data.maskcnt = maskcnt;
17087
17088 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17089 {
17090 if (data.devices_status == STATUS_CRACKED) break;
17091
17092 data.devices_status = STATUS_INIT;
17093
17094 if (maskpos > rd->maskpos)
17095 {
17096 rd->dictpos = 0;
17097 }
17098
17099 rd->maskpos = maskpos;
17100 data.maskpos = maskpos;
17101
17102 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17103 {
17104 char *mask = masks[maskpos];
17105
17106 if (mask_from_file == 1)
17107 {
17108 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17109
17110 char *str_ptr;
17111 uint str_pos;
17112
17113 uint mask_offset = 0;
17114
17115 uint separator_cnt;
17116
17117 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17118 {
17119 str_ptr = strstr (mask + mask_offset, ",");
17120
17121 if (str_ptr == NULL) break;
17122
17123 str_pos = str_ptr - mask;
17124
17125 // escaped separator, i.e. "\,"
17126
17127 if (str_pos > 0)
17128 {
17129 if (mask[str_pos - 1] == '\\')
17130 {
17131 separator_cnt --;
17132
17133 mask_offset = str_pos + 1;
17134
17135 continue;
17136 }
17137 }
17138
17139 // reset the offset
17140
17141 mask_offset = 0;
17142
17143 mask[str_pos] = '\0';
17144
17145 switch (separator_cnt)
17146 {
17147 case 0:
17148 mp_reset_usr (mp_usr, 0);
17149
17150 custom_charset_1 = mask;
17151 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17152 break;
17153
17154 case 1:
17155 mp_reset_usr (mp_usr, 1);
17156
17157 custom_charset_2 = mask;
17158 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17159 break;
17160
17161 case 2:
17162 mp_reset_usr (mp_usr, 2);
17163
17164 custom_charset_3 = mask;
17165 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17166 break;
17167
17168 case 3:
17169 mp_reset_usr (mp_usr, 3);
17170
17171 custom_charset_4 = mask;
17172 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17173 break;
17174 }
17175
17176 mask = mask + str_pos + 1;
17177 }
17178 }
17179
17180 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17181 {
17182 if (maskpos > 0)
17183 {
17184 local_free (css_buf);
17185 local_free (data.root_css_buf);
17186 local_free (data.markov_css_buf);
17187
17188 local_free (masks[maskpos - 1]);
17189 }
17190
17191 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17192
17193 data.mask = mask;
17194 data.css_cnt = css_cnt;
17195 data.css_buf = css_buf;
17196
17197 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17198
17199 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17200
17201 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17202 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17203
17204 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17205
17206 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17207
17208 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17209 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17210
17211 data.root_css_buf = root_css_buf;
17212 data.markov_css_buf = markov_css_buf;
17213
17214 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17215
17216 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17217
17218 local_free (root_table_buf);
17219 local_free (markov_table_buf);
17220
17221 // args
17222
17223 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17224 {
17225 hc_device_param_t *device_param = &data.devices_param[device_id];
17226
17227 if (device_param->skipped) continue;
17228
17229 device_param->kernel_params_mp[0] = &device_param->d_combs;
17230 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17231 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17232
17233 device_param->kernel_params_mp_buf64[3] = 0;
17234 device_param->kernel_params_mp_buf32[4] = css_cnt;
17235 device_param->kernel_params_mp_buf32[5] = 0;
17236 device_param->kernel_params_mp_buf32[6] = 0;
17237 device_param->kernel_params_mp_buf32[7] = 0;
17238
17239 if (attack_mode == ATTACK_MODE_HYBRID1)
17240 {
17241 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17242 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17243 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17244 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17245 }
17246 else if (attack_mode == ATTACK_MODE_HYBRID2)
17247 {
17248 device_param->kernel_params_mp_buf32[5] = 0;
17249 device_param->kernel_params_mp_buf32[6] = 0;
17250 device_param->kernel_params_mp_buf32[7] = 0;
17251 }
17252
17253 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]);
17254 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]);
17255 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]);
17256
17257 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);
17258 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);
17259 }
17260 }
17261 else if (attack_mode == ATTACK_MODE_BF)
17262 {
17263 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17264
17265 if (increment)
17266 {
17267 for (uint i = 0; i < dictcnt; i++)
17268 {
17269 local_free (dictfiles[i]);
17270 }
17271
17272 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17273 {
17274 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17275
17276 if (l1_filename == NULL) break;
17277
17278 dictcnt++;
17279
17280 dictfiles[dictcnt - 1] = l1_filename;
17281 }
17282 }
17283 else
17284 {
17285 dictcnt++;
17286
17287 dictfiles[dictcnt - 1] = mask;
17288 }
17289
17290 if (dictcnt == 0)
17291 {
17292 log_error ("ERROR: Mask is too small");
17293
17294 return (-1);
17295 }
17296 }
17297 }
17298
17299 free (induction_dictionaries);
17300
17301 // induction_dictionaries_cnt = 0; // implied
17302
17303 if (attack_mode != ATTACK_MODE_BF)
17304 {
17305 if (keyspace == 0)
17306 {
17307 induction_dictionaries = scan_directory (induction_directory);
17308
17309 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17310 }
17311 }
17312
17313 if (induction_dictionaries_cnt)
17314 {
17315 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17316 }
17317
17318 /**
17319 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17320 */
17321 if (keyspace == 1)
17322 {
17323 if ((maskcnt > 1) || (dictcnt > 1))
17324 {
17325 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17326
17327 return (-1);
17328 }
17329 }
17330
17331 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17332 {
17333 char *subid = logfile_generate_subid ();
17334
17335 data.subid = subid;
17336
17337 logfile_sub_msg ("START");
17338
17339 data.devices_status = STATUS_INIT;
17340
17341 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17342 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17343 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17344
17345 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17346
17347 data.cpt_pos = 0;
17348
17349 data.cpt_start = time (NULL);
17350
17351 data.cpt_total = 0;
17352
17353 if (data.restore == 0)
17354 {
17355 rd->words_cur = skip;
17356
17357 skip = 0;
17358
17359 data.skip = 0;
17360 }
17361
17362 data.ms_paused = 0;
17363
17364 data.kernel_power_final = 0;
17365
17366 data.words_cur = rd->words_cur;
17367
17368 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17369 {
17370 hc_device_param_t *device_param = &data.devices_param[device_id];
17371
17372 if (device_param->skipped) continue;
17373
17374 device_param->speed_pos = 0;
17375
17376 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17377 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17378
17379 device_param->exec_pos = 0;
17380
17381 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17382
17383 device_param->outerloop_pos = 0;
17384 device_param->outerloop_left = 0;
17385 device_param->innerloop_pos = 0;
17386 device_param->innerloop_left = 0;
17387
17388 // some more resets:
17389
17390 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17391
17392 device_param->pws_cnt = 0;
17393
17394 device_param->words_off = 0;
17395 device_param->words_done = 0;
17396 }
17397
17398 // figure out some workload
17399
17400 if (attack_mode == ATTACK_MODE_STRAIGHT)
17401 {
17402 if (data.wordlist_mode == WL_MODE_FILE)
17403 {
17404 char *dictfile = NULL;
17405
17406 if (induction_dictionaries_cnt)
17407 {
17408 dictfile = induction_dictionaries[0];
17409 }
17410 else
17411 {
17412 dictfile = dictfiles[dictpos];
17413 }
17414
17415 data.dictfile = dictfile;
17416
17417 logfile_sub_string (dictfile);
17418
17419 for (uint i = 0; i < rp_files_cnt; i++)
17420 {
17421 logfile_sub_var_string ("rulefile", rp_files[i]);
17422 }
17423
17424 FILE *fd2 = fopen (dictfile, "rb");
17425
17426 if (fd2 == NULL)
17427 {
17428 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17429
17430 return (-1);
17431 }
17432
17433 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17434
17435 fclose (fd2);
17436
17437 if (data.words_cnt == 0)
17438 {
17439 if (data.devices_status == STATUS_CRACKED) break;
17440 if (data.devices_status == STATUS_ABORTED) break;
17441
17442 dictpos++;
17443
17444 continue;
17445 }
17446 }
17447 }
17448 else if (attack_mode == ATTACK_MODE_COMBI)
17449 {
17450 char *dictfile = data.dictfile;
17451 char *dictfile2 = data.dictfile2;
17452
17453 logfile_sub_string (dictfile);
17454 logfile_sub_string (dictfile2);
17455
17456 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17457 {
17458 FILE *fd2 = fopen (dictfile, "rb");
17459
17460 if (fd2 == NULL)
17461 {
17462 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17463
17464 return (-1);
17465 }
17466
17467 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17468
17469 fclose (fd2);
17470 }
17471 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17472 {
17473 FILE *fd2 = fopen (dictfile2, "rb");
17474
17475 if (fd2 == NULL)
17476 {
17477 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17478
17479 return (-1);
17480 }
17481
17482 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17483
17484 fclose (fd2);
17485 }
17486
17487 if (data.words_cnt == 0)
17488 {
17489 if (data.devices_status == STATUS_CRACKED) break;
17490 if (data.devices_status == STATUS_ABORTED) break;
17491
17492 dictpos++;
17493
17494 continue;
17495 }
17496 }
17497 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17498 {
17499 char *dictfile = NULL;
17500
17501 if (induction_dictionaries_cnt)
17502 {
17503 dictfile = induction_dictionaries[0];
17504 }
17505 else
17506 {
17507 dictfile = dictfiles[dictpos];
17508 }
17509
17510 data.dictfile = dictfile;
17511
17512 char *mask = data.mask;
17513
17514 logfile_sub_string (dictfile);
17515 logfile_sub_string (mask);
17516
17517 FILE *fd2 = fopen (dictfile, "rb");
17518
17519 if (fd2 == NULL)
17520 {
17521 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17522
17523 return (-1);
17524 }
17525
17526 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17527
17528 fclose (fd2);
17529
17530 if (data.words_cnt == 0)
17531 {
17532 if (data.devices_status == STATUS_CRACKED) break;
17533 if (data.devices_status == STATUS_ABORTED) break;
17534
17535 dictpos++;
17536
17537 continue;
17538 }
17539 }
17540 else if (attack_mode == ATTACK_MODE_BF)
17541 {
17542 local_free (css_buf);
17543 local_free (data.root_css_buf);
17544 local_free (data.markov_css_buf);
17545
17546 char *mask = dictfiles[dictpos];
17547
17548 logfile_sub_string (mask);
17549
17550 // base
17551
17552 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17553
17554 if (opts_type & OPTS_TYPE_PT_UNICODE)
17555 {
17556 uint css_cnt_unicode = css_cnt * 2;
17557
17558 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17559
17560 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17561 {
17562 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17563
17564 css_buf_unicode[j + 1].cs_buf[0] = 0;
17565 css_buf_unicode[j + 1].cs_len = 1;
17566 }
17567
17568 free (css_buf);
17569
17570 css_buf = css_buf_unicode;
17571 css_cnt = css_cnt_unicode;
17572 }
17573
17574 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17575
17576 uint mask_min = pw_min;
17577 uint mask_max = pw_max;
17578
17579 if (opts_type & OPTS_TYPE_PT_UNICODE)
17580 {
17581 mask_min *= 2;
17582 mask_max *= 2;
17583 }
17584
17585 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17586 {
17587 if (css_cnt < mask_min)
17588 {
17589 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17590 }
17591
17592 if (css_cnt > mask_max)
17593 {
17594 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17595 }
17596
17597 // skip to next mask
17598
17599 dictpos++;
17600
17601 rd->dictpos = dictpos;
17602
17603 logfile_sub_msg ("STOP");
17604
17605 continue;
17606 }
17607
17608 uint save_css_cnt = css_cnt;
17609
17610 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17611 {
17612 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17613 {
17614 uint salt_len = (uint) data.salts_buf[0].salt_len;
17615 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17616
17617 uint css_cnt_salt = css_cnt + salt_len;
17618
17619 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17620
17621 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17622
17623 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17624 {
17625 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17626 css_buf_salt[j].cs_len = 1;
17627 }
17628
17629 free (css_buf);
17630
17631 css_buf = css_buf_salt;
17632 css_cnt = css_cnt_salt;
17633 }
17634 }
17635
17636 data.mask = mask;
17637 data.css_cnt = css_cnt;
17638 data.css_buf = css_buf;
17639
17640 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17641
17642 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17643
17644 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17645
17646 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17647 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17648
17649 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17650
17651 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17652
17653 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17654 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17655
17656 data.root_css_buf = root_css_buf;
17657 data.markov_css_buf = markov_css_buf;
17658
17659 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17660
17661 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17662
17663 local_free (root_table_buf);
17664 local_free (markov_table_buf);
17665
17666 // copy + args
17667
17668 uint css_cnt_l = css_cnt;
17669 uint css_cnt_r;
17670
17671 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17672 {
17673 if (save_css_cnt < 6)
17674 {
17675 css_cnt_r = 1;
17676 }
17677 else if (save_css_cnt == 6)
17678 {
17679 css_cnt_r = 2;
17680 }
17681 else
17682 {
17683 if (opts_type & OPTS_TYPE_PT_UNICODE)
17684 {
17685 if (save_css_cnt == 8 || save_css_cnt == 10)
17686 {
17687 css_cnt_r = 2;
17688 }
17689 else
17690 {
17691 css_cnt_r = 4;
17692 }
17693 }
17694 else
17695 {
17696 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17697 {
17698 css_cnt_r = 3;
17699 }
17700 else
17701 {
17702 css_cnt_r = 4;
17703 }
17704 }
17705 }
17706 }
17707 else
17708 {
17709 css_cnt_r = 1;
17710
17711 /* unfinished code?
17712 int sum = css_buf[css_cnt_r - 1].cs_len;
17713
17714 for (uint i = 1; i < 4 && i < css_cnt; i++)
17715 {
17716 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17717
17718 css_cnt_r++;
17719
17720 sum *= css_buf[css_cnt_r - 1].cs_len;
17721 }
17722 */
17723 }
17724
17725 css_cnt_l -= css_cnt_r;
17726
17727 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17728
17729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17730 {
17731 hc_device_param_t *device_param = &data.devices_param[device_id];
17732
17733 if (device_param->skipped) continue;
17734
17735 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17736 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17737 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17738
17739 device_param->kernel_params_mp_l_buf64[3] = 0;
17740 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17741 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17742 device_param->kernel_params_mp_l_buf32[6] = 0;
17743 device_param->kernel_params_mp_l_buf32[7] = 0;
17744 device_param->kernel_params_mp_l_buf32[8] = 0;
17745
17746 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17747 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17748 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17749 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17750
17751 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17752 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17753 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17754
17755 device_param->kernel_params_mp_r_buf64[3] = 0;
17756 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17757 device_param->kernel_params_mp_r_buf32[5] = 0;
17758 device_param->kernel_params_mp_r_buf32[6] = 0;
17759 device_param->kernel_params_mp_r_buf32[7] = 0;
17760
17761 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]);
17762 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]);
17763 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]);
17764
17765 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]);
17766 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]);
17767 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]);
17768
17769 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);
17770 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);
17771 }
17772 }
17773
17774 u64 words_base = data.words_cnt;
17775
17776 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17777 {
17778 if (data.kernel_rules_cnt)
17779 {
17780 words_base /= data.kernel_rules_cnt;
17781 }
17782 }
17783 else if (data.attack_kern == ATTACK_KERN_COMBI)
17784 {
17785 if (data.combs_cnt)
17786 {
17787 words_base /= data.combs_cnt;
17788 }
17789 }
17790 else if (data.attack_kern == ATTACK_KERN_BF)
17791 {
17792 if (data.bfs_cnt)
17793 {
17794 words_base /= data.bfs_cnt;
17795 }
17796 }
17797
17798 data.words_base = words_base;
17799
17800 if (keyspace == 1)
17801 {
17802 log_info ("%llu", (unsigned long long int) words_base);
17803
17804 return (0);
17805 }
17806
17807 if (data.words_cur > data.words_base)
17808 {
17809 log_error ("ERROR: restore value greater keyspace");
17810
17811 return (-1);
17812 }
17813
17814 if (data.words_cur)
17815 {
17816 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17817 {
17818 for (uint i = 0; i < data.salts_cnt; i++)
17819 {
17820 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17821 }
17822 }
17823 else if (data.attack_kern == ATTACK_KERN_COMBI)
17824 {
17825 for (uint i = 0; i < data.salts_cnt; i++)
17826 {
17827 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17828 }
17829 }
17830 else if (data.attack_kern == ATTACK_KERN_BF)
17831 {
17832 for (uint i = 0; i < data.salts_cnt; i++)
17833 {
17834 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17835 }
17836 }
17837 }
17838
17839 /*
17840 * Update loopback file
17841 */
17842
17843 if (loopback == 1)
17844 {
17845 time_t now;
17846
17847 time (&now);
17848
17849 uint random_num = get_random_num (0, 9999);
17850
17851 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17852
17853 data.loopback_file = loopback_file;
17854 }
17855
17856 /*
17857 * Update dictionary statistic
17858 */
17859
17860 if (keyspace == 0)
17861 {
17862 dictstat_fp = fopen (dictstat, "wb");
17863
17864 if (dictstat_fp)
17865 {
17866 lock_file (dictstat_fp);
17867
17868 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17869
17870 fclose (dictstat_fp);
17871 }
17872 }
17873
17874 /**
17875 * create autotune threads
17876 */
17877
17878 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17879
17880 data.devices_status = STATUS_AUTOTUNE;
17881
17882 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17883 {
17884 hc_device_param_t *device_param = &devices_param[device_id];
17885
17886 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17887 }
17888
17889 hc_thread_wait (data.devices_cnt, c_threads);
17890
17891 /*
17892 * Inform user about possible slow speeds
17893 */
17894
17895 uint hardware_power_all = 0;
17896
17897 uint kernel_power_all = 0;
17898
17899 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17900 {
17901 hc_device_param_t *device_param = &devices_param[device_id];
17902
17903 hardware_power_all += device_param->hardware_power;
17904
17905 kernel_power_all += device_param->kernel_power;
17906 }
17907
17908 data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices
17909
17910 data.kernel_power_all = kernel_power_all;
17911
17912 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17913 {
17914 if (data.words_base < kernel_power_all)
17915 {
17916 if (quiet == 0)
17917 {
17918 log_info ("ATTENTION!");
17919 log_info (" The wordlist or mask you are using is too small.");
17920 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17921 log_info (" The cracking speed will drop.");
17922 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17923 log_info ("");
17924 }
17925 }
17926 }
17927
17928 /**
17929 * create cracker threads
17930 */
17931
17932 data.devices_status = STATUS_RUNNING;
17933
17934 if (initial_restore_done == 0)
17935 {
17936 if (data.restore_disable == 0) cycle_restore ();
17937
17938 initial_restore_done = 1;
17939 }
17940
17941 hc_timer_set (&data.timer_running);
17942
17943 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17944 {
17945 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17946 {
17947 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17948 if (quiet == 0) fflush (stdout);
17949 }
17950 }
17951 else if (wordlist_mode == WL_MODE_STDIN)
17952 {
17953 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17954 if (data.quiet == 0) log_info ("");
17955 }
17956
17957 time_t runtime_start;
17958
17959 time (&runtime_start);
17960
17961 data.runtime_start = runtime_start;
17962
17963 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17964 {
17965 hc_device_param_t *device_param = &devices_param[device_id];
17966
17967 if (wordlist_mode == WL_MODE_STDIN)
17968 {
17969 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17970 }
17971 else
17972 {
17973 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17974 }
17975 }
17976
17977 hc_thread_wait (data.devices_cnt, c_threads);
17978
17979 local_free (c_threads);
17980
17981 data.restore = 0;
17982
17983 // finalize task
17984
17985 logfile_sub_var_uint ("status-after-work", data.devices_status);
17986
17987 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17988
17989 if (data.devices_status == STATUS_CRACKED) break;
17990 if (data.devices_status == STATUS_ABORTED) break;
17991
17992 if (data.devices_status == STATUS_BYPASS)
17993 {
17994 data.devices_status = STATUS_RUNNING;
17995 }
17996
17997 if (induction_dictionaries_cnt)
17998 {
17999 unlink (induction_dictionaries[0]);
18000 }
18001
18002 free (induction_dictionaries);
18003
18004 if (attack_mode != ATTACK_MODE_BF)
18005 {
18006 induction_dictionaries = scan_directory (induction_directory);
18007
18008 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18009 }
18010
18011 if (benchmark == 0)
18012 {
18013 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18014 {
18015 if (quiet == 0) clear_prompt ();
18016
18017 if (quiet == 0) log_info ("");
18018
18019 if (status == 1)
18020 {
18021 status_display ();
18022 }
18023 else
18024 {
18025 if (quiet == 0) status_display ();
18026 }
18027
18028 if (quiet == 0) log_info ("");
18029 }
18030 }
18031
18032 if (attack_mode == ATTACK_MODE_BF)
18033 {
18034 dictpos++;
18035
18036 rd->dictpos = dictpos;
18037 }
18038 else
18039 {
18040 if (induction_dictionaries_cnt)
18041 {
18042 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18043 }
18044 else
18045 {
18046 dictpos++;
18047
18048 rd->dictpos = dictpos;
18049 }
18050 }
18051
18052 time_t runtime_stop;
18053
18054 time (&runtime_stop);
18055
18056 data.runtime_stop = runtime_stop;
18057
18058 logfile_sub_uint (runtime_start);
18059 logfile_sub_uint (runtime_stop);
18060
18061 logfile_sub_msg ("STOP");
18062
18063 global_free (subid);
18064 }
18065
18066 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18067
18068 if (data.devices_status == STATUS_CRACKED) break;
18069 if (data.devices_status == STATUS_ABORTED) break;
18070 if (data.devices_status == STATUS_QUIT) break;
18071
18072 if (data.devices_status == STATUS_BYPASS)
18073 {
18074 data.devices_status = STATUS_RUNNING;
18075 }
18076 }
18077
18078 // 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
18079
18080 if (attack_mode == ATTACK_MODE_STRAIGHT)
18081 {
18082 if (data.wordlist_mode == WL_MODE_FILE)
18083 {
18084 if (data.dictfile == NULL)
18085 {
18086 if (dictfiles != NULL)
18087 {
18088 data.dictfile = dictfiles[0];
18089
18090 hc_timer_set (&data.timer_running);
18091 }
18092 }
18093 }
18094 }
18095 // NOTE: combi is okay because it is already set beforehand
18096 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18097 {
18098 if (data.dictfile == NULL)
18099 {
18100 if (dictfiles != NULL)
18101 {
18102 hc_timer_set (&data.timer_running);
18103
18104 data.dictfile = dictfiles[0];
18105 }
18106 }
18107 }
18108 else if (attack_mode == ATTACK_MODE_BF)
18109 {
18110 if (data.mask == NULL)
18111 {
18112 hc_timer_set (&data.timer_running);
18113
18114 data.mask = masks[0];
18115 }
18116 }
18117
18118 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18119 {
18120 data.devices_status = STATUS_EXHAUSTED;
18121 }
18122
18123 // if cracked / aborted remove last induction dictionary
18124
18125 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18126 {
18127 struct stat induct_stat;
18128
18129 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18130 {
18131 unlink (induction_dictionaries[file_pos]);
18132 }
18133 }
18134
18135 // wait for non-interactive threads
18136
18137 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18138 {
18139 hc_thread_wait (1, &ni_threads[thread_idx]);
18140 }
18141
18142 local_free (ni_threads);
18143
18144 // wait for interactive threads
18145
18146 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18147 {
18148 hc_thread_wait (1, &i_threads[thread_idx]);
18149 }
18150
18151 local_free (i_threads);
18152
18153 // we dont need restore file anymore
18154 if (data.restore_disable == 0)
18155 {
18156 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18157 {
18158 unlink (eff_restore_file);
18159 unlink (new_restore_file);
18160 }
18161 else
18162 {
18163 cycle_restore ();
18164 }
18165 }
18166
18167 // finally save left hashes
18168
18169 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18170 {
18171 save_hash ();
18172 }
18173
18174 /**
18175 * Clean up
18176 */
18177
18178 if (benchmark == 1)
18179 {
18180 status_benchmark ();
18181
18182 if (machine_readable == 0)
18183 {
18184 log_info ("");
18185 }
18186 }
18187 else
18188 {
18189 if (quiet == 0) clear_prompt ();
18190
18191 if (quiet == 0) log_info ("");
18192
18193 if (status == 1)
18194 {
18195 status_display ();
18196 }
18197 else
18198 {
18199 if (quiet == 0) status_display ();
18200 }
18201
18202 if (quiet == 0) log_info ("");
18203 }
18204
18205 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18206 {
18207 hc_device_param_t *device_param = &data.devices_param[device_id];
18208
18209 if (device_param->skipped) continue;
18210
18211 local_free (device_param->combs_buf);
18212
18213 local_free (device_param->hooks_buf);
18214
18215 local_free (device_param->device_name);
18216
18217 local_free (device_param->device_name_chksum);
18218
18219 local_free (device_param->device_version);
18220
18221 local_free (device_param->driver_version);
18222
18223 if (device_param->pws_buf) myfree (device_param->pws_buf);
18224 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18225 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18226 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18227 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18228 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18229 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18230 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18231 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18232 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18233 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18234 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18235 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18236 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18237 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18238 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18239 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18240 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18241 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18242 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18243 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18244 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18245 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18246 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18247 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18248 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18249 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18250 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18251 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18252
18253 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18254 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18255 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18256 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18257 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18258 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18259 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18260 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18261 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18262 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18263 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18264
18265 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18266 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18267 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18268
18269 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18270 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18271 }
18272
18273 // reset default fan speed
18274
18275 #ifdef HAVE_HWMON
18276 if (gpu_temp_disable == 0)
18277 {
18278 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18279 {
18280 hc_thread_mutex_lock (mux_adl);
18281
18282 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18283 {
18284 hc_device_param_t *device_param = &data.devices_param[device_id];
18285
18286 if (device_param->skipped) continue;
18287
18288 if (data.hm_device[device_id].fan_set_supported == 1)
18289 {
18290 int fanspeed = temp_retain_fanspeed_value[device_id];
18291 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18292
18293 if (fanpolicy == 1)
18294 {
18295 int rc = -1;
18296
18297 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18298 {
18299 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18300 }
18301 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18302 {
18303
18304 }
18305
18306 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18307 }
18308 }
18309 }
18310
18311 hc_thread_mutex_unlock (mux_adl);
18312 }
18313 }
18314
18315 // reset power tuning
18316
18317 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18318 {
18319 hc_thread_mutex_lock (mux_adl);
18320
18321 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18322 {
18323 hc_device_param_t *device_param = &data.devices_param[device_id];
18324
18325 if (device_param->skipped) continue;
18326
18327 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18328 {
18329 if (data.hm_device[device_id].od_version == 6)
18330 {
18331 // check powertune capabilities first, if not available then skip device
18332
18333 int powertune_supported = 0;
18334
18335 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18336 {
18337 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18338
18339 return (-1);
18340 }
18341
18342 if (powertune_supported != 0)
18343 {
18344 // powercontrol settings
18345
18346 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18347 {
18348 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18349
18350 return (-1);
18351 }
18352
18353 // clocks
18354
18355 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18356
18357 performance_state->iNumberOfPerformanceLevels = 2;
18358
18359 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18360 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18361 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18362 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18363
18364 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18365 {
18366 log_info ("ERROR: Failed to restore ADL performance state");
18367
18368 return (-1);
18369 }
18370
18371 local_free (performance_state);
18372 }
18373 }
18374 }
18375
18376 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18377 {
18378 unsigned int limit = nvml_power_limit[device_id];
18379
18380 if (limit > 0)
18381 {
18382 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18383 }
18384 }
18385 }
18386
18387 hc_thread_mutex_unlock (mux_adl);
18388 }
18389
18390 if (gpu_temp_disable == 0)
18391 {
18392 if (data.hm_nvml)
18393 {
18394 hm_NVML_nvmlShutdown (data.hm_nvml);
18395
18396 nvml_close (data.hm_nvml);
18397
18398 data.hm_nvml = NULL;
18399 }
18400
18401 if (data.hm_adl)
18402 {
18403 hm_ADL_Main_Control_Destroy (data.hm_adl);
18404
18405 adl_close (data.hm_adl);
18406
18407 data.hm_adl = NULL;
18408 }
18409 }
18410 #endif // HAVE_HWMON
18411
18412 // free memory
18413
18414 local_free (masks);
18415
18416 local_free (dictstat_base);
18417
18418 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18419 {
18420 pot_t *pot_ptr = &pot[pot_pos];
18421
18422 hash_t *hash = &pot_ptr->hash;
18423
18424 local_free (hash->digest);
18425
18426 if (isSalted)
18427 {
18428 local_free (hash->salt);
18429 }
18430 }
18431
18432 local_free (pot);
18433
18434 local_free (all_kernel_rules_cnt);
18435 local_free (all_kernel_rules_buf);
18436
18437 local_free (wl_data->buf);
18438 local_free (wl_data);
18439
18440 local_free (bitmap_s1_a);
18441 local_free (bitmap_s1_b);
18442 local_free (bitmap_s1_c);
18443 local_free (bitmap_s1_d);
18444 local_free (bitmap_s2_a);
18445 local_free (bitmap_s2_b);
18446 local_free (bitmap_s2_c);
18447 local_free (bitmap_s2_d);
18448
18449 #ifdef HAVE_HWMON
18450 local_free (temp_retain_fanspeed_value);
18451 local_free (od_clock_mem_status);
18452 local_free (od_power_control_status);
18453 local_free (nvml_power_limit);
18454 #endif
18455
18456 global_free (devices_param);
18457
18458 global_free (kernel_rules_buf);
18459
18460 global_free (root_css_buf);
18461 global_free (markov_css_buf);
18462
18463 global_free (digests_buf);
18464 global_free (digests_shown);
18465 global_free (digests_shown_tmp);
18466
18467 global_free (salts_buf);
18468 global_free (salts_shown);
18469
18470 global_free (esalts_buf);
18471
18472 global_free (words_progress_done);
18473 global_free (words_progress_rejected);
18474 global_free (words_progress_restored);
18475
18476 if (pot_fp) fclose (pot_fp);
18477
18478 if (data.devices_status == STATUS_QUIT) break;
18479 }
18480
18481 // destroy others mutex
18482
18483 hc_thread_mutex_delete (mux_dispatcher);
18484 hc_thread_mutex_delete (mux_counter);
18485 hc_thread_mutex_delete (mux_display);
18486 hc_thread_mutex_delete (mux_adl);
18487
18488 // free memory
18489
18490 local_free (eff_restore_file);
18491 local_free (new_restore_file);
18492
18493 local_free (rd);
18494
18495 // tuning db
18496
18497 tuning_db_destroy (tuning_db);
18498
18499 // loopback
18500
18501 local_free (loopback_file);
18502
18503 if (loopback == 1) unlink (loopback_file);
18504
18505 // induction directory
18506
18507 if (induction_dir == NULL)
18508 {
18509 if (attack_mode != ATTACK_MODE_BF)
18510 {
18511 if (rmdir (induction_directory) == -1)
18512 {
18513 if (errno == ENOENT)
18514 {
18515 // good, we can ignore
18516 }
18517 else if (errno == ENOTEMPTY)
18518 {
18519 // good, we can ignore
18520 }
18521 else
18522 {
18523 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18524
18525 return (-1);
18526 }
18527 }
18528
18529 local_free (induction_directory);
18530 }
18531 }
18532
18533 // outfile-check directory
18534
18535 if (outfile_check_dir == NULL)
18536 {
18537 if (rmdir (outfile_check_directory) == -1)
18538 {
18539 if (errno == ENOENT)
18540 {
18541 // good, we can ignore
18542 }
18543 else if (errno == ENOTEMPTY)
18544 {
18545 // good, we can ignore
18546 }
18547 else
18548 {
18549 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18550
18551 return (-1);
18552 }
18553 }
18554
18555 local_free (outfile_check_directory);
18556 }
18557
18558 time_t proc_stop;
18559
18560 time (&proc_stop);
18561
18562 logfile_top_uint (proc_start);
18563 logfile_top_uint (proc_stop);
18564
18565 logfile_top_msg ("STOP");
18566
18567 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18568 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18569
18570 if (data.ocl) ocl_close (data.ocl);
18571
18572 if (data.devices_status == STATUS_ABORTED) return 2;
18573 if (data.devices_status == STATUS_QUIT) return 2;
18574 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18575 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18576 if (data.devices_status == STATUS_CRACKED) return 0;
18577
18578 return -1;
18579 }
Hashcat additions to support pwdhash