projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Workaround OpenCL runtimes that do not accept -I parameter in the OpenCL kernel build...
[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 __APPLE__
10 #include <stdio.h>
11 #endif
12
13 #ifdef __FreeBSD__
14 #include <stdio.h>
15 #endif
16
17 #include <common.h>
18 #include <shared.h>
19 #include <rp_kernel_on_cpu.h>
20 #include <getopt.h>
21
22 const char *PROGNAME = "hashcat";
23 const uint VERSION_BIN = 300;
24 const uint RESTORE_MIN = 300;
25
26 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
27
28 #define INCR_RULES 10000
29 #define INCR_SALTS 100000
30 #define INCR_MASKS 1000
31 #define INCR_POT 1000
32
33 #define USAGE 0
34 #define VERSION 0
35 #define QUIET 0
36 #define MARKOV_THRESHOLD 0
37 #define MARKOV_DISABLE 0
38 #define MARKOV_CLASSIC 0
39 #define BENCHMARK 0
40 #define STDOUT_FLAG 0
41 #define RESTORE 0
42 #define RESTORE_TIMER 60
43 #define RESTORE_DISABLE 0
44 #define STATUS 0
45 #define STATUS_TIMER 10
46 #define MACHINE_READABLE 0
47 #define LOOPBACK 0
48 #define WEAK_HASH_THRESHOLD 100
49 #define SHOW 0
50 #define LEFT 0
51 #define USERNAME 0
52 #define REMOVE 0
53 #define REMOVE_TIMER 60
54 #define SKIP 0
55 #define LIMIT 0
56 #define KEYSPACE 0
57 #define POTFILE_DISABLE 0
58 #define DEBUG_MODE 0
59 #define RP_GEN 0
60 #define RP_GEN_FUNC_MIN 1
61 #define RP_GEN_FUNC_MAX 4
62 #define RP_GEN_SEED 0
63 #define RULE_BUF_L ":"
64 #define RULE_BUF_R ":"
65 #define FORCE 0
66 #define RUNTIME 0
67 #define HEX_CHARSET 0
68 #define HEX_SALT 0
69 #define HEX_WORDLIST 0
70 #define OUTFILE_FORMAT 3
71 #define OUTFILE_AUTOHEX 1
72 #define OUTFILE_CHECK_TIMER 5
73 #define ATTACK_MODE 0
74 #define HASH_MODE 0
75 #define SEGMENT_SIZE 32
76 #define INCREMENT 0
77 #define INCREMENT_MIN 1
78 #define INCREMENT_MAX PW_MAX
79 #define SEPARATOR ':'
80 #define BITMAP_MIN 16
81 #define BITMAP_MAX 24
82 #define NVIDIA_SPIN_DAMP 100
83 #define GPU_TEMP_DISABLE 0
84 #define GPU_TEMP_ABORT 90
85 #define GPU_TEMP_RETAIN 75
86 #define WORKLOAD_PROFILE 2
87 #define KERNEL_ACCEL 0
88 #define KERNEL_LOOPS 0
89 #define KERNEL_RULES 1024
90 #define KERNEL_COMBS 1024
91 #define KERNEL_BFS 1024
92 #define KERNEL_THREADS_MAX 256
93 #define KERNEL_THREADS_MAX_CPU 1
94 #define POWERTUNE_ENABLE 0
95 #define LOGFILE_DISABLE 0
96 #define SCRYPT_TMTO 0
97 #define OPENCL_VECTOR_WIDTH 0
98
99 #define WL_MODE_STDIN 1
100 #define WL_MODE_FILE 2
101 #define WL_MODE_MASK 3
102
103 #define HL_MODE_FILE 4
104 #define HL_MODE_ARG 5
105
106 #define HLFMTS_CNT 11
107 #define HLFMT_HASHCAT 0
108 #define HLFMT_PWDUMP 1
109 #define HLFMT_PASSWD 2
110 #define HLFMT_SHADOW 3
111 #define HLFMT_DCC 4
112 #define HLFMT_DCC2 5
113 #define HLFMT_NETNTLM1 7
114 #define HLFMT_NETNTLM2 8
115 #define HLFMT_NSLDAP 9
116 #define HLFMT_NSLDAPS 10
117
118 #define HLFMT_TEXT_HASHCAT "native hashcat"
119 #define HLFMT_TEXT_PWDUMP "pwdump"
120 #define HLFMT_TEXT_PASSWD "passwd"
121 #define HLFMT_TEXT_SHADOW "shadow"
122 #define HLFMT_TEXT_DCC "DCC"
123 #define HLFMT_TEXT_DCC2 "DCC 2"
124 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
125 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
126 #define HLFMT_TEXT_NSLDAP "nsldap"
127 #define HLFMT_TEXT_NSLDAPS "nsldaps"
128
129 #define ATTACK_MODE_STRAIGHT 0
130 #define ATTACK_MODE_COMBI 1
131 #define ATTACK_MODE_TOGGLE 2
132 #define ATTACK_MODE_BF 3
133 #define ATTACK_MODE_PERM 4
134 #define ATTACK_MODE_TABLE 5
135 #define ATTACK_MODE_HYBRID1 6
136 #define ATTACK_MODE_HYBRID2 7
137 #define ATTACK_MODE_NONE 100
138
139 #define ATTACK_KERN_STRAIGHT 0
140 #define ATTACK_KERN_COMBI 1
141 #define ATTACK_KERN_BF 3
142 #define ATTACK_KERN_NONE 100
143
144 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
145 #define ATTACK_EXEC_INSIDE_KERNEL 11
146
147 #define COMBINATOR_MODE_BASE_LEFT 10001
148 #define COMBINATOR_MODE_BASE_RIGHT 10002
149
150 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
151 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
152
153 #define MAX_CUT_TRIES 4
154
155 #define MAX_DICTSTAT 10000
156
157 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
158
159 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
160
161 #define global_free(attr) \
162 { \
163 myfree ((void *) data.attr); \
164 \
165 data.attr = NULL; \
166 }
167
168 #define local_free(attr) \
169 { \
170 myfree ((void *) attr); \
171 \
172 attr = NULL; \
173 }
174
175 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
176 #define HC_API_CALL __stdcall
177 #else
178 #define HC_API_CALL
179 #endif
180
181 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
182 {
183 900,
184 0,
185 5100,
186 100,
187 1400,
188 10800,
189 1700,
190 5000,
191 10100,
192 6000,
193 6100,
194 6900,
195 11700,
196 11800,
197 400,
198 8900,
199 11900,
200 12000,
201 10900,
202 12100,
203 23,
204 2500,
205 5300,
206 5400,
207 5500,
208 5600,
209 7300,
210 7500,
211 13100,
212 8300,
213 11100,
214 11200,
215 11400,
216 121,
217 2611,
218 2711,
219 2811,
220 8400,
221 11,
222 2612,
223 7900,
224 21,
225 11000,
226 124,
227 10000,
228 3711,
229 7600,
230 12,
231 131,
232 132,
233 1731,
234 200,
235 300,
236 3100,
237 112,
238 12300,
239 8000,
240 141,
241 1441,
242 1600,
243 12600,
244 1421,
245 101,
246 111,
247 1711,
248 3000,
249 1000,
250 1100,
251 2100,
252 12800,
253 1500,
254 12400,
255 500,
256 3200,
257 7400,
258 1800,
259 122,
260 1722,
261 7100,
262 6300,
263 6700,
264 6400,
265 6500,
266 2400,
267 2410,
268 5700,
269 9200,
270 9300,
271 22,
272 501,
273 5800,
274 8100,
275 8500,
276 7200,
277 9900,
278 7700,
279 7800,
280 10300,
281 8600,
282 8700,
283 9100,
284 133,
285 13500,
286 11600,
287 13600,
288 12500,
289 13000,
290 13200,
291 13300,
292 6211,
293 6221,
294 6231,
295 6241,
296 13711,
297 13721,
298 13731,
299 13741,
300 13751,
301 13761,
302 8800,
303 12900,
304 12200,
305 9700,
306 9710,
307 9800,
308 9810,
309 9400,
310 9500,
311 9600,
312 10400,
313 10410,
314 10500,
315 10600,
316 10700,
317 9000,
318 5200,
319 6800,
320 6600,
321 8200,
322 11300,
323 12700,
324 13400,
325 125
326 };
327
328 /**
329 * types
330 */
331
332 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
333
334 /**
335 * globals
336 */
337
338 static unsigned int full01 = 0x01010101;
339 static unsigned int full80 = 0x80808080;
340
341 int SUPPRESS_OUTPUT = 0;
342
343 hc_thread_mutex_t mux_adl;
344 hc_thread_mutex_t mux_counter;
345 hc_thread_mutex_t mux_dispatcher;
346 hc_thread_mutex_t mux_display;
347
348 hc_global_data_t data;
349
350 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
351
352 const char *USAGE_MINI[] =
353 {
354 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
355 "",
356 "Try --help for more help.",
357 NULL
358 };
359
360 const char *USAGE_BIG[] =
361 {
362 "%s, advanced password recovery",
363 "",
364 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
365 "",
366 "- [ Options ] -",
367 "",
368 " Options Short / Long | Type | Description | Example",
369 "===============================+======+======================================================+=======================",
370 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
371 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
372 " -V, --version | | Print version |",
373 " -h, --help | | Print help |",
374 " --quiet | | Suppress output |",
375 " --hex-charset | | Assume charset is given in hex |",
376 " --hex-salt | | Assume salt is given in hex |",
377 " --hex-wordlist | | Assume words in wordlist is given in hex |",
378 " --force | | Ignore warnings |",
379 " --status | | Enable automatic update of the status-screen |",
380 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
381 " --machine-readable | | Display the status view in a machine readable format |",
382 " --loopback | | Add new plains to induct directory |",
383 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
384 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
385 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
386 " --markov-classic | | Enables classic markov-chains, no per-position |",
387 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
388 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
389 " --session | Str | Define specific session name | --session=mysession",
390 " --restore | | Restore session from --session |",
391 " --restore-disable | | Do not write restore file |",
392 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
393 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
394 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
395 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
396 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
397 " --stdout | | Do not crack a hash, instead print candidates only |",
398 " --show | | Compare hashlist with potfile; Show cracked hashes |",
399 " --left | | Compare hashlist with potfile; Show uncracked hashes |",
400 " --username | | Enable ignoring of usernames in hashfile |",
401 " --remove | | Enable remove of hash once it is cracked |",
402 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
403 " --potfile-disable | | Do not write potfile |",
404 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
405 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
406 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
407 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
408 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
409 " --logfile-disable | | Disable the logfile |",
410 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
411 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
412 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
413 " -b, --benchmark | | Run benchmark |",
414 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
415 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
416 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
417 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
418 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
419 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
420 " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1",
421 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
422 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
423 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
424 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
425 " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50",
426 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
427 #ifdef HAVE_HWMON
428 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
429 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
430 " --powertune-enable | | Enable power tuning, restores settings when finished |",
431 #endif
432 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
433 " -s, --skip | Num | Skip X words from the start | -s 1000000",
434 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
435 " --keyspace | | Show keyspace base:mod values and quit |",
436 " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'",
437 " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'",
438 " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule",
439 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
440 " --generate-rules-func-min | Num | Force min X funcs per rule |",
441 " --generate-rules-func-max | Num | Force max X funcs per rule |",
442 " --generate-rules-seed | Num | Force RNG seed set to X |",
443 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
444 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
445 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
446 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
447 " -i, --increment | | Enable mask increment mode |",
448 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
449 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
450 "",
451 "- [ Hash modes ] -",
452 "",
453 " # | Name | Category",
454 " ======+==================================================+======================================",
455 " 900 | MD4 | Raw Hash",
456 " 0 | MD5 | Raw Hash",
457 " 5100 | Half MD5 | Raw Hash",
458 " 100 | SHA1 | Raw Hash",
459 " 10800 | SHA-384 | Raw Hash",
460 " 1400 | SHA-256 | Raw Hash",
461 " 1700 | SHA-512 | Raw Hash",
462 " 5000 | SHA-3(Keccak) | Raw Hash",
463 " 10100 | SipHash | Raw Hash",
464 " 6000 | RipeMD160 | Raw Hash",
465 " 6100 | Whirlpool | Raw Hash",
466 " 6900 | GOST R 34.11-94 | Raw Hash",
467 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
468 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
469 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
474 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
475 " 2600 | md5(md5($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
477 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
478 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
479 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
480 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
481 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
482 " 4500 | sha1(sha1($pass)) | Raw Hash, Salted and / or Iterated",
483 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
484 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
485 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
486 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
487 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
488 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
489 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
490 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
491 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
492 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
493 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
494 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
495 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
496 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
497 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
498 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
499 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
500 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
501 " 400 | phpass | Generic KDF",
502 " 8900 | scrypt | Generic KDF",
503 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
504 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
505 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
506 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
507 " 23 | Skype | Network protocols",
508 " 2500 | WPA/WPA2 | Network protocols",
509 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
510 " 5300 | IKE-PSK MD5 | Network protocols",
511 " 5400 | IKE-PSK SHA1 | Network protocols",
512 " 5500 | NetNTLMv1 | Network protocols",
513 " 5500 | NetNTLMv1 + ESS | Network protocols",
514 " 5600 | NetNTLMv2 | Network protocols",
515 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
516 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
517 " 8300 | DNSSEC (NSEC3) | Network protocols",
518 " 10200 | Cram MD5 | Network protocols",
519 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
520 " 11200 | MySQL CRAM (SHA1) | Network protocols",
521 " 11400 | SIP digest authentication (MD5) | Network protocols",
522 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
523 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
524 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
525 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
526 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
527 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
528 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
529 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
530 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
531 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
532 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
533 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
534 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
535 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
536 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
537 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
538 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
539 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
540 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
541 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
542 " 12 | PostgreSQL | Database Server",
543 " 131 | MSSQL(2000) | Database Server",
544 " 132 | MSSQL(2005) | Database Server",
545 " 1731 | MSSQL(2012) | Database Server",
546 " 1731 | MSSQL(2014) | Database Server",
547 " 200 | MySQL323 | Database Server",
548 " 300 | MySQL4.1/MySQL5 | Database Server",
549 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
550 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
551 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
552 " 8000 | Sybase ASE | Database Server",
553 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
554 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
555 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
556 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
557 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
558 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
559 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
560 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
561 " 11500 | CRC32 | Checksums",
562 " 3000 | LM | Operating-Systems",
563 " 1000 | NTLM | Operating-Systems",
564 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
565 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
566 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
567 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
568 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
569 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
570 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
571 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
572 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
573 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
574 " 1722 | OSX v10.7 | Operating-Systems",
575 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
576 " 6300 | AIX {smd5} | Operating-Systems",
577 " 6700 | AIX {ssha1} | Operating-Systems",
578 " 6400 | AIX {ssha256} | Operating-Systems",
579 " 6500 | AIX {ssha512} | Operating-Systems",
580 " 2400 | Cisco-PIX | Operating-Systems",
581 " 2410 | Cisco-ASA | Operating-Systems",
582 " 500 | Cisco-IOS $1$ | Operating-Systems",
583 " 5700 | Cisco-IOS $4$ | Operating-Systems",
584 " 9200 | Cisco-IOS $8$ | Operating-Systems",
585 " 9300 | Cisco-IOS $9$ | Operating-Systems",
586 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
587 " 501 | Juniper IVE | Operating-Systems",
588 " 5800 | Android PIN | Operating-Systems",
589 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
590 " 8100 | Citrix Netscaler | Operating-Systems",
591 " 8500 | RACF | Operating-Systems",
592 " 7200 | GRUB 2 | Operating-Systems",
593 " 9900 | Radmin2 | Operating-Systems",
594 " 125 | ArubaOS | Operating-Systems",
595 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
596 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
597 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
598 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
599 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
600 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
601 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
602 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
603 " 11600 | 7-Zip | Archives",
604 " 12500 | RAR3-hp | Archives",
605 " 13000 | RAR5 | Archives",
606 " 13200 | AxCrypt | Archives",
607 " 13300 | AxCrypt in memory SHA1 | Archives",
608 " 13600 | WinZip | Archives",
609 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
610 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
611 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
612 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
613 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
614 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
615 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
616 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
617 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
618 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
619 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
620 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
621 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
623 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
624 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
625 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
626 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
627 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
628 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
629 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
630 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
631 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
632 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
633 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
634 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
635 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
636 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
637 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
638 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
639 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
640 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
641 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
642 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
643 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
644 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
645 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
646 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
647 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
648 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
649 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
650 " 9400 | MS Office 2007 | Documents",
651 " 9500 | MS Office 2010 | Documents",
652 " 9600 | MS Office 2013 | Documents",
653 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
654 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
655 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
656 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
657 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
658 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
659 " 9000 | Password Safe v2 | Password Managers",
660 " 5200 | Password Safe v3 | Password Managers",
661 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
662 " 6600 | 1Password, agilekeychain | Password Managers",
663 " 8200 | 1Password, cloudkeychain | Password Managers",
664 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
665 " 12700 | Blockchain, My Wallet | Password Managers",
666 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
667 "",
668 "- [ Outfile Formats ] -",
669 "",
670 " # | Format",
671 " ===+========",
672 " 1 | hash[:salt]",
673 " 2 | plain",
674 " 3 | hash[:salt]:plain",
675 " 4 | hex_plain",
676 " 5 | hash[:salt]:hex_plain",
677 " 6 | plain:hex_plain",
678 " 7 | hash[:salt]:plain:hex_plain",
679 " 8 | crackpos",
680 " 9 | hash[:salt]:crack_pos",
681 " 10 | plain:crack_pos",
682 " 11 | hash[:salt]:plain:crack_pos",
683 " 12 | hex_plain:crack_pos",
684 " 13 | hash[:salt]:hex_plain:crack_pos",
685 " 14 | plain:hex_plain:crack_pos",
686 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
687 "",
688 "- [ Rule Debugging Modes ] -",
689 "",
690 " # | Format",
691 " ===+========",
692 " 1 | Finding-Rule",
693 " 2 | Original-Word",
694 " 3 | Original-Word:Finding-Rule",
695 " 4 | Original-Word:Finding-Rule:Processed-Word",
696 "",
697 "- [ Attack Modes ] -",
698 "",
699 " # | Mode",
700 " ===+======",
701 " 0 | Straight",
702 " 1 | Combination",
703 " 3 | Brute-force",
704 " 6 | Hybrid Wordlist + Mask",
705 " 7 | Hybrid Mask + Wordlist",
706 "",
707 "- [ Built-in Charsets ] -",
708 "",
709 " ? | Charset",
710 " ===+=========",
711 " l | abcdefghijklmnopqrstuvwxyz",
712 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
713 " d | 0123456789",
714 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
715 " a | ?l?u?d?s",
716 " b | 0x00 - 0xff",
717 "",
718 "- [ OpenCL Device Types ] -",
719 "",
720 " # | Device Type",
721 " ===+=============",
722 " 1 | CPU",
723 " 2 | GPU",
724 " 3 | FPGA, DSP, Co-Processor",
725 "",
726 "- [ Workload Profiles ] -",
727 "",
728 " # | Performance | Runtime | Power Consumption | Desktop Impact",
729 " ===+=============+=========+===================+=================",
730 " 1 | Low | 2 ms | Low | Minimal",
731 " 2 | Default | 12 ms | Economic | Noticeable",
732 " 3 | High | 96 ms | High | Unresponsive",
733 " 4 | Nightmare | 480 ms | Insane | Headless",
734 "",
735 "- [ Basic Examples ] -",
736 "",
737 " Attack- | Hash- |",
738 " Mode | Type | Example command",
739 " ==================+=======+==================================================================",
740 " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict",
741 " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule",
742 " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a",
743 " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict",
744 "",
745 "If you still have no idea what just happened try following pages:",
746 "",
747 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
748 "* https://hashcat.net/wiki/#frequently_asked_questions",
749 NULL
750 };
751
752 /**
753 * hashcat specific functions
754 */
755
756 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
757 {
758 int exec_pos = (int) device_param->exec_pos - last_num_entries;
759
760 if (exec_pos < 0) exec_pos += EXEC_CACHE;
761
762 double exec_ms_sum = 0;
763
764 int exec_ms_cnt = 0;
765
766 for (int i = 0; i < last_num_entries; i++)
767 {
768 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
769
770 if (exec_ms)
771 {
772 exec_ms_sum += exec_ms;
773
774 exec_ms_cnt++;
775 }
776 }
777
778 if (exec_ms_cnt == 0) return 0;
779
780 return exec_ms_sum / exec_ms_cnt;
781 }
782
783 void status_display_machine_readable ()
784 {
785 FILE *out = stdout;
786
787 fprintf (out, "STATUS\t%u\t", data.devices_status);
788
789 /**
790 * speed new
791 */
792
793 fprintf (out, "SPEED\t");
794
795 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
796 {
797 hc_device_param_t *device_param = &data.devices_param[device_id];
798
799 if (device_param->skipped) continue;
800
801 u64 speed_cnt = 0;
802 double speed_ms = 0;
803
804 for (int i = 0; i < SPEED_CACHE; i++)
805 {
806 speed_cnt += device_param->speed_cnt[i];
807 speed_ms += device_param->speed_ms[i];
808 }
809
810 speed_cnt /= SPEED_CACHE;
811 speed_ms /= SPEED_CACHE;
812
813 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
814 }
815
816 /**
817 * exec time
818 */
819
820 fprintf (out, "EXEC_RUNTIME\t");
821
822 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
823 {
824 hc_device_param_t *device_param = &data.devices_param[device_id];
825
826 if (device_param->skipped) continue;
827
828 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
829
830 fprintf (out, "%f\t", exec_ms_avg);
831 }
832
833 /**
834 * words_cur
835 */
836
837 u64 words_cur = get_lowest_words_done ();
838
839 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
840
841 /**
842 * counter
843 */
844
845 u64 progress_total = data.words_cnt * data.salts_cnt;
846
847 u64 all_done = 0;
848 u64 all_rejected = 0;
849 u64 all_restored = 0;
850
851 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
852 {
853 all_done += data.words_progress_done[salt_pos];
854 all_rejected += data.words_progress_rejected[salt_pos];
855 all_restored += data.words_progress_restored[salt_pos];
856 }
857
858 u64 progress_cur = all_restored + all_done + all_rejected;
859 u64 progress_end = progress_total;
860
861 u64 progress_skip = 0;
862
863 if (data.skip)
864 {
865 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
866
867 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
868 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
869 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
870 }
871
872 if (data.limit)
873 {
874 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
875
876 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
877 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
878 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
879 }
880
881 u64 progress_cur_relative_skip = progress_cur - progress_skip;
882 u64 progress_end_relative_skip = progress_end - progress_skip;
883
884 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
885
886 /**
887 * cracks
888 */
889
890 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
891 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
892
893 /**
894 * temperature
895 */
896
897 #ifdef HAVE_HWMON
898 if (data.gpu_temp_disable == 0)
899 {
900 fprintf (out, "TEMP\t");
901
902 hc_thread_mutex_lock (mux_adl);
903
904 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
905 {
906 hc_device_param_t *device_param = &data.devices_param[device_id];
907
908 if (device_param->skipped) continue;
909
910 int temp = hm_get_temperature_with_device_id (device_id);
911
912 fprintf (out, "%d\t", temp);
913 }
914
915 hc_thread_mutex_unlock (mux_adl);
916 }
917 #endif // HAVE_HWMON
918
919 /**
920 * flush
921 */
922
923 fputs (EOL, out);
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931
932 // in this case some required buffers are free'd, ascii_digest() would run into segfault
933 if (data.shutdown_inner == 1) return;
934
935 if (data.machine_readable == 1)
936 {
937 status_display_machine_readable ();
938
939 return;
940 }
941
942 char tmp_buf[1000] = { 0 };
943
944 uint tmp_len = 0;
945
946 log_info ("Session.Name...: %s", data.session);
947
948 char *status_type = strstatus (data.devices_status);
949
950 uint hash_mode = data.hash_mode;
951
952 char *hash_type = strhashtype (hash_mode); // not a bug
953
954 log_info ("Status.........: %s", status_type);
955
956 /**
957 * show rules
958 */
959
960 if (data.rp_files_cnt)
961 {
962 uint i;
963
964 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
965 {
966 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
967 }
968
969 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
970
971 log_info ("Rules.Type.....: %s", tmp_buf);
972
973 tmp_len = 0;
974 }
975
976 if (data.rp_gen)
977 {
978 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
979
980 if (data.rp_gen_seed)
981 {
982 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
983 }
984 }
985
986 /**
987 * show input
988 */
989
990 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
991 {
992 if (data.wordlist_mode == WL_MODE_FILE)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
995 }
996 else if (data.wordlist_mode == WL_MODE_STDIN)
997 {
998 log_info ("Input.Mode.....: Pipe");
999 }
1000 }
1001 else if (data.attack_mode == ATTACK_MODE_COMBI)
1002 {
1003 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1004 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1005 }
1006 else if (data.attack_mode == ATTACK_MODE_BF)
1007 {
1008 char *mask = data.mask;
1009
1010 if (mask != NULL)
1011 {
1012 uint mask_len = data.css_cnt;
1013
1014 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1015
1016 if (mask_len > 0)
1017 {
1018 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1019 {
1020 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1021 {
1022 mask_len -= data.salts_buf[0].salt_len;
1023 }
1024 }
1025
1026 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1027
1028 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1029 }
1030
1031 if (data.maskcnt > 1)
1032 {
1033 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1034
1035 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1036 }
1037
1038 log_info ("Input.Mode.....: %s", tmp_buf);
1039 }
1040
1041 tmp_len = 0;
1042 }
1043 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1044 {
1045 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1046 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1047 }
1048 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1049 {
1050 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1051 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1052 }
1053
1054 if (data.digests_cnt == 1)
1055 {
1056 if (data.hash_mode == 2500)
1057 {
1058 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1059
1060 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1061 (char *) data.salts_buf[0].salt_buf,
1062 wpa->orig_mac1[0],
1063 wpa->orig_mac1[1],
1064 wpa->orig_mac1[2],
1065 wpa->orig_mac1[3],
1066 wpa->orig_mac1[4],
1067 wpa->orig_mac1[5],
1068 wpa->orig_mac2[0],
1069 wpa->orig_mac2[1],
1070 wpa->orig_mac2[2],
1071 wpa->orig_mac2[3],
1072 wpa->orig_mac2[4],
1073 wpa->orig_mac2[5]);
1074 }
1075 else if (data.hash_mode == 5200)
1076 {
1077 log_info ("Hash.Target....: File (%s)", data.hashfile);
1078 }
1079 else if (data.hash_mode == 9000)
1080 {
1081 log_info ("Hash.Target....: File (%s)", data.hashfile);
1082 }
1083 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1084 {
1085 log_info ("Hash.Target....: File (%s)", data.hashfile);
1086 }
1087 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1088 {
1089 log_info ("Hash.Target....: File (%s)", data.hashfile);
1090 }
1091 else
1092 {
1093 char out_buf[HCBUFSIZ] = { 0 };
1094
1095 ascii_digest (out_buf, 0, 0);
1096
1097 // limit length
1098 if (strlen (out_buf) > 40)
1099 {
1100 out_buf[41] = '.';
1101 out_buf[42] = '.';
1102 out_buf[43] = '.';
1103 out_buf[44] = 0;
1104 }
1105
1106 log_info ("Hash.Target....: %s", out_buf);
1107 }
1108 }
1109 else
1110 {
1111 if (data.hash_mode == 3000)
1112 {
1113 char out_buf1[32] = { 0 };
1114 char out_buf2[32] = { 0 };
1115
1116 ascii_digest (out_buf1, 0, 0);
1117 ascii_digest (out_buf2, 0, 1);
1118
1119 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1120 }
1121 else
1122 {
1123 log_info ("Hash.Target....: File (%s)", data.hashfile);
1124 }
1125 }
1126
1127 log_info ("Hash.Type......: %s", hash_type);
1128
1129 /**
1130 * speed new
1131 */
1132
1133 u64 speed_cnt[DEVICES_MAX] = { 0 };
1134 double speed_ms[DEVICES_MAX] = { 0 };
1135
1136 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1137 {
1138 hc_device_param_t *device_param = &data.devices_param[device_id];
1139
1140 if (device_param->skipped) continue;
1141
1142 speed_cnt[device_id] = 0;
1143 speed_ms[device_id] = 0;
1144
1145 for (int i = 0; i < SPEED_CACHE; i++)
1146 {
1147 speed_cnt[device_id] += device_param->speed_cnt[i];
1148 speed_ms[device_id] += device_param->speed_ms[i];
1149 }
1150
1151 speed_cnt[device_id] /= SPEED_CACHE;
1152 speed_ms[device_id] /= SPEED_CACHE;
1153 }
1154
1155 double hashes_all_ms = 0;
1156
1157 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1158
1159 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1160 {
1161 hc_device_param_t *device_param = &data.devices_param[device_id];
1162
1163 if (device_param->skipped) continue;
1164
1165 hashes_dev_ms[device_id] = 0;
1166
1167 if (speed_ms[device_id])
1168 {
1169 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1170
1171 hashes_all_ms += hashes_dev_ms[device_id];
1172 }
1173 }
1174
1175 /**
1176 * exec time
1177 */
1178
1179 double exec_all_ms[DEVICES_MAX] = { 0 };
1180
1181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1182 {
1183 hc_device_param_t *device_param = &data.devices_param[device_id];
1184
1185 if (device_param->skipped) continue;
1186
1187 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1188
1189 exec_all_ms[device_id] = exec_ms_avg;
1190 }
1191
1192 /**
1193 * timers
1194 */
1195
1196 double ms_running = 0;
1197
1198 hc_timer_get (data.timer_running, ms_running);
1199
1200 double ms_paused = data.ms_paused;
1201
1202 if (data.devices_status == STATUS_PAUSED)
1203 {
1204 double ms_paused_tmp = 0;
1205
1206 hc_timer_get (data.timer_paused, ms_paused_tmp);
1207
1208 ms_paused += ms_paused_tmp;
1209 }
1210
1211 #ifdef WIN
1212
1213 __time64_t sec_run = ms_running / 1000;
1214
1215 #else
1216
1217 time_t sec_run = ms_running / 1000;
1218
1219 #endif
1220
1221 if (sec_run)
1222 {
1223 char display_run[32] = { 0 };
1224
1225 struct tm tm_run;
1226
1227 struct tm *tmp = NULL;
1228
1229 #ifdef WIN
1230
1231 tmp = _gmtime64 (&sec_run);
1232
1233 #else
1234
1235 tmp = gmtime (&sec_run);
1236
1237 #endif
1238
1239 if (tmp != NULL)
1240 {
1241 memset (&tm_run, 0, sizeof (tm_run));
1242
1243 memcpy (&tm_run, tmp, sizeof (tm_run));
1244
1245 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1246
1247 char *start = ctime (&data.proc_start);
1248
1249 size_t start_len = strlen (start);
1250
1251 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1252 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1253
1254 log_info ("Time.Started...: %s (%s)", start, display_run);
1255 }
1256 }
1257 else
1258 {
1259 log_info ("Time.Started...: 0 secs");
1260 }
1261
1262 /**
1263 * counters
1264 */
1265
1266 u64 progress_total = data.words_cnt * data.salts_cnt;
1267
1268 u64 all_done = 0;
1269 u64 all_rejected = 0;
1270 u64 all_restored = 0;
1271
1272 u64 progress_noneed = 0;
1273
1274 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1275 {
1276 all_done += data.words_progress_done[salt_pos];
1277 all_rejected += data.words_progress_rejected[salt_pos];
1278 all_restored += data.words_progress_restored[salt_pos];
1279
1280 // Important for ETA only
1281
1282 if (data.salts_shown[salt_pos] == 1)
1283 {
1284 const u64 all = data.words_progress_done[salt_pos]
1285 + data.words_progress_rejected[salt_pos]
1286 + data.words_progress_restored[salt_pos];
1287
1288 const u64 left = data.words_cnt - all;
1289
1290 progress_noneed += left;
1291 }
1292 }
1293
1294 u64 progress_cur = all_restored + all_done + all_rejected;
1295 u64 progress_end = progress_total;
1296
1297 u64 progress_skip = 0;
1298
1299 if (data.skip)
1300 {
1301 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1302
1303 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1306 }
1307
1308 if (data.limit)
1309 {
1310 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1311
1312 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1314 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1315 }
1316
1317 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1318 u64 progress_end_relative_skip = progress_end - progress_skip;
1319
1320 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1321 {
1322 if (data.devices_status != STATUS_CRACKED)
1323 {
1324 #ifdef WIN
1325 __time64_t sec_etc = 0;
1326 #else
1327 time_t sec_etc = 0;
1328 #endif
1329
1330 if (hashes_all_ms)
1331 {
1332 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1333
1334 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1335
1336 sec_etc = ms_left / 1000;
1337 }
1338
1339 if (sec_etc == 0)
1340 {
1341 //log_info ("Time.Estimated.: 0 secs");
1342 }
1343 else if ((u64) sec_etc > ETC_MAX)
1344 {
1345 log_info ("Time.Estimated.: > 10 Years");
1346 }
1347 else
1348 {
1349 char display_etc[32] = { 0 };
1350 char display_runtime[32] = { 0 };
1351
1352 struct tm tm_etc;
1353 struct tm tm_runtime;
1354
1355 struct tm *tmp = NULL;
1356
1357 #ifdef WIN
1358 tmp = _gmtime64 (&sec_etc);
1359 #else
1360 tmp = gmtime (&sec_etc);
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1366
1367 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1368
1369 time_t now;
1370
1371 time (&now);
1372
1373 now += sec_etc;
1374
1375 char *etc = ctime (&now);
1376
1377 size_t etc_len = strlen (etc);
1378
1379 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1380 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1381
1382 if (data.runtime)
1383 {
1384 time_t runtime_cur;
1385
1386 time (&runtime_cur);
1387
1388 #ifdef WIN
1389
1390 __time64_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1391
1392 tmp = _gmtime64 (&runtime_left);
1393
1394 #else
1395
1396 time_t runtime_left = data.proc_start + data.runtime - runtime_cur;
1397
1398 tmp = gmtime (&runtime_left);
1399
1400 #endif
1401
1402 if ((tmp != NULL) && (runtime_left > 0) && (runtime_left < sec_etc))
1403 {
1404 memcpy (&tm_runtime, tmp, sizeof (tm_runtime));
1405
1406 format_timer_display (&tm_runtime, display_runtime, sizeof (display_runtime));
1407
1408 log_info ("Time.Estimated.: %s (%s), but limited (%s)", etc, display_etc, display_runtime);
1409 }
1410 else
1411 {
1412 log_info ("Time.Estimated.: %s (%s), but limit exceeded", etc, display_etc);
1413 }
1414 }
1415 else
1416 {
1417 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1418 }
1419 }
1420 }
1421 }
1422 }
1423
1424 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1425 {
1426 hc_device_param_t *device_param = &data.devices_param[device_id];
1427
1428 if (device_param->skipped) continue;
1429
1430 char display_dev_cur[16] = { 0 };
1431
1432 strncpy (display_dev_cur, "0.00", 4);
1433
1434 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1435
1436 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1437 }
1438
1439 char display_all_cur[16] = { 0 };
1440
1441 strncpy (display_all_cur, "0.00", 4);
1442
1443 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1444
1445 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1446
1447 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1448 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1449
1450 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);
1451
1452 // crack-per-time
1453
1454 if (data.digests_cnt > 100)
1455 {
1456 time_t now = time (NULL);
1457
1458 int cpt_cur_min = 0;
1459 int cpt_cur_hour = 0;
1460 int cpt_cur_day = 0;
1461
1462 for (int i = 0; i < CPT_BUF; i++)
1463 {
1464 const uint cracked = data.cpt_buf[i].cracked;
1465 const time_t timestamp = data.cpt_buf[i].timestamp;
1466
1467 if ((timestamp + 60) > now)
1468 {
1469 cpt_cur_min += cracked;
1470 }
1471
1472 if ((timestamp + 3600) > now)
1473 {
1474 cpt_cur_hour += cracked;
1475 }
1476
1477 if ((timestamp + 86400) > now)
1478 {
1479 cpt_cur_day += cracked;
1480 }
1481 }
1482
1483 double ms_real = ms_running - ms_paused;
1484
1485 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1486 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1487 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1488
1489 if ((data.cpt_start + 86400) < now)
1490 {
1491 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1492 cpt_cur_min,
1493 cpt_cur_hour,
1494 cpt_cur_day,
1495 cpt_avg_min,
1496 cpt_avg_hour,
1497 cpt_avg_day);
1498 }
1499 else if ((data.cpt_start + 3600) < now)
1500 {
1501 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1502 cpt_cur_min,
1503 cpt_cur_hour,
1504 cpt_avg_min,
1505 cpt_avg_hour,
1506 cpt_avg_day);
1507 }
1508 else if ((data.cpt_start + 60) < now)
1509 {
1510 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1511 cpt_cur_min,
1512 cpt_avg_min,
1513 cpt_avg_hour,
1514 cpt_avg_day);
1515 }
1516 else
1517 {
1518 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1519 cpt_avg_min,
1520 cpt_avg_hour,
1521 cpt_avg_day);
1522 }
1523 }
1524
1525 // Restore point
1526
1527 u64 restore_point = get_lowest_words_done ();
1528
1529 u64 restore_total = data.words_base;
1530
1531 float percent_restore = 0;
1532
1533 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1534
1535 if (progress_end_relative_skip)
1536 {
1537 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1538 {
1539 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1540 float percent_rejected = 0.0;
1541
1542 if (progress_cur)
1543 {
1544 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1545 }
1546
1547 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);
1548 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1549
1550 if (data.restore_disable == 0)
1551 {
1552 if (percent_finished != 1)
1553 {
1554 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1555 }
1556 }
1557 }
1558 }
1559 else
1560 {
1561 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1562 {
1563 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1564 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1565
1566 if (data.restore_disable == 0)
1567 {
1568 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1569 }
1570 }
1571 else
1572 {
1573 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1574 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1575
1576 // --restore not allowed if stdin is used -- really? why?
1577
1578 //if (data.restore_disable == 0)
1579 //{
1580 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1581 //}
1582 }
1583 }
1584
1585 #ifdef HAVE_HWMON
1586
1587 if (data.devices_status == STATUS_EXHAUSTED) return;
1588 if (data.devices_status == STATUS_CRACKED) return;
1589 if (data.devices_status == STATUS_ABORTED) return;
1590 if (data.devices_status == STATUS_QUIT) return;
1591
1592 if (data.gpu_temp_disable == 0)
1593 {
1594 hc_thread_mutex_lock (mux_adl);
1595
1596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1597 {
1598 hc_device_param_t *device_param = &data.devices_param[device_id];
1599
1600 if (device_param->skipped) continue;
1601
1602 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1603 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1604 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1605 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1606 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1607 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1608 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1609
1610 char output_buf[256] = { 0 };
1611
1612 int output_len = 0;
1613
1614 if (num_temperature >= 0)
1615 {
1616 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1617
1618 output_len = strlen (output_buf);
1619 }
1620
1621 if (num_fanspeed >= 0)
1622 {
1623 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1624
1625 output_len = strlen (output_buf);
1626 }
1627
1628 if (num_utilization >= 0)
1629 {
1630 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1631
1632 output_len = strlen (output_buf);
1633 }
1634
1635 if (num_corespeed >= 0)
1636 {
1637 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1638
1639 output_len = strlen (output_buf);
1640 }
1641
1642 if (num_memoryspeed >= 0)
1643 {
1644 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1645
1646 output_len = strlen (output_buf);
1647 }
1648
1649 if (num_buslanes >= 0)
1650 {
1651 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1652
1653 output_len = strlen (output_buf);
1654 }
1655
1656 if (num_throttle == 1)
1657 {
1658 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1659
1660 output_len = strlen (output_buf);
1661 }
1662
1663 if (output_len == 0)
1664 {
1665 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1666
1667 output_len = strlen (output_buf);
1668 }
1669
1670 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1671 }
1672
1673 hc_thread_mutex_unlock (mux_adl);
1674 }
1675
1676 #endif // HAVE_HWMON
1677 }
1678
1679 static void status_benchmark_automate ()
1680 {
1681 u64 speed_cnt[DEVICES_MAX] = { 0 };
1682 double speed_ms[DEVICES_MAX] = { 0 };
1683
1684 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1685 {
1686 hc_device_param_t *device_param = &data.devices_param[device_id];
1687
1688 if (device_param->skipped) continue;
1689
1690 speed_cnt[device_id] = device_param->speed_cnt[0];
1691 speed_ms[device_id] = device_param->speed_ms[0];
1692 }
1693
1694 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 hashes_dev_ms[device_id] = 0;
1703
1704 if (speed_ms[device_id])
1705 {
1706 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1707 }
1708 }
1709
1710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1711 {
1712 hc_device_param_t *device_param = &data.devices_param[device_id];
1713
1714 if (device_param->skipped) continue;
1715
1716 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1717 }
1718 }
1719
1720 static void status_benchmark ()
1721 {
1722 if (data.devices_status == STATUS_INIT) return;
1723 if (data.devices_status == STATUS_STARTING) return;
1724
1725 if (data.shutdown_inner == 1) return;
1726
1727 if (data.machine_readable == 1)
1728 {
1729 status_benchmark_automate ();
1730
1731 return;
1732 }
1733
1734 u64 speed_cnt[DEVICES_MAX] = { 0 };
1735 double speed_ms[DEVICES_MAX] = { 0 };
1736
1737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1738 {
1739 hc_device_param_t *device_param = &data.devices_param[device_id];
1740
1741 if (device_param->skipped) continue;
1742
1743 speed_cnt[device_id] = device_param->speed_cnt[0];
1744 speed_ms[device_id] = device_param->speed_ms[0];
1745 }
1746
1747 double hashes_all_ms = 0;
1748
1749 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1750
1751 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1752 {
1753 hc_device_param_t *device_param = &data.devices_param[device_id];
1754
1755 if (device_param->skipped) continue;
1756
1757 hashes_dev_ms[device_id] = 0;
1758
1759 if (speed_ms[device_id])
1760 {
1761 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1762
1763 hashes_all_ms += hashes_dev_ms[device_id];
1764 }
1765 }
1766
1767 /**
1768 * exec time
1769 */
1770
1771 double exec_all_ms[DEVICES_MAX] = { 0 };
1772
1773 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1774 {
1775 hc_device_param_t *device_param = &data.devices_param[device_id];
1776
1777 if (device_param->skipped) continue;
1778
1779 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1780
1781 exec_all_ms[device_id] = exec_ms_avg;
1782 }
1783
1784 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1785 {
1786 hc_device_param_t *device_param = &data.devices_param[device_id];
1787
1788 if (device_param->skipped) continue;
1789
1790 char display_dev_cur[16] = { 0 };
1791
1792 strncpy (display_dev_cur, "0.00", 4);
1793
1794 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1795
1796 if (data.devices_active >= 10)
1797 {
1798 log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1799 }
1800 else
1801 {
1802 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1803 }
1804 }
1805
1806 char display_all_cur[16] = { 0 };
1807
1808 strncpy (display_all_cur, "0.00", 4);
1809
1810 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1811
1812 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1813 }
1814
1815 /**
1816 * hashcat -only- functions
1817 */
1818
1819 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1820 {
1821 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1822 {
1823 if (attack_kern == ATTACK_KERN_STRAIGHT)
1824 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1825 else if (attack_kern == ATTACK_KERN_COMBI)
1826 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1827 else if (attack_kern == ATTACK_KERN_BF)
1828 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1829 }
1830 else
1831 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1832 }
1833
1834 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)
1835 {
1836 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1837 {
1838 if (attack_kern == ATTACK_KERN_STRAIGHT)
1839 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1840 else if (attack_kern == ATTACK_KERN_COMBI)
1841 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1842 else if (attack_kern == ATTACK_KERN_BF)
1843 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1844 }
1845 else
1846 {
1847 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1848 }
1849 }
1850
1851 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1852 {
1853 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1854 {
1855 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1856 }
1857 else
1858 {
1859 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1860 }
1861 }
1862
1863 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)
1864 {
1865 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1866 {
1867 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1868 }
1869 else
1870 {
1871 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1872 }
1873 }
1874
1875 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1876 {
1877 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1878 }
1879
1880 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1881 {
1882 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1883 }
1884
1885 static char *filename_from_filepath (char *filepath)
1886 {
1887 char *ptr = NULL;
1888
1889 if ((ptr = strrchr (filepath, '/')) != NULL)
1890 {
1891 ptr++;
1892 }
1893 else if ((ptr = strrchr (filepath, '\\')) != NULL)
1894 {
1895 ptr++;
1896 }
1897 else
1898 {
1899 ptr = filepath;
1900 }
1901
1902 return ptr;
1903 }
1904
1905 static uint convert_from_hex (char *line_buf, const uint line_len)
1906 {
1907 if (line_len & 1) return (line_len); // not in hex
1908
1909 if (data.hex_wordlist == 1)
1910 {
1911 uint i;
1912 uint j;
1913
1914 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1915 {
1916 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1917 }
1918
1919 memset (line_buf + i, 0, line_len - i);
1920
1921 return (i);
1922 }
1923 else if (line_len >= 6) // $HEX[] = 6
1924 {
1925 if (line_buf[0] != '$') return (line_len);
1926 if (line_buf[1] != 'H') return (line_len);
1927 if (line_buf[2] != 'E') return (line_len);
1928 if (line_buf[3] != 'X') return (line_len);
1929 if (line_buf[4] != '[') return (line_len);
1930 if (line_buf[line_len - 1] != ']') return (line_len);
1931
1932 uint i;
1933 uint j;
1934
1935 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1936 {
1937 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1938 }
1939
1940 memset (line_buf + i, 0, line_len - i);
1941
1942 return (i);
1943 }
1944
1945 return (line_len);
1946 }
1947
1948 static void clear_prompt ()
1949 {
1950 fputc ('\r', stdout);
1951
1952 for (size_t i = 0; i < strlen (PROMPT); i++)
1953 {
1954 fputc (' ', stdout);
1955 }
1956
1957 fputc ('\r', stdout);
1958
1959 fflush (stdout);
1960 }
1961
1962 static int gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1963 {
1964 cl_int CL_err = 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);
1965
1966 if (CL_err != CL_SUCCESS)
1967 {
1968 log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
1969
1970 return -1;
1971 }
1972
1973 return 0;
1974 }
1975
1976 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1977 {
1978 char *outfile = data.outfile;
1979 uint quiet = data.quiet;
1980 FILE *pot_fp = data.pot_fp;
1981 uint loopback = data.loopback;
1982 uint debug_mode = data.debug_mode;
1983 char *debug_file = data.debug_file;
1984
1985 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1986 int debug_rule_len = 0; // -1 error
1987 uint debug_plain_len = 0;
1988
1989 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1990
1991 // hash
1992
1993 char out_buf[HCBUFSIZ] = { 0 };
1994
1995 const u32 salt_pos = plain->salt_pos;
1996 const u32 digest_pos = plain->digest_pos; // relative
1997 const u32 gidvid = plain->gidvid;
1998 const u32 il_pos = plain->il_pos;
1999
2000 ascii_digest (out_buf, salt_pos, digest_pos);
2001
2002 // plain
2003
2004 u64 crackpos = device_param->words_off;
2005
2006 uint plain_buf[16] = { 0 };
2007
2008 u8 *plain_ptr = (u8 *) plain_buf;
2009
2010 unsigned int plain_len = 0;
2011
2012 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2013 {
2014 pw_t pw;
2015
2016 gidd_to_pw_t (device_param, gidvid, &pw);
2017
2018 for (int i = 0; i < 16; i++)
2019 {
2020 plain_buf[i] = pw.i[i];
2021 }
2022
2023 plain_len = pw.pw_len;
2024
2025 const uint off = device_param->innerloop_pos + il_pos;
2026
2027 if (debug_mode > 0)
2028 {
2029 debug_rule_len = 0;
2030
2031 // save rule
2032 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
2033 {
2034 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
2035
2036 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
2037 }
2038
2039 // save plain
2040 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
2041 {
2042 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
2043
2044 memcpy (debug_plain_ptr, plain_ptr, plain_len);
2045
2046 debug_plain_len = plain_len;
2047 }
2048 }
2049
2050 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2051
2052 crackpos += gidvid;
2053 crackpos *= data.kernel_rules_cnt;
2054 crackpos += device_param->innerloop_pos + il_pos;
2055
2056 if (plain_len > data.pw_max) plain_len = data.pw_max;
2057 }
2058 else if (data.attack_mode == ATTACK_MODE_COMBI)
2059 {
2060 pw_t pw;
2061
2062 gidd_to_pw_t (device_param, gidvid, &pw);
2063
2064 for (int i = 0; i < 16; i++)
2065 {
2066 plain_buf[i] = pw.i[i];
2067 }
2068
2069 plain_len = pw.pw_len;
2070
2071 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2072 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2073
2074 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2075 {
2076 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2077 }
2078 else
2079 {
2080 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2081
2082 memcpy (plain_ptr, comb_buf, comb_len);
2083 }
2084
2085 plain_len += comb_len;
2086
2087 crackpos += gidvid;
2088 crackpos *= data.combs_cnt;
2089 crackpos += device_param->innerloop_pos + il_pos;
2090
2091 if (data.pw_max != PW_DICTMAX1)
2092 {
2093 if (plain_len > data.pw_max) plain_len = data.pw_max;
2094 }
2095 }
2096 else if (data.attack_mode == ATTACK_MODE_BF)
2097 {
2098 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2099 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2100
2101 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2102 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2103
2104 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2105 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2106
2107 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2108 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2109
2110 plain_len = data.css_cnt;
2111
2112 crackpos += gidvid;
2113 crackpos *= data.bfs_cnt;
2114 crackpos += device_param->innerloop_pos + il_pos;
2115 }
2116 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2117 {
2118 pw_t pw;
2119
2120 gidd_to_pw_t (device_param, gidvid, &pw);
2121
2122 for (int i = 0; i < 16; i++)
2123 {
2124 plain_buf[i] = pw.i[i];
2125 }
2126
2127 plain_len = pw.pw_len;
2128
2129 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2130
2131 uint start = 0;
2132 uint stop = device_param->kernel_params_mp_buf32[4];
2133
2134 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2135
2136 plain_len += start + stop;
2137
2138 crackpos += gidvid;
2139 crackpos *= data.combs_cnt;
2140 crackpos += device_param->innerloop_pos + il_pos;
2141
2142 if (data.pw_max != PW_DICTMAX1)
2143 {
2144 if (plain_len > data.pw_max) plain_len = data.pw_max;
2145 }
2146 }
2147 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2148 {
2149 pw_t pw;
2150
2151 gidd_to_pw_t (device_param, gidvid, &pw);
2152
2153 for (int i = 0; i < 16; i++)
2154 {
2155 plain_buf[i] = pw.i[i];
2156 }
2157
2158 plain_len = pw.pw_len;
2159
2160 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2161
2162 uint start = 0;
2163 uint stop = device_param->kernel_params_mp_buf32[4];
2164
2165 memmove (plain_ptr + stop, plain_ptr, plain_len);
2166
2167 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2168
2169 plain_len += start + stop;
2170
2171 crackpos += gidvid;
2172 crackpos *= data.combs_cnt;
2173 crackpos += device_param->innerloop_pos + il_pos;
2174
2175 if (data.pw_max != PW_DICTMAX1)
2176 {
2177 if (plain_len > data.pw_max) plain_len = data.pw_max;
2178 }
2179 }
2180
2181 if (data.attack_mode == ATTACK_MODE_BF)
2182 {
2183 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2184 {
2185 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2186 {
2187 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2188 {
2189 plain_len = plain_len - data.salts_buf[0].salt_len;
2190 }
2191 }
2192
2193 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2194 {
2195 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2196 {
2197 plain_ptr[j] = plain_ptr[i];
2198 }
2199
2200 plain_len = plain_len / 2;
2201 }
2202 }
2203 }
2204
2205 // if enabled, update also the potfile
2206
2207 if (pot_fp)
2208 {
2209 lock_file (pot_fp);
2210
2211 fprintf (pot_fp, "%s:", out_buf);
2212
2213 format_plain (pot_fp, plain_ptr, plain_len, 1);
2214
2215 fputc ('\n', pot_fp);
2216
2217 fflush (pot_fp);
2218
2219 unlock_file (pot_fp);
2220 }
2221
2222 // outfile
2223
2224 FILE *out_fp = NULL;
2225
2226 if (outfile != NULL)
2227 {
2228 if ((out_fp = fopen (outfile, "ab")) == NULL)
2229 {
2230 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2231
2232 out_fp = stdout;
2233 }
2234
2235 lock_file (out_fp);
2236 }
2237 else
2238 {
2239 out_fp = stdout;
2240
2241 if (quiet == 0) clear_prompt ();
2242 }
2243
2244 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2245
2246 if (outfile != NULL)
2247 {
2248 if (out_fp != stdout)
2249 {
2250 fclose (out_fp);
2251 }
2252 }
2253 else
2254 {
2255 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2256 {
2257 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2258 {
2259 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2260 if (quiet == 0) fflush (stdout);
2261 }
2262 }
2263 }
2264
2265 // loopback
2266
2267 if (loopback)
2268 {
2269 char *loopback_file = data.loopback_file;
2270
2271 FILE *fb_fp = NULL;
2272
2273 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2274 {
2275 lock_file (fb_fp);
2276
2277 format_plain (fb_fp, plain_ptr, plain_len, 1);
2278
2279 fputc ('\n', fb_fp);
2280
2281 fclose (fb_fp);
2282 }
2283 }
2284
2285 // (rule) debug mode
2286
2287 // the next check implies that:
2288 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2289 // - debug_mode > 0
2290
2291 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2292 {
2293 if (debug_rule_len < 0) debug_rule_len = 0;
2294
2295 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2296
2297 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2298
2299 if ((quiet == 0) && (debug_file == NULL))
2300 {
2301 fprintf (stdout, "%s", PROMPT);
2302
2303 fflush (stdout);
2304 }
2305 }
2306 }
2307
2308 static int check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2309 {
2310 salt_t *salt_buf = &data.salts_buf[salt_pos];
2311
2312 u32 num_cracked;
2313
2314 cl_int CL_err;
2315
2316 CL_err = hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2317
2318 if (CL_err != CL_SUCCESS)
2319 {
2320 log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
2321
2322 return -1;
2323 }
2324
2325 if (num_cracked)
2326 {
2327 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2328
2329 log_info_nn ("");
2330
2331 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2332
2333 CL_err = 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);
2334
2335 if (CL_err != CL_SUCCESS)
2336 {
2337 log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
2338
2339 return -1;
2340 }
2341
2342 uint cpt_cracked = 0;
2343
2344 hc_thread_mutex_lock (mux_display);
2345
2346 for (uint i = 0; i < num_cracked; i++)
2347 {
2348 const uint hash_pos = cracked[i].hash_pos;
2349
2350 if (data.digests_shown[hash_pos] == 1) continue;
2351
2352 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2353 {
2354 data.digests_shown[hash_pos] = 1;
2355
2356 data.digests_done++;
2357
2358 cpt_cracked++;
2359
2360 salt_buf->digests_done++;
2361
2362 if (salt_buf->digests_done == salt_buf->digests_cnt)
2363 {
2364 data.salts_shown[salt_pos] = 1;
2365
2366 data.salts_done++;
2367 }
2368 }
2369
2370 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2371
2372 check_hash (device_param, &cracked[i]);
2373 }
2374
2375 hc_thread_mutex_unlock (mux_display);
2376
2377 myfree (cracked);
2378
2379 if (cpt_cracked > 0)
2380 {
2381 hc_thread_mutex_lock (mux_display);
2382
2383 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2384 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2385
2386 data.cpt_pos++;
2387
2388 data.cpt_total += cpt_cracked;
2389
2390 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2391
2392 hc_thread_mutex_unlock (mux_display);
2393 }
2394
2395 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2396 {
2397 // we need to reset cracked state on the device
2398 // otherwise host thinks again and again the hash was cracked
2399 // and returns invalid password each time
2400
2401 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2402
2403 CL_err = 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);
2404
2405 if (CL_err != CL_SUCCESS)
2406 {
2407 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
2408
2409 return -1;
2410 }
2411 }
2412
2413 num_cracked = 0;
2414
2415 CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2416
2417 if (CL_err != CL_SUCCESS)
2418 {
2419 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
2420
2421 return -1;
2422 }
2423 }
2424
2425 return 0;
2426 }
2427
2428 // stolen from princeprocessor ;)
2429
2430 typedef struct
2431 {
2432 FILE *fp;
2433
2434 char buf[BUFSIZ];
2435 int len;
2436
2437 } out_t;
2438
2439 static void out_flush (out_t *out)
2440 {
2441 fwrite (out->buf, 1, out->len, out->fp);
2442
2443 out->len = 0;
2444 }
2445
2446 static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
2447 {
2448 char *ptr = out->buf + out->len;
2449
2450 memcpy (ptr, pw_buf, pw_len);
2451
2452 ptr[pw_len] = '\n';
2453
2454 out->len += pw_len + 1;
2455
2456 if (out->len >= BUFSIZ - 100)
2457 {
2458 out_flush (out);
2459 }
2460 }
2461
2462 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2463 {
2464 out_t out;
2465
2466 out.fp = stdout;
2467 out.len = 0;
2468
2469 uint plain_buf[16] = { 0 };
2470
2471 u8 *plain_ptr = (u8 *) plain_buf;
2472
2473 uint plain_len = 0;
2474
2475 const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know
2476
2477 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2478 {
2479 pw_t pw;
2480
2481 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2482 {
2483 gidd_to_pw_t (device_param, gidvid, &pw);
2484
2485 const uint pos = device_param->innerloop_pos;
2486
2487 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2488 {
2489 for (int i = 0; i < 8; i++)
2490 {
2491 plain_buf[i] = pw.i[i];
2492 }
2493
2494 plain_len = pw.pw_len;
2495
2496 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2497
2498 if (plain_len > data.pw_max) plain_len = data.pw_max;
2499
2500 out_push (&out, plain_ptr, plain_len);
2501 }
2502 }
2503 }
2504 else if (data.attack_mode == ATTACK_MODE_COMBI)
2505 {
2506 pw_t pw;
2507
2508 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2509 {
2510 gidd_to_pw_t (device_param, gidvid, &pw);
2511
2512 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2513 {
2514 for (int i = 0; i < 8; i++)
2515 {
2516 plain_buf[i] = pw.i[i];
2517 }
2518
2519 plain_len = pw.pw_len;
2520
2521 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2522 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2523
2524 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2525 {
2526 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2527 }
2528 else
2529 {
2530 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2531
2532 memcpy (plain_ptr, comb_buf, comb_len);
2533 }
2534
2535 plain_len += comb_len;
2536
2537 if (data.pw_max != PW_DICTMAX1)
2538 {
2539 if (plain_len > data.pw_max) plain_len = data.pw_max;
2540 }
2541
2542 out_push (&out, plain_ptr, plain_len);
2543 }
2544 }
2545 }
2546 else if (data.attack_mode == ATTACK_MODE_BF)
2547 {
2548 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2549 {
2550 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2551 {
2552 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2553 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2554
2555 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2556 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2557
2558 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2559 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2560
2561 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2562 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2563
2564 plain_len = data.css_cnt;
2565
2566 out_push (&out, plain_ptr, plain_len);
2567 }
2568 }
2569 }
2570 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2571 {
2572 pw_t pw;
2573
2574 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2575 {
2576 gidd_to_pw_t (device_param, gidvid, &pw);
2577
2578 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2579 {
2580 for (int i = 0; i < 8; i++)
2581 {
2582 plain_buf[i] = pw.i[i];
2583 }
2584
2585 plain_len = pw.pw_len;
2586
2587 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2588
2589 uint start = 0;
2590 uint stop = device_param->kernel_params_mp_buf32[4];
2591
2592 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2593
2594 plain_len += start + stop;
2595
2596 out_push (&out, plain_ptr, plain_len);
2597 }
2598 }
2599 }
2600 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2601 {
2602 pw_t pw;
2603
2604 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2605 {
2606 gidd_to_pw_t (device_param, gidvid, &pw);
2607
2608 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2609 {
2610 for (int i = 0; i < 8; i++)
2611 {
2612 plain_buf[i] = pw.i[i];
2613 }
2614
2615 plain_len = pw.pw_len;
2616
2617 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2618
2619 uint start = 0;
2620 uint stop = device_param->kernel_params_mp_buf32[4];
2621
2622 memmove (plain_ptr + stop, plain_ptr, plain_len);
2623
2624 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2625
2626 plain_len += start + stop;
2627
2628 out_push (&out, plain_ptr, plain_len);
2629 }
2630 }
2631 }
2632
2633 out_flush (&out);
2634 }
2635
2636 static void save_hash ()
2637 {
2638 char *hashfile = data.hashfile;
2639
2640 char new_hashfile[256] = { 0 };
2641 char old_hashfile[256] = { 0 };
2642
2643 snprintf (new_hashfile, 255, "%s.new", hashfile);
2644 snprintf (old_hashfile, 255, "%s.old", hashfile);
2645
2646 unlink (new_hashfile);
2647
2648 char separator = data.separator;
2649
2650 FILE *fp = fopen (new_hashfile, "wb");
2651
2652 if (fp == NULL)
2653 {
2654 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2655
2656 exit (-1);
2657 }
2658
2659 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2660 {
2661 if (data.salts_shown[salt_pos] == 1) continue;
2662
2663 salt_t *salt_buf = &data.salts_buf[salt_pos];
2664
2665 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2666 {
2667 uint idx = salt_buf->digests_offset + digest_pos;
2668
2669 if (data.digests_shown[idx] == 1) continue;
2670
2671 if (data.hash_mode != 2500)
2672 {
2673 if (data.username == 1)
2674 {
2675 user_t *user = data.hash_info[idx]->user;
2676
2677 uint i;
2678
2679 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2680
2681 fputc (separator, fp);
2682 }
2683
2684 char out_buf[HCBUFSIZ]; // scratch buffer
2685
2686 out_buf[0] = 0;
2687
2688 ascii_digest (out_buf, salt_pos, digest_pos);
2689
2690 fputs (out_buf, fp);
2691
2692 fputc ('\n', fp);
2693 }
2694 else
2695 {
2696 hccap_t hccap;
2697
2698 to_hccap_t (&hccap, salt_pos, digest_pos);
2699
2700 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2701 }
2702 }
2703 }
2704
2705 fflush (fp);
2706
2707 fclose (fp);
2708
2709 unlink (old_hashfile);
2710
2711 if (rename (hashfile, old_hashfile) != 0)
2712 {
2713 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2714
2715 exit (-1);
2716 }
2717
2718 unlink (hashfile);
2719
2720 if (rename (new_hashfile, hashfile) != 0)
2721 {
2722 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2723
2724 exit (-1);
2725 }
2726
2727 unlink (old_hashfile);
2728 }
2729
2730 static int run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2731 {
2732 cl_int CL_err = CL_SUCCESS;
2733
2734 uint num_elements = num;
2735
2736 device_param->kernel_params_buf32[33] = data.combs_mode;
2737 device_param->kernel_params_buf32[34] = num;
2738
2739 uint kernel_threads = device_param->kernel_threads;
2740
2741 while (num_elements % kernel_threads) num_elements++;
2742
2743 cl_kernel kernel = NULL;
2744
2745 switch (kern_run)
2746 {
2747 case KERN_RUN_1: kernel = device_param->kernel1; break;
2748 case KERN_RUN_12: kernel = device_param->kernel12; break;
2749 case KERN_RUN_2: kernel = device_param->kernel2; break;
2750 case KERN_RUN_23: kernel = device_param->kernel23; break;
2751 case KERN_RUN_3: kernel = device_param->kernel3; break;
2752 }
2753
2754 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2755 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2756 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2757 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2758 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2759 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2760 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2761 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2762 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]);
2763 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]);
2764 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]);
2765
2766 if (CL_err != CL_SUCCESS)
2767 {
2768 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
2769
2770 return -1;
2771 }
2772
2773 cl_event event;
2774
2775 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2776 {
2777 const size_t global_work_size[3] = { num_elements, 32, 1 };
2778 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2779
2780 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2781
2782 if (CL_err != CL_SUCCESS)
2783 {
2784 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2785
2786 return -1;
2787 }
2788 }
2789 else
2790 {
2791 if (kern_run == KERN_RUN_2)
2792 {
2793 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2794 {
2795 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2796 }
2797 }
2798
2799 while (num_elements % kernel_threads) num_elements++;
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 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2805
2806 if (CL_err != CL_SUCCESS)
2807 {
2808 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2809
2810 return -1;
2811 }
2812 }
2813
2814 CL_err = hc_clFlush (data.ocl, device_param->command_queue);
2815
2816 if (CL_err != CL_SUCCESS)
2817 {
2818 log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
2819
2820 return -1;
2821 }
2822
2823 if (device_param->nvidia_spin_damp)
2824 {
2825 if (data.devices_status == STATUS_RUNNING)
2826 {
2827 if (iteration < EXPECTED_ITERATIONS)
2828 {
2829 switch (kern_run)
2830 {
2831 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break;
2832 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break;
2833 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break;
2834 }
2835 }
2836 }
2837 }
2838
2839 CL_err = hc_clWaitForEvents (data.ocl, 1, &event);
2840
2841 if (CL_err != CL_SUCCESS)
2842 {
2843 log_error ("ERROR: clWaitForEvents(): %s\n", val2cstr_cl (CL_err));
2844
2845 return -1;
2846 }
2847
2848 cl_ulong time_start;
2849 cl_ulong time_end;
2850
2851 CL_err |= hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2852 CL_err |= hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2853
2854 if (CL_err != CL_SUCCESS)
2855 {
2856 log_error ("ERROR: clGetEventProfilingInfo(): %s\n", val2cstr_cl (CL_err));
2857
2858 return -1;
2859 }
2860
2861 const double exec_us = (double) (time_end - time_start) / 1000;
2862
2863 if (data.devices_status == STATUS_RUNNING)
2864 {
2865 if (iteration < EXPECTED_ITERATIONS)
2866 {
2867 switch (kern_run)
2868 {
2869 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2870 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2871 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2872 }
2873 }
2874 }
2875
2876 if (event_update)
2877 {
2878 uint exec_pos = device_param->exec_pos;
2879
2880 device_param->exec_ms[exec_pos] = exec_us / 1000;
2881
2882 exec_pos++;
2883
2884 if (exec_pos == EXEC_CACHE)
2885 {
2886 exec_pos = 0;
2887 }
2888
2889 device_param->exec_pos = exec_pos;
2890 }
2891
2892 CL_err = hc_clReleaseEvent (data.ocl, event);
2893
2894 if (CL_err != CL_SUCCESS)
2895 {
2896 log_error ("ERROR: clReleaseEvent(): %s\n", val2cstr_cl (CL_err));
2897
2898 return -1;
2899 }
2900
2901 CL_err = hc_clFinish (data.ocl, device_param->command_queue);
2902
2903 if (CL_err != CL_SUCCESS)
2904 {
2905 log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
2906
2907 return -1;
2908 }
2909
2910 return 0;
2911 }
2912
2913 static int run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2914 {
2915 cl_int CL_err = CL_SUCCESS;
2916
2917 uint num_elements = num;
2918
2919 switch (kern_run)
2920 {
2921 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2922 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2923 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2924 }
2925
2926 // causes problems with special threads like in bcrypt
2927 // const uint kernel_threads = device_param->kernel_threads;
2928
2929 uint kernel_threads = device_param->kernel_threads;
2930
2931 while (num_elements % kernel_threads) num_elements++;
2932
2933 cl_kernel kernel = NULL;
2934
2935 switch (kern_run)
2936 {
2937 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2938 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2939 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2940 }
2941
2942 switch (kern_run)
2943 {
2944 case KERN_RUN_MP: CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2945 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2946 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2947 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2948 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2949 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2950 break;
2951 case KERN_RUN_MP_R: CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2952 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2953 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2954 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2955 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2956 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2957 break;
2958 case KERN_RUN_MP_L: CL_err |= hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2959 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2960 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2961 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2962 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2963 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2964 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2965 break;
2966 }
2967
2968 if (CL_err != CL_SUCCESS)
2969 {
2970 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
2971
2972 return -1;
2973 }
2974
2975 const size_t global_work_size[3] = { num_elements, 1, 1 };
2976 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2977
2978 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2979
2980 if (CL_err != CL_SUCCESS)
2981 {
2982 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
2983
2984 return -1;
2985 }
2986
2987 CL_err = hc_clFlush (data.ocl, device_param->command_queue);
2988
2989 if (CL_err != CL_SUCCESS)
2990 {
2991 log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
2992
2993 return -1;
2994 }
2995
2996 CL_err = hc_clFinish (data.ocl, device_param->command_queue);
2997
2998 if (CL_err != CL_SUCCESS)
2999 {
3000 log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3001
3002 return -1;
3003 }
3004
3005 return 0;
3006 }
3007
3008 static int run_kernel_tm (hc_device_param_t *device_param)
3009 {
3010 cl_int CL_err = CL_SUCCESS;
3011
3012 const uint num_elements = 1024; // fixed
3013
3014 uint kernel_threads = 32;
3015
3016 cl_kernel kernel = device_param->kernel_tm;
3017
3018 const size_t global_work_size[3] = { num_elements, 1, 1 };
3019 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
3020
3021 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3022
3023 if (CL_err != CL_SUCCESS)
3024 {
3025 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3026
3027 return -1;
3028 }
3029
3030 CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3031
3032 if (CL_err != CL_SUCCESS)
3033 {
3034 log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3035
3036 return -1;
3037 }
3038
3039 CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3040
3041 if (CL_err != CL_SUCCESS)
3042 {
3043 log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3044
3045 return -1;
3046 }
3047
3048 return 0;
3049 }
3050
3051 static int run_kernel_amp (hc_device_param_t *device_param, const uint num)
3052 {
3053 cl_int CL_err = CL_SUCCESS;
3054
3055 uint num_elements = num;
3056
3057 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
3058 device_param->kernel_params_amp_buf32[6] = num_elements;
3059
3060 // causes problems with special threads like in bcrypt
3061 // const uint kernel_threads = device_param->kernel_threads;
3062
3063 uint kernel_threads = device_param->kernel_threads;
3064
3065 while (num_elements % kernel_threads) num_elements++;
3066
3067 cl_kernel kernel = device_param->kernel_amp;
3068
3069 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
3070 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
3071
3072 if (CL_err != CL_SUCCESS)
3073 {
3074 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
3075
3076 return -1;
3077 }
3078
3079 const size_t global_work_size[3] = { num_elements, 1, 1 };
3080 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
3081
3082 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3083
3084 if (CL_err != CL_SUCCESS)
3085 {
3086 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3087
3088 return -1;
3089 }
3090
3091 CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3092
3093 if (CL_err != CL_SUCCESS)
3094 {
3095 log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3096
3097 return -1;
3098 }
3099
3100 CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3101
3102 if (CL_err != CL_SUCCESS)
3103 {
3104 log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3105
3106 return -1;
3107 }
3108
3109 return 0;
3110 }
3111
3112 static int run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
3113 {
3114 cl_int CL_err = CL_SUCCESS;
3115
3116 const u32 num16d = num / 16;
3117 const u32 num16m = num % 16;
3118
3119 if (num16d)
3120 {
3121 device_param->kernel_params_memset_buf32[1] = value;
3122 device_param->kernel_params_memset_buf32[2] = num16d;
3123
3124 uint kernel_threads = device_param->kernel_threads;
3125
3126 uint num_elements = num16d;
3127
3128 while (num_elements % kernel_threads) num_elements++;
3129
3130 cl_kernel kernel = device_param->kernel_memset;
3131
3132 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
3133 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
3134 CL_err |= hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
3135
3136 if (CL_err != CL_SUCCESS)
3137 {
3138 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
3139
3140 return -1;
3141 }
3142
3143 const size_t global_work_size[3] = { num_elements, 1, 1 };
3144 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
3145
3146 CL_err = hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
3147
3148 if (CL_err != CL_SUCCESS)
3149 {
3150 log_error ("ERROR: clEnqueueNDRangeKernel(): %s\n", val2cstr_cl (CL_err));
3151
3152 return -1;
3153 }
3154
3155 CL_err = hc_clFlush (data.ocl, device_param->command_queue);
3156
3157 if (CL_err != CL_SUCCESS)
3158 {
3159 log_error ("ERROR: clFlush(): %s\n", val2cstr_cl (CL_err));
3160
3161 return -1;
3162 }
3163
3164 CL_err = hc_clFinish (data.ocl, device_param->command_queue);
3165
3166 if (CL_err != CL_SUCCESS)
3167 {
3168 log_error ("ERROR: clFinish(): %s\n", val2cstr_cl (CL_err));
3169
3170 return -1;
3171 }
3172 }
3173
3174 if (num16m)
3175 {
3176 u32 tmp[4];
3177
3178 tmp[0] = value;
3179 tmp[1] = value;
3180 tmp[2] = value;
3181 tmp[3] = value;
3182
3183 CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
3184
3185 if (CL_err != CL_SUCCESS)
3186 {
3187 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3188
3189 return -1;
3190 }
3191 }
3192
3193 return 0;
3194 }
3195
3196 static int run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
3197 {
3198 return run_kernel_memset (device_param, buf, 0, size);
3199 }
3200
3201 static int 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)
3202 {
3203 cl_int CL_err = CL_SUCCESS;
3204
3205 if (data.hash_mode == 2000)
3206 {
3207 process_stdout (device_param, pws_cnt);
3208
3209 return 0;
3210 }
3211
3212 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3213 {
3214 if (attack_mode == ATTACK_MODE_BF)
3215 {
3216 if (opts_type & OPTS_TYPE_PT_BITSLICE)
3217 {
3218 const uint size_tm = 32 * sizeof (bs_word_t);
3219
3220 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
3221
3222 run_kernel_tm (device_param);
3223
3224 CL_err = 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);
3225
3226 if (CL_err != CL_SUCCESS)
3227 {
3228 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3229
3230 return -1;
3231 }
3232 }
3233 }
3234
3235 if (highest_pw_len < 16)
3236 {
3237 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
3238 }
3239 else if (highest_pw_len < 32)
3240 {
3241 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
3242 }
3243 else
3244 {
3245 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
3246 }
3247 }
3248 else
3249 {
3250 run_kernel_amp (device_param, pws_cnt);
3251
3252 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
3253
3254 if (opts_type & OPTS_TYPE_HOOK12)
3255 {
3256 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
3257
3258 CL_err = 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);
3259
3260 if (CL_err != CL_SUCCESS)
3261 {
3262 log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
3263
3264 return -1;
3265 }
3266
3267 // do something with data
3268
3269 CL_err = 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);
3270
3271 if (CL_err != CL_SUCCESS)
3272 {
3273 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3274
3275 return -1;
3276 }
3277 }
3278
3279 uint iter = salt_buf->salt_iter;
3280
3281 uint loop_step = device_param->kernel_loops;
3282
3283 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
3284 {
3285 uint loop_left = iter - loop_pos;
3286
3287 loop_left = MIN (loop_left, loop_step);
3288
3289 device_param->kernel_params_buf32[28] = loop_pos;
3290 device_param->kernel_params_buf32[29] = loop_left;
3291
3292 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
3293
3294 if (data.devices_status == STATUS_CRACKED) break;
3295 if (data.devices_status == STATUS_ABORTED) break;
3296 if (data.devices_status == STATUS_QUIT) break;
3297 if (data.devices_status == STATUS_BYPASS) break;
3298
3299 /**
3300 * speed
3301 */
3302
3303 const float iter_part = (float) (loop_pos + loop_left) / iter;
3304
3305 const u64 perf_sum_all = pws_cnt * iter_part;
3306
3307 double speed_ms;
3308
3309 hc_timer_get (device_param->timer_speed, speed_ms);
3310
3311 const u32 speed_pos = device_param->speed_pos;
3312
3313 device_param->speed_cnt[speed_pos] = perf_sum_all;
3314
3315 device_param->speed_ms[speed_pos] = speed_ms;
3316
3317 if (data.benchmark == 1)
3318 {
3319 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
3320 }
3321 }
3322
3323 if (opts_type & OPTS_TYPE_HOOK23)
3324 {
3325 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3326
3327 CL_err = 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);
3328
3329 if (CL_err != CL_SUCCESS)
3330 {
3331 log_error ("ERROR: clEnqueueReadBuffer(): %s\n", val2cstr_cl (CL_err));
3332
3333 return -1;
3334 }
3335
3336 // do something with data
3337
3338 CL_err = 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);
3339
3340 if (CL_err != CL_SUCCESS)
3341 {
3342 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3343
3344 return -1;
3345 }
3346 }
3347
3348 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3349 }
3350
3351 return 0;
3352 }
3353
3354 static int run_rule_engine (const int rule_len, const char *rule_buf)
3355 {
3356 if (rule_len == 0)
3357 {
3358 return 0;
3359 }
3360 else if (rule_len == 1)
3361 {
3362 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3363 }
3364
3365 return 1;
3366 }
3367
3368 static int run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3369 {
3370 cl_int CL_err = CL_SUCCESS;
3371
3372 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3373 {
3374 CL_err = 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);
3375
3376 if (CL_err != CL_SUCCESS)
3377 {
3378 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3379
3380 return -1;
3381 }
3382 }
3383 else if (data.attack_kern == ATTACK_KERN_COMBI)
3384 {
3385 if (data.attack_mode == ATTACK_MODE_COMBI)
3386 {
3387 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3388 {
3389 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3390 {
3391 for (u32 i = 0; i < pws_cnt; i++)
3392 {
3393 const u32 pw_len = device_param->pws_buf[i].pw_len;
3394
3395 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3396
3397 ptr[pw_len] = 0x01;
3398 }
3399 }
3400 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3401 {
3402 for (u32 i = 0; i < pws_cnt; i++)
3403 {
3404 const u32 pw_len = device_param->pws_buf[i].pw_len;
3405
3406 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3407
3408 ptr[pw_len] = 0x80;
3409 }
3410 }
3411 }
3412 }
3413 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3414 {
3415 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3416 {
3417 for (u32 i = 0; i < pws_cnt; i++)
3418 {
3419 const u32 pw_len = device_param->pws_buf[i].pw_len;
3420
3421 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3422
3423 ptr[pw_len] = 0x01;
3424 }
3425 }
3426 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3427 {
3428 for (u32 i = 0; i < pws_cnt; i++)
3429 {
3430 const u32 pw_len = device_param->pws_buf[i].pw_len;
3431
3432 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3433
3434 ptr[pw_len] = 0x80;
3435 }
3436 }
3437 }
3438
3439 CL_err = 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);
3440
3441 if (CL_err != CL_SUCCESS)
3442 {
3443 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3444
3445 return -1;
3446 }
3447 }
3448 else if (data.attack_kern == ATTACK_KERN_BF)
3449 {
3450 const u64 off = device_param->words_off;
3451
3452 device_param->kernel_params_mp_l_buf64[3] = off;
3453
3454 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3455 }
3456
3457 return 0;
3458 }
3459
3460 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3461 {
3462 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3463
3464 device_param->kernel_params_buf32[28] = 0;
3465 device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set
3466 device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3467
3468 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3469 {
3470 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3471 }
3472 else
3473 {
3474 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3475 }
3476
3477 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3478
3479 return exec_ms_prev;
3480 }
3481
3482 static int autotune (hc_device_param_t *device_param)
3483 {
3484 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3485
3486 const u32 kernel_accel_min = device_param->kernel_accel_min;
3487 const u32 kernel_accel_max = device_param->kernel_accel_max;
3488
3489 const u32 kernel_loops_min = device_param->kernel_loops_min;
3490 const u32 kernel_loops_max = device_param->kernel_loops_max;
3491
3492 u32 kernel_accel = kernel_accel_min;
3493 u32 kernel_loops = kernel_loops_min;
3494
3495 // in this case the user specified a fixed -u and -n on the commandline
3496 // no way to tune anything
3497 // but we need to run a few caching rounds
3498
3499 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3500 {
3501 if (data.hash_mode != 2000)
3502 {
3503 try_run (device_param, kernel_accel, kernel_loops);
3504 try_run (device_param, kernel_accel, kernel_loops);
3505 try_run (device_param, kernel_accel, kernel_loops);
3506 try_run (device_param, kernel_accel, kernel_loops);
3507 }
3508
3509 device_param->kernel_accel = kernel_accel;
3510 device_param->kernel_loops = kernel_loops;
3511
3512 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3513
3514 device_param->kernel_power = kernel_power;
3515
3516 return 0;
3517 }
3518
3519 // from here it's clear we are allowed to autotune
3520 // so let's init some fake words
3521
3522 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3523
3524 if (data.attack_kern == ATTACK_KERN_BF)
3525 {
3526 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3527 }
3528 else
3529 {
3530 for (u32 i = 0; i < kernel_power_max; i++)
3531 {
3532 device_param->pws_buf[i].i[0] = i;
3533 device_param->pws_buf[i].i[1] = 0x01234567;
3534 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3535 }
3536
3537 cl_int CL_err = 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);
3538
3539 if (CL_err != CL_SUCCESS)
3540 {
3541 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3542
3543 return -1;
3544 }
3545 }
3546
3547 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3548 {
3549 if (data.kernel_rules_cnt > 1)
3550 {
3551 cl_int CL_err = 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);
3552
3553 if (CL_err != CL_SUCCESS)
3554 {
3555 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3556
3557 return -1;
3558 }
3559 }
3560 }
3561 else
3562 {
3563 run_kernel_amp (device_param, kernel_power_max);
3564 }
3565
3566 #define VERIFIER_CNT 1
3567
3568 // first find out highest kernel-loops that stays below target_ms
3569
3570 if (kernel_loops_min < kernel_loops_max)
3571 {
3572 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3573 {
3574 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3575
3576 for (int i = 0; i < VERIFIER_CNT; i++)
3577 {
3578 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3579
3580 exec_ms = MIN (exec_ms, exec_ms_v);
3581 }
3582
3583 if (exec_ms < target_ms) break;
3584 }
3585 }
3586
3587 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3588
3589 #define STEPS_CNT 10
3590
3591 if (kernel_accel_min < kernel_accel_max)
3592 {
3593 for (int i = 0; i < STEPS_CNT; i++)
3594 {
3595 const u32 kernel_accel_try = 1 << i;
3596
3597 if (kernel_accel_try < kernel_accel_min) continue;
3598 if (kernel_accel_try > kernel_accel_max) break;
3599
3600 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3601
3602 for (int i = 0; i < VERIFIER_CNT; i++)
3603 {
3604 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3605
3606 exec_ms = MIN (exec_ms, exec_ms_v);
3607 }
3608
3609 if (exec_ms > target_ms) break;
3610
3611 kernel_accel = kernel_accel_try;
3612 }
3613 }
3614
3615 // at this point we want to know the actual runtime for the following reason:
3616 // we need a reference for the balancing loop following up, and this
3617 // the balancing loop can have an effect that the creates a new opportunity, for example:
3618 // if the target is 95 ms and the current runtime is 48ms the above loop
3619 // stopped the execution because the previous exec_ms was > 95ms
3620 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3621 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3622
3623 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3624
3625 for (int i = 0; i < VERIFIER_CNT; i++)
3626 {
3627 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3628
3629 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3630 }
3631
3632 u32 diff = kernel_loops - kernel_accel;
3633
3634 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3635 {
3636 u32 kernel_accel_orig = kernel_accel;
3637 u32 kernel_loops_orig = kernel_loops;
3638
3639 for (u32 f = 1; f < 1024; f++)
3640 {
3641 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3642 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3643
3644 if (kernel_accel_try > kernel_accel_max) break;
3645 if (kernel_loops_try < kernel_loops_min) break;
3646
3647 u32 diff_new = kernel_loops_try - kernel_accel_try;
3648
3649 if (diff_new > diff) break;
3650
3651 diff_new = diff;
3652
3653 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3654
3655 for (int i = 0; i < VERIFIER_CNT; i++)
3656 {
3657 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3658
3659 exec_ms = MIN (exec_ms, exec_ms_v);
3660 }
3661
3662 if (exec_ms < exec_ms_pre_final)
3663 {
3664 exec_ms_pre_final = exec_ms;
3665
3666 kernel_accel = kernel_accel_try;
3667 kernel_loops = kernel_loops_try;
3668 }
3669 }
3670 }
3671
3672 const double exec_left = target_ms / exec_ms_pre_final;
3673
3674 const double accel_left = kernel_accel_max / kernel_accel;
3675
3676 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3677
3678 if (exec_accel_min >= 1.0)
3679 {
3680 // this is safe to not overflow kernel_accel_max because of accel_left
3681
3682 kernel_accel = (double) kernel_accel * exec_accel_min;
3683 }
3684
3685 // reset them fake words
3686
3687 /*
3688 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3689
3690 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);
3691 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);
3692 */
3693
3694 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3695
3696 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3697 {
3698 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3699 }
3700
3701 // reset timer
3702
3703 device_param->exec_pos = 0;
3704
3705 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3706
3707 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3708 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3709 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3710
3711 // store
3712
3713 device_param->kernel_accel = kernel_accel;
3714 device_param->kernel_loops = kernel_loops;
3715
3716 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3717
3718 device_param->kernel_power = kernel_power;
3719
3720 #ifdef DEBUG
3721
3722 if (data.quiet == 0)
3723 {
3724 clear_prompt ();
3725
3726 log_info ("- Device #%u: autotuned kernel-accel to %u\n"
3727 "- Device #%u: autotuned kernel-loops to %u\n",
3728 device_param->device_id + 1, kernel_accel,
3729 device_param->device_id + 1, kernel_loops);
3730
3731 fprintf (stdout, "%s", PROMPT);
3732
3733 fflush (stdout);
3734 }
3735
3736 #endif
3737
3738 return 0;
3739 }
3740
3741 static int run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3742 {
3743 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3744
3745 // init speed timer
3746
3747 uint speed_pos = device_param->speed_pos;
3748
3749 #ifdef _POSIX
3750 if (device_param->timer_speed.tv_sec == 0)
3751 {
3752 hc_timer_set (&device_param->timer_speed);
3753 }
3754 #endif
3755
3756 #ifdef _WIN
3757 if (device_param->timer_speed.QuadPart == 0)
3758 {
3759 hc_timer_set (&device_param->timer_speed);
3760 }
3761 #endif
3762
3763 // find higest password length, this is for optimization stuff
3764
3765 uint highest_pw_len = 0;
3766
3767 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3768 {
3769 }
3770 else if (data.attack_kern == ATTACK_KERN_COMBI)
3771 {
3772 }
3773 else if (data.attack_kern == ATTACK_KERN_BF)
3774 {
3775 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3776 + device_param->kernel_params_mp_l_buf32[5];
3777 }
3778
3779 // iteration type
3780
3781 uint innerloop_step = 0;
3782 uint innerloop_cnt = 0;
3783
3784 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3785 else innerloop_step = 1;
3786
3787 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3788 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3789 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3790
3791 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3792
3793 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3794 {
3795 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3796
3797 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3798
3799 if (data.devices_status == STATUS_CRACKED) break;
3800 if (data.devices_status == STATUS_ABORTED) break;
3801 if (data.devices_status == STATUS_QUIT) break;
3802 if (data.devices_status == STATUS_BYPASS) break;
3803
3804 salt_t *salt_buf = &data.salts_buf[salt_pos];
3805
3806 device_param->kernel_params_buf32[27] = salt_pos;
3807 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
3808 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
3809
3810 FILE *combs_fp = device_param->combs_fp;
3811
3812 if (data.attack_mode == ATTACK_MODE_COMBI)
3813 {
3814 rewind (combs_fp);
3815 }
3816
3817 // innerloops
3818
3819 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3820 {
3821 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3822
3823 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3824
3825 if (data.devices_status == STATUS_CRACKED) break;
3826 if (data.devices_status == STATUS_ABORTED) break;
3827 if (data.devices_status == STATUS_QUIT) break;
3828 if (data.devices_status == STATUS_BYPASS) break;
3829
3830 uint fast_iteration = 0;
3831
3832 uint innerloop_left = innerloop_cnt - innerloop_pos;
3833
3834 if (innerloop_left > innerloop_step)
3835 {
3836 innerloop_left = innerloop_step;
3837
3838 fast_iteration = 1;
3839 }
3840
3841 device_param->innerloop_pos = innerloop_pos;
3842 device_param->innerloop_left = innerloop_left;
3843
3844 device_param->kernel_params_buf32[30] = innerloop_left;
3845
3846 // i think we can get rid of this
3847 if (innerloop_left == 0)
3848 {
3849 puts ("bug, how should this happen????\n");
3850
3851 continue;
3852 }
3853
3854 if (data.salts_shown[salt_pos] == 1)
3855 {
3856 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3857
3858 continue;
3859 }
3860
3861 // initialize amplifiers
3862
3863 if (data.attack_mode == ATTACK_MODE_COMBI)
3864 {
3865 uint i = 0;
3866
3867 while (i < innerloop_left)
3868 {
3869 if (feof (combs_fp)) break;
3870
3871 int line_len = fgetl (combs_fp, line_buf);
3872
3873 if (line_len >= PW_MAX1) continue;
3874
3875 line_len = convert_from_hex (line_buf, line_len);
3876
3877 char *line_buf_new = line_buf;
3878
3879 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3880 {
3881 char rule_buf_out[BLOCK_SIZE] = { 0 };
3882
3883 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3884
3885 if (rule_len_out < 0)
3886 {
3887 data.words_progress_rejected[salt_pos] += pws_cnt;
3888
3889 continue;
3890 }
3891
3892 line_len = rule_len_out;
3893
3894 line_buf_new = rule_buf_out;
3895 }
3896
3897 line_len = MIN (line_len, PW_DICTMAX);
3898
3899 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3900
3901 memcpy (ptr, line_buf_new, line_len);
3902
3903 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3904
3905 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3906 {
3907 uppercase (ptr, line_len);
3908 }
3909
3910 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3911 {
3912 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3913 {
3914 ptr[line_len] = 0x80;
3915 }
3916
3917 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3918 {
3919 ptr[line_len] = 0x01;
3920 }
3921 }
3922
3923 device_param->combs_buf[i].pw_len = line_len;
3924
3925 i++;
3926 }
3927
3928 for (uint j = i; j < innerloop_left; j++)
3929 {
3930 device_param->combs_buf[j].i[0] = 0;
3931 device_param->combs_buf[j].i[1] = 0;
3932 device_param->combs_buf[j].i[2] = 0;
3933 device_param->combs_buf[j].i[3] = 0;
3934 device_param->combs_buf[j].i[4] = 0;
3935 device_param->combs_buf[j].i[5] = 0;
3936 device_param->combs_buf[j].i[6] = 0;
3937 device_param->combs_buf[j].i[7] = 0;
3938
3939 device_param->combs_buf[j].pw_len = 0;
3940 }
3941
3942 innerloop_left = i;
3943 }
3944 else if (data.attack_mode == ATTACK_MODE_BF)
3945 {
3946 u64 off = innerloop_pos;
3947
3948 device_param->kernel_params_mp_r_buf64[3] = off;
3949
3950 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3951 }
3952 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3953 {
3954 u64 off = innerloop_pos;
3955
3956 device_param->kernel_params_mp_buf64[3] = off;
3957
3958 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3959 }
3960 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3961 {
3962 u64 off = innerloop_pos;
3963
3964 device_param->kernel_params_mp_buf64[3] = off;
3965
3966 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3967 }
3968
3969 // copy amplifiers
3970
3971 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3972 {
3973 cl_int CL_err = 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);
3974
3975 if (CL_err != CL_SUCCESS)
3976 {
3977 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
3978
3979 return -1;
3980 }
3981 }
3982 else if (data.attack_mode == ATTACK_MODE_COMBI)
3983 {
3984 cl_int CL_err = 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);
3985
3986 if (CL_err != CL_SUCCESS)
3987 {
3988 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
3989
3990 return -1;
3991 }
3992 }
3993 else if (data.attack_mode == ATTACK_MODE_BF)
3994 {
3995 cl_int CL_err = 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);
3996
3997 if (CL_err != CL_SUCCESS)
3998 {
3999 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4000
4001 return -1;
4002 }
4003 }
4004 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
4005 {
4006 cl_int CL_err = 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);
4007
4008 if (CL_err != CL_SUCCESS)
4009 {
4010 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4011
4012 return -1;
4013 }
4014 }
4015 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
4016 {
4017 cl_int CL_err = 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);
4018
4019 if (CL_err != CL_SUCCESS)
4020 {
4021 log_error ("ERROR: clEnqueueCopyBuffer(): %s\n", val2cstr_cl (CL_err));
4022
4023 return -1;
4024 }
4025 }
4026
4027 if (data.benchmark == 1)
4028 {
4029 hc_timer_set (&device_param->timer_speed);
4030 }
4031
4032 int rc = choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
4033
4034 if (rc == -1) return -1;
4035
4036 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4037
4038 if (data.devices_status == STATUS_CRACKED) break;
4039 if (data.devices_status == STATUS_ABORTED) break;
4040 if (data.devices_status == STATUS_QUIT) break;
4041 if (data.devices_status == STATUS_BYPASS) break;
4042
4043 /**
4044 * result
4045 */
4046
4047 if (data.benchmark == 0)
4048 {
4049 check_cracked (device_param, salt_pos);
4050 }
4051
4052 /**
4053 * progress
4054 */
4055
4056 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
4057
4058 hc_thread_mutex_lock (mux_counter);
4059
4060 data.words_progress_done[salt_pos] += perf_sum_all;
4061
4062 hc_thread_mutex_unlock (mux_counter);
4063
4064 /**
4065 * speed
4066 */
4067
4068 double speed_ms;
4069
4070 hc_timer_get (device_param->timer_speed, speed_ms);
4071
4072 hc_timer_set (&device_param->timer_speed);
4073
4074 // current speed
4075
4076 //hc_thread_mutex_lock (mux_display);
4077
4078 device_param->speed_cnt[speed_pos] = perf_sum_all;
4079
4080 device_param->speed_ms[speed_pos] = speed_ms;
4081
4082 //hc_thread_mutex_unlock (mux_display);
4083
4084 speed_pos++;
4085
4086 if (speed_pos == SPEED_CACHE)
4087 {
4088 speed_pos = 0;
4089 }
4090
4091 /**
4092 * benchmark
4093 */
4094
4095 if (data.benchmark == 1) break;
4096 }
4097 }
4098
4099 device_param->speed_pos = speed_pos;
4100
4101 myfree (line_buf);
4102
4103 return 0;
4104 }
4105
4106 static void load_segment (wl_data_t *wl_data, FILE *fd)
4107 {
4108 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
4109
4110 wl_data->pos = 0;
4111
4112 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
4113
4114 wl_data->buf[wl_data->cnt] = 0;
4115
4116 if (wl_data->cnt == 0) return;
4117
4118 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
4119
4120 while (!feof (fd))
4121 {
4122 if (wl_data->cnt == wl_data->avail)
4123 {
4124 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
4125
4126 wl_data->avail += wl_data->incr;
4127 }
4128
4129 const int c = fgetc (fd);
4130
4131 if (c == EOF) break;
4132
4133 wl_data->buf[wl_data->cnt] = (char) c;
4134
4135 wl_data->cnt++;
4136
4137 if (c == '\n') break;
4138 }
4139
4140 // ensure stream ends with a newline
4141
4142 if (wl_data->buf[wl_data->cnt - 1] != '\n')
4143 {
4144 wl_data->cnt++;
4145
4146 wl_data->buf[wl_data->cnt - 1] = '\n';
4147 }
4148
4149 return;
4150 }
4151
4152 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
4153 {
4154 char *ptr = buf;
4155
4156 for (u32 i = 0; i < sz; i++, ptr++)
4157 {
4158 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
4159
4160 if (i == 7)
4161 {
4162 *off = i;
4163 *len = i;
4164
4165 return;
4166 }
4167
4168 if (*ptr != '\n') continue;
4169
4170 *off = i + 1;
4171
4172 if ((i > 0) && (buf[i - 1] == '\r')) i--;
4173
4174 *len = i;
4175
4176 return;
4177 }
4178
4179 *off = sz;
4180 *len = sz;
4181 }
4182
4183 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
4184 {
4185 char *ptr = buf;
4186
4187 for (u32 i = 0; i < sz; i++, ptr++)
4188 {
4189 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
4190
4191 if (*ptr != '\n') continue;
4192
4193 *off = i + 1;
4194
4195 if ((i > 0) && (buf[i - 1] == '\r')) i--;
4196
4197 *len = i;
4198
4199 return;
4200 }
4201
4202 *off = sz;
4203 *len = sz;
4204 }
4205
4206 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
4207 {
4208 char *ptr = buf;
4209
4210 for (u32 i = 0; i < sz; i++, ptr++)
4211 {
4212 if (*ptr != '\n') continue;
4213
4214 *off = i + 1;
4215
4216 if ((i > 0) && (buf[i - 1] == '\r')) i--;
4217
4218 *len = i;
4219
4220 return;
4221 }
4222
4223 *off = sz;
4224 *len = sz;
4225 }
4226
4227 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
4228 {
4229 while (wl_data->pos < wl_data->cnt)
4230 {
4231 uint off;
4232 uint len;
4233
4234 char *ptr = wl_data->buf + wl_data->pos;
4235
4236 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
4237
4238 wl_data->pos += off;
4239
4240 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4241 {
4242 char rule_buf_out[BLOCK_SIZE] = { 0 };
4243
4244 int rule_len_out = -1;
4245
4246 if (len < BLOCK_SIZE)
4247 {
4248 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
4249 }
4250
4251 if (rule_len_out < 0)
4252 {
4253 continue;
4254 }
4255
4256 if (rule_len_out > PW_MAX)
4257 {
4258 continue;
4259 }
4260 }
4261 else
4262 {
4263 if (len > PW_MAX)
4264 {
4265 continue;
4266 }
4267 }
4268
4269 *out_buf = ptr;
4270 *out_len = len;
4271
4272 return;
4273 }
4274
4275 if (feof (fd))
4276 {
4277 fprintf (stderr, "BUG feof()!!\n");
4278
4279 return;
4280 }
4281
4282 load_segment (wl_data, fd);
4283
4284 get_next_word (wl_data, fd, out_buf, out_len);
4285 }
4286
4287 #ifdef _POSIX
4288 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
4289 #endif
4290
4291 #ifdef _WIN
4292 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
4293 #endif
4294 {
4295 hc_signal (NULL);
4296
4297 dictstat_t d;
4298
4299 d.cnt = 0;
4300
4301 #ifdef _POSIX
4302 fstat (fileno (fd), &d.stat);
4303 #endif
4304
4305 #ifdef _WIN
4306 _fstat64 (fileno (fd), &d.stat);
4307 #endif
4308
4309 d.stat.st_mode = 0;
4310 d.stat.st_nlink = 0;
4311 d.stat.st_uid = 0;
4312 d.stat.st_gid = 0;
4313 d.stat.st_rdev = 0;
4314 d.stat.st_atime = 0;
4315
4316 #ifdef _POSIX
4317 d.stat.st_blksize = 0;
4318 d.stat.st_blocks = 0;
4319 #endif
4320
4321 if (d.stat.st_size == 0) return 0;
4322
4323 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4324
4325 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
4326 {
4327 if (d_cache)
4328 {
4329 u64 cnt = d_cache->cnt;
4330
4331 u64 keyspace = cnt;
4332
4333 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4334 {
4335 keyspace *= data.kernel_rules_cnt;
4336 }
4337 else if (data.attack_kern == ATTACK_KERN_COMBI)
4338 {
4339 keyspace *= data.combs_cnt;
4340 }
4341
4342 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);
4343 if (data.quiet == 0) log_info ("");
4344
4345 hc_signal (sigHandler_default);
4346
4347 return (keyspace);
4348 }
4349 }
4350
4351 time_t now = 0;
4352 time_t prev = 0;
4353
4354 u64 comp = 0;
4355 u64 cnt = 0;
4356 u64 cnt2 = 0;
4357
4358 while (!feof (fd))
4359 {
4360 load_segment (wl_data, fd);
4361
4362 comp += wl_data->cnt;
4363
4364 u32 i = 0;
4365
4366 while (i < wl_data->cnt)
4367 {
4368 u32 len;
4369 u32 off;
4370
4371 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
4372
4373 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4374 {
4375 char rule_buf_out[BLOCK_SIZE] = { 0 };
4376
4377 int rule_len_out = -1;
4378
4379 if (len < BLOCK_SIZE)
4380 {
4381 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
4382 }
4383
4384 if (rule_len_out < 0)
4385 {
4386 len = PW_MAX1;
4387 }
4388 else
4389 {
4390 len = rule_len_out;
4391 }
4392 }
4393
4394 if (len < PW_MAX1)
4395 {
4396 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
4397 {
4398 cnt += data.kernel_rules_cnt;
4399 }
4400 else if (data.attack_kern == ATTACK_KERN_COMBI)
4401 {
4402 cnt += data.combs_cnt;
4403 }
4404
4405 d.cnt++;
4406 }
4407
4408 i += off;
4409
4410 cnt2++;
4411 }
4412
4413 time (&now);
4414
4415 if ((now - prev) == 0) continue;
4416
4417 float percent = (float) comp / (float) d.stat.st_size;
4418
4419 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);
4420
4421 time (&prev);
4422 }
4423
4424 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);
4425 if (data.quiet == 0) log_info ("");
4426
4427 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4428
4429 hc_signal (sigHandler_default);
4430
4431 return (cnt);
4432 }
4433
4434 static void *thread_monitor (void *p)
4435 {
4436 uint runtime_check = 0;
4437 uint remove_check = 0;
4438 uint status_check = 0;
4439 uint restore_check = 0;
4440
4441 uint restore_left = data.restore_timer;
4442 uint remove_left = data.remove_timer;
4443 uint status_left = data.status_timer;
4444
4445 #ifdef HAVE_HWMON
4446 uint hwmon_check = 0;
4447
4448 int slowdown_warnings = 0;
4449
4450 // these variables are mainly used for fan control
4451
4452 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4453
4454 // temperature controller "loopback" values
4455
4456 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4457 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4458
4459 int temp_threshold = 1; // degrees celcius
4460
4461 int fan_speed_min = 15; // in percentage
4462 int fan_speed_max = 100;
4463
4464 time_t last_temp_check_time;
4465 #endif // HAVE_HWMON
4466
4467 uint sleep_time = 1;
4468
4469 if (data.runtime)
4470 {
4471 runtime_check = 1;
4472 }
4473
4474 if (data.restore_timer)
4475 {
4476 restore_check = 1;
4477 }
4478
4479 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4480 {
4481 remove_check = 1;
4482 }
4483
4484 if (data.status == 1)
4485 {
4486 status_check = 1;
4487 }
4488
4489 #ifdef HAVE_HWMON
4490 if (data.gpu_temp_disable == 0)
4491 {
4492 time (&last_temp_check_time);
4493
4494 hwmon_check = 1;
4495 }
4496 #endif
4497
4498 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4499 {
4500 #ifdef HAVE_HWMON
4501 if (hwmon_check == 0)
4502 #endif
4503 return (p);
4504 }
4505
4506 while (data.shutdown_inner == 0)
4507 {
4508 hc_sleep (sleep_time);
4509
4510 if (data.devices_status != STATUS_RUNNING) continue;
4511
4512 #ifdef HAVE_HWMON
4513
4514 if (hwmon_check == 1)
4515 {
4516 hc_thread_mutex_lock (mux_adl);
4517
4518 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4519 {
4520 hc_device_param_t *device_param = &data.devices_param[device_id];
4521
4522 if (device_param->skipped) continue;
4523
4524 if (device_param->device_vendor_id == VENDOR_ID_NV)
4525 {
4526 if (data.hm_nvapi)
4527 {
4528 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info;
4529 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status;
4530
4531 memset (&perfPolicies_info, 0, sizeof (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1));
4532 memset (&perfPolicies_status, 0, sizeof (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1));
4533
4534 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4535 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4536
4537 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4538
4539 perfPolicies_status.info_value = perfPolicies_info.info_value;
4540
4541 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4542
4543 if (perfPolicies_status.throttle & 2)
4544 {
4545 if (slowdown_warnings < 3)
4546 {
4547 if (data.quiet == 0) clear_prompt ();
4548
4549 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4550
4551 if (slowdown_warnings == 2)
4552 {
4553 log_info ("");
4554 }
4555
4556 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4557 if (data.quiet == 0) fflush (stdout);
4558
4559 slowdown_warnings++;
4560 }
4561 }
4562 else
4563 {
4564 slowdown_warnings = 0;
4565 }
4566 }
4567 }
4568 }
4569
4570 hc_thread_mutex_unlock (mux_adl);
4571 }
4572
4573 if (hwmon_check == 1)
4574 {
4575 hc_thread_mutex_lock (mux_adl);
4576
4577 time_t temp_check_time;
4578
4579 time (&temp_check_time);
4580
4581 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4582
4583 if (Ta == 0) Ta = 1;
4584
4585 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4586 {
4587 hc_device_param_t *device_param = &data.devices_param[device_id];
4588
4589 if (device_param->skipped) continue;
4590
4591 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4592
4593 const int temperature = hm_get_temperature_with_device_id (device_id);
4594
4595 if (temperature > (int) data.gpu_temp_abort)
4596 {
4597 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4598
4599 if (data.devices_status != STATUS_QUIT) myabort ();
4600
4601 break;
4602 }
4603
4604 const int gpu_temp_retain = data.gpu_temp_retain;
4605
4606 if (gpu_temp_retain)
4607 {
4608 if (data.hm_device[device_id].fan_set_supported == 1)
4609 {
4610 int temp_cur = temperature;
4611
4612 int temp_diff_new = gpu_temp_retain - temp_cur;
4613
4614 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4615
4616 // calculate Ta value (time difference in seconds between the last check and this check)
4617
4618 last_temp_check_time = temp_check_time;
4619
4620 float Kp = 1.8;
4621 float Ki = 0.005;
4622 float Kd = 6;
4623
4624 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4625
4626 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);
4627
4628 if (abs (fan_diff_required) >= temp_threshold)
4629 {
4630 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4631
4632 int fan_speed_level = fan_speed_cur;
4633
4634 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4635
4636 int fan_speed_new = fan_speed_level - fan_diff_required;
4637
4638 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4639 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4640
4641 if (fan_speed_new != fan_speed_cur)
4642 {
4643 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4644 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4645
4646 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4647 {
4648 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4649 {
4650 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4651 }
4652 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4653 {
4654 #ifdef WIN
4655 hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1);
4656 #endif
4657
4658 #ifdef __linux__
4659 hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new);
4660 #endif
4661 }
4662
4663 fan_speed_chgd[device_id] = 1;
4664 }
4665
4666 temp_diff_old[device_id] = temp_diff_new;
4667 }
4668 }
4669 }
4670 }
4671 }
4672
4673 hc_thread_mutex_unlock (mux_adl);
4674 }
4675 #endif // HAVE_HWMON
4676
4677 if (restore_check == 1)
4678 {
4679 restore_left--;
4680
4681 if (restore_left == 0)
4682 {
4683 if (data.restore_disable == 0) cycle_restore ();
4684
4685 restore_left = data.restore_timer;
4686 }
4687 }
4688
4689 if ((runtime_check == 1) && (data.runtime_start > 0))
4690 {
4691 time_t runtime_cur;
4692
4693 time (&runtime_cur);
4694
4695 int runtime_left = data.proc_start + data.runtime - runtime_cur;
4696
4697 if (runtime_left <= 0)
4698 {
4699 if (data.benchmark == 0)
4700 {
4701 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4702 }
4703
4704 if (data.devices_status != STATUS_QUIT) myabort ();
4705 }
4706 }
4707
4708 if (remove_check == 1)
4709 {
4710 remove_left--;
4711
4712 if (remove_left == 0)
4713 {
4714 if (data.digests_saved != data.digests_done)
4715 {
4716 data.digests_saved = data.digests_done;
4717
4718 save_hash ();
4719 }
4720
4721 remove_left = data.remove_timer;
4722 }
4723 }
4724
4725 if (status_check == 1)
4726 {
4727 status_left--;
4728
4729 if (status_left == 0)
4730 {
4731 hc_thread_mutex_lock (mux_display);
4732
4733 if (data.quiet == 0) clear_prompt ();
4734
4735 if (data.quiet == 0) log_info ("");
4736
4737 status_display ();
4738
4739 if (data.quiet == 0) log_info ("");
4740
4741 hc_thread_mutex_unlock (mux_display);
4742
4743 status_left = data.status_timer;
4744 }
4745 }
4746 }
4747
4748 #ifdef HAVE_HWMON
4749 myfree (fan_speed_chgd);
4750
4751 myfree (temp_diff_old);
4752 myfree (temp_diff_sum);
4753 #endif
4754
4755 p = NULL;
4756
4757 return (p);
4758 }
4759
4760 static void *thread_outfile_remove (void *p)
4761 {
4762 // some hash-dependent constants
4763 char *outfile_dir = data.outfile_check_directory;
4764 uint dgst_size = data.dgst_size;
4765 uint isSalted = data.isSalted;
4766 uint esalt_size = data.esalt_size;
4767 uint hash_mode = data.hash_mode;
4768
4769 uint outfile_check_timer = data.outfile_check_timer;
4770
4771 char separator = data.separator;
4772
4773 // some hash-dependent functions
4774 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4775 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4776
4777 // buffers
4778 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4779
4780 hash_buf.digest = mymalloc (dgst_size);
4781
4782 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4783
4784 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4785
4786 uint digest_buf[64] = { 0 };
4787
4788 outfile_data_t *out_info = NULL;
4789
4790 char **out_files = NULL;
4791
4792 time_t folder_mtime = 0;
4793
4794 int out_cnt = 0;
4795
4796 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4797
4798 while (data.shutdown_inner == 0)
4799 {
4800 hc_sleep (1);
4801
4802 if (data.devices_status != STATUS_RUNNING) continue;
4803
4804 check_left--;
4805
4806 if (check_left == 0)
4807 {
4808 struct stat outfile_check_stat;
4809
4810 if (stat (outfile_dir, &outfile_check_stat) == 0)
4811 {
4812 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4813
4814 if (is_dir == 1)
4815 {
4816 if (outfile_check_stat.st_mtime > folder_mtime)
4817 {
4818 char **out_files_new = scan_directory (outfile_dir);
4819
4820 int out_cnt_new = count_dictionaries (out_files_new);
4821
4822 outfile_data_t *out_info_new = NULL;
4823
4824 if (out_cnt_new > 0)
4825 {
4826 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4827
4828 for (int i = 0; i < out_cnt_new; i++)
4829 {
4830 out_info_new[i].file_name = out_files_new[i];
4831
4832 // check if there are files that we have seen/checked before (and not changed)
4833
4834 for (int j = 0; j < out_cnt; j++)
4835 {
4836 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4837 {
4838 struct stat outfile_stat;
4839
4840 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4841 {
4842 if (outfile_stat.st_ctime == out_info[j].ctime)
4843 {
4844 out_info_new[i].ctime = out_info[j].ctime;
4845 out_info_new[i].seek = out_info[j].seek;
4846 }
4847 }
4848 }
4849 }
4850 }
4851 }
4852
4853 local_free (out_info);
4854 local_free (out_files);
4855
4856 out_files = out_files_new;
4857 out_cnt = out_cnt_new;
4858 out_info = out_info_new;
4859
4860 folder_mtime = outfile_check_stat.st_mtime;
4861 }
4862
4863 for (int j = 0; j < out_cnt; j++)
4864 {
4865 FILE *fp = fopen (out_info[j].file_name, "rb");
4866
4867 if (fp != NULL)
4868 {
4869 //hc_thread_mutex_lock (mux_display);
4870
4871 #ifdef _POSIX
4872 struct stat outfile_stat;
4873
4874 fstat (fileno (fp), &outfile_stat);
4875 #endif
4876
4877 #ifdef _WIN
4878 struct stat64 outfile_stat;
4879
4880 _fstat64 (fileno (fp), &outfile_stat);
4881 #endif
4882
4883 if (outfile_stat.st_ctime > out_info[j].ctime)
4884 {
4885 out_info[j].ctime = outfile_stat.st_ctime;
4886 out_info[j].seek = 0;
4887 }
4888
4889 fseek (fp, out_info[j].seek, SEEK_SET);
4890
4891 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4892
4893 while (!feof (fp))
4894 {
4895 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4896
4897 if (ptr == NULL) break;
4898
4899 int line_len = strlen (line_buf);
4900
4901 if (line_len <= 0) continue;
4902
4903 int iter = MAX_CUT_TRIES;
4904
4905 for (uint i = line_len - 1; i && iter; i--, line_len--)
4906 {
4907 if (line_buf[i] != separator) continue;
4908
4909 int parser_status = PARSER_OK;
4910
4911 if ((hash_mode != 2500) && (hash_mode != 6800))
4912 {
4913 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4914 }
4915
4916 uint found = 0;
4917
4918 if (parser_status == PARSER_OK)
4919 {
4920 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4921 {
4922 if (data.salts_shown[salt_pos] == 1) continue;
4923
4924 salt_t *salt_buf = &data.salts_buf[salt_pos];
4925
4926 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4927 {
4928 uint idx = salt_buf->digests_offset + digest_pos;
4929
4930 if (data.digests_shown[idx] == 1) continue;
4931
4932 uint cracked = 0;
4933
4934 if (hash_mode == 6800)
4935 {
4936 if (i == salt_buf->salt_len)
4937 {
4938 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4939 }
4940 }
4941 else if (hash_mode == 2500)
4942 {
4943 // BSSID : MAC1 : MAC2 (:plain)
4944 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4945 {
4946 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4947
4948 if (!cracked) continue;
4949
4950 // now compare MAC1 and MAC2 too, since we have this additional info
4951 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4952 char *mac2_pos = mac1_pos + 12 + 1;
4953
4954 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4955 wpa_t *wpa = &wpas[salt_pos];
4956
4957 // compare hex string(s) vs binary MAC address(es)
4958
4959 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4960 {
4961 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4962 {
4963 cracked = 0;
4964
4965 break;
4966 }
4967 }
4968
4969 // early skip ;)
4970 if (!cracked) continue;
4971
4972 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4973 {
4974 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4975 {
4976 cracked = 0;
4977
4978 break;
4979 }
4980 }
4981 }
4982 }
4983 else
4984 {
4985 char *digests_buf_ptr = (char *) data.digests_buf;
4986
4987 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4988
4989 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4990 }
4991
4992 if (cracked == 1)
4993 {
4994 found = 1;
4995
4996 data.digests_shown[idx] = 1;
4997
4998 data.digests_done++;
4999
5000 salt_buf->digests_done++;
5001
5002 if (salt_buf->digests_done == salt_buf->digests_cnt)
5003 {
5004 data.salts_shown[salt_pos] = 1;
5005
5006 data.salts_done++;
5007
5008 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
5009 }
5010 }
5011 }
5012
5013 if (data.devices_status == STATUS_CRACKED) break;
5014 }
5015 }
5016
5017 if (found) break;
5018
5019 if (data.devices_status == STATUS_CRACKED) break;
5020
5021 iter--;
5022 }
5023
5024 if (data.devices_status == STATUS_CRACKED) break;
5025 }
5026
5027 myfree (line_buf);
5028
5029 out_info[j].seek = ftell (fp);
5030
5031 //hc_thread_mutex_unlock (mux_display);
5032
5033 fclose (fp);
5034 }
5035 }
5036 }
5037 }
5038
5039 check_left = outfile_check_timer;
5040 }
5041 }
5042
5043 if (esalt_size) local_free (hash_buf.esalt);
5044
5045 if (isSalted) local_free (hash_buf.salt);
5046
5047 local_free (hash_buf.digest);
5048
5049 local_free (out_info);
5050
5051 local_free (out_files);
5052
5053 p = NULL;
5054
5055 return (p);
5056 }
5057
5058 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
5059 {
5060 //if (device_param->pws_cnt < device_param->kernel_power)
5061 //{
5062 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
5063
5064 u8 *ptr = (u8 *) pw->i;
5065
5066 memcpy (ptr, pw_buf, pw_len);
5067
5068 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
5069
5070 pw->pw_len = pw_len;
5071
5072 device_param->pws_cnt++;
5073 //}
5074 //else
5075 //{
5076 // fprintf (stderr, "BUG pw_add()!!\n");
5077 //
5078 // return;
5079 //}
5080 }
5081
5082 static void set_kernel_power_final (const u64 kernel_power_final)
5083 {
5084 if (data.quiet == 0)
5085 {
5086 clear_prompt ();
5087
5088 //log_info ("");
5089
5090 log_info ("INFO: approaching final keyspace, workload adjusted");
5091 log_info ("");
5092
5093 fprintf (stdout, "%s", PROMPT);
5094
5095 fflush (stdout);
5096 }
5097
5098 data.kernel_power_final = kernel_power_final;
5099 }
5100
5101 static u32 get_power (hc_device_param_t *device_param)
5102 {
5103 const u64 kernel_power_final = data.kernel_power_final;
5104
5105 if (kernel_power_final)
5106 {
5107 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
5108
5109 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
5110
5111 // work should be at least the hardware power available without any accelerator
5112
5113 const u64 work = MAX (words_left_device, device_param->hardware_power);
5114
5115 return work;
5116 }
5117
5118 return device_param->kernel_power;
5119 }
5120
5121 static uint get_work (hc_device_param_t *device_param, const u64 max)
5122 {
5123 hc_thread_mutex_lock (mux_dispatcher);
5124
5125 const u64 words_cur = data.words_cur;
5126 const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base);
5127
5128 device_param->words_off = words_cur;
5129
5130 const u64 kernel_power_all = data.kernel_power_all;
5131
5132 const u64 words_left = words_base - words_cur;
5133
5134 if (words_left < kernel_power_all)
5135 {
5136 if (data.kernel_power_final == 0)
5137 {
5138 set_kernel_power_final (words_left);
5139 }
5140 }
5141
5142 const u32 kernel_power = get_power (device_param);
5143
5144 uint work = MIN (words_left, kernel_power);
5145
5146 work = MIN (work, max);
5147
5148 data.words_cur += work;
5149
5150 hc_thread_mutex_unlock (mux_dispatcher);
5151
5152 return work;
5153 }
5154
5155 static void *thread_autotune (void *p)
5156 {
5157 hc_device_param_t *device_param = (hc_device_param_t *) p;
5158
5159 if (device_param->skipped) return NULL;
5160
5161 autotune (device_param);
5162
5163 return NULL;
5164 }
5165
5166 static void *thread_calc_stdin (void *p)
5167 {
5168 hc_device_param_t *device_param = (hc_device_param_t *) p;
5169
5170 if (device_param->skipped) return NULL;
5171
5172 char *buf = (char *) mymalloc (HCBUFSIZ);
5173
5174 const uint attack_kern = data.attack_kern;
5175
5176 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5177 {
5178 hc_thread_mutex_lock (mux_dispatcher);
5179
5180 if (feof (stdin) != 0)
5181 {
5182 hc_thread_mutex_unlock (mux_dispatcher);
5183
5184 break;
5185 }
5186
5187 uint words_cur = 0;
5188
5189 while (words_cur < device_param->kernel_power)
5190 {
5191 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
5192
5193 if (line_buf == NULL) break;
5194
5195 uint line_len = in_superchop (line_buf);
5196
5197 line_len = convert_from_hex (line_buf, line_len);
5198
5199 // post-process rule engine
5200
5201 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5202 {
5203 char rule_buf_out[BLOCK_SIZE] = { 0 };
5204
5205 int rule_len_out = -1;
5206
5207 if (line_len < BLOCK_SIZE)
5208 {
5209 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5210 }
5211
5212 if (rule_len_out < 0) continue;
5213
5214 line_buf = rule_buf_out;
5215 line_len = rule_len_out;
5216 }
5217
5218 if (line_len > PW_MAX)
5219 {
5220 continue;
5221 }
5222
5223 // hmm that's always the case, or?
5224
5225 if (attack_kern == ATTACK_KERN_STRAIGHT)
5226 {
5227 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5228 {
5229 hc_thread_mutex_lock (mux_counter);
5230
5231 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5232 {
5233 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5234 }
5235
5236 hc_thread_mutex_unlock (mux_counter);
5237
5238 continue;
5239 }
5240 }
5241
5242 pw_add (device_param, (u8 *) line_buf, line_len);
5243
5244 words_cur++;
5245
5246 if (data.devices_status == STATUS_CRACKED) break;
5247 if (data.devices_status == STATUS_ABORTED) break;
5248 if (data.devices_status == STATUS_QUIT) break;
5249 if (data.devices_status == STATUS_BYPASS) break;
5250 }
5251
5252 hc_thread_mutex_unlock (mux_dispatcher);
5253
5254 if (data.devices_status == STATUS_CRACKED) break;
5255 if (data.devices_status == STATUS_ABORTED) break;
5256 if (data.devices_status == STATUS_QUIT) break;
5257 if (data.devices_status == STATUS_BYPASS) break;
5258
5259 // flush
5260
5261 const uint pws_cnt = device_param->pws_cnt;
5262
5263 if (pws_cnt)
5264 {
5265 run_copy (device_param, pws_cnt);
5266
5267 run_cracker (device_param, pws_cnt);
5268
5269 device_param->pws_cnt = 0;
5270
5271 /*
5272 still required?
5273 if (attack_kern == ATTACK_KERN_STRAIGHT)
5274 {
5275 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5276 }
5277 else if (attack_kern == ATTACK_KERN_COMBI)
5278 {
5279 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5280 }
5281 */
5282 }
5283 }
5284
5285 device_param->kernel_accel = 0;
5286 device_param->kernel_loops = 0;
5287
5288 myfree (buf);
5289
5290 return NULL;
5291 }
5292
5293 static void *thread_calc (void *p)
5294 {
5295 hc_device_param_t *device_param = (hc_device_param_t *) p;
5296
5297 if (device_param->skipped) return NULL;
5298
5299 const uint attack_mode = data.attack_mode;
5300 const uint attack_kern = data.attack_kern;
5301
5302 if (attack_mode == ATTACK_MODE_BF)
5303 {
5304 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5305 {
5306 const uint work = get_work (device_param, -1);
5307
5308 if (work == 0) break;
5309
5310 const u64 words_off = device_param->words_off;
5311 const u64 words_fin = words_off + work;
5312
5313 const uint pws_cnt = work;
5314
5315 device_param->pws_cnt = pws_cnt;
5316
5317 if (pws_cnt)
5318 {
5319 run_copy (device_param, pws_cnt);
5320
5321 run_cracker (device_param, pws_cnt);
5322
5323 device_param->pws_cnt = 0;
5324
5325 /*
5326 still required?
5327 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
5328 */
5329 }
5330
5331 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5332
5333 if (data.devices_status == STATUS_CRACKED) break;
5334 if (data.devices_status == STATUS_ABORTED) break;
5335 if (data.devices_status == STATUS_QUIT) break;
5336 if (data.devices_status == STATUS_BYPASS) break;
5337
5338 if (data.benchmark == 1) break;
5339
5340 device_param->words_done = words_fin;
5341 }
5342 }
5343 else
5344 {
5345 const uint segment_size = data.segment_size;
5346
5347 char *dictfile = data.dictfile;
5348
5349 if (attack_mode == ATTACK_MODE_COMBI)
5350 {
5351 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5352 {
5353 dictfile = data.dictfile2;
5354 }
5355 }
5356
5357 FILE *fd = fopen (dictfile, "rb");
5358
5359 if (fd == NULL)
5360 {
5361 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
5362
5363 return NULL;
5364 }
5365
5366 if (attack_mode == ATTACK_MODE_COMBI)
5367 {
5368 const uint combs_mode = data.combs_mode;
5369
5370 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
5371 {
5372 const char *dictfilec = data.dictfile2;
5373
5374 FILE *combs_fp = fopen (dictfilec, "rb");
5375
5376 if (combs_fp == NULL)
5377 {
5378 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5379
5380 fclose (fd);
5381
5382 return NULL;
5383 }
5384
5385 device_param->combs_fp = combs_fp;
5386 }
5387 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
5388 {
5389 const char *dictfilec = data.dictfile;
5390
5391 FILE *combs_fp = fopen (dictfilec, "rb");
5392
5393 if (combs_fp == NULL)
5394 {
5395 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
5396
5397 fclose (fd);
5398
5399 return NULL;
5400 }
5401
5402 device_param->combs_fp = combs_fp;
5403 }
5404 }
5405
5406 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
5407
5408 wl_data->buf = (char *) mymalloc (segment_size);
5409 wl_data->avail = segment_size;
5410 wl_data->incr = segment_size;
5411 wl_data->cnt = 0;
5412 wl_data->pos = 0;
5413
5414 u64 words_cur = 0;
5415
5416 while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
5417 {
5418 u64 words_off = 0;
5419 u64 words_fin = 0;
5420
5421 u64 max = -1;
5422
5423 while (max)
5424 {
5425 const uint work = get_work (device_param, max);
5426
5427 if (work == 0) break;
5428
5429 max = 0;
5430
5431 words_off = device_param->words_off;
5432 words_fin = words_off + work;
5433
5434 char *line_buf;
5435 uint line_len;
5436
5437 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5438
5439 for ( ; words_cur < words_fin; words_cur++)
5440 {
5441 get_next_word (wl_data, fd, &line_buf, &line_len);
5442
5443 line_len = convert_from_hex (line_buf, line_len);
5444
5445 // post-process rule engine
5446
5447 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5448 {
5449 char rule_buf_out[BLOCK_SIZE] = { 0 };
5450
5451 int rule_len_out = -1;
5452
5453 if (line_len < BLOCK_SIZE)
5454 {
5455 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5456 }
5457
5458 if (rule_len_out < 0) continue;
5459
5460 line_buf = rule_buf_out;
5461 line_len = rule_len_out;
5462 }
5463
5464 if (attack_kern == ATTACK_KERN_STRAIGHT)
5465 {
5466 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5467 {
5468 max++;
5469
5470 hc_thread_mutex_lock (mux_counter);
5471
5472 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5473 {
5474 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5475 }
5476
5477 hc_thread_mutex_unlock (mux_counter);
5478
5479 continue;
5480 }
5481 }
5482 else if (attack_kern == ATTACK_KERN_COMBI)
5483 {
5484 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5485 // since we still need to combine the plains
5486
5487 if (line_len > data.pw_max)
5488 {
5489 max++;
5490
5491 hc_thread_mutex_lock (mux_counter);
5492
5493 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5494 {
5495 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5496 }
5497
5498 hc_thread_mutex_unlock (mux_counter);
5499
5500 continue;
5501 }
5502 }
5503
5504 pw_add (device_param, (u8 *) line_buf, line_len);
5505
5506 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5507
5508 if (data.devices_status == STATUS_CRACKED) break;
5509 if (data.devices_status == STATUS_ABORTED) break;
5510 if (data.devices_status == STATUS_QUIT) break;
5511 if (data.devices_status == STATUS_BYPASS) break;
5512 }
5513
5514 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5515
5516 if (data.devices_status == STATUS_CRACKED) break;
5517 if (data.devices_status == STATUS_ABORTED) break;
5518 if (data.devices_status == STATUS_QUIT) break;
5519 if (data.devices_status == STATUS_BYPASS) break;
5520 }
5521
5522 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5523
5524 if (data.devices_status == STATUS_CRACKED) break;
5525 if (data.devices_status == STATUS_ABORTED) break;
5526 if (data.devices_status == STATUS_QUIT) break;
5527 if (data.devices_status == STATUS_BYPASS) break;
5528
5529 //
5530 // flush
5531 //
5532
5533 const uint pws_cnt = device_param->pws_cnt;
5534
5535 if (pws_cnt)
5536 {
5537 run_copy (device_param, pws_cnt);
5538
5539 run_cracker (device_param, pws_cnt);
5540
5541 device_param->pws_cnt = 0;
5542
5543 /*
5544 still required?
5545 if (attack_kern == ATTACK_KERN_STRAIGHT)
5546 {
5547 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5548 }
5549 else if (attack_kern == ATTACK_KERN_COMBI)
5550 {
5551 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5552 }
5553 */
5554 }
5555
5556 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5557
5558 if (data.devices_status == STATUS_CRACKED) break;
5559 if (data.devices_status == STATUS_ABORTED) break;
5560 if (data.devices_status == STATUS_QUIT) break;
5561 if (data.devices_status == STATUS_BYPASS) break;
5562
5563 if (words_fin == 0) break;
5564
5565 device_param->words_done = words_fin;
5566 }
5567
5568 if (attack_mode == ATTACK_MODE_COMBI)
5569 {
5570 fclose (device_param->combs_fp);
5571 }
5572
5573 free (wl_data->buf);
5574 free (wl_data);
5575
5576 fclose (fd);
5577 }
5578
5579 device_param->kernel_accel = 0;
5580 device_param->kernel_loops = 0;
5581
5582 return NULL;
5583 }
5584
5585 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5586 {
5587 if (!device_param)
5588 {
5589 log_error ("ERROR: %s : Invalid argument", __func__);
5590
5591 exit (-1);
5592 }
5593
5594 salt_t *salt_buf = &data.salts_buf[salt_pos];
5595
5596 device_param->kernel_params_buf32[27] = salt_pos;
5597 device_param->kernel_params_buf32[30] = 1;
5598 device_param->kernel_params_buf32[31] = salt_buf->digests_cnt;
5599 device_param->kernel_params_buf32[32] = salt_buf->digests_offset;
5600 device_param->kernel_params_buf32[33] = 0;
5601 device_param->kernel_params_buf32[34] = 1;
5602
5603 char *dictfile_old = data.dictfile;
5604
5605 const char *weak_hash_check = "weak-hash-check";
5606
5607 data.dictfile = (char *) weak_hash_check;
5608
5609 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5610
5611 data.kernel_rules_buf[0].cmds[0] = 0;
5612
5613 /**
5614 * run the kernel
5615 */
5616
5617 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5618 {
5619 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5620 }
5621 else
5622 {
5623 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5624
5625 uint loop_step = 16;
5626
5627 const uint iter = salt_buf->salt_iter;
5628
5629 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5630 {
5631 uint loop_left = iter - loop_pos;
5632
5633 loop_left = MIN (loop_left, loop_step);
5634
5635 device_param->kernel_params_buf32[28] = loop_pos;
5636 device_param->kernel_params_buf32[29] = loop_left;
5637
5638 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5639 }
5640
5641 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5642 }
5643
5644 /**
5645 * result
5646 */
5647
5648 check_cracked (device_param, salt_pos);
5649
5650 /**
5651 * cleanup
5652 */
5653
5654 device_param->kernel_params_buf32[27] = 0;
5655 device_param->kernel_params_buf32[28] = 0;
5656 device_param->kernel_params_buf32[29] = 0;
5657 device_param->kernel_params_buf32[30] = 0;
5658 device_param->kernel_params_buf32[31] = 0;
5659 device_param->kernel_params_buf32[32] = 0;
5660 device_param->kernel_params_buf32[33] = 0;
5661 device_param->kernel_params_buf32[34] = 0;
5662
5663 data.dictfile = dictfile_old;
5664
5665 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5666 }
5667
5668 // hlfmt hashcat
5669
5670 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5671 {
5672 if (data.username == 0)
5673 {
5674 *hashbuf_pos = line_buf;
5675 *hashbuf_len = line_len;
5676 }
5677 else
5678 {
5679 char *pos = line_buf;
5680 int len = line_len;
5681
5682 for (int i = 0; i < line_len; i++, pos++, len--)
5683 {
5684 if (line_buf[i] == data.separator)
5685 {
5686 pos++;
5687
5688 len--;
5689
5690 break;
5691 }
5692 }
5693
5694 *hashbuf_pos = pos;
5695 *hashbuf_len = len;
5696 }
5697 }
5698
5699 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5700 {
5701 char *pos = NULL;
5702 int len = 0;
5703
5704 int sep_cnt = 0;
5705
5706 for (int i = 0; i < line_len; i++)
5707 {
5708 if (line_buf[i] == data.separator)
5709 {
5710 sep_cnt++;
5711
5712 continue;
5713 }
5714
5715 if (sep_cnt == 0)
5716 {
5717 if (pos == NULL) pos = line_buf + i;
5718
5719 len++;
5720 }
5721 }
5722
5723 *userbuf_pos = pos;
5724 *userbuf_len = len;
5725 }
5726
5727 // hlfmt pwdump
5728
5729 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5730 {
5731 int sep_cnt = 0;
5732
5733 int sep2_len = 0;
5734 int sep3_len = 0;
5735
5736 for (int i = 0; i < line_len; i++)
5737 {
5738 if (line_buf[i] == ':')
5739 {
5740 sep_cnt++;
5741
5742 continue;
5743 }
5744
5745 if (sep_cnt == 2) sep2_len++;
5746 if (sep_cnt == 3) sep3_len++;
5747 }
5748
5749 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5750
5751 return 0;
5752 }
5753
5754 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5755 {
5756 char *pos = NULL;
5757 int len = 0;
5758
5759 int sep_cnt = 0;
5760
5761 for (int i = 0; i < line_len; i++)
5762 {
5763 if (line_buf[i] == ':')
5764 {
5765 sep_cnt++;
5766
5767 continue;
5768 }
5769
5770 if (data.hash_mode == 1000)
5771 {
5772 if (sep_cnt == 3)
5773 {
5774 if (pos == NULL) pos = line_buf + i;
5775
5776 len++;
5777 }
5778 }
5779 else if (data.hash_mode == 3000)
5780 {
5781 if (sep_cnt == 2)
5782 {
5783 if (pos == NULL) pos = line_buf + i;
5784
5785 len++;
5786 }
5787 }
5788 }
5789
5790 *hashbuf_pos = pos;
5791 *hashbuf_len = len;
5792 }
5793
5794 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5795 {
5796 char *pos = NULL;
5797 int len = 0;
5798
5799 int sep_cnt = 0;
5800
5801 for (int i = 0; i < line_len; i++)
5802 {
5803 if (line_buf[i] == ':')
5804 {
5805 sep_cnt++;
5806
5807 continue;
5808 }
5809
5810 if (sep_cnt == 0)
5811 {
5812 if (pos == NULL) pos = line_buf + i;
5813
5814 len++;
5815 }
5816 }
5817
5818 *userbuf_pos = pos;
5819 *userbuf_len = len;
5820 }
5821
5822 // hlfmt passwd
5823
5824 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5825 {
5826 int sep_cnt = 0;
5827
5828 char sep5_first = 0;
5829 char sep6_first = 0;
5830
5831 for (int i = 0; i < line_len; i++)
5832 {
5833 if (line_buf[i] == ':')
5834 {
5835 sep_cnt++;
5836
5837 continue;
5838 }
5839
5840 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5841 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5842 }
5843
5844 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5845
5846 return 0;
5847 }
5848
5849 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5850 {
5851 char *pos = NULL;
5852 int len = 0;
5853
5854 int sep_cnt = 0;
5855
5856 for (int i = 0; i < line_len; i++)
5857 {
5858 if (line_buf[i] == ':')
5859 {
5860 sep_cnt++;
5861
5862 continue;
5863 }
5864
5865 if (sep_cnt == 1)
5866 {
5867 if (pos == NULL) pos = line_buf + i;
5868
5869 len++;
5870 }
5871 }
5872
5873 *hashbuf_pos = pos;
5874 *hashbuf_len = len;
5875 }
5876
5877 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5878 {
5879 char *pos = NULL;
5880 int len = 0;
5881
5882 int sep_cnt = 0;
5883
5884 for (int i = 0; i < line_len; i++)
5885 {
5886 if (line_buf[i] == ':')
5887 {
5888 sep_cnt++;
5889
5890 continue;
5891 }
5892
5893 if (sep_cnt == 0)
5894 {
5895 if (pos == NULL) pos = line_buf + i;
5896
5897 len++;
5898 }
5899 }
5900
5901 *userbuf_pos = pos;
5902 *userbuf_len = len;
5903 }
5904
5905 // hlfmt shadow
5906
5907 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5908 {
5909 int sep_cnt = 0;
5910
5911 for (int i = 0; i < line_len; i++)
5912 {
5913 if (line_buf[i] == ':') sep_cnt++;
5914 }
5915
5916 if (sep_cnt == 8) return 1;
5917
5918 return 0;
5919 }
5920
5921 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5922 {
5923 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5924 }
5925
5926 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5927 {
5928 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5929 }
5930
5931 // hlfmt main
5932
5933 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5934 {
5935 switch (hashfile_format)
5936 {
5937 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5938 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5939 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5940 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5941 }
5942 }
5943
5944 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5945 {
5946 switch (hashfile_format)
5947 {
5948 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5949 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5950 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5951 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5952 }
5953 }
5954
5955 char *strhlfmt (const uint hashfile_format)
5956 {
5957 switch (hashfile_format)
5958 {
5959 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5960 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5961 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5962 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5963 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5964 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5965 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5966 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5967 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5968 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5969 }
5970
5971 return ((char *) "Unknown");
5972 }
5973
5974 static uint hlfmt_detect (FILE *fp, uint max_check)
5975 {
5976 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5977
5978 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5979 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5980
5981 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5982
5983 uint num_check = 0;
5984
5985 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5986
5987 while (!feof (fp))
5988 {
5989 int line_len = fgetl (fp, line_buf);
5990
5991 if (line_len == 0) continue;
5992
5993 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5994 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5995 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5996
5997 if (num_check == max_check) break;
5998
5999 num_check++;
6000 }
6001
6002 myfree (line_buf);
6003
6004 uint hashlist_format = HLFMT_HASHCAT;
6005
6006 for (int i = 1; i < HLFMTS_CNT; i++)
6007 {
6008 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
6009
6010 hashlist_format = i;
6011 }
6012
6013 free (formats_cnt);
6014
6015 return hashlist_format;
6016 }
6017
6018 /**
6019 * some further helper function
6020 */
6021
6022 // wrapper around mymalloc for ADL
6023
6024 #if defined(HAVE_HWMON)
6025 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
6026 {
6027 return mymalloc (iSize);
6028 }
6029 #endif
6030
6031 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)
6032 {
6033 u64 collisions = 0;
6034
6035 const uint dgst_pos0 = data.dgst_pos0;
6036 const uint dgst_pos1 = data.dgst_pos1;
6037 const uint dgst_pos2 = data.dgst_pos2;
6038 const uint dgst_pos3 = data.dgst_pos3;
6039
6040 memset (bitmap_a, 0, bitmap_size);
6041 memset (bitmap_b, 0, bitmap_size);
6042 memset (bitmap_c, 0, bitmap_size);
6043 memset (bitmap_d, 0, bitmap_size);
6044
6045 for (uint i = 0; i < digests_cnt; i++)
6046 {
6047 uint *digest_ptr = (uint *) digests_buf_ptr;
6048
6049 digests_buf_ptr += dgst_size;
6050
6051 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
6052 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
6053 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
6054 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
6055
6056 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
6057 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
6058 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
6059 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
6060
6061 if (bitmap_a[idx0] & val0) collisions++;
6062 if (bitmap_b[idx1] & val1) collisions++;
6063 if (bitmap_c[idx2] & val2) collisions++;
6064 if (bitmap_d[idx3] & val3) collisions++;
6065
6066 bitmap_a[idx0] |= val0;
6067 bitmap_b[idx1] |= val1;
6068 bitmap_c[idx2] |= val2;
6069 bitmap_d[idx3] |= val3;
6070
6071 if (collisions >= collisions_max) return 0x7fffffff;
6072 }
6073
6074 return collisions;
6075 }
6076
6077 /**
6078 * main
6079 */
6080
6081 #ifdef WIN
6082 void SetConsoleWindowSize (const int x)
6083 {
6084 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
6085
6086 if (h == INVALID_HANDLE_VALUE) return;
6087
6088 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
6089
6090 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
6091
6092 SMALL_RECT *sr = &bufferInfo.srWindow;
6093
6094 sr->Right = MAX (sr->Right, x - 1);
6095
6096 COORD co;
6097
6098 co.X = sr->Right + 1;
6099 co.Y = 9999;
6100
6101 if (!SetConsoleScreenBufferSize (h, co)) return;
6102
6103 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
6104 }
6105 #endif
6106
6107 int main (int argc, char **argv)
6108 {
6109 #ifdef WIN
6110 SetConsoleWindowSize (132);
6111 #endif
6112
6113 /**
6114 * To help users a bit
6115 */
6116
6117 char *compute = getenv ("COMPUTE");
6118
6119 if (compute)
6120 {
6121 static char display[100];
6122
6123 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
6124
6125 putenv (display);
6126 }
6127 else
6128 {
6129 if (getenv ("DISPLAY") == NULL)
6130 putenv ((char *) "DISPLAY=:0");
6131 }
6132
6133 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
6134 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
6135
6136 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
6137 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
6138
6139 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
6140 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
6141
6142 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
6143 putenv ((char *) "CUDA_CACHE_DISABLE=1");
6144
6145 if (getenv ("POCL_KERNEL_CACHE") == NULL)
6146 putenv ((char *) "POCL_KERNEL_CACHE=0");
6147
6148 umask (077);
6149
6150 /**
6151 * There's some buggy OpenCL runtime that do not support -I.
6152 * A workaround is to chdir() to the OpenCL folder,
6153 * then compile the kernels,
6154 * then chdir() back to where we came from so we need to save it first
6155 */
6156
6157 char cwd[1024];
6158
6159 if (getcwd (cwd, sizeof (cwd) - 1) == NULL)
6160 {
6161 log_error ("ERROR: getcwd(): %s", strerror (errno));
6162
6163 return -1;
6164 }
6165
6166 /**
6167 * Real init
6168 */
6169
6170 memset (&data, 0, sizeof (hc_global_data_t));
6171
6172 time_t proc_start;
6173
6174 time (&proc_start);
6175
6176 data.proc_start = proc_start;
6177
6178 int myargc = argc;
6179 char **myargv = argv;
6180
6181 hc_thread_mutex_init (mux_dispatcher);
6182 hc_thread_mutex_init (mux_counter);
6183 hc_thread_mutex_init (mux_display);
6184 hc_thread_mutex_init (mux_adl);
6185
6186 /**
6187 * commandline parameters
6188 */
6189
6190 uint usage = USAGE;
6191 uint version = VERSION;
6192 uint quiet = QUIET;
6193 uint benchmark = BENCHMARK;
6194 uint stdout_flag = STDOUT_FLAG;
6195 uint show = SHOW;
6196 uint left = LEFT;
6197 uint username = USERNAME;
6198 uint remove = REMOVE;
6199 uint remove_timer = REMOVE_TIMER;
6200 u64 skip = SKIP;
6201 u64 limit = LIMIT;
6202 uint keyspace = KEYSPACE;
6203 uint potfile_disable = POTFILE_DISABLE;
6204 char *potfile_path = NULL;
6205 uint debug_mode = DEBUG_MODE;
6206 char *debug_file = NULL;
6207 char *induction_dir = NULL;
6208 char *outfile_check_dir = NULL;
6209 uint force = FORCE;
6210 uint runtime = RUNTIME;
6211 uint hash_mode = HASH_MODE;
6212 uint attack_mode = ATTACK_MODE;
6213 uint markov_disable = MARKOV_DISABLE;
6214 uint markov_classic = MARKOV_CLASSIC;
6215 uint markov_threshold = MARKOV_THRESHOLD;
6216 char *markov_hcstat = NULL;
6217 char *outfile = NULL;
6218 uint outfile_format = OUTFILE_FORMAT;
6219 uint outfile_autohex = OUTFILE_AUTOHEX;
6220 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
6221 uint restore = RESTORE;
6222 uint restore_timer = RESTORE_TIMER;
6223 uint restore_disable = RESTORE_DISABLE;
6224 uint status = STATUS;
6225 uint status_timer = STATUS_TIMER;
6226 uint machine_readable = MACHINE_READABLE;
6227 uint loopback = LOOPBACK;
6228 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
6229 char *session = NULL;
6230 uint hex_charset = HEX_CHARSET;
6231 uint hex_salt = HEX_SALT;
6232 uint hex_wordlist = HEX_WORDLIST;
6233 uint rp_gen = RP_GEN;
6234 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
6235 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
6236 uint rp_gen_seed = RP_GEN_SEED;
6237 char *rule_buf_l = (char *) RULE_BUF_L;
6238 char *rule_buf_r = (char *) RULE_BUF_R;
6239 uint increment = INCREMENT;
6240 uint increment_min = INCREMENT_MIN;
6241 uint increment_max = INCREMENT_MAX;
6242 char *cpu_affinity = NULL;
6243 OCL_PTR *ocl = NULL;
6244 char *opencl_devices = NULL;
6245 char *opencl_platforms = NULL;
6246 char *opencl_device_types = NULL;
6247 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
6248 char *truecrypt_keyfiles = NULL;
6249 char *veracrypt_keyfiles = NULL;
6250 uint veracrypt_pim = 0;
6251 uint workload_profile = WORKLOAD_PROFILE;
6252 uint kernel_accel = KERNEL_ACCEL;
6253 uint kernel_loops = KERNEL_LOOPS;
6254 uint nvidia_spin_damp = NVIDIA_SPIN_DAMP;
6255 uint gpu_temp_disable = GPU_TEMP_DISABLE;
6256 #ifdef HAVE_HWMON
6257 uint gpu_temp_abort = GPU_TEMP_ABORT;
6258 uint gpu_temp_retain = GPU_TEMP_RETAIN;
6259 uint powertune_enable = POWERTUNE_ENABLE;
6260 #endif
6261 uint logfile_disable = LOGFILE_DISABLE;
6262 uint segment_size = SEGMENT_SIZE;
6263 uint scrypt_tmto = SCRYPT_TMTO;
6264 char separator = SEPARATOR;
6265 uint bitmap_min = BITMAP_MIN;
6266 uint bitmap_max = BITMAP_MAX;
6267 char *custom_charset_1 = NULL;
6268 char *custom_charset_2 = NULL;
6269 char *custom_charset_3 = NULL;
6270 char *custom_charset_4 = NULL;
6271
6272 #define IDX_HELP 'h'
6273 #define IDX_VERSION 'V'
6274 #define IDX_VERSION_LOWER 'v'
6275 #define IDX_QUIET 0xff02
6276 #define IDX_SHOW 0xff03
6277 #define IDX_LEFT 0xff04
6278 #define IDX_REMOVE 0xff05
6279 #define IDX_REMOVE_TIMER 0xff37
6280 #define IDX_SKIP 's'
6281 #define IDX_LIMIT 'l'
6282 #define IDX_KEYSPACE 0xff35
6283 #define IDX_POTFILE_DISABLE 0xff06
6284 #define IDX_POTFILE_PATH 0xffe0
6285 #define IDX_DEBUG_MODE 0xff43
6286 #define IDX_DEBUG_FILE 0xff44
6287 #define IDX_INDUCTION_DIR 0xff46
6288 #define IDX_OUTFILE_CHECK_DIR 0xff47
6289 #define IDX_USERNAME 0xff07
6290 #define IDX_FORCE 0xff08
6291 #define IDX_RUNTIME 0xff09
6292 #define IDX_BENCHMARK 'b'
6293 #define IDX_STDOUT_FLAG 0xff77
6294 #define IDX_HASH_MODE 'm'
6295 #define IDX_ATTACK_MODE 'a'
6296 #define IDX_RP_FILE 'r'
6297 #define IDX_RP_GEN 'g'
6298 #define IDX_RP_GEN_FUNC_MIN 0xff10
6299 #define IDX_RP_GEN_FUNC_MAX 0xff11
6300 #define IDX_RP_GEN_SEED 0xff34
6301 #define IDX_RULE_BUF_L 'j'
6302 #define IDX_RULE_BUF_R 'k'
6303 #define IDX_INCREMENT 'i'
6304 #define IDX_INCREMENT_MIN 0xff12
6305 #define IDX_INCREMENT_MAX 0xff13
6306 #define IDX_OUTFILE 'o'
6307 #define IDX_OUTFILE_FORMAT 0xff14
6308 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
6309 #define IDX_OUTFILE_CHECK_TIMER 0xff45
6310 #define IDX_RESTORE 0xff15
6311 #define IDX_RESTORE_DISABLE 0xff27
6312 #define IDX_STATUS 0xff17
6313 #define IDX_STATUS_TIMER 0xff18
6314 #define IDX_MACHINE_READABLE 0xff50
6315 #define IDX_LOOPBACK 0xff38
6316 #define IDX_WEAK_HASH_THRESHOLD 0xff42
6317 #define IDX_SESSION 0xff19
6318 #define IDX_HEX_CHARSET 0xff20
6319 #define IDX_HEX_SALT 0xff21
6320 #define IDX_HEX_WORDLIST 0xff40
6321 #define IDX_MARKOV_DISABLE 0xff22
6322 #define IDX_MARKOV_CLASSIC 0xff23
6323 #define IDX_MARKOV_THRESHOLD 't'
6324 #define IDX_MARKOV_HCSTAT 0xff24
6325 #define IDX_CPU_AFFINITY 0xff25
6326 #define IDX_OPENCL_DEVICES 'd'
6327 #define IDX_OPENCL_PLATFORMS 0xff72
6328 #define IDX_OPENCL_DEVICE_TYPES 'D'
6329 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
6330 #define IDX_WORKLOAD_PROFILE 'w'
6331 #define IDX_KERNEL_ACCEL 'n'
6332 #define IDX_KERNEL_LOOPS 'u'
6333 #define IDX_NVIDIA_SPIN_DAMP 0xff79
6334 #define IDX_GPU_TEMP_DISABLE 0xff29
6335 #define IDX_GPU_TEMP_ABORT 0xff30
6336 #define IDX_GPU_TEMP_RETAIN 0xff31
6337 #define IDX_POWERTUNE_ENABLE 0xff41
6338 #define IDX_LOGFILE_DISABLE 0xff51
6339 #define IDX_TRUECRYPT_KEYFILES 0xff52
6340 #define IDX_VERACRYPT_KEYFILES 0xff53
6341 #define IDX_VERACRYPT_PIM 0xff54
6342 #define IDX_SCRYPT_TMTO 0xff61
6343 #define IDX_SEGMENT_SIZE 'c'
6344 #define IDX_SEPARATOR 'p'
6345 #define IDX_BITMAP_MIN 0xff70
6346 #define IDX_BITMAP_MAX 0xff71
6347 #define IDX_CUSTOM_CHARSET_1 '1'
6348 #define IDX_CUSTOM_CHARSET_2 '2'
6349 #define IDX_CUSTOM_CHARSET_3 '3'
6350 #define IDX_CUSTOM_CHARSET_4 '4'
6351
6352 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:";
6353
6354 struct option long_options[] =
6355 {
6356 {"help", no_argument, 0, IDX_HELP},
6357 {"version", no_argument, 0, IDX_VERSION},
6358 {"quiet", no_argument, 0, IDX_QUIET},
6359 {"show", no_argument, 0, IDX_SHOW},
6360 {"left", no_argument, 0, IDX_LEFT},
6361 {"username", no_argument, 0, IDX_USERNAME},
6362 {"remove", no_argument, 0, IDX_REMOVE},
6363 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
6364 {"skip", required_argument, 0, IDX_SKIP},
6365 {"limit", required_argument, 0, IDX_LIMIT},
6366 {"keyspace", no_argument, 0, IDX_KEYSPACE},
6367 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
6368 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
6369 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
6370 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
6371 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
6372 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
6373 {"force", no_argument, 0, IDX_FORCE},
6374 {"benchmark", no_argument, 0, IDX_BENCHMARK},
6375 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
6376 {"restore", no_argument, 0, IDX_RESTORE},
6377 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
6378 {"status", no_argument, 0, IDX_STATUS},
6379 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
6380 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
6381 {"loopback", no_argument, 0, IDX_LOOPBACK},
6382 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
6383 {"session", required_argument, 0, IDX_SESSION},
6384 {"runtime", required_argument, 0, IDX_RUNTIME},
6385 {"generate-rules", required_argument, 0, IDX_RP_GEN},
6386 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
6387 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
6388 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
6389 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
6390 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
6391 {"hash-type", required_argument, 0, IDX_HASH_MODE},
6392 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
6393 {"rules-file", required_argument, 0, IDX_RP_FILE},
6394 {"outfile", required_argument, 0, IDX_OUTFILE},
6395 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
6396 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
6397 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
6398 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
6399 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
6400 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
6401 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
6402 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
6403 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
6404 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
6405 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
6406 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
6407 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
6408 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
6409 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
6410 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
6411 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
6412 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
6413 {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP},
6414 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
6415 #ifdef HAVE_HWMON
6416 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
6417 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
6418 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
6419 #endif // HAVE_HWMON
6420 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
6421 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
6422 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
6423 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
6424 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
6425 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
6426 {"seperator", required_argument, 0, IDX_SEPARATOR},
6427 {"separator", required_argument, 0, IDX_SEPARATOR},
6428 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
6429 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
6430 {"increment", no_argument, 0, IDX_INCREMENT},
6431 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
6432 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
6433 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
6434 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
6435 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
6436 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
6437 {0, 0, 0, 0}
6438 };
6439
6440 uint rp_files_cnt = 0;
6441
6442 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6443
6444 int option_index = 0;
6445 int c = -1;
6446
6447 optind = 1;
6448 optopt = 0;
6449
6450 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6451 {
6452 switch (c)
6453 {
6454 case IDX_HELP: usage = 1; break;
6455 case IDX_VERSION:
6456 case IDX_VERSION_LOWER: version = 1; break;
6457 case IDX_RESTORE: restore = 1; break;
6458 case IDX_SESSION: session = optarg; break;
6459 case IDX_SHOW: show = 1; break;
6460 case IDX_LEFT: left = 1; break;
6461 case '?': return -1;
6462 }
6463 }
6464
6465 if (optopt != 0)
6466 {
6467 log_error ("ERROR: Invalid argument specified");
6468
6469 return -1;
6470 }
6471
6472 /**
6473 * exit functions
6474 */
6475
6476 if (version)
6477 {
6478 log_info ("%s", VERSION_TAG);
6479
6480 return 0;
6481 }
6482
6483 if (usage)
6484 {
6485 usage_big_print (PROGNAME);
6486
6487 return 0;
6488 }
6489
6490 /**
6491 * session needs to be set, always!
6492 */
6493
6494 if (session == NULL) session = (char *) PROGNAME;
6495
6496 /**
6497 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6498 */
6499
6500 char *exec_path = get_exec_path ();
6501
6502
6503 #if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__)
6504
6505 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6506 char *resolved_exec_path = realpath (exec_path, NULL);
6507
6508 if (resolved_install_folder == NULL)
6509 {
6510 log_error ("ERROR: %s: %s", resolved_install_folder, strerror (errno));
6511
6512 return -1;
6513 }
6514
6515 if (resolved_exec_path == NULL)
6516 {
6517 log_error ("ERROR: %s: %s", resolved_exec_path, strerror (errno));
6518
6519 return -1;
6520 }
6521
6522 char *install_dir = get_install_dir (resolved_exec_path);
6523 char *profile_dir = NULL;
6524 char *session_dir = NULL;
6525 char *shared_dir = NULL;
6526
6527 if (strcmp (install_dir, resolved_install_folder) == 0)
6528 {
6529 struct passwd *pw = getpwuid (getuid ());
6530
6531 const char *homedir = pw->pw_dir;
6532
6533 profile_dir = get_profile_dir (homedir);
6534 session_dir = get_session_dir (profile_dir);
6535 shared_dir = strdup (SHARED_FOLDER);
6536
6537 mkdir (profile_dir, 0700);
6538 mkdir (session_dir, 0700);
6539 }
6540 else
6541 {
6542 profile_dir = install_dir;
6543 session_dir = install_dir;
6544 shared_dir = install_dir;
6545 }
6546
6547 myfree (resolved_install_folder);
6548 myfree (resolved_exec_path);
6549
6550 #else
6551
6552 char *install_dir = get_install_dir (exec_path);
6553 char *profile_dir = install_dir;
6554 char *session_dir = install_dir;
6555 char *shared_dir = install_dir;
6556
6557 #endif
6558
6559 data.install_dir = install_dir;
6560 data.profile_dir = profile_dir;
6561 data.session_dir = session_dir;
6562 data.shared_dir = shared_dir;
6563
6564 myfree (exec_path);
6565
6566 /**
6567 * kernel cache, we need to make sure folder exist
6568 */
6569
6570 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6571
6572 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6573
6574 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6575
6576 mkdir (kernels_folder, 0700);
6577
6578 myfree (kernels_folder);
6579
6580 /**
6581 * session
6582 */
6583
6584 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6585
6586 data.session = session;
6587
6588 char *eff_restore_file = (char *) mymalloc (session_size);
6589 char *new_restore_file = (char *) mymalloc (session_size);
6590
6591 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6592 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6593
6594 data.eff_restore_file = eff_restore_file;
6595 data.new_restore_file = new_restore_file;
6596
6597 if (((show == 1) || (left == 1)) && (restore == 1))
6598 {
6599 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6600 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6601
6602 return -1;
6603 }
6604
6605 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6606 if ((show == 1) || (left == 1))
6607 {
6608 restore_disable = 1;
6609
6610 restore = 0;
6611 }
6612
6613 data.restore_disable = restore_disable;
6614
6615 restore_data_t *rd = init_restore (argc, argv);
6616
6617 data.rd = rd;
6618
6619 /**
6620 * restore file
6621 */
6622
6623 if (restore == 1)
6624 {
6625 read_restore (eff_restore_file, rd);
6626
6627 if (rd->version_bin < RESTORE_MIN)
6628 {
6629 log_error ("ERROR: Incompatible restore-file version");
6630
6631 return -1;
6632 }
6633
6634 myargc = rd->argc;
6635 myargv = rd->argv;
6636
6637 #ifdef _POSIX
6638 rd->pid = getpid ();
6639 #elif _WIN
6640 rd->pid = GetCurrentProcessId ();
6641 #endif
6642 }
6643
6644 uint hash_mode_chgd = 0;
6645 uint runtime_chgd = 0;
6646 uint kernel_loops_chgd = 0;
6647 uint kernel_accel_chgd = 0;
6648 uint nvidia_spin_damp_chgd = 0;
6649 uint attack_mode_chgd = 0;
6650 uint outfile_format_chgd = 0;
6651 uint rp_gen_seed_chgd = 0;
6652 uint remove_timer_chgd = 0;
6653 uint increment_min_chgd = 0;
6654 uint increment_max_chgd = 0;
6655 uint workload_profile_chgd = 0;
6656 uint opencl_vector_width_chgd = 0;
6657
6658 optind = 1;
6659 optopt = 0;
6660 option_index = 0;
6661
6662 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6663 {
6664 switch (c)
6665 {
6666 //case IDX_HELP: usage = 1; break;
6667 //case IDX_VERSION: version = 1; break;
6668 //case IDX_RESTORE: restore = 1; break;
6669 case IDX_QUIET: quiet = 1; break;
6670 //case IDX_SHOW: show = 1; break;
6671 case IDX_SHOW: break;
6672 //case IDX_LEFT: left = 1; break;
6673 case IDX_LEFT: break;
6674 case IDX_USERNAME: username = 1; break;
6675 case IDX_REMOVE: remove = 1; break;
6676 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6677 remove_timer_chgd = 1; break;
6678 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6679 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6680 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6681 case IDX_DEBUG_FILE: debug_file = optarg; break;
6682 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6683 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6684 case IDX_FORCE: force = 1; break;
6685 case IDX_SKIP: skip = atoll (optarg); break;
6686 case IDX_LIMIT: limit = atoll (optarg); break;
6687 case IDX_KEYSPACE: keyspace = 1; break;
6688 case IDX_BENCHMARK: benchmark = 1; break;
6689 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6690 case IDX_RESTORE: break;
6691 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6692 case IDX_STATUS: status = 1; break;
6693 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6694 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6695 case IDX_LOOPBACK: loopback = 1; break;
6696 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6697 //case IDX_SESSION: session = optarg; break;
6698 case IDX_SESSION: break;
6699 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6700 hash_mode_chgd = 1; break;
6701 case IDX_RUNTIME: runtime = atoi (optarg);
6702 runtime_chgd = 1; break;
6703 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6704 attack_mode_chgd = 1; break;
6705 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6706 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6707 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6708 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6709 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6710 rp_gen_seed_chgd = 1; break;
6711 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6712 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6713 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6714 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6715 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6716 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6717 case IDX_OUTFILE: outfile = optarg; break;
6718 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6719 outfile_format_chgd = 1; break;
6720 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6721 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6722 case IDX_HEX_CHARSET: hex_charset = 1; break;
6723 case IDX_HEX_SALT: hex_salt = 1; break;
6724 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6725 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6726 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6727 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6728 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6729 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6730 opencl_vector_width_chgd = 1; break;
6731 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6732 workload_profile_chgd = 1; break;
6733 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6734 kernel_accel_chgd = 1; break;
6735 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6736 kernel_loops_chgd = 1; break;
6737 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6738 nvidia_spin_damp_chgd = 1; break;
6739 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6740 #ifdef HAVE_HWMON
6741 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6742 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6743 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6744 #endif // HAVE_HWMON
6745 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6746 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6747 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6748 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6749 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6750 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6751 case IDX_SEPARATOR: separator = optarg[0]; break;
6752 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6753 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6754 case IDX_INCREMENT: increment = 1; break;
6755 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6756 increment_min_chgd = 1; break;
6757 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6758 increment_max_chgd = 1; break;
6759 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6760 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6761 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6762 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6763
6764 default:
6765 log_error ("ERROR: Invalid argument specified");
6766 return -1;
6767 }
6768 }
6769
6770 if (optopt != 0)
6771 {
6772 log_error ("ERROR: Invalid argument specified");
6773
6774 return -1;
6775 }
6776
6777 /**
6778 * Inform user things getting started,
6779 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6780 * - we do not need to check algorithm_pos
6781 */
6782
6783 if (quiet == 0)
6784 {
6785 if (benchmark == 1)
6786 {
6787 if (machine_readable == 0)
6788 {
6789 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6790 log_info ("");
6791 }
6792 else
6793 {
6794 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6795 }
6796 }
6797 else if (restore == 1)
6798 {
6799 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6800 log_info ("");
6801 }
6802 else if (stdout_flag == 1)
6803 {
6804 // do nothing
6805 }
6806 else if (keyspace == 1)
6807 {
6808 // do nothing
6809 }
6810 else
6811 {
6812 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6813 log_info ("");
6814 }
6815 }
6816
6817 /**
6818 * sanity check
6819 */
6820
6821 if (attack_mode > 7)
6822 {
6823 log_error ("ERROR: Invalid attack-mode specified");
6824
6825 return -1;
6826 }
6827
6828 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6829 {
6830 log_error ("ERROR: Invalid runtime specified");
6831
6832 return -1;
6833 }
6834
6835 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6836 {
6837 log_error ("ERROR: Invalid hash-type specified");
6838
6839 return -1;
6840 }
6841
6842 // renamed hash modes
6843
6844 if (hash_mode_chgd)
6845 {
6846 int n = -1;
6847
6848 switch (hash_mode)
6849 {
6850 case 123: n = 124;
6851 break;
6852 }
6853
6854 if (n >= 0)
6855 {
6856 log_error ("Old -m specified, use -m %d instead", n);
6857
6858 return -1;
6859 }
6860 }
6861
6862 if (username == 1)
6863 {
6864 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6865 {
6866 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6867
6868 return -1;
6869 }
6870 }
6871
6872 if (outfile_format > 16)
6873 {
6874 log_error ("ERROR: Invalid outfile-format specified");
6875
6876 return -1;
6877 }
6878
6879 if (left == 1)
6880 {
6881 if (outfile_format_chgd == 1)
6882 {
6883 if (outfile_format > 1)
6884 {
6885 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6886
6887 return -1;
6888 }
6889 }
6890 else
6891 {
6892 outfile_format = OUTFILE_FMT_HASH;
6893 }
6894 }
6895
6896 if (show == 1)
6897 {
6898 if (outfile_format_chgd == 1)
6899 {
6900 if ((outfile_format > 7) && (outfile_format < 16))
6901 {
6902 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6903
6904 return -1;
6905 }
6906 }
6907 }
6908
6909 if (increment_min < INCREMENT_MIN)
6910 {
6911 log_error ("ERROR: Invalid increment-min specified");
6912
6913 return -1;
6914 }
6915
6916 if (increment_max > INCREMENT_MAX)
6917 {
6918 log_error ("ERROR: Invalid increment-max specified");
6919
6920 return -1;
6921 }
6922
6923 if (increment_min > increment_max)
6924 {
6925 log_error ("ERROR: Invalid increment-min specified");
6926
6927 return -1;
6928 }
6929
6930 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6931 {
6932 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6933
6934 return -1;
6935 }
6936
6937 if ((increment == 0) && (increment_min_chgd == 1))
6938 {
6939 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6940
6941 return -1;
6942 }
6943
6944 if ((increment == 0) && (increment_max_chgd == 1))
6945 {
6946 log_error ("ERROR: Increment-max is only supported combined with increment switch");
6947
6948 return -1;
6949 }
6950
6951 if (rp_files_cnt && rp_gen)
6952 {
6953 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6954
6955 return -1;
6956 }
6957
6958 if (rp_files_cnt || rp_gen)
6959 {
6960 if (attack_mode != ATTACK_MODE_STRAIGHT)
6961 {
6962 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6963
6964 return -1;
6965 }
6966 }
6967
6968 if (rp_gen_func_min > rp_gen_func_max)
6969 {
6970 log_error ("ERROR: Invalid rp-gen-func-min specified");
6971
6972 return -1;
6973 }
6974
6975 if (kernel_accel_chgd == 1)
6976 {
6977 if (force == 0)
6978 {
6979 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
6980 log_info ("Please consider using the -w option instead");
6981 log_info ("You can use --force to override this but do not post error reports if you do so");
6982 log_info ("");
6983
6984 return -1;
6985 }
6986
6987 if (kernel_accel < 1)
6988 {
6989 log_error ("ERROR: Invalid kernel-accel specified");
6990
6991 return -1;
6992 }
6993
6994 if (kernel_accel > 1024)
6995 {
6996 log_error ("ERROR: Invalid kernel-accel specified");
6997
6998 return -1;
6999 }
7000 }
7001
7002 if (kernel_loops_chgd == 1)
7003 {
7004 if (force == 0)
7005 {
7006 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
7007 log_info ("Please consider using the -w option instead");
7008 log_info ("You can use --force to override this but do not post error reports if you do so");
7009 log_info ("");
7010
7011 return -1;
7012 }
7013
7014 if (kernel_loops < 1)
7015 {
7016 log_error ("ERROR: Invalid kernel-loops specified");
7017
7018 return -1;
7019 }
7020
7021 if (kernel_loops > 1024)
7022 {
7023 log_error ("ERROR: Invalid kernel-loops specified");
7024
7025 return -1;
7026 }
7027 }
7028
7029 if ((workload_profile < 1) || (workload_profile > 4))
7030 {
7031 log_error ("ERROR: workload-profile %i not available", workload_profile);
7032
7033 return -1;
7034 }
7035
7036 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
7037 {
7038 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
7039
7040 return -1;
7041 }
7042
7043 if (show == 1 || left == 1)
7044 {
7045 attack_mode = ATTACK_MODE_NONE;
7046
7047 if (remove == 1)
7048 {
7049 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
7050
7051 return -1;
7052 }
7053
7054 if (potfile_disable == 1)
7055 {
7056 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
7057
7058 return -1;
7059 }
7060 }
7061
7062 uint attack_kern = ATTACK_KERN_NONE;
7063
7064 switch (attack_mode)
7065 {
7066 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
7067 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
7068 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
7069 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
7070 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
7071 }
7072
7073 if (benchmark == 1)
7074 {
7075 if (myargv[optind] != 0)
7076 {
7077 log_error ("ERROR: Invalid argument for benchmark mode specified");
7078
7079 return -1;
7080 }
7081
7082 if (attack_mode_chgd == 1)
7083 {
7084 if (attack_mode != ATTACK_MODE_BF)
7085 {
7086 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
7087
7088 return -1;
7089 }
7090 }
7091 }
7092 else
7093 {
7094 if (stdout_flag == 1) // no hash here
7095 {
7096 optind--;
7097 }
7098
7099 if (keyspace == 1)
7100 {
7101 int num_additional_params = 1;
7102
7103 if (attack_kern == ATTACK_KERN_COMBI)
7104 {
7105 num_additional_params = 2;
7106 }
7107
7108 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
7109
7110 if (keyspace_wordlist_specified == 0) optind--;
7111 }
7112
7113 if (attack_kern == ATTACK_KERN_NONE)
7114 {
7115 if ((optind + 1) != myargc)
7116 {
7117 usage_mini_print (myargv[0]);
7118
7119 return -1;
7120 }
7121 }
7122 else if (attack_kern == ATTACK_KERN_STRAIGHT)
7123 {
7124 if ((optind + 1) > myargc)
7125 {
7126 usage_mini_print (myargv[0]);
7127
7128 return -1;
7129 }
7130 }
7131 else if (attack_kern == ATTACK_KERN_COMBI)
7132 {
7133 if ((optind + 3) != myargc)
7134 {
7135 usage_mini_print (myargv[0]);
7136
7137 return -1;
7138 }
7139 }
7140 else if (attack_kern == ATTACK_KERN_BF)
7141 {
7142 if ((optind + 1) > myargc)
7143 {
7144 usage_mini_print (myargv[0]);
7145
7146 return -1;
7147 }
7148 }
7149 else
7150 {
7151 usage_mini_print (myargv[0]);
7152
7153 return -1;
7154 }
7155 }
7156
7157 if (skip != 0 && limit != 0)
7158 {
7159 limit += skip;
7160 }
7161
7162 if (keyspace == 1)
7163 {
7164 if (show == 1)
7165 {
7166 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
7167
7168 return -1;
7169 }
7170 else if (left == 1)
7171 {
7172 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
7173
7174 return -1;
7175 }
7176
7177 potfile_disable = 1;
7178
7179 restore_disable = 1;
7180
7181 restore = 0;
7182
7183 weak_hash_threshold = 0;
7184
7185 quiet = 1;
7186 }
7187
7188 if (stdout_flag == 1)
7189 {
7190 status_timer = 0;
7191 restore_timer = 0;
7192 restore_disable = 1;
7193 restore = 0;
7194 potfile_disable = 1;
7195 weak_hash_threshold = 0;
7196 gpu_temp_disable = 1;
7197 hash_mode = 2000;
7198 quiet = 1;
7199 outfile_format = OUTFILE_FMT_PLAIN;
7200 kernel_accel = 1024;
7201 kernel_loops = 1024;
7202 force = 1;
7203 outfile_check_timer = 0;
7204 session = "stdout";
7205 opencl_vector_width = 1;
7206 }
7207
7208 if (remove_timer_chgd == 1)
7209 {
7210 if (remove == 0)
7211 {
7212 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
7213
7214 return -1;
7215 }
7216
7217 if (remove_timer < 1)
7218 {
7219 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
7220
7221 return -1;
7222 }
7223 }
7224
7225 if (loopback == 1)
7226 {
7227 if (attack_mode == ATTACK_MODE_STRAIGHT)
7228 {
7229 if ((rp_files_cnt == 0) && (rp_gen == 0))
7230 {
7231 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
7232
7233 return -1;
7234 }
7235 }
7236 else
7237 {
7238 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
7239
7240 return -1;
7241 }
7242 }
7243
7244 if (debug_mode > 0)
7245 {
7246 if (attack_mode != ATTACK_MODE_STRAIGHT)
7247 {
7248 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
7249
7250 return -1;
7251 }
7252
7253 if ((rp_files_cnt == 0) && (rp_gen == 0))
7254 {
7255 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
7256
7257 return -1;
7258 }
7259 }
7260
7261 if (debug_mode > 4)
7262 {
7263 log_error ("ERROR: Invalid debug-mode specified");
7264
7265 return -1;
7266 }
7267
7268 if (debug_file != NULL)
7269 {
7270 if (debug_mode < 1)
7271 {
7272 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
7273
7274 return -1;
7275 }
7276 }
7277
7278 if (induction_dir != NULL)
7279 {
7280 if (attack_mode == ATTACK_MODE_BF)
7281 {
7282 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
7283
7284 return -1;
7285 }
7286 }
7287
7288 if (attack_mode != ATTACK_MODE_STRAIGHT)
7289 {
7290 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
7291 {
7292 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
7293
7294 return -1;
7295 }
7296
7297 weak_hash_threshold = 0;
7298 }
7299
7300 if (nvidia_spin_damp > 100)
7301 {
7302 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
7303
7304 return -1;
7305 }
7306
7307
7308 /**
7309 * induction directory
7310 */
7311
7312 char *induction_directory = NULL;
7313
7314 if (attack_mode != ATTACK_MODE_BF)
7315 {
7316 if (induction_dir == NULL)
7317 {
7318 induction_directory = (char *) mymalloc (session_size);
7319
7320 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
7321
7322 // create induction folder if it does not already exist
7323
7324 if (keyspace == 0)
7325 {
7326 if (rmdir (induction_directory) == -1)
7327 {
7328 if (errno == ENOENT)
7329 {
7330 // good, we can ignore
7331 }
7332 else if (errno == ENOTEMPTY)
7333 {
7334 char *induction_directory_mv = (char *) mymalloc (session_size);
7335
7336 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7337
7338 if (rename (induction_directory, induction_directory_mv) != 0)
7339 {
7340 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7341
7342 return -1;
7343 }
7344 }
7345 else
7346 {
7347 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7348
7349 return -1;
7350 }
7351 }
7352
7353 if (mkdir (induction_directory, 0700) == -1)
7354 {
7355 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7356
7357 return -1;
7358 }
7359 }
7360 }
7361 else
7362 {
7363 induction_directory = induction_dir;
7364 }
7365 }
7366
7367 data.induction_directory = induction_directory;
7368
7369 /**
7370 * loopback
7371 */
7372
7373 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7374
7375 char *loopback_file = (char *) mymalloc (loopback_size);
7376
7377 /**
7378 * tuning db
7379 */
7380
7381 char tuning_db_file[256] = { 0 };
7382
7383 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7384
7385 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7386
7387 /**
7388 * outfile-check directory
7389 */
7390
7391 char *outfile_check_directory = NULL;
7392
7393 if (outfile_check_dir == NULL)
7394 {
7395 outfile_check_directory = (char *) mymalloc (session_size);
7396
7397 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7398 }
7399 else
7400 {
7401 outfile_check_directory = outfile_check_dir;
7402 }
7403
7404 data.outfile_check_directory = outfile_check_directory;
7405
7406 if (keyspace == 0)
7407 {
7408 struct stat outfile_check_stat;
7409
7410 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7411 {
7412 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7413
7414 if (is_dir == 0)
7415 {
7416 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7417
7418 return -1;
7419 }
7420 }
7421 else if (outfile_check_dir == NULL)
7422 {
7423 if (mkdir (outfile_check_directory, 0700) == -1)
7424 {
7425 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7426
7427 return -1;
7428 }
7429 }
7430 }
7431
7432 /**
7433 * special other stuff
7434 */
7435
7436 if (hash_mode == 9710)
7437 {
7438 outfile_format = 5;
7439 outfile_format_chgd = 1;
7440 }
7441
7442 if (hash_mode == 9810)
7443 {
7444 outfile_format = 5;
7445 outfile_format_chgd = 1;
7446 }
7447
7448 if (hash_mode == 10410)
7449 {
7450 outfile_format = 5;
7451 outfile_format_chgd = 1;
7452 }
7453
7454 /**
7455 * store stuff
7456 */
7457
7458 data.hash_mode = hash_mode;
7459 data.restore = restore;
7460 data.restore_timer = restore_timer;
7461 data.restore_disable = restore_disable;
7462 data.status = status;
7463 data.status_timer = status_timer;
7464 data.machine_readable = machine_readable;
7465 data.loopback = loopback;
7466 data.runtime = runtime;
7467 data.remove = remove;
7468 data.remove_timer = remove_timer;
7469 data.debug_mode = debug_mode;
7470 data.debug_file = debug_file;
7471 data.username = username;
7472 data.quiet = quiet;
7473 data.outfile = outfile;
7474 data.outfile_format = outfile_format;
7475 data.outfile_autohex = outfile_autohex;
7476 data.hex_charset = hex_charset;
7477 data.hex_salt = hex_salt;
7478 data.hex_wordlist = hex_wordlist;
7479 data.separator = separator;
7480 data.rp_files = rp_files;
7481 data.rp_files_cnt = rp_files_cnt;
7482 data.rp_gen = rp_gen;
7483 data.rp_gen_seed = rp_gen_seed;
7484 data.force = force;
7485 data.benchmark = benchmark;
7486 data.skip = skip;
7487 data.limit = limit;
7488 #ifdef HAVE_HWMON
7489 data.powertune_enable = powertune_enable;
7490 #endif
7491 data.logfile_disable = logfile_disable;
7492 data.truecrypt_keyfiles = truecrypt_keyfiles;
7493 data.veracrypt_keyfiles = veracrypt_keyfiles;
7494 data.veracrypt_pim = veracrypt_pim;
7495 data.scrypt_tmto = scrypt_tmto;
7496 data.workload_profile = workload_profile;
7497
7498 /**
7499 * cpu affinity
7500 */
7501
7502 if (cpu_affinity)
7503 {
7504 set_cpu_affinity (cpu_affinity);
7505 }
7506
7507 if (rp_gen_seed_chgd == 0)
7508 {
7509 srand (proc_start);
7510 }
7511 else
7512 {
7513 srand (rp_gen_seed);
7514 }
7515
7516 /**
7517 * logfile init
7518 */
7519
7520 if (logfile_disable == 0)
7521 {
7522 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7523
7524 char *logfile = (char *) mymalloc (logfile_size);
7525
7526 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7527
7528 data.logfile = logfile;
7529
7530 char *topid = logfile_generate_topid ();
7531
7532 data.topid = topid;
7533 }
7534
7535 // logfile_append() checks for logfile_disable internally to make it easier from here
7536
7537 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7538 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7539 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7540 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7541 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7542 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7543 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7544 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7545 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7546 #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));
7547
7548 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7549 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7550 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7551 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7552 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7553 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7554 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7555 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7556
7557 logfile_top_msg ("START");
7558
7559 logfile_top_uint (attack_mode);
7560 logfile_top_uint (attack_kern);
7561 logfile_top_uint (benchmark);
7562 logfile_top_uint (stdout_flag);
7563 logfile_top_uint (bitmap_min);
7564 logfile_top_uint (bitmap_max);
7565 logfile_top_uint (debug_mode);
7566 logfile_top_uint (force);
7567 logfile_top_uint (kernel_accel);
7568 logfile_top_uint (kernel_loops);
7569 logfile_top_uint (nvidia_spin_damp);
7570 logfile_top_uint (gpu_temp_disable);
7571 #ifdef HAVE_HWMON
7572 logfile_top_uint (gpu_temp_abort);
7573 logfile_top_uint (gpu_temp_retain);
7574 #endif
7575 logfile_top_uint (hash_mode);
7576 logfile_top_uint (hex_charset);
7577 logfile_top_uint (hex_salt);
7578 logfile_top_uint (hex_wordlist);
7579 logfile_top_uint (increment);
7580 logfile_top_uint (increment_max);
7581 logfile_top_uint (increment_min);
7582 logfile_top_uint (keyspace);
7583 logfile_top_uint (left);
7584 logfile_top_uint (logfile_disable);
7585 logfile_top_uint (loopback);
7586 logfile_top_uint (markov_classic);
7587 logfile_top_uint (markov_disable);
7588 logfile_top_uint (markov_threshold);
7589 logfile_top_uint (outfile_autohex);
7590 logfile_top_uint (outfile_check_timer);
7591 logfile_top_uint (outfile_format);
7592 logfile_top_uint (potfile_disable);
7593 logfile_top_string (potfile_path);
7594 #if defined(HAVE_HWMON)
7595 logfile_top_uint (powertune_enable);
7596 #endif
7597 logfile_top_uint (scrypt_tmto);
7598 logfile_top_uint (quiet);
7599 logfile_top_uint (remove);
7600 logfile_top_uint (remove_timer);
7601 logfile_top_uint (restore);
7602 logfile_top_uint (restore_disable);
7603 logfile_top_uint (restore_timer);
7604 logfile_top_uint (rp_gen);
7605 logfile_top_uint (rp_gen_func_max);
7606 logfile_top_uint (rp_gen_func_min);
7607 logfile_top_uint (rp_gen_seed);
7608 logfile_top_uint (runtime);
7609 logfile_top_uint (segment_size);
7610 logfile_top_uint (show);
7611 logfile_top_uint (status);
7612 logfile_top_uint (machine_readable);
7613 logfile_top_uint (status_timer);
7614 logfile_top_uint (usage);
7615 logfile_top_uint (username);
7616 logfile_top_uint (version);
7617 logfile_top_uint (weak_hash_threshold);
7618 logfile_top_uint (workload_profile);
7619 logfile_top_uint64 (limit);
7620 logfile_top_uint64 (skip);
7621 logfile_top_char (separator);
7622 logfile_top_string (cpu_affinity);
7623 logfile_top_string (custom_charset_1);
7624 logfile_top_string (custom_charset_2);
7625 logfile_top_string (custom_charset_3);
7626 logfile_top_string (custom_charset_4);
7627 logfile_top_string (debug_file);
7628 logfile_top_string (opencl_devices);
7629 logfile_top_string (opencl_platforms);
7630 logfile_top_string (opencl_device_types);
7631 logfile_top_uint (opencl_vector_width);
7632 logfile_top_string (induction_dir);
7633 logfile_top_string (markov_hcstat);
7634 logfile_top_string (outfile);
7635 logfile_top_string (outfile_check_dir);
7636 logfile_top_string (rule_buf_l);
7637 logfile_top_string (rule_buf_r);
7638 logfile_top_string (session);
7639 logfile_top_string (truecrypt_keyfiles);
7640 logfile_top_string (veracrypt_keyfiles);
7641 logfile_top_uint (veracrypt_pim);
7642
7643 /**
7644 * Init OpenCL library loader
7645 */
7646
7647 if (keyspace == 0)
7648 {
7649 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7650
7651 ocl_init (ocl);
7652
7653 data.ocl = ocl;
7654 }
7655
7656 /**
7657 * OpenCL platform selection
7658 */
7659
7660 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7661
7662 /**
7663 * OpenCL device selection
7664 */
7665
7666 u32 devices_filter = setup_devices_filter (opencl_devices);
7667
7668 /**
7669 * OpenCL device type selection
7670 */
7671
7672 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7673
7674 /**
7675 * benchmark
7676 */
7677
7678 if (benchmark == 1)
7679 {
7680 /**
7681 * disable useless stuff for benchmark
7682 */
7683
7684 status_timer = 0;
7685 restore_timer = 0;
7686 restore_disable = 1;
7687 potfile_disable = 1;
7688 weak_hash_threshold = 0;
7689 nvidia_spin_damp = 0;
7690 gpu_temp_disable = 1;
7691 outfile_check_timer = 0;
7692
7693 #ifdef HAVE_HWMON
7694 if (powertune_enable == 1)
7695 {
7696 gpu_temp_disable = 0;
7697 }
7698 #endif
7699
7700 data.status_timer = status_timer;
7701 data.restore_timer = restore_timer;
7702 data.restore_disable = restore_disable;
7703 data.outfile_check_timer = outfile_check_timer;
7704
7705 /**
7706 * force attack mode to be bruteforce
7707 */
7708
7709 attack_mode = ATTACK_MODE_BF;
7710 attack_kern = ATTACK_KERN_BF;
7711
7712 if (workload_profile_chgd == 0)
7713 {
7714 workload_profile = 3;
7715
7716 data.workload_profile = workload_profile;
7717 }
7718 }
7719
7720 /**
7721 * status, monitor and outfile remove threads
7722 */
7723
7724 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7725
7726 data.wordlist_mode = wordlist_mode;
7727
7728 if (wordlist_mode == WL_MODE_STDIN)
7729 {
7730 status = 1;
7731
7732 data.status = status;
7733 }
7734
7735 uint outer_threads_cnt = 0;
7736
7737 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7738
7739 data.shutdown_outer = 0;
7740
7741 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7742 {
7743 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7744 {
7745 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7746
7747 outer_threads_cnt++;
7748 }
7749 }
7750
7751 /**
7752 * config
7753 */
7754
7755 uint hash_type = 0;
7756 uint salt_type = 0;
7757 uint attack_exec = 0;
7758 uint opts_type = 0;
7759 uint kern_type = 0;
7760 uint dgst_size = 0;
7761 uint esalt_size = 0;
7762 uint opti_type = 0;
7763 uint dgst_pos0 = -1;
7764 uint dgst_pos1 = -1;
7765 uint dgst_pos2 = -1;
7766 uint dgst_pos3 = -1;
7767
7768 int (*parse_func) (char *, uint, hash_t *);
7769 int (*sort_by_digest) (const void *, const void *);
7770
7771 uint algorithm_pos = 0;
7772 uint algorithm_max = 1;
7773
7774 uint *algorithms = default_benchmark_algorithms;
7775
7776 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7777
7778 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7779 {
7780 /*
7781 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7782 * the following algos are skipped entirely
7783 */
7784
7785 if (algorithm_pos > 0)
7786 {
7787 local_free (rd);
7788
7789 rd = init_restore (argc, argv);
7790
7791 data.rd = rd;
7792 }
7793
7794 /**
7795 * update hash_mode in case of multihash benchmark
7796 */
7797
7798 if (benchmark == 1)
7799 {
7800 if (hash_mode_chgd == 0)
7801 {
7802 hash_mode = algorithms[algorithm_pos];
7803
7804 data.hash_mode = hash_mode;
7805 }
7806
7807 quiet = 1;
7808
7809 data.quiet = quiet;
7810 }
7811
7812 switch (hash_mode)
7813 {
7814 case 0: hash_type = HASH_TYPE_MD5;
7815 salt_type = SALT_TYPE_NONE;
7816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7817 opts_type = OPTS_TYPE_PT_GENERATE_LE
7818 | OPTS_TYPE_PT_ADD80
7819 | OPTS_TYPE_PT_ADDBITS14;
7820 kern_type = KERN_TYPE_MD5;
7821 dgst_size = DGST_SIZE_4_4;
7822 parse_func = md5_parse_hash;
7823 sort_by_digest = sort_by_digest_4_4;
7824 opti_type = OPTI_TYPE_ZERO_BYTE
7825 | OPTI_TYPE_PRECOMPUTE_INIT
7826 | OPTI_TYPE_PRECOMPUTE_MERKLE
7827 | OPTI_TYPE_MEET_IN_MIDDLE
7828 | OPTI_TYPE_EARLY_SKIP
7829 | OPTI_TYPE_NOT_ITERATED
7830 | OPTI_TYPE_NOT_SALTED
7831 | OPTI_TYPE_RAW_HASH;
7832 dgst_pos0 = 0;
7833 dgst_pos1 = 3;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 1;
7836 break;
7837
7838 case 10: hash_type = HASH_TYPE_MD5;
7839 salt_type = SALT_TYPE_INTERN;
7840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_LE
7842 | OPTS_TYPE_ST_ADD80
7843 | OPTS_TYPE_ST_ADDBITS14;
7844 kern_type = KERN_TYPE_MD5_PWSLT;
7845 dgst_size = DGST_SIZE_4_4;
7846 parse_func = md5s_parse_hash;
7847 sort_by_digest = sort_by_digest_4_4;
7848 opti_type = OPTI_TYPE_ZERO_BYTE
7849 | OPTI_TYPE_PRECOMPUTE_INIT
7850 | OPTI_TYPE_PRECOMPUTE_MERKLE
7851 | OPTI_TYPE_MEET_IN_MIDDLE
7852 | OPTI_TYPE_EARLY_SKIP
7853 | OPTI_TYPE_NOT_ITERATED
7854 | OPTI_TYPE_APPENDED_SALT
7855 | OPTI_TYPE_RAW_HASH;
7856 dgst_pos0 = 0;
7857 dgst_pos1 = 3;
7858 dgst_pos2 = 2;
7859 dgst_pos3 = 1;
7860 break;
7861
7862 case 11: hash_type = HASH_TYPE_MD5;
7863 salt_type = SALT_TYPE_INTERN;
7864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7865 opts_type = OPTS_TYPE_PT_GENERATE_LE
7866 | OPTS_TYPE_ST_ADD80
7867 | OPTS_TYPE_ST_ADDBITS14;
7868 kern_type = KERN_TYPE_MD5_PWSLT;
7869 dgst_size = DGST_SIZE_4_4;
7870 parse_func = joomla_parse_hash;
7871 sort_by_digest = sort_by_digest_4_4;
7872 opti_type = OPTI_TYPE_ZERO_BYTE
7873 | OPTI_TYPE_PRECOMPUTE_INIT
7874 | OPTI_TYPE_PRECOMPUTE_MERKLE
7875 | OPTI_TYPE_MEET_IN_MIDDLE
7876 | OPTI_TYPE_EARLY_SKIP
7877 | OPTI_TYPE_NOT_ITERATED
7878 | OPTI_TYPE_APPENDED_SALT
7879 | OPTI_TYPE_RAW_HASH;
7880 dgst_pos0 = 0;
7881 dgst_pos1 = 3;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 1;
7884 break;
7885
7886 case 12: hash_type = HASH_TYPE_MD5;
7887 salt_type = SALT_TYPE_INTERN;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_LE
7890 | OPTS_TYPE_ST_ADD80
7891 | OPTS_TYPE_ST_ADDBITS14;
7892 kern_type = KERN_TYPE_MD5_PWSLT;
7893 dgst_size = DGST_SIZE_4_4;
7894 parse_func = postgresql_parse_hash;
7895 sort_by_digest = sort_by_digest_4_4;
7896 opti_type = OPTI_TYPE_ZERO_BYTE
7897 | OPTI_TYPE_PRECOMPUTE_INIT
7898 | OPTI_TYPE_PRECOMPUTE_MERKLE
7899 | OPTI_TYPE_MEET_IN_MIDDLE
7900 | OPTI_TYPE_EARLY_SKIP
7901 | OPTI_TYPE_NOT_ITERATED
7902 | OPTI_TYPE_APPENDED_SALT
7903 | OPTI_TYPE_RAW_HASH;
7904 dgst_pos0 = 0;
7905 dgst_pos1 = 3;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 1;
7908 break;
7909
7910 case 20: hash_type = HASH_TYPE_MD5;
7911 salt_type = SALT_TYPE_INTERN;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_LE
7914 | OPTS_TYPE_PT_ADD80
7915 | OPTS_TYPE_PT_ADDBITS14;
7916 kern_type = KERN_TYPE_MD5_SLTPW;
7917 dgst_size = DGST_SIZE_4_4;
7918 parse_func = md5s_parse_hash;
7919 sort_by_digest = sort_by_digest_4_4;
7920 opti_type = OPTI_TYPE_ZERO_BYTE
7921 | OPTI_TYPE_PRECOMPUTE_INIT
7922 | OPTI_TYPE_PRECOMPUTE_MERKLE
7923 | OPTI_TYPE_EARLY_SKIP
7924 | OPTI_TYPE_NOT_ITERATED
7925 | OPTI_TYPE_PREPENDED_SALT
7926 | OPTI_TYPE_RAW_HASH;
7927 dgst_pos0 = 0;
7928 dgst_pos1 = 3;
7929 dgst_pos2 = 2;
7930 dgst_pos3 = 1;
7931 break;
7932
7933 case 21: hash_type = HASH_TYPE_MD5;
7934 salt_type = SALT_TYPE_INTERN;
7935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7936 opts_type = OPTS_TYPE_PT_GENERATE_LE
7937 | OPTS_TYPE_PT_ADD80
7938 | OPTS_TYPE_PT_ADDBITS14;
7939 kern_type = KERN_TYPE_MD5_SLTPW;
7940 dgst_size = DGST_SIZE_4_4;
7941 parse_func = osc_parse_hash;
7942 sort_by_digest = sort_by_digest_4_4;
7943 opti_type = OPTI_TYPE_ZERO_BYTE
7944 | OPTI_TYPE_PRECOMPUTE_INIT
7945 | OPTI_TYPE_PRECOMPUTE_MERKLE
7946 | OPTI_TYPE_EARLY_SKIP
7947 | OPTI_TYPE_NOT_ITERATED
7948 | OPTI_TYPE_PREPENDED_SALT
7949 | OPTI_TYPE_RAW_HASH;
7950 dgst_pos0 = 0;
7951 dgst_pos1 = 3;
7952 dgst_pos2 = 2;
7953 dgst_pos3 = 1;
7954 break;
7955
7956 case 22: hash_type = HASH_TYPE_MD5;
7957 salt_type = SALT_TYPE_EMBEDDED;
7958 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7959 opts_type = OPTS_TYPE_PT_GENERATE_LE
7960 | OPTS_TYPE_PT_ADD80
7961 | OPTS_TYPE_PT_ADDBITS14;
7962 kern_type = KERN_TYPE_MD5_SLTPW;
7963 dgst_size = DGST_SIZE_4_4;
7964 parse_func = netscreen_parse_hash;
7965 sort_by_digest = sort_by_digest_4_4;
7966 opti_type = OPTI_TYPE_ZERO_BYTE
7967 | OPTI_TYPE_PRECOMPUTE_INIT
7968 | OPTI_TYPE_PRECOMPUTE_MERKLE
7969 | OPTI_TYPE_EARLY_SKIP
7970 | OPTI_TYPE_NOT_ITERATED
7971 | OPTI_TYPE_PREPENDED_SALT
7972 | OPTI_TYPE_RAW_HASH;
7973 dgst_pos0 = 0;
7974 dgst_pos1 = 3;
7975 dgst_pos2 = 2;
7976 dgst_pos3 = 1;
7977 break;
7978
7979 case 23: hash_type = HASH_TYPE_MD5;
7980 salt_type = SALT_TYPE_EMBEDDED;
7981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7982 opts_type = OPTS_TYPE_PT_GENERATE_LE
7983 | OPTS_TYPE_PT_ADD80
7984 | OPTS_TYPE_PT_ADDBITS14;
7985 kern_type = KERN_TYPE_MD5_SLTPW;
7986 dgst_size = DGST_SIZE_4_4;
7987 parse_func = skype_parse_hash;
7988 sort_by_digest = sort_by_digest_4_4;
7989 opti_type = OPTI_TYPE_ZERO_BYTE
7990 | OPTI_TYPE_PRECOMPUTE_INIT
7991 | OPTI_TYPE_PRECOMPUTE_MERKLE
7992 | OPTI_TYPE_EARLY_SKIP
7993 | OPTI_TYPE_NOT_ITERATED
7994 | OPTI_TYPE_PREPENDED_SALT
7995 | OPTI_TYPE_RAW_HASH;
7996 dgst_pos0 = 0;
7997 dgst_pos1 = 3;
7998 dgst_pos2 = 2;
7999 dgst_pos3 = 1;
8000 break;
8001
8002 case 30: hash_type = HASH_TYPE_MD5;
8003 salt_type = SALT_TYPE_INTERN;
8004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8005 opts_type = OPTS_TYPE_PT_GENERATE_LE
8006 | OPTS_TYPE_PT_UNICODE
8007 | OPTS_TYPE_ST_ADD80
8008 | OPTS_TYPE_ST_ADDBITS14;
8009 kern_type = KERN_TYPE_MD5_PWUSLT;
8010 dgst_size = DGST_SIZE_4_4;
8011 parse_func = md5s_parse_hash;
8012 sort_by_digest = sort_by_digest_4_4;
8013 opti_type = OPTI_TYPE_ZERO_BYTE
8014 | OPTI_TYPE_PRECOMPUTE_INIT
8015 | OPTI_TYPE_PRECOMPUTE_MERKLE
8016 | OPTI_TYPE_MEET_IN_MIDDLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_RAW_HASH;
8021 dgst_pos0 = 0;
8022 dgst_pos1 = 3;
8023 dgst_pos2 = 2;
8024 dgst_pos3 = 1;
8025 break;
8026
8027 case 40: hash_type = HASH_TYPE_MD5;
8028 salt_type = SALT_TYPE_INTERN;
8029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8030 opts_type = OPTS_TYPE_PT_GENERATE_LE
8031 | OPTS_TYPE_PT_ADD80
8032 | OPTS_TYPE_PT_ADDBITS14
8033 | OPTS_TYPE_PT_UNICODE;
8034 kern_type = KERN_TYPE_MD5_SLTPWU;
8035 dgst_size = DGST_SIZE_4_4;
8036 parse_func = md5s_parse_hash;
8037 sort_by_digest = sort_by_digest_4_4;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_PREPENDED_SALT
8044 | OPTI_TYPE_RAW_HASH;
8045 dgst_pos0 = 0;
8046 dgst_pos1 = 3;
8047 dgst_pos2 = 2;
8048 dgst_pos3 = 1;
8049 break;
8050
8051 case 50: hash_type = HASH_TYPE_MD5;
8052 salt_type = SALT_TYPE_INTERN;
8053 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8054 opts_type = OPTS_TYPE_PT_GENERATE_LE
8055 | OPTS_TYPE_ST_ADD80
8056 | OPTS_TYPE_ST_ADDBITS14;
8057 kern_type = KERN_TYPE_HMACMD5_PW;
8058 dgst_size = DGST_SIZE_4_4;
8059 parse_func = hmacmd5_parse_hash;
8060 sort_by_digest = sort_by_digest_4_4;
8061 opti_type = OPTI_TYPE_ZERO_BYTE
8062 | OPTI_TYPE_NOT_ITERATED;
8063 dgst_pos0 = 0;
8064 dgst_pos1 = 3;
8065 dgst_pos2 = 2;
8066 dgst_pos3 = 1;
8067 break;
8068
8069 case 60: hash_type = HASH_TYPE_MD5;
8070 salt_type = SALT_TYPE_INTERN;
8071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8072 opts_type = OPTS_TYPE_PT_GENERATE_LE
8073 | OPTS_TYPE_PT_ADD80
8074 | OPTS_TYPE_PT_ADDBITS14;
8075 kern_type = KERN_TYPE_HMACMD5_SLT;
8076 dgst_size = DGST_SIZE_4_4;
8077 parse_func = hmacmd5_parse_hash;
8078 sort_by_digest = sort_by_digest_4_4;
8079 opti_type = OPTI_TYPE_ZERO_BYTE
8080 | OPTI_TYPE_NOT_ITERATED;
8081 dgst_pos0 = 0;
8082 dgst_pos1 = 3;
8083 dgst_pos2 = 2;
8084 dgst_pos3 = 1;
8085 break;
8086
8087 case 100: hash_type = HASH_TYPE_SHA1;
8088 salt_type = SALT_TYPE_NONE;
8089 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8090 opts_type = OPTS_TYPE_PT_GENERATE_BE
8091 | OPTS_TYPE_PT_ADD80
8092 | OPTS_TYPE_PT_ADDBITS15;
8093 kern_type = KERN_TYPE_SHA1;
8094 dgst_size = DGST_SIZE_4_5;
8095 parse_func = sha1_parse_hash;
8096 sort_by_digest = sort_by_digest_4_5;
8097 opti_type = OPTI_TYPE_ZERO_BYTE
8098 | OPTI_TYPE_PRECOMPUTE_INIT
8099 | OPTI_TYPE_PRECOMPUTE_MERKLE
8100 | OPTI_TYPE_EARLY_SKIP
8101 | OPTI_TYPE_NOT_ITERATED
8102 | OPTI_TYPE_NOT_SALTED
8103 | OPTI_TYPE_RAW_HASH;
8104 dgst_pos0 = 3;
8105 dgst_pos1 = 4;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 1;
8108 break;
8109
8110 case 101: hash_type = HASH_TYPE_SHA1;
8111 salt_type = SALT_TYPE_NONE;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_SHA1;
8117 dgst_size = DGST_SIZE_4_5;
8118 parse_func = sha1b64_parse_hash;
8119 sort_by_digest = sort_by_digest_4_5;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_PRECOMPUTE_INIT
8122 | OPTI_TYPE_PRECOMPUTE_MERKLE
8123 | OPTI_TYPE_EARLY_SKIP
8124 | OPTI_TYPE_NOT_ITERATED
8125 | OPTI_TYPE_NOT_SALTED
8126 | OPTI_TYPE_RAW_HASH;
8127 dgst_pos0 = 3;
8128 dgst_pos1 = 4;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 1;
8131 break;
8132
8133 case 110: hash_type = HASH_TYPE_SHA1;
8134 salt_type = SALT_TYPE_INTERN;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_BE
8137 | OPTS_TYPE_ST_ADD80
8138 | OPTS_TYPE_ST_ADDBITS15;
8139 kern_type = KERN_TYPE_SHA1_PWSLT;
8140 dgst_size = DGST_SIZE_4_5;
8141 parse_func = sha1s_parse_hash;
8142 sort_by_digest = sort_by_digest_4_5;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_APPENDED_SALT
8149 | OPTI_TYPE_RAW_HASH;
8150 dgst_pos0 = 3;
8151 dgst_pos1 = 4;
8152 dgst_pos2 = 2;
8153 dgst_pos3 = 1;
8154 break;
8155
8156 case 111: hash_type = HASH_TYPE_SHA1;
8157 salt_type = SALT_TYPE_EMBEDDED;
8158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8159 opts_type = OPTS_TYPE_PT_GENERATE_BE
8160 | OPTS_TYPE_ST_ADD80
8161 | OPTS_TYPE_ST_ADDBITS15;
8162 kern_type = KERN_TYPE_SHA1_PWSLT;
8163 dgst_size = DGST_SIZE_4_5;
8164 parse_func = sha1b64s_parse_hash;
8165 sort_by_digest = sort_by_digest_4_5;
8166 opti_type = OPTI_TYPE_ZERO_BYTE
8167 | OPTI_TYPE_PRECOMPUTE_INIT
8168 | OPTI_TYPE_PRECOMPUTE_MERKLE
8169 | OPTI_TYPE_EARLY_SKIP
8170 | OPTI_TYPE_NOT_ITERATED
8171 | OPTI_TYPE_APPENDED_SALT
8172 | OPTI_TYPE_RAW_HASH;
8173 dgst_pos0 = 3;
8174 dgst_pos1 = 4;
8175 dgst_pos2 = 2;
8176 dgst_pos3 = 1;
8177 break;
8178
8179 case 112: hash_type = HASH_TYPE_SHA1;
8180 salt_type = SALT_TYPE_INTERN;
8181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8182 opts_type = OPTS_TYPE_PT_GENERATE_BE
8183 | OPTS_TYPE_ST_ADD80
8184 | OPTS_TYPE_ST_ADDBITS15
8185 | OPTS_TYPE_ST_HEX;
8186 kern_type = KERN_TYPE_SHA1_PWSLT;
8187 dgst_size = DGST_SIZE_4_5;
8188 parse_func = oracles_parse_hash;
8189 sort_by_digest = sort_by_digest_4_5;
8190 opti_type = OPTI_TYPE_ZERO_BYTE
8191 | OPTI_TYPE_PRECOMPUTE_INIT
8192 | OPTI_TYPE_PRECOMPUTE_MERKLE
8193 | OPTI_TYPE_EARLY_SKIP
8194 | OPTI_TYPE_NOT_ITERATED
8195 | OPTI_TYPE_APPENDED_SALT
8196 | OPTI_TYPE_RAW_HASH;
8197 dgst_pos0 = 3;
8198 dgst_pos1 = 4;
8199 dgst_pos2 = 2;
8200 dgst_pos3 = 1;
8201 break;
8202
8203 case 120: hash_type = HASH_TYPE_SHA1;
8204 salt_type = SALT_TYPE_INTERN;
8205 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8206 opts_type = OPTS_TYPE_PT_GENERATE_BE
8207 | OPTS_TYPE_PT_ADD80
8208 | OPTS_TYPE_PT_ADDBITS15;
8209 kern_type = KERN_TYPE_SHA1_SLTPW;
8210 dgst_size = DGST_SIZE_4_5;
8211 parse_func = sha1s_parse_hash;
8212 sort_by_digest = sort_by_digest_4_5;
8213 opti_type = OPTI_TYPE_ZERO_BYTE
8214 | OPTI_TYPE_PRECOMPUTE_INIT
8215 | OPTI_TYPE_PRECOMPUTE_MERKLE
8216 | OPTI_TYPE_EARLY_SKIP
8217 | OPTI_TYPE_NOT_ITERATED
8218 | OPTI_TYPE_PREPENDED_SALT
8219 | OPTI_TYPE_RAW_HASH;
8220 dgst_pos0 = 3;
8221 dgst_pos1 = 4;
8222 dgst_pos2 = 2;
8223 dgst_pos3 = 1;
8224 break;
8225
8226 case 121: hash_type = HASH_TYPE_SHA1;
8227 salt_type = SALT_TYPE_INTERN;
8228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8229 opts_type = OPTS_TYPE_PT_GENERATE_BE
8230 | OPTS_TYPE_PT_ADD80
8231 | OPTS_TYPE_PT_ADDBITS15
8232 | OPTS_TYPE_ST_LOWER;
8233 kern_type = KERN_TYPE_SHA1_SLTPW;
8234 dgst_size = DGST_SIZE_4_5;
8235 parse_func = smf_parse_hash;
8236 sort_by_digest = sort_by_digest_4_5;
8237 opti_type = OPTI_TYPE_ZERO_BYTE
8238 | OPTI_TYPE_PRECOMPUTE_INIT
8239 | OPTI_TYPE_PRECOMPUTE_MERKLE
8240 | OPTI_TYPE_EARLY_SKIP
8241 | OPTI_TYPE_NOT_ITERATED
8242 | OPTI_TYPE_PREPENDED_SALT
8243 | OPTI_TYPE_RAW_HASH;
8244 dgst_pos0 = 3;
8245 dgst_pos1 = 4;
8246 dgst_pos2 = 2;
8247 dgst_pos3 = 1;
8248 break;
8249
8250 case 122: hash_type = HASH_TYPE_SHA1;
8251 salt_type = SALT_TYPE_EMBEDDED;
8252 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8253 opts_type = OPTS_TYPE_PT_GENERATE_BE
8254 | OPTS_TYPE_PT_ADD80
8255 | OPTS_TYPE_PT_ADDBITS15
8256 | OPTS_TYPE_ST_HEX;
8257 kern_type = KERN_TYPE_SHA1_SLTPW;
8258 dgst_size = DGST_SIZE_4_5;
8259 parse_func = osx1_parse_hash;
8260 sort_by_digest = sort_by_digest_4_5;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED
8266 | OPTI_TYPE_PREPENDED_SALT
8267 | OPTI_TYPE_RAW_HASH;
8268 dgst_pos0 = 3;
8269 dgst_pos1 = 4;
8270 dgst_pos2 = 2;
8271 dgst_pos3 = 1;
8272 break;
8273
8274 case 124: hash_type = HASH_TYPE_SHA1;
8275 salt_type = SALT_TYPE_EMBEDDED;
8276 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8277 opts_type = OPTS_TYPE_PT_GENERATE_BE
8278 | OPTS_TYPE_PT_ADD80
8279 | OPTS_TYPE_PT_ADDBITS15;
8280 kern_type = KERN_TYPE_SHA1_SLTPW;
8281 dgst_size = DGST_SIZE_4_5;
8282 parse_func = djangosha1_parse_hash;
8283 sort_by_digest = sort_by_digest_4_5;
8284 opti_type = OPTI_TYPE_ZERO_BYTE
8285 | OPTI_TYPE_PRECOMPUTE_INIT
8286 | OPTI_TYPE_PRECOMPUTE_MERKLE
8287 | OPTI_TYPE_EARLY_SKIP
8288 | OPTI_TYPE_NOT_ITERATED
8289 | OPTI_TYPE_PREPENDED_SALT
8290 | OPTI_TYPE_RAW_HASH;
8291 dgst_pos0 = 3;
8292 dgst_pos1 = 4;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 1;
8295 break;
8296
8297 case 125: hash_type = HASH_TYPE_SHA1;
8298 salt_type = SALT_TYPE_EMBEDDED;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_BE
8301 | OPTS_TYPE_PT_ADD80
8302 | OPTS_TYPE_PT_ADDBITS15
8303 | OPTS_TYPE_ST_HEX;
8304 kern_type = KERN_TYPE_SHA1_SLTPW;
8305 dgst_size = DGST_SIZE_4_5;
8306 parse_func = arubaos_parse_hash;
8307 sort_by_digest = sort_by_digest_4_5;
8308 opti_type = OPTI_TYPE_ZERO_BYTE
8309 | OPTI_TYPE_PRECOMPUTE_INIT
8310 | OPTI_TYPE_PRECOMPUTE_MERKLE
8311 | OPTI_TYPE_EARLY_SKIP
8312 | OPTI_TYPE_NOT_ITERATED
8313 | OPTI_TYPE_PREPENDED_SALT
8314 | OPTI_TYPE_RAW_HASH;
8315 dgst_pos0 = 3;
8316 dgst_pos1 = 4;
8317 dgst_pos2 = 2;
8318 dgst_pos3 = 1;
8319 break;
8320
8321 case 130: hash_type = HASH_TYPE_SHA1;
8322 salt_type = SALT_TYPE_INTERN;
8323 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8324 opts_type = OPTS_TYPE_PT_GENERATE_BE
8325 | OPTS_TYPE_PT_UNICODE
8326 | OPTS_TYPE_ST_ADD80
8327 | OPTS_TYPE_ST_ADDBITS15;
8328 kern_type = KERN_TYPE_SHA1_PWUSLT;
8329 dgst_size = DGST_SIZE_4_5;
8330 parse_func = sha1s_parse_hash;
8331 sort_by_digest = sort_by_digest_4_5;
8332 opti_type = OPTI_TYPE_ZERO_BYTE
8333 | OPTI_TYPE_PRECOMPUTE_INIT
8334 | OPTI_TYPE_PRECOMPUTE_MERKLE
8335 | OPTI_TYPE_EARLY_SKIP
8336 | OPTI_TYPE_NOT_ITERATED
8337 | OPTI_TYPE_APPENDED_SALT
8338 | OPTI_TYPE_RAW_HASH;
8339 dgst_pos0 = 3;
8340 dgst_pos1 = 4;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 1;
8343 break;
8344
8345 case 131: hash_type = HASH_TYPE_SHA1;
8346 salt_type = SALT_TYPE_EMBEDDED;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_BE
8349 | OPTS_TYPE_PT_UNICODE
8350 | OPTS_TYPE_PT_UPPER
8351 | OPTS_TYPE_ST_ADD80
8352 | OPTS_TYPE_ST_ADDBITS15
8353 | OPTS_TYPE_ST_HEX;
8354 kern_type = KERN_TYPE_SHA1_PWUSLT;
8355 dgst_size = DGST_SIZE_4_5;
8356 parse_func = mssql2000_parse_hash;
8357 sort_by_digest = sort_by_digest_4_5;
8358 opti_type = OPTI_TYPE_ZERO_BYTE
8359 | OPTI_TYPE_PRECOMPUTE_INIT
8360 | OPTI_TYPE_PRECOMPUTE_MERKLE
8361 | OPTI_TYPE_EARLY_SKIP
8362 | OPTI_TYPE_NOT_ITERATED
8363 | OPTI_TYPE_APPENDED_SALT
8364 | OPTI_TYPE_RAW_HASH;
8365 dgst_pos0 = 3;
8366 dgst_pos1 = 4;
8367 dgst_pos2 = 2;
8368 dgst_pos3 = 1;
8369 break;
8370
8371 case 132: hash_type = HASH_TYPE_SHA1;
8372 salt_type = SALT_TYPE_EMBEDDED;
8373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8374 opts_type = OPTS_TYPE_PT_GENERATE_BE
8375 | OPTS_TYPE_PT_UNICODE
8376 | OPTS_TYPE_ST_ADD80
8377 | OPTS_TYPE_ST_ADDBITS15
8378 | OPTS_TYPE_ST_HEX;
8379 kern_type = KERN_TYPE_SHA1_PWUSLT;
8380 dgst_size = DGST_SIZE_4_5;
8381 parse_func = mssql2005_parse_hash;
8382 sort_by_digest = sort_by_digest_4_5;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_PRECOMPUTE_MERKLE
8386 | OPTI_TYPE_EARLY_SKIP
8387 | OPTI_TYPE_NOT_ITERATED
8388 | OPTI_TYPE_APPENDED_SALT
8389 | OPTI_TYPE_RAW_HASH;
8390 dgst_pos0 = 3;
8391 dgst_pos1 = 4;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 133: hash_type = HASH_TYPE_SHA1;
8397 salt_type = SALT_TYPE_EMBEDDED;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_BE
8400 | OPTS_TYPE_PT_UNICODE
8401 | OPTS_TYPE_ST_ADD80
8402 | OPTS_TYPE_ST_ADDBITS15;
8403 kern_type = KERN_TYPE_SHA1_PWUSLT;
8404 dgst_size = DGST_SIZE_4_5;
8405 parse_func = peoplesoft_parse_hash;
8406 sort_by_digest = sort_by_digest_4_5;
8407 opti_type = OPTI_TYPE_ZERO_BYTE
8408 | OPTI_TYPE_PRECOMPUTE_INIT
8409 | OPTI_TYPE_PRECOMPUTE_MERKLE
8410 | OPTI_TYPE_EARLY_SKIP
8411 | OPTI_TYPE_NOT_ITERATED
8412 | OPTI_TYPE_APPENDED_SALT
8413 | OPTI_TYPE_RAW_HASH;
8414 dgst_pos0 = 3;
8415 dgst_pos1 = 4;
8416 dgst_pos2 = 2;
8417 dgst_pos3 = 1;
8418 break;
8419
8420 case 140: hash_type = HASH_TYPE_SHA1;
8421 salt_type = SALT_TYPE_INTERN;
8422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8423 opts_type = OPTS_TYPE_PT_GENERATE_BE
8424 | OPTS_TYPE_PT_ADD80
8425 | OPTS_TYPE_PT_ADDBITS15
8426 | OPTS_TYPE_PT_UNICODE;
8427 kern_type = KERN_TYPE_SHA1_SLTPWU;
8428 dgst_size = DGST_SIZE_4_5;
8429 parse_func = sha1s_parse_hash;
8430 sort_by_digest = sort_by_digest_4_5;
8431 opti_type = OPTI_TYPE_ZERO_BYTE
8432 | OPTI_TYPE_PRECOMPUTE_INIT
8433 | OPTI_TYPE_PRECOMPUTE_MERKLE
8434 | OPTI_TYPE_EARLY_SKIP
8435 | OPTI_TYPE_NOT_ITERATED
8436 | OPTI_TYPE_PREPENDED_SALT
8437 | OPTI_TYPE_RAW_HASH;
8438 dgst_pos0 = 3;
8439 dgst_pos1 = 4;
8440 dgst_pos2 = 2;
8441 dgst_pos3 = 1;
8442 break;
8443
8444 case 141: hash_type = HASH_TYPE_SHA1;
8445 salt_type = SALT_TYPE_EMBEDDED;
8446 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8447 opts_type = OPTS_TYPE_PT_GENERATE_BE
8448 | OPTS_TYPE_PT_ADD80
8449 | OPTS_TYPE_PT_ADDBITS15
8450 | OPTS_TYPE_PT_UNICODE
8451 | OPTS_TYPE_ST_BASE64;
8452 kern_type = KERN_TYPE_SHA1_SLTPWU;
8453 dgst_size = DGST_SIZE_4_5;
8454 parse_func = episerver_parse_hash;
8455 sort_by_digest = sort_by_digest_4_5;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_ITERATED
8461 | OPTI_TYPE_PREPENDED_SALT
8462 | OPTI_TYPE_RAW_HASH;
8463 dgst_pos0 = 3;
8464 dgst_pos1 = 4;
8465 dgst_pos2 = 2;
8466 dgst_pos3 = 1;
8467 break;
8468
8469 case 150: hash_type = HASH_TYPE_SHA1;
8470 salt_type = SALT_TYPE_INTERN;
8471 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8472 opts_type = OPTS_TYPE_PT_GENERATE_BE
8473 | OPTS_TYPE_ST_ADD80
8474 | OPTS_TYPE_ST_ADDBITS15;
8475 kern_type = KERN_TYPE_HMACSHA1_PW;
8476 dgst_size = DGST_SIZE_4_5;
8477 parse_func = hmacsha1_parse_hash;
8478 sort_by_digest = sort_by_digest_4_5;
8479 opti_type = OPTI_TYPE_ZERO_BYTE
8480 | OPTI_TYPE_NOT_ITERATED;
8481 dgst_pos0 = 3;
8482 dgst_pos1 = 4;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 160: hash_type = HASH_TYPE_SHA1;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_HMACSHA1_SLT;
8494 dgst_size = DGST_SIZE_4_5;
8495 parse_func = hmacsha1_parse_hash;
8496 sort_by_digest = sort_by_digest_4_5;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_NOT_ITERATED;
8499 dgst_pos0 = 3;
8500 dgst_pos1 = 4;
8501 dgst_pos2 = 2;
8502 dgst_pos3 = 1;
8503 break;
8504
8505 case 200: hash_type = HASH_TYPE_MYSQL;
8506 salt_type = SALT_TYPE_NONE;
8507 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8508 opts_type = 0;
8509 kern_type = KERN_TYPE_MYSQL;
8510 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8511 parse_func = mysql323_parse_hash;
8512 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8513 opti_type = OPTI_TYPE_ZERO_BYTE;
8514 dgst_pos0 = 0;
8515 dgst_pos1 = 1;
8516 dgst_pos2 = 2;
8517 dgst_pos3 = 3;
8518 break;
8519
8520 case 300: hash_type = HASH_TYPE_SHA1;
8521 salt_type = SALT_TYPE_NONE;
8522 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8523 opts_type = OPTS_TYPE_PT_GENERATE_BE
8524 | OPTS_TYPE_PT_ADD80
8525 | OPTS_TYPE_PT_ADDBITS15;
8526 kern_type = KERN_TYPE_MYSQL41;
8527 dgst_size = DGST_SIZE_4_5;
8528 parse_func = sha1_parse_hash;
8529 sort_by_digest = sort_by_digest_4_5;
8530 opti_type = OPTI_TYPE_ZERO_BYTE
8531 | OPTI_TYPE_PRECOMPUTE_INIT
8532 | OPTI_TYPE_PRECOMPUTE_MERKLE
8533 | OPTI_TYPE_EARLY_SKIP
8534 | OPTI_TYPE_NOT_ITERATED
8535 | OPTI_TYPE_NOT_SALTED;
8536 dgst_pos0 = 3;
8537 dgst_pos1 = 4;
8538 dgst_pos2 = 2;
8539 dgst_pos3 = 1;
8540 break;
8541
8542 case 400: hash_type = HASH_TYPE_MD5;
8543 salt_type = SALT_TYPE_EMBEDDED;
8544 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8545 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8546 kern_type = KERN_TYPE_PHPASS;
8547 dgst_size = DGST_SIZE_4_4;
8548 parse_func = phpass_parse_hash;
8549 sort_by_digest = sort_by_digest_4_4;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_SLOW_HASH_SIMD;
8552 dgst_pos0 = 0;
8553 dgst_pos1 = 1;
8554 dgst_pos2 = 2;
8555 dgst_pos3 = 3;
8556 break;
8557
8558 case 500: hash_type = HASH_TYPE_MD5;
8559 salt_type = SALT_TYPE_EMBEDDED;
8560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8561 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8562 kern_type = KERN_TYPE_MD5CRYPT;
8563 dgst_size = DGST_SIZE_4_4;
8564 parse_func = md5crypt_parse_hash;
8565 sort_by_digest = sort_by_digest_4_4;
8566 opti_type = OPTI_TYPE_ZERO_BYTE;
8567 dgst_pos0 = 0;
8568 dgst_pos1 = 1;
8569 dgst_pos2 = 2;
8570 dgst_pos3 = 3;
8571 break;
8572
8573 case 501: hash_type = HASH_TYPE_MD5;
8574 salt_type = SALT_TYPE_EMBEDDED;
8575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8576 opts_type = OPTS_TYPE_PT_GENERATE_LE
8577 | OPTS_TYPE_HASH_COPY;
8578 kern_type = KERN_TYPE_MD5CRYPT;
8579 dgst_size = DGST_SIZE_4_4;
8580 parse_func = juniper_parse_hash;
8581 sort_by_digest = sort_by_digest_4_4;
8582 opti_type = OPTI_TYPE_ZERO_BYTE;
8583 dgst_pos0 = 0;
8584 dgst_pos1 = 1;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 3;
8587 break;
8588
8589 case 900: hash_type = HASH_TYPE_MD4;
8590 salt_type = SALT_TYPE_NONE;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE
8593 | OPTS_TYPE_PT_ADD80
8594 | OPTS_TYPE_PT_ADDBITS14;
8595 kern_type = KERN_TYPE_MD4;
8596 dgst_size = DGST_SIZE_4_4;
8597 parse_func = md4_parse_hash;
8598 sort_by_digest = sort_by_digest_4_4;
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_PRECOMPUTE_INIT
8601 | OPTI_TYPE_PRECOMPUTE_MERKLE
8602 | OPTI_TYPE_MEET_IN_MIDDLE
8603 | OPTI_TYPE_EARLY_SKIP
8604 | OPTI_TYPE_NOT_ITERATED
8605 | OPTI_TYPE_NOT_SALTED
8606 | OPTI_TYPE_RAW_HASH;
8607 dgst_pos0 = 0;
8608 dgst_pos1 = 3;
8609 dgst_pos2 = 2;
8610 dgst_pos3 = 1;
8611 break;
8612
8613 case 1000: hash_type = HASH_TYPE_MD4;
8614 salt_type = SALT_TYPE_NONE;
8615 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8616 opts_type = OPTS_TYPE_PT_GENERATE_LE
8617 | OPTS_TYPE_PT_ADD80
8618 | OPTS_TYPE_PT_ADDBITS14
8619 | OPTS_TYPE_PT_UNICODE;
8620 kern_type = KERN_TYPE_MD4_PWU;
8621 dgst_size = DGST_SIZE_4_4;
8622 parse_func = md4_parse_hash;
8623 sort_by_digest = sort_by_digest_4_4;
8624 opti_type = OPTI_TYPE_ZERO_BYTE
8625 | OPTI_TYPE_PRECOMPUTE_INIT
8626 | OPTI_TYPE_PRECOMPUTE_MERKLE
8627 | OPTI_TYPE_MEET_IN_MIDDLE
8628 | OPTI_TYPE_EARLY_SKIP
8629 | OPTI_TYPE_NOT_ITERATED
8630 | OPTI_TYPE_NOT_SALTED
8631 | OPTI_TYPE_RAW_HASH;
8632 dgst_pos0 = 0;
8633 dgst_pos1 = 3;
8634 dgst_pos2 = 2;
8635 dgst_pos3 = 1;
8636 break;
8637
8638 case 1100: hash_type = HASH_TYPE_MD4;
8639 salt_type = SALT_TYPE_INTERN;
8640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8641 opts_type = OPTS_TYPE_PT_GENERATE_LE
8642 | OPTS_TYPE_PT_ADD80
8643 | OPTS_TYPE_PT_ADDBITS14
8644 | OPTS_TYPE_PT_UNICODE
8645 | OPTS_TYPE_ST_ADD80
8646 | OPTS_TYPE_ST_UNICODE
8647 | OPTS_TYPE_ST_LOWER;
8648 kern_type = KERN_TYPE_MD44_PWUSLT;
8649 dgst_size = DGST_SIZE_4_4;
8650 parse_func = dcc_parse_hash;
8651 sort_by_digest = sort_by_digest_4_4;
8652 opti_type = OPTI_TYPE_ZERO_BYTE
8653 | OPTI_TYPE_PRECOMPUTE_INIT
8654 | OPTI_TYPE_PRECOMPUTE_MERKLE
8655 | OPTI_TYPE_EARLY_SKIP
8656 | OPTI_TYPE_NOT_ITERATED;
8657 dgst_pos0 = 0;
8658 dgst_pos1 = 3;
8659 dgst_pos2 = 2;
8660 dgst_pos3 = 1;
8661 break;
8662
8663 case 1400: hash_type = HASH_TYPE_SHA256;
8664 salt_type = SALT_TYPE_NONE;
8665 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8666 opts_type = OPTS_TYPE_PT_GENERATE_BE
8667 | OPTS_TYPE_PT_ADD80
8668 | OPTS_TYPE_PT_ADDBITS15;
8669 kern_type = KERN_TYPE_SHA256;
8670 dgst_size = DGST_SIZE_4_8;
8671 parse_func = sha256_parse_hash;
8672 sort_by_digest = sort_by_digest_4_8;
8673 opti_type = OPTI_TYPE_ZERO_BYTE
8674 | OPTI_TYPE_PRECOMPUTE_INIT
8675 | OPTI_TYPE_PRECOMPUTE_MERKLE
8676 | OPTI_TYPE_EARLY_SKIP
8677 | OPTI_TYPE_NOT_ITERATED
8678 | OPTI_TYPE_NOT_SALTED
8679 | OPTI_TYPE_RAW_HASH;
8680 dgst_pos0 = 3;
8681 dgst_pos1 = 7;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 6;
8684 break;
8685
8686 case 1410: hash_type = HASH_TYPE_SHA256;
8687 salt_type = SALT_TYPE_INTERN;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_BE
8690 | OPTS_TYPE_ST_ADD80
8691 | OPTS_TYPE_ST_ADDBITS15;
8692 kern_type = KERN_TYPE_SHA256_PWSLT;
8693 dgst_size = DGST_SIZE_4_8;
8694 parse_func = sha256s_parse_hash;
8695 sort_by_digest = sort_by_digest_4_8;
8696 opti_type = OPTI_TYPE_ZERO_BYTE
8697 | OPTI_TYPE_PRECOMPUTE_INIT
8698 | OPTI_TYPE_PRECOMPUTE_MERKLE
8699 | OPTI_TYPE_EARLY_SKIP
8700 | OPTI_TYPE_NOT_ITERATED
8701 | OPTI_TYPE_APPENDED_SALT
8702 | OPTI_TYPE_RAW_HASH;
8703 dgst_pos0 = 3;
8704 dgst_pos1 = 7;
8705 dgst_pos2 = 2;
8706 dgst_pos3 = 6;
8707 break;
8708
8709 case 1420: hash_type = HASH_TYPE_SHA256;
8710 salt_type = SALT_TYPE_INTERN;
8711 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8712 opts_type = OPTS_TYPE_PT_GENERATE_BE
8713 | OPTS_TYPE_PT_ADD80
8714 | OPTS_TYPE_PT_ADDBITS15;
8715 kern_type = KERN_TYPE_SHA256_SLTPW;
8716 dgst_size = DGST_SIZE_4_8;
8717 parse_func = sha256s_parse_hash;
8718 sort_by_digest = sort_by_digest_4_8;
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 | OPTI_TYPE_PREPENDED_SALT
8725 | OPTI_TYPE_RAW_HASH;
8726 dgst_pos0 = 3;
8727 dgst_pos1 = 7;
8728 dgst_pos2 = 2;
8729 dgst_pos3 = 6;
8730 break;
8731
8732 case 1421: hash_type = HASH_TYPE_SHA256;
8733 salt_type = SALT_TYPE_EMBEDDED;
8734 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8735 opts_type = OPTS_TYPE_PT_GENERATE_BE
8736 | OPTS_TYPE_PT_ADD80
8737 | OPTS_TYPE_PT_ADDBITS15;
8738 kern_type = KERN_TYPE_SHA256_SLTPW;
8739 dgst_size = DGST_SIZE_4_8;
8740 parse_func = hmailserver_parse_hash;
8741 sort_by_digest = sort_by_digest_4_8;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_PRECOMPUTE_INIT
8744 | OPTI_TYPE_PRECOMPUTE_MERKLE
8745 | OPTI_TYPE_EARLY_SKIP
8746 | OPTI_TYPE_NOT_ITERATED
8747 | OPTI_TYPE_PREPENDED_SALT
8748 | OPTI_TYPE_RAW_HASH;
8749 dgst_pos0 = 3;
8750 dgst_pos1 = 7;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 6;
8753 break;
8754
8755 case 1430: hash_type = HASH_TYPE_SHA256;
8756 salt_type = SALT_TYPE_INTERN;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_BE
8759 | OPTS_TYPE_PT_UNICODE
8760 | OPTS_TYPE_ST_ADD80
8761 | OPTS_TYPE_ST_ADDBITS15;
8762 kern_type = KERN_TYPE_SHA256_PWUSLT;
8763 dgst_size = DGST_SIZE_4_8;
8764 parse_func = sha256s_parse_hash;
8765 sort_by_digest = sort_by_digest_4_8;
8766 opti_type = OPTI_TYPE_ZERO_BYTE
8767 | OPTI_TYPE_PRECOMPUTE_INIT
8768 | OPTI_TYPE_PRECOMPUTE_MERKLE
8769 | OPTI_TYPE_EARLY_SKIP
8770 | OPTI_TYPE_NOT_ITERATED
8771 | OPTI_TYPE_APPENDED_SALT
8772 | OPTI_TYPE_RAW_HASH;
8773 dgst_pos0 = 3;
8774 dgst_pos1 = 7;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 6;
8777 break;
8778
8779 case 1440: hash_type = HASH_TYPE_SHA256;
8780 salt_type = SALT_TYPE_INTERN;
8781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_BE
8783 | OPTS_TYPE_PT_ADD80
8784 | OPTS_TYPE_PT_ADDBITS15
8785 | OPTS_TYPE_PT_UNICODE;
8786 kern_type = KERN_TYPE_SHA256_SLTPWU;
8787 dgst_size = DGST_SIZE_4_8;
8788 parse_func = sha256s_parse_hash;
8789 sort_by_digest = sort_by_digest_4_8;
8790 opti_type = OPTI_TYPE_ZERO_BYTE
8791 | OPTI_TYPE_PRECOMPUTE_INIT
8792 | OPTI_TYPE_PRECOMPUTE_MERKLE
8793 | OPTI_TYPE_EARLY_SKIP
8794 | OPTI_TYPE_NOT_ITERATED
8795 | OPTI_TYPE_PREPENDED_SALT
8796 | OPTI_TYPE_RAW_HASH;
8797 dgst_pos0 = 3;
8798 dgst_pos1 = 7;
8799 dgst_pos2 = 2;
8800 dgst_pos3 = 6;
8801 break;
8802
8803 case 1441: hash_type = HASH_TYPE_SHA256;
8804 salt_type = SALT_TYPE_EMBEDDED;
8805 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8806 opts_type = OPTS_TYPE_PT_GENERATE_BE
8807 | OPTS_TYPE_PT_ADD80
8808 | OPTS_TYPE_PT_ADDBITS15
8809 | OPTS_TYPE_PT_UNICODE
8810 | OPTS_TYPE_ST_BASE64;
8811 kern_type = KERN_TYPE_SHA256_SLTPWU;
8812 dgst_size = DGST_SIZE_4_8;
8813 parse_func = episerver4_parse_hash;
8814 sort_by_digest = sort_by_digest_4_8;
8815 opti_type = OPTI_TYPE_ZERO_BYTE
8816 | OPTI_TYPE_PRECOMPUTE_INIT
8817 | OPTI_TYPE_PRECOMPUTE_MERKLE
8818 | OPTI_TYPE_EARLY_SKIP
8819 | OPTI_TYPE_NOT_ITERATED
8820 | OPTI_TYPE_PREPENDED_SALT
8821 | OPTI_TYPE_RAW_HASH;
8822 dgst_pos0 = 3;
8823 dgst_pos1 = 7;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 6;
8826 break;
8827
8828 case 1450: hash_type = HASH_TYPE_SHA256;
8829 salt_type = SALT_TYPE_INTERN;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_BE
8832 | OPTS_TYPE_ST_ADD80;
8833 kern_type = KERN_TYPE_HMACSHA256_PW;
8834 dgst_size = DGST_SIZE_4_8;
8835 parse_func = hmacsha256_parse_hash;
8836 sort_by_digest = sort_by_digest_4_8;
8837 opti_type = OPTI_TYPE_ZERO_BYTE
8838 | OPTI_TYPE_NOT_ITERATED;
8839 dgst_pos0 = 3;
8840 dgst_pos1 = 7;
8841 dgst_pos2 = 2;
8842 dgst_pos3 = 6;
8843 break;
8844
8845 case 1460: hash_type = HASH_TYPE_SHA256;
8846 salt_type = SALT_TYPE_INTERN;
8847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_BE
8849 | OPTS_TYPE_PT_ADD80
8850 | OPTS_TYPE_PT_ADDBITS15;
8851 kern_type = KERN_TYPE_HMACSHA256_SLT;
8852 dgst_size = DGST_SIZE_4_8;
8853 parse_func = hmacsha256_parse_hash;
8854 sort_by_digest = sort_by_digest_4_8;
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_NOT_ITERATED;
8857 dgst_pos0 = 3;
8858 dgst_pos1 = 7;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 6;
8861 break;
8862
8863 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE
8867 | OPTS_TYPE_PT_BITSLICE;
8868 kern_type = KERN_TYPE_DESCRYPT;
8869 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8870 parse_func = descrypt_parse_hash;
8871 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8872 opti_type = OPTI_TYPE_ZERO_BYTE
8873 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8874 dgst_pos0 = 0;
8875 dgst_pos1 = 1;
8876 dgst_pos2 = 2;
8877 dgst_pos3 = 3;
8878 break;
8879
8880 case 1600: hash_type = HASH_TYPE_MD5;
8881 salt_type = SALT_TYPE_EMBEDDED;
8882 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8883 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8884 kern_type = KERN_TYPE_APR1CRYPT;
8885 dgst_size = DGST_SIZE_4_4;
8886 parse_func = md5apr1_parse_hash;
8887 sort_by_digest = sort_by_digest_4_4;
8888 opti_type = OPTI_TYPE_ZERO_BYTE;
8889 dgst_pos0 = 0;
8890 dgst_pos1 = 1;
8891 dgst_pos2 = 2;
8892 dgst_pos3 = 3;
8893 break;
8894
8895 case 1700: hash_type = HASH_TYPE_SHA512;
8896 salt_type = SALT_TYPE_NONE;
8897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8898 opts_type = OPTS_TYPE_PT_GENERATE_BE
8899 | OPTS_TYPE_PT_ADD80
8900 | OPTS_TYPE_PT_ADDBITS15;
8901 kern_type = KERN_TYPE_SHA512;
8902 dgst_size = DGST_SIZE_8_8;
8903 parse_func = sha512_parse_hash;
8904 sort_by_digest = sort_by_digest_8_8;
8905 opti_type = OPTI_TYPE_ZERO_BYTE
8906 | OPTI_TYPE_PRECOMPUTE_INIT
8907 | OPTI_TYPE_PRECOMPUTE_MERKLE
8908 | OPTI_TYPE_EARLY_SKIP
8909 | OPTI_TYPE_NOT_ITERATED
8910 | OPTI_TYPE_NOT_SALTED
8911 | OPTI_TYPE_USES_BITS_64
8912 | OPTI_TYPE_RAW_HASH;
8913 dgst_pos0 = 14;
8914 dgst_pos1 = 15;
8915 dgst_pos2 = 6;
8916 dgst_pos3 = 7;
8917 break;
8918
8919 case 1710: hash_type = HASH_TYPE_SHA512;
8920 salt_type = SALT_TYPE_INTERN;
8921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8922 opts_type = OPTS_TYPE_PT_GENERATE_BE
8923 | OPTS_TYPE_ST_ADD80
8924 | OPTS_TYPE_ST_ADDBITS15;
8925 kern_type = KERN_TYPE_SHA512_PWSLT;
8926 dgst_size = DGST_SIZE_8_8;
8927 parse_func = sha512s_parse_hash;
8928 sort_by_digest = sort_by_digest_8_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE
8930 | OPTI_TYPE_PRECOMPUTE_INIT
8931 | OPTI_TYPE_PRECOMPUTE_MERKLE
8932 | OPTI_TYPE_EARLY_SKIP
8933 | OPTI_TYPE_NOT_ITERATED
8934 | OPTI_TYPE_APPENDED_SALT
8935 | OPTI_TYPE_USES_BITS_64
8936 | OPTI_TYPE_RAW_HASH;
8937 dgst_pos0 = 14;
8938 dgst_pos1 = 15;
8939 dgst_pos2 = 6;
8940 dgst_pos3 = 7;
8941 break;
8942
8943 case 1711: hash_type = HASH_TYPE_SHA512;
8944 salt_type = SALT_TYPE_EMBEDDED;
8945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8946 opts_type = OPTS_TYPE_PT_GENERATE_BE
8947 | OPTS_TYPE_ST_ADD80
8948 | OPTS_TYPE_ST_ADDBITS15;
8949 kern_type = KERN_TYPE_SHA512_PWSLT;
8950 dgst_size = DGST_SIZE_8_8;
8951 parse_func = sha512b64s_parse_hash;
8952 sort_by_digest = sort_by_digest_8_8;
8953 opti_type = OPTI_TYPE_ZERO_BYTE
8954 | OPTI_TYPE_PRECOMPUTE_INIT
8955 | OPTI_TYPE_PRECOMPUTE_MERKLE
8956 | OPTI_TYPE_EARLY_SKIP
8957 | OPTI_TYPE_NOT_ITERATED
8958 | OPTI_TYPE_APPENDED_SALT
8959 | OPTI_TYPE_USES_BITS_64
8960 | OPTI_TYPE_RAW_HASH;
8961 dgst_pos0 = 14;
8962 dgst_pos1 = 15;
8963 dgst_pos2 = 6;
8964 dgst_pos3 = 7;
8965 break;
8966
8967 case 1720: hash_type = HASH_TYPE_SHA512;
8968 salt_type = SALT_TYPE_INTERN;
8969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_BE
8971 | OPTS_TYPE_PT_ADD80
8972 | OPTS_TYPE_PT_ADDBITS15;
8973 kern_type = KERN_TYPE_SHA512_SLTPW;
8974 dgst_size = DGST_SIZE_8_8;
8975 parse_func = sha512s_parse_hash;
8976 sort_by_digest = sort_by_digest_8_8;
8977 opti_type = OPTI_TYPE_ZERO_BYTE
8978 | OPTI_TYPE_PRECOMPUTE_INIT
8979 | OPTI_TYPE_PRECOMPUTE_MERKLE
8980 | OPTI_TYPE_EARLY_SKIP
8981 | OPTI_TYPE_NOT_ITERATED
8982 | OPTI_TYPE_PREPENDED_SALT
8983 | OPTI_TYPE_USES_BITS_64
8984 | OPTI_TYPE_RAW_HASH;
8985 dgst_pos0 = 14;
8986 dgst_pos1 = 15;
8987 dgst_pos2 = 6;
8988 dgst_pos3 = 7;
8989 break;
8990
8991 case 1722: hash_type = HASH_TYPE_SHA512;
8992 salt_type = SALT_TYPE_EMBEDDED;
8993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8994 opts_type = OPTS_TYPE_PT_GENERATE_BE
8995 | OPTS_TYPE_PT_ADD80
8996 | OPTS_TYPE_PT_ADDBITS15
8997 | OPTS_TYPE_ST_HEX;
8998 kern_type = KERN_TYPE_SHA512_SLTPW;
8999 dgst_size = DGST_SIZE_8_8;
9000 parse_func = osx512_parse_hash;
9001 sort_by_digest = sort_by_digest_8_8;
9002 opti_type = OPTI_TYPE_ZERO_BYTE
9003 | OPTI_TYPE_PRECOMPUTE_INIT
9004 | OPTI_TYPE_PRECOMPUTE_MERKLE
9005 | OPTI_TYPE_EARLY_SKIP
9006 | OPTI_TYPE_NOT_ITERATED
9007 | OPTI_TYPE_PREPENDED_SALT
9008 | OPTI_TYPE_USES_BITS_64
9009 | OPTI_TYPE_RAW_HASH;
9010 dgst_pos0 = 14;
9011 dgst_pos1 = 15;
9012 dgst_pos2 = 6;
9013 dgst_pos3 = 7;
9014 break;
9015
9016 case 1730: hash_type = HASH_TYPE_SHA512;
9017 salt_type = SALT_TYPE_INTERN;
9018 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_BE
9020 | OPTS_TYPE_PT_UNICODE
9021 | OPTS_TYPE_ST_ADD80
9022 | OPTS_TYPE_ST_ADDBITS15;
9023 kern_type = KERN_TYPE_SHA512_PWSLTU;
9024 dgst_size = DGST_SIZE_8_8;
9025 parse_func = sha512s_parse_hash;
9026 sort_by_digest = sort_by_digest_8_8;
9027 opti_type = OPTI_TYPE_ZERO_BYTE
9028 | OPTI_TYPE_PRECOMPUTE_INIT
9029 | OPTI_TYPE_PRECOMPUTE_MERKLE
9030 | OPTI_TYPE_EARLY_SKIP
9031 | OPTI_TYPE_NOT_ITERATED
9032 | OPTI_TYPE_APPENDED_SALT
9033 | OPTI_TYPE_USES_BITS_64
9034 | OPTI_TYPE_RAW_HASH;
9035 dgst_pos0 = 14;
9036 dgst_pos1 = 15;
9037 dgst_pos2 = 6;
9038 dgst_pos3 = 7;
9039 break;
9040
9041 case 1731: hash_type = HASH_TYPE_SHA512;
9042 salt_type = SALT_TYPE_EMBEDDED;
9043 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9044 opts_type = OPTS_TYPE_PT_GENERATE_BE
9045 | OPTS_TYPE_PT_UNICODE
9046 | OPTS_TYPE_ST_ADD80
9047 | OPTS_TYPE_ST_ADDBITS15
9048 | OPTS_TYPE_ST_HEX;
9049 kern_type = KERN_TYPE_SHA512_PWSLTU;
9050 dgst_size = DGST_SIZE_8_8;
9051 parse_func = mssql2012_parse_hash;
9052 sort_by_digest = sort_by_digest_8_8;
9053 opti_type = OPTI_TYPE_ZERO_BYTE
9054 | OPTI_TYPE_PRECOMPUTE_INIT
9055 | OPTI_TYPE_PRECOMPUTE_MERKLE
9056 | OPTI_TYPE_EARLY_SKIP
9057 | OPTI_TYPE_NOT_ITERATED
9058 | OPTI_TYPE_APPENDED_SALT
9059 | OPTI_TYPE_USES_BITS_64
9060 | OPTI_TYPE_RAW_HASH;
9061 dgst_pos0 = 14;
9062 dgst_pos1 = 15;
9063 dgst_pos2 = 6;
9064 dgst_pos3 = 7;
9065 break;
9066
9067 case 1740: hash_type = HASH_TYPE_SHA512;
9068 salt_type = SALT_TYPE_INTERN;
9069 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9070 opts_type = OPTS_TYPE_PT_GENERATE_BE
9071 | OPTS_TYPE_PT_ADD80
9072 | OPTS_TYPE_PT_ADDBITS15
9073 | OPTS_TYPE_PT_UNICODE;
9074 kern_type = KERN_TYPE_SHA512_SLTPWU;
9075 dgst_size = DGST_SIZE_8_8;
9076 parse_func = sha512s_parse_hash;
9077 sort_by_digest = sort_by_digest_8_8;
9078 opti_type = OPTI_TYPE_ZERO_BYTE
9079 | OPTI_TYPE_PRECOMPUTE_INIT
9080 | OPTI_TYPE_PRECOMPUTE_MERKLE
9081 | OPTI_TYPE_EARLY_SKIP
9082 | OPTI_TYPE_NOT_ITERATED
9083 | OPTI_TYPE_PREPENDED_SALT
9084 | OPTI_TYPE_USES_BITS_64
9085 | OPTI_TYPE_RAW_HASH;
9086 dgst_pos0 = 14;
9087 dgst_pos1 = 15;
9088 dgst_pos2 = 6;
9089 dgst_pos3 = 7;
9090 break;
9091
9092 case 1750: hash_type = HASH_TYPE_SHA512;
9093 salt_type = SALT_TYPE_INTERN;
9094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_BE
9096 | OPTS_TYPE_ST_ADD80;
9097 kern_type = KERN_TYPE_HMACSHA512_PW;
9098 dgst_size = DGST_SIZE_8_8;
9099 parse_func = hmacsha512_parse_hash;
9100 sort_by_digest = sort_by_digest_8_8;
9101 opti_type = OPTI_TYPE_ZERO_BYTE
9102 | OPTI_TYPE_USES_BITS_64
9103 | OPTI_TYPE_NOT_ITERATED;
9104 dgst_pos0 = 14;
9105 dgst_pos1 = 15;
9106 dgst_pos2 = 6;
9107 dgst_pos3 = 7;
9108 break;
9109
9110 case 1760: hash_type = HASH_TYPE_SHA512;
9111 salt_type = SALT_TYPE_INTERN;
9112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9113 opts_type = OPTS_TYPE_PT_GENERATE_BE
9114 | OPTS_TYPE_PT_ADD80
9115 | OPTS_TYPE_PT_ADDBITS15;
9116 kern_type = KERN_TYPE_HMACSHA512_SLT;
9117 dgst_size = DGST_SIZE_8_8;
9118 parse_func = hmacsha512_parse_hash;
9119 sort_by_digest = sort_by_digest_8_8;
9120 opti_type = OPTI_TYPE_ZERO_BYTE
9121 | OPTI_TYPE_USES_BITS_64
9122 | OPTI_TYPE_NOT_ITERATED;
9123 dgst_pos0 = 14;
9124 dgst_pos1 = 15;
9125 dgst_pos2 = 6;
9126 dgst_pos3 = 7;
9127 break;
9128
9129 case 1800: hash_type = HASH_TYPE_SHA512;
9130 salt_type = SALT_TYPE_EMBEDDED;
9131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9132 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9133 kern_type = KERN_TYPE_SHA512CRYPT;
9134 dgst_size = DGST_SIZE_8_8;
9135 parse_func = sha512crypt_parse_hash;
9136 sort_by_digest = sort_by_digest_8_8;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_USES_BITS_64;
9139 dgst_pos0 = 0;
9140 dgst_pos1 = 1;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 3;
9143 break;
9144
9145 case 2000: hash_type = HASH_TYPE_STDOUT;
9146 salt_type = SALT_TYPE_NONE;
9147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9149 kern_type = KERN_TYPE_STDOUT;
9150 dgst_size = DGST_SIZE_4_4;
9151 parse_func = NULL;
9152 sort_by_digest = NULL;
9153 opti_type = 0;
9154 dgst_pos0 = 0;
9155 dgst_pos1 = 0;
9156 dgst_pos2 = 0;
9157 dgst_pos3 = 0;
9158 break;
9159
9160 case 2100: hash_type = HASH_TYPE_DCC2;
9161 salt_type = SALT_TYPE_EMBEDDED;
9162 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9163 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9164 | OPTS_TYPE_ST_LOWER
9165 | OPTS_TYPE_ST_UNICODE;
9166 kern_type = KERN_TYPE_DCC2;
9167 dgst_size = DGST_SIZE_4_4;
9168 parse_func = dcc2_parse_hash;
9169 sort_by_digest = sort_by_digest_4_4;
9170 opti_type = OPTI_TYPE_ZERO_BYTE
9171 | OPTI_TYPE_SLOW_HASH_SIMD;
9172 dgst_pos0 = 0;
9173 dgst_pos1 = 1;
9174 dgst_pos2 = 2;
9175 dgst_pos3 = 3;
9176 break;
9177
9178 case 2400: hash_type = HASH_TYPE_MD5;
9179 salt_type = SALT_TYPE_NONE;
9180 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9182 kern_type = KERN_TYPE_MD5PIX;
9183 dgst_size = DGST_SIZE_4_4;
9184 parse_func = md5pix_parse_hash;
9185 sort_by_digest = sort_by_digest_4_4;
9186 opti_type = OPTI_TYPE_ZERO_BYTE
9187 | OPTI_TYPE_PRECOMPUTE_INIT
9188 | OPTI_TYPE_PRECOMPUTE_MERKLE
9189 | OPTI_TYPE_EARLY_SKIP
9190 | OPTI_TYPE_NOT_ITERATED
9191 | OPTI_TYPE_NOT_SALTED;
9192 dgst_pos0 = 0;
9193 dgst_pos1 = 3;
9194 dgst_pos2 = 2;
9195 dgst_pos3 = 1;
9196 break;
9197
9198 case 2410: hash_type = HASH_TYPE_MD5;
9199 salt_type = SALT_TYPE_INTERN;
9200 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9201 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9202 kern_type = KERN_TYPE_MD5ASA;
9203 dgst_size = DGST_SIZE_4_4;
9204 parse_func = md5asa_parse_hash;
9205 sort_by_digest = sort_by_digest_4_4;
9206 opti_type = OPTI_TYPE_ZERO_BYTE
9207 | OPTI_TYPE_PRECOMPUTE_INIT
9208 | OPTI_TYPE_PRECOMPUTE_MERKLE
9209 | OPTI_TYPE_EARLY_SKIP
9210 | OPTI_TYPE_NOT_ITERATED;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 3;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 1;
9215 break;
9216
9217 case 2500: hash_type = HASH_TYPE_WPA;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_WPA;
9222 dgst_size = DGST_SIZE_4_4;
9223 parse_func = wpa_parse_hash;
9224 sort_by_digest = sort_by_digest_4_4;
9225 opti_type = OPTI_TYPE_ZERO_BYTE
9226 | OPTI_TYPE_SLOW_HASH_SIMD;
9227 dgst_pos0 = 0;
9228 dgst_pos1 = 1;
9229 dgst_pos2 = 2;
9230 dgst_pos3 = 3;
9231 break;
9232
9233 case 2600: hash_type = HASH_TYPE_MD5;
9234 salt_type = SALT_TYPE_VIRTUAL;
9235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9236 opts_type = OPTS_TYPE_PT_GENERATE_LE
9237 | OPTS_TYPE_PT_ADD80
9238 | OPTS_TYPE_PT_ADDBITS14
9239 | OPTS_TYPE_ST_ADD80;
9240 kern_type = KERN_TYPE_MD55_PWSLT1;
9241 dgst_size = DGST_SIZE_4_4;
9242 parse_func = md5md5_parse_hash;
9243 sort_by_digest = sort_by_digest_4_4;
9244 opti_type = OPTI_TYPE_ZERO_BYTE
9245 | OPTI_TYPE_PRECOMPUTE_INIT
9246 | OPTI_TYPE_PRECOMPUTE_MERKLE
9247 | OPTI_TYPE_EARLY_SKIP;
9248 dgst_pos0 = 0;
9249 dgst_pos1 = 3;
9250 dgst_pos2 = 2;
9251 dgst_pos3 = 1;
9252 break;
9253
9254 case 2611: hash_type = HASH_TYPE_MD5;
9255 salt_type = SALT_TYPE_INTERN;
9256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9257 opts_type = OPTS_TYPE_PT_GENERATE_LE
9258 | OPTS_TYPE_PT_ADD80
9259 | OPTS_TYPE_PT_ADDBITS14
9260 | OPTS_TYPE_ST_ADD80;
9261 kern_type = KERN_TYPE_MD55_PWSLT1;
9262 dgst_size = DGST_SIZE_4_4;
9263 parse_func = vb3_parse_hash;
9264 sort_by_digest = sort_by_digest_4_4;
9265 opti_type = OPTI_TYPE_ZERO_BYTE
9266 | OPTI_TYPE_PRECOMPUTE_INIT
9267 | OPTI_TYPE_PRECOMPUTE_MERKLE
9268 | OPTI_TYPE_EARLY_SKIP;
9269 dgst_pos0 = 0;
9270 dgst_pos1 = 3;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 1;
9273 break;
9274
9275 case 2612: hash_type = HASH_TYPE_MD5;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE
9279 | OPTS_TYPE_PT_ADD80
9280 | OPTS_TYPE_PT_ADDBITS14
9281 | OPTS_TYPE_ST_ADD80
9282 | OPTS_TYPE_ST_HEX;
9283 kern_type = KERN_TYPE_MD55_PWSLT1;
9284 dgst_size = DGST_SIZE_4_4;
9285 parse_func = phps_parse_hash;
9286 sort_by_digest = sort_by_digest_4_4;
9287 opti_type = OPTI_TYPE_ZERO_BYTE
9288 | OPTI_TYPE_PRECOMPUTE_INIT
9289 | OPTI_TYPE_PRECOMPUTE_MERKLE
9290 | OPTI_TYPE_EARLY_SKIP;
9291 dgst_pos0 = 0;
9292 dgst_pos1 = 3;
9293 dgst_pos2 = 2;
9294 dgst_pos3 = 1;
9295 break;
9296
9297 case 2711: hash_type = HASH_TYPE_MD5;
9298 salt_type = SALT_TYPE_INTERN;
9299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9300 opts_type = OPTS_TYPE_PT_GENERATE_LE
9301 | OPTS_TYPE_PT_ADD80
9302 | OPTS_TYPE_PT_ADDBITS14
9303 | OPTS_TYPE_ST_ADD80;
9304 kern_type = KERN_TYPE_MD55_PWSLT2;
9305 dgst_size = DGST_SIZE_4_4;
9306 parse_func = vb30_parse_hash;
9307 sort_by_digest = sort_by_digest_4_4;
9308 opti_type = OPTI_TYPE_ZERO_BYTE
9309 | OPTI_TYPE_PRECOMPUTE_INIT
9310 | OPTI_TYPE_EARLY_SKIP;
9311 dgst_pos0 = 0;
9312 dgst_pos1 = 3;
9313 dgst_pos2 = 2;
9314 dgst_pos3 = 1;
9315 break;
9316
9317 case 2811: hash_type = HASH_TYPE_MD5;
9318 salt_type = SALT_TYPE_INTERN;
9319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9320 opts_type = OPTS_TYPE_PT_GENERATE_LE
9321 | OPTS_TYPE_PT_ADD80
9322 | OPTS_TYPE_PT_ADDBITS14;
9323 kern_type = KERN_TYPE_MD55_SLTPW;
9324 dgst_size = DGST_SIZE_4_4;
9325 parse_func = ipb2_parse_hash;
9326 sort_by_digest = sort_by_digest_4_4;
9327 opti_type = OPTI_TYPE_ZERO_BYTE
9328 | OPTI_TYPE_PRECOMPUTE_INIT
9329 | OPTI_TYPE_EARLY_SKIP;
9330 dgst_pos0 = 0;
9331 dgst_pos1 = 3;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 1;
9334 break;
9335
9336 case 3000: hash_type = HASH_TYPE_LM;
9337 salt_type = SALT_TYPE_NONE;
9338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE
9340 | OPTS_TYPE_PT_UPPER
9341 | OPTS_TYPE_PT_BITSLICE;
9342 kern_type = KERN_TYPE_LM;
9343 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9344 parse_func = lm_parse_hash;
9345 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9346 opti_type = OPTI_TYPE_ZERO_BYTE
9347 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9348 dgst_pos0 = 0;
9349 dgst_pos1 = 1;
9350 dgst_pos2 = 2;
9351 dgst_pos3 = 3;
9352 break;
9353
9354 case 3100: hash_type = HASH_TYPE_ORACLEH;
9355 salt_type = SALT_TYPE_INTERN;
9356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9357 opts_type = OPTS_TYPE_PT_GENERATE_LE
9358 | OPTS_TYPE_PT_UPPER
9359 | OPTS_TYPE_ST_UPPER;
9360 kern_type = KERN_TYPE_ORACLEH;
9361 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9362 parse_func = oracleh_parse_hash;
9363 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9364 opti_type = OPTI_TYPE_ZERO_BYTE;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 3200: hash_type = HASH_TYPE_BCRYPT;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE
9375 | OPTS_TYPE_ST_GENERATE_LE;
9376 kern_type = KERN_TYPE_BCRYPT;
9377 dgst_size = DGST_SIZE_4_6;
9378 parse_func = bcrypt_parse_hash;
9379 sort_by_digest = sort_by_digest_4_6;
9380 opti_type = OPTI_TYPE_ZERO_BYTE;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 3710: hash_type = HASH_TYPE_MD5;
9388 salt_type = SALT_TYPE_INTERN;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE
9391 | OPTS_TYPE_PT_ADD80
9392 | OPTS_TYPE_PT_ADDBITS14;
9393 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9394 dgst_size = DGST_SIZE_4_4;
9395 parse_func = md5s_parse_hash;
9396 sort_by_digest = sort_by_digest_4_4;
9397 opti_type = OPTI_TYPE_ZERO_BYTE
9398 | OPTI_TYPE_PRECOMPUTE_INIT
9399 | OPTI_TYPE_PRECOMPUTE_MERKLE
9400 | OPTI_TYPE_EARLY_SKIP;
9401 dgst_pos0 = 0;
9402 dgst_pos1 = 3;
9403 dgst_pos2 = 2;
9404 dgst_pos3 = 1;
9405 break;
9406
9407 case 3711: hash_type = HASH_TYPE_MD5;
9408 salt_type = SALT_TYPE_EMBEDDED;
9409 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9410 opts_type = OPTS_TYPE_PT_GENERATE_LE
9411 | OPTS_TYPE_PT_ADD80
9412 | OPTS_TYPE_PT_ADDBITS14;
9413 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = mediawiki_b_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_ZERO_BYTE
9418 | OPTI_TYPE_PRECOMPUTE_INIT
9419 | OPTI_TYPE_PRECOMPUTE_MERKLE
9420 | OPTI_TYPE_EARLY_SKIP;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 3;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 1;
9425 break;
9426
9427 case 3800: hash_type = HASH_TYPE_MD5;
9428 salt_type = SALT_TYPE_INTERN;
9429 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE
9431 | OPTS_TYPE_ST_ADDBITS14;
9432 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9433 dgst_size = DGST_SIZE_4_4;
9434 parse_func = md5s_parse_hash;
9435 sort_by_digest = sort_by_digest_4_4;
9436 opti_type = OPTI_TYPE_ZERO_BYTE
9437 | OPTI_TYPE_PRECOMPUTE_INIT
9438 | OPTI_TYPE_PRECOMPUTE_MERKLE
9439 | OPTI_TYPE_EARLY_SKIP
9440 | OPTI_TYPE_NOT_ITERATED
9441 | OPTI_TYPE_RAW_HASH;
9442 dgst_pos0 = 0;
9443 dgst_pos1 = 3;
9444 dgst_pos2 = 2;
9445 dgst_pos3 = 1;
9446 break;
9447
9448 case 4300: hash_type = HASH_TYPE_MD5;
9449 salt_type = SALT_TYPE_VIRTUAL;
9450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9451 opts_type = OPTS_TYPE_PT_GENERATE_LE
9452 | OPTS_TYPE_PT_ADD80
9453 | OPTS_TYPE_PT_ADDBITS14
9454 | OPTS_TYPE_ST_ADD80;
9455 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9456 dgst_size = DGST_SIZE_4_4;
9457 parse_func = md5md5_parse_hash;
9458 sort_by_digest = sort_by_digest_4_4;
9459 opti_type = OPTI_TYPE_ZERO_BYTE
9460 | OPTI_TYPE_PRECOMPUTE_INIT
9461 | OPTI_TYPE_PRECOMPUTE_MERKLE
9462 | OPTI_TYPE_EARLY_SKIP;
9463 dgst_pos0 = 0;
9464 dgst_pos1 = 3;
9465 dgst_pos2 = 2;
9466 dgst_pos3 = 1;
9467 break;
9468
9469
9470 case 4400: hash_type = HASH_TYPE_MD5;
9471 salt_type = SALT_TYPE_NONE;
9472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9473 opts_type = OPTS_TYPE_PT_GENERATE_BE
9474 | OPTS_TYPE_PT_ADD80
9475 | OPTS_TYPE_PT_ADDBITS15;
9476 kern_type = KERN_TYPE_MD5_SHA1;
9477 dgst_size = DGST_SIZE_4_4;
9478 parse_func = md5_parse_hash;
9479 sort_by_digest = sort_by_digest_4_4;
9480 opti_type = OPTI_TYPE_ZERO_BYTE
9481 | OPTI_TYPE_PRECOMPUTE_INIT
9482 | OPTI_TYPE_PRECOMPUTE_MERKLE
9483 | OPTI_TYPE_EARLY_SKIP
9484 | OPTI_TYPE_NOT_ITERATED
9485 | OPTI_TYPE_NOT_SALTED
9486 | OPTI_TYPE_RAW_HASH;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 3;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 1;
9491 break;
9492
9493 case 4500: hash_type = HASH_TYPE_SHA1;
9494 salt_type = SALT_TYPE_NONE;
9495 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_BE
9497 | OPTS_TYPE_PT_ADD80
9498 | OPTS_TYPE_PT_ADDBITS15;
9499 kern_type = KERN_TYPE_SHA11;
9500 dgst_size = DGST_SIZE_4_5;
9501 parse_func = sha1_parse_hash;
9502 sort_by_digest = sort_by_digest_4_5;
9503 opti_type = OPTI_TYPE_ZERO_BYTE
9504 | OPTI_TYPE_PRECOMPUTE_INIT
9505 | OPTI_TYPE_PRECOMPUTE_MERKLE
9506 | OPTI_TYPE_EARLY_SKIP
9507 | OPTI_TYPE_NOT_SALTED;
9508 dgst_pos0 = 3;
9509 dgst_pos1 = 4;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 1;
9512 break;
9513
9514 case 4700: hash_type = HASH_TYPE_SHA1;
9515 salt_type = SALT_TYPE_NONE;
9516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE
9518 | OPTS_TYPE_PT_ADD80
9519 | OPTS_TYPE_PT_ADDBITS14;
9520 kern_type = KERN_TYPE_SHA1_MD5;
9521 dgst_size = DGST_SIZE_4_5;
9522 parse_func = sha1_parse_hash;
9523 sort_by_digest = sort_by_digest_4_5;
9524 opti_type = OPTI_TYPE_ZERO_BYTE
9525 | OPTI_TYPE_PRECOMPUTE_INIT
9526 | OPTI_TYPE_PRECOMPUTE_MERKLE
9527 | OPTI_TYPE_EARLY_SKIP
9528 | OPTI_TYPE_NOT_ITERATED
9529 | OPTI_TYPE_NOT_SALTED
9530 | OPTI_TYPE_RAW_HASH;
9531 dgst_pos0 = 3;
9532 dgst_pos1 = 4;
9533 dgst_pos2 = 2;
9534 dgst_pos3 = 1;
9535 break;
9536
9537 case 4800: hash_type = HASH_TYPE_MD5;
9538 salt_type = SALT_TYPE_EMBEDDED;
9539 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9540 opts_type = OPTS_TYPE_PT_GENERATE_LE
9541 | OPTS_TYPE_PT_ADDBITS14;
9542 kern_type = KERN_TYPE_MD5_CHAP;
9543 dgst_size = DGST_SIZE_4_4;
9544 parse_func = chap_parse_hash;
9545 sort_by_digest = sort_by_digest_4_4;
9546 opti_type = OPTI_TYPE_ZERO_BYTE
9547 | OPTI_TYPE_PRECOMPUTE_INIT
9548 | OPTI_TYPE_PRECOMPUTE_MERKLE
9549 | OPTI_TYPE_MEET_IN_MIDDLE
9550 | OPTI_TYPE_EARLY_SKIP
9551 | OPTI_TYPE_NOT_ITERATED
9552 | OPTI_TYPE_RAW_HASH;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 3;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 1;
9557 break;
9558
9559 case 4900: hash_type = HASH_TYPE_SHA1;
9560 salt_type = SALT_TYPE_INTERN;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9564 dgst_size = DGST_SIZE_4_5;
9565 parse_func = sha1s_parse_hash;
9566 sort_by_digest = sort_by_digest_4_5;
9567 opti_type = OPTI_TYPE_ZERO_BYTE
9568 | OPTI_TYPE_PRECOMPUTE_INIT
9569 | OPTI_TYPE_PRECOMPUTE_MERKLE
9570 | OPTI_TYPE_EARLY_SKIP;
9571 dgst_pos0 = 3;
9572 dgst_pos1 = 4;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 1;
9575 break;
9576
9577 case 5000: hash_type = HASH_TYPE_KECCAK;
9578 salt_type = SALT_TYPE_EMBEDDED;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE
9581 | OPTS_TYPE_PT_ADD01;
9582 kern_type = KERN_TYPE_KECCAK;
9583 dgst_size = DGST_SIZE_8_25;
9584 parse_func = keccak_parse_hash;
9585 sort_by_digest = sort_by_digest_8_25;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_USES_BITS_64
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 2;
9590 dgst_pos1 = 3;
9591 dgst_pos2 = 4;
9592 dgst_pos3 = 5;
9593 break;
9594
9595 case 5100: hash_type = HASH_TYPE_MD5H;
9596 salt_type = SALT_TYPE_NONE;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE
9599 | OPTS_TYPE_PT_ADD80
9600 | OPTS_TYPE_PT_ADDBITS14;
9601 kern_type = KERN_TYPE_MD5H;
9602 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9603 parse_func = md5half_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_RAW_HASH;
9607 dgst_pos0 = 0;
9608 dgst_pos1 = 1;
9609 dgst_pos2 = 2;
9610 dgst_pos3 = 3;
9611 break;
9612
9613 case 5200: hash_type = HASH_TYPE_SHA256;
9614 salt_type = SALT_TYPE_EMBEDDED;
9615 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9616 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9617 kern_type = KERN_TYPE_PSAFE3;
9618 dgst_size = DGST_SIZE_4_8;
9619 parse_func = psafe3_parse_hash;
9620 sort_by_digest = sort_by_digest_4_8;
9621 opti_type = OPTI_TYPE_ZERO_BYTE;
9622 dgst_pos0 = 0;
9623 dgst_pos1 = 1;
9624 dgst_pos2 = 2;
9625 dgst_pos3 = 3;
9626 break;
9627
9628 case 5300: hash_type = HASH_TYPE_MD5;
9629 salt_type = SALT_TYPE_EMBEDDED;
9630 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9631 opts_type = OPTS_TYPE_PT_GENERATE_LE
9632 | OPTS_TYPE_ST_ADD80;
9633 kern_type = KERN_TYPE_IKEPSK_MD5;
9634 dgst_size = DGST_SIZE_4_4;
9635 parse_func = ikepsk_md5_parse_hash;
9636 sort_by_digest = sort_by_digest_4_4;
9637 opti_type = OPTI_TYPE_ZERO_BYTE;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 3;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 1;
9642 break;
9643
9644 case 5400: hash_type = HASH_TYPE_SHA1;
9645 salt_type = SALT_TYPE_EMBEDDED;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_BE
9648 | OPTS_TYPE_ST_ADD80;
9649 kern_type = KERN_TYPE_IKEPSK_SHA1;
9650 dgst_size = DGST_SIZE_4_5;
9651 parse_func = ikepsk_sha1_parse_hash;
9652 sort_by_digest = sort_by_digest_4_5;
9653 opti_type = OPTI_TYPE_ZERO_BYTE;
9654 dgst_pos0 = 3;
9655 dgst_pos1 = 4;
9656 dgst_pos2 = 2;
9657 dgst_pos3 = 1;
9658 break;
9659
9660 case 5500: hash_type = HASH_TYPE_NETNTLM;
9661 salt_type = SALT_TYPE_EMBEDDED;
9662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9663 opts_type = OPTS_TYPE_PT_GENERATE_LE
9664 | OPTS_TYPE_PT_ADD80
9665 | OPTS_TYPE_PT_ADDBITS14
9666 | OPTS_TYPE_PT_UNICODE
9667 | OPTS_TYPE_ST_HEX;
9668 kern_type = KERN_TYPE_NETNTLMv1;
9669 dgst_size = DGST_SIZE_4_4;
9670 parse_func = netntlmv1_parse_hash;
9671 sort_by_digest = sort_by_digest_4_4;
9672 opti_type = OPTI_TYPE_ZERO_BYTE
9673 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9674 dgst_pos0 = 0;
9675 dgst_pos1 = 1;
9676 dgst_pos2 = 2;
9677 dgst_pos3 = 3;
9678 break;
9679
9680 case 5600: hash_type = HASH_TYPE_MD5;
9681 salt_type = SALT_TYPE_EMBEDDED;
9682 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9683 opts_type = OPTS_TYPE_PT_GENERATE_LE
9684 | OPTS_TYPE_PT_ADD80
9685 | OPTS_TYPE_PT_ADDBITS14
9686 | OPTS_TYPE_PT_UNICODE;
9687 kern_type = KERN_TYPE_NETNTLMv2;
9688 dgst_size = DGST_SIZE_4_4;
9689 parse_func = netntlmv2_parse_hash;
9690 sort_by_digest = sort_by_digest_4_4;
9691 opti_type = OPTI_TYPE_ZERO_BYTE;
9692 dgst_pos0 = 0;
9693 dgst_pos1 = 3;
9694 dgst_pos2 = 2;
9695 dgst_pos3 = 1;
9696 break;
9697
9698 case 5700: hash_type = HASH_TYPE_SHA256;
9699 salt_type = SALT_TYPE_NONE;
9700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9701 opts_type = OPTS_TYPE_PT_GENERATE_BE
9702 | OPTS_TYPE_PT_ADD80
9703 | OPTS_TYPE_PT_ADDBITS15;
9704 kern_type = KERN_TYPE_SHA256;
9705 dgst_size = DGST_SIZE_4_8;
9706 parse_func = cisco4_parse_hash;
9707 sort_by_digest = sort_by_digest_4_8;
9708 opti_type = OPTI_TYPE_ZERO_BYTE
9709 | OPTI_TYPE_PRECOMPUTE_INIT
9710 | OPTI_TYPE_PRECOMPUTE_MERKLE
9711 | OPTI_TYPE_EARLY_SKIP
9712 | OPTI_TYPE_NOT_ITERATED
9713 | OPTI_TYPE_NOT_SALTED
9714 | OPTI_TYPE_RAW_HASH;
9715 dgst_pos0 = 3;
9716 dgst_pos1 = 7;
9717 dgst_pos2 = 2;
9718 dgst_pos3 = 6;
9719 break;
9720
9721 case 5800: hash_type = HASH_TYPE_SHA1;
9722 salt_type = SALT_TYPE_INTERN;
9723 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9724 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9725 | OPTS_TYPE_ST_ADD80;
9726 kern_type = KERN_TYPE_ANDROIDPIN;
9727 dgst_size = DGST_SIZE_4_5;
9728 parse_func = androidpin_parse_hash;
9729 sort_by_digest = sort_by_digest_4_5;
9730 opti_type = OPTI_TYPE_ZERO_BYTE;
9731 dgst_pos0 = 0;
9732 dgst_pos1 = 1;
9733 dgst_pos2 = 2;
9734 dgst_pos3 = 3;
9735 break;
9736
9737 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9738 salt_type = SALT_TYPE_NONE;
9739 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9740 opts_type = OPTS_TYPE_PT_GENERATE_LE
9741 | OPTS_TYPE_PT_ADD80;
9742 kern_type = KERN_TYPE_RIPEMD160;
9743 dgst_size = DGST_SIZE_4_5;
9744 parse_func = ripemd160_parse_hash;
9745 sort_by_digest = sort_by_digest_4_5;
9746 opti_type = OPTI_TYPE_ZERO_BYTE;
9747 dgst_pos0 = 0;
9748 dgst_pos1 = 1;
9749 dgst_pos2 = 2;
9750 dgst_pos3 = 3;
9751 break;
9752
9753 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9754 salt_type = SALT_TYPE_NONE;
9755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9756 opts_type = OPTS_TYPE_PT_GENERATE_BE
9757 | OPTS_TYPE_PT_ADD80;
9758 kern_type = KERN_TYPE_WHIRLPOOL;
9759 dgst_size = DGST_SIZE_4_16;
9760 parse_func = whirlpool_parse_hash;
9761 sort_by_digest = sort_by_digest_4_16;
9762 opti_type = OPTI_TYPE_ZERO_BYTE;
9763 dgst_pos0 = 0;
9764 dgst_pos1 = 1;
9765 dgst_pos2 = 2;
9766 dgst_pos3 = 3;
9767 break;
9768
9769 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9770 salt_type = SALT_TYPE_EMBEDDED;
9771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9773 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9774 dgst_size = DGST_SIZE_4_5;
9775 parse_func = truecrypt_parse_hash_2k;
9776 sort_by_digest = sort_by_digest_4_5;
9777 opti_type = OPTI_TYPE_ZERO_BYTE;
9778 dgst_pos0 = 0;
9779 dgst_pos1 = 1;
9780 dgst_pos2 = 2;
9781 dgst_pos3 = 3;
9782 break;
9783
9784 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9785 salt_type = SALT_TYPE_EMBEDDED;
9786 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9787 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9788 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9789 dgst_size = DGST_SIZE_4_5;
9790 parse_func = truecrypt_parse_hash_2k;
9791 sort_by_digest = sort_by_digest_4_5;
9792 opti_type = OPTI_TYPE_ZERO_BYTE;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9803 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9804 dgst_size = DGST_SIZE_4_5;
9805 parse_func = truecrypt_parse_hash_2k;
9806 sort_by_digest = sort_by_digest_4_5;
9807 opti_type = OPTI_TYPE_ZERO_BYTE;
9808 dgst_pos0 = 0;
9809 dgst_pos1 = 1;
9810 dgst_pos2 = 2;
9811 dgst_pos3 = 3;
9812 break;
9813
9814 case 6221: hash_type = HASH_TYPE_SHA512;
9815 salt_type = SALT_TYPE_EMBEDDED;
9816 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9817 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9818 kern_type = KERN_TYPE_TCSHA512_XTS512;
9819 dgst_size = DGST_SIZE_8_8;
9820 parse_func = truecrypt_parse_hash_1k;
9821 sort_by_digest = sort_by_digest_8_8;
9822 opti_type = OPTI_TYPE_ZERO_BYTE
9823 | OPTI_TYPE_USES_BITS_64;
9824 dgst_pos0 = 0;
9825 dgst_pos1 = 1;
9826 dgst_pos2 = 2;
9827 dgst_pos3 = 3;
9828 break;
9829
9830 case 6222: hash_type = HASH_TYPE_SHA512;
9831 salt_type = SALT_TYPE_EMBEDDED;
9832 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9834 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9835 dgst_size = DGST_SIZE_8_8;
9836 parse_func = truecrypt_parse_hash_1k;
9837 sort_by_digest = sort_by_digest_8_8;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_USES_BITS_64;
9840 dgst_pos0 = 0;
9841 dgst_pos1 = 1;
9842 dgst_pos2 = 2;
9843 dgst_pos3 = 3;
9844 break;
9845
9846 case 6223: hash_type = HASH_TYPE_SHA512;
9847 salt_type = SALT_TYPE_EMBEDDED;
9848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9849 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9850 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9851 dgst_size = DGST_SIZE_8_8;
9852 parse_func = truecrypt_parse_hash_1k;
9853 sort_by_digest = sort_by_digest_8_8;
9854 opti_type = OPTI_TYPE_ZERO_BYTE
9855 | OPTI_TYPE_USES_BITS_64;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9863 salt_type = SALT_TYPE_EMBEDDED;
9864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9866 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9867 dgst_size = DGST_SIZE_4_8;
9868 parse_func = truecrypt_parse_hash_1k;
9869 sort_by_digest = sort_by_digest_4_8;
9870 opti_type = OPTI_TYPE_ZERO_BYTE;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9878 salt_type = SALT_TYPE_EMBEDDED;
9879 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9881 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9882 dgst_size = DGST_SIZE_4_8;
9883 parse_func = truecrypt_parse_hash_1k;
9884 sort_by_digest = sort_by_digest_4_8;
9885 opti_type = OPTI_TYPE_ZERO_BYTE;
9886 dgst_pos0 = 0;
9887 dgst_pos1 = 1;
9888 dgst_pos2 = 2;
9889 dgst_pos3 = 3;
9890 break;
9891
9892 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9893 salt_type = SALT_TYPE_EMBEDDED;
9894 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9895 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9896 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9897 dgst_size = DGST_SIZE_4_8;
9898 parse_func = truecrypt_parse_hash_1k;
9899 sort_by_digest = sort_by_digest_4_8;
9900 opti_type = OPTI_TYPE_ZERO_BYTE;
9901 dgst_pos0 = 0;
9902 dgst_pos1 = 1;
9903 dgst_pos2 = 2;
9904 dgst_pos3 = 3;
9905 break;
9906
9907 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9908 salt_type = SALT_TYPE_EMBEDDED;
9909 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9910 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9911 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9912 dgst_size = DGST_SIZE_4_5;
9913 parse_func = truecrypt_parse_hash_1k;
9914 sort_by_digest = sort_by_digest_4_5;
9915 opti_type = OPTI_TYPE_ZERO_BYTE;
9916 dgst_pos0 = 0;
9917 dgst_pos1 = 1;
9918 dgst_pos2 = 2;
9919 dgst_pos3 = 3;
9920 break;
9921
9922 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9923 salt_type = SALT_TYPE_EMBEDDED;
9924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9926 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9927 dgst_size = DGST_SIZE_4_5;
9928 parse_func = truecrypt_parse_hash_1k;
9929 sort_by_digest = sort_by_digest_4_5;
9930 opti_type = OPTI_TYPE_ZERO_BYTE;
9931 dgst_pos0 = 0;
9932 dgst_pos1 = 1;
9933 dgst_pos2 = 2;
9934 dgst_pos3 = 3;
9935 break;
9936
9937 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9938 salt_type = SALT_TYPE_EMBEDDED;
9939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9941 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9942 dgst_size = DGST_SIZE_4_5;
9943 parse_func = truecrypt_parse_hash_1k;
9944 sort_by_digest = sort_by_digest_4_5;
9945 opti_type = OPTI_TYPE_ZERO_BYTE;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 1;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 3;
9950 break;
9951
9952 case 6300: hash_type = HASH_TYPE_MD5;
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_MD5AIX;
9957 dgst_size = DGST_SIZE_4_4;
9958 parse_func = md5aix_parse_hash;
9959 sort_by_digest = sort_by_digest_4_4;
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 6400: hash_type = HASH_TYPE_SHA256;
9968 salt_type = SALT_TYPE_EMBEDDED;
9969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9970 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9971 kern_type = KERN_TYPE_SHA256AIX;
9972 dgst_size = DGST_SIZE_4_8;
9973 parse_func = sha256aix_parse_hash;
9974 sort_by_digest = sort_by_digest_4_8;
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 6500: hash_type = HASH_TYPE_SHA512;
9983 salt_type = SALT_TYPE_EMBEDDED;
9984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9985 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9986 kern_type = KERN_TYPE_SHA512AIX;
9987 dgst_size = DGST_SIZE_8_8;
9988 parse_func = sha512aix_parse_hash;
9989 sort_by_digest = sort_by_digest_8_8;
9990 opti_type = OPTI_TYPE_ZERO_BYTE
9991 | OPTI_TYPE_USES_BITS_64;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 1;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 3;
9996 break;
9997
9998 case 6600: hash_type = HASH_TYPE_AES;
9999 salt_type = SALT_TYPE_EMBEDDED;
10000 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10002 kern_type = KERN_TYPE_AGILEKEY;
10003 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10004 parse_func = agilekey_parse_hash;
10005 sort_by_digest = sort_by_digest_4_5;
10006 opti_type = OPTI_TYPE_ZERO_BYTE;
10007 dgst_pos0 = 0;
10008 dgst_pos1 = 1;
10009 dgst_pos2 = 2;
10010 dgst_pos3 = 3;
10011 break;
10012
10013 case 6700: hash_type = HASH_TYPE_SHA1;
10014 salt_type = SALT_TYPE_EMBEDDED;
10015 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10016 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10017 kern_type = KERN_TYPE_SHA1AIX;
10018 dgst_size = DGST_SIZE_4_5;
10019 parse_func = sha1aix_parse_hash;
10020 sort_by_digest = sort_by_digest_4_5;
10021 opti_type = OPTI_TYPE_ZERO_BYTE;
10022 dgst_pos0 = 0;
10023 dgst_pos1 = 1;
10024 dgst_pos2 = 2;
10025 dgst_pos3 = 3;
10026 break;
10027
10028 case 6800: hash_type = HASH_TYPE_AES;
10029 salt_type = SALT_TYPE_EMBEDDED;
10030 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10031 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10032 kern_type = KERN_TYPE_LASTPASS;
10033 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
10034 parse_func = lastpass_parse_hash;
10035 sort_by_digest = sort_by_digest_4_8;
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 6900: hash_type = HASH_TYPE_GOST;
10044 salt_type = SALT_TYPE_NONE;
10045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10047 kern_type = KERN_TYPE_GOST;
10048 dgst_size = DGST_SIZE_4_8;
10049 parse_func = gost_parse_hash;
10050 sort_by_digest = sort_by_digest_4_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 7100: hash_type = HASH_TYPE_SHA512;
10059 salt_type = SALT_TYPE_EMBEDDED;
10060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10062 kern_type = KERN_TYPE_PBKDF2_SHA512;
10063 dgst_size = DGST_SIZE_8_16;
10064 parse_func = sha512osx_parse_hash;
10065 sort_by_digest = sort_by_digest_8_16;
10066 opti_type = OPTI_TYPE_ZERO_BYTE
10067 | OPTI_TYPE_USES_BITS_64
10068 | OPTI_TYPE_SLOW_HASH_SIMD;
10069 dgst_pos0 = 0;
10070 dgst_pos1 = 1;
10071 dgst_pos2 = 2;
10072 dgst_pos3 = 3;
10073 break;
10074
10075 case 7200: hash_type = HASH_TYPE_SHA512;
10076 salt_type = SALT_TYPE_EMBEDDED;
10077 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10078 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10079 kern_type = KERN_TYPE_PBKDF2_SHA512;
10080 dgst_size = DGST_SIZE_8_16;
10081 parse_func = sha512grub_parse_hash;
10082 sort_by_digest = sort_by_digest_8_16;
10083 opti_type = OPTI_TYPE_ZERO_BYTE
10084 | OPTI_TYPE_USES_BITS_64
10085 | OPTI_TYPE_SLOW_HASH_SIMD;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 7300: hash_type = HASH_TYPE_SHA1;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_BE
10096 | OPTS_TYPE_ST_ADD80
10097 | OPTS_TYPE_ST_ADDBITS15;
10098 kern_type = KERN_TYPE_RAKP;
10099 dgst_size = DGST_SIZE_4_5;
10100 parse_func = rakp_parse_hash;
10101 sort_by_digest = sort_by_digest_4_5;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_NOT_ITERATED;
10104 dgst_pos0 = 3;
10105 dgst_pos1 = 4;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 1;
10108 break;
10109
10110 case 7400: hash_type = HASH_TYPE_SHA256;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10114 kern_type = KERN_TYPE_SHA256CRYPT;
10115 dgst_size = DGST_SIZE_4_8;
10116 parse_func = sha256crypt_parse_hash;
10117 sort_by_digest = sort_by_digest_4_8;
10118 opti_type = OPTI_TYPE_ZERO_BYTE;
10119 dgst_pos0 = 0;
10120 dgst_pos1 = 1;
10121 dgst_pos2 = 2;
10122 dgst_pos3 = 3;
10123 break;
10124
10125 case 7500: hash_type = HASH_TYPE_KRB5PA;
10126 salt_type = SALT_TYPE_EMBEDDED;
10127 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10128 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10129 kern_type = KERN_TYPE_KRB5PA;
10130 dgst_size = DGST_SIZE_4_4;
10131 parse_func = krb5pa_parse_hash;
10132 sort_by_digest = sort_by_digest_4_4;
10133 opti_type = OPTI_TYPE_ZERO_BYTE
10134 | OPTI_TYPE_NOT_ITERATED;
10135 dgst_pos0 = 0;
10136 dgst_pos1 = 1;
10137 dgst_pos2 = 2;
10138 dgst_pos3 = 3;
10139 break;
10140
10141 case 7600: hash_type = HASH_TYPE_SHA1;
10142 salt_type = SALT_TYPE_INTERN;
10143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10144 opts_type = OPTS_TYPE_PT_GENERATE_BE
10145 | OPTS_TYPE_PT_ADD80
10146 | OPTS_TYPE_PT_ADDBITS15;
10147 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
10148 dgst_size = DGST_SIZE_4_5;
10149 parse_func = redmine_parse_hash;
10150 sort_by_digest = sort_by_digest_4_5;
10151 opti_type = OPTI_TYPE_ZERO_BYTE
10152 | OPTI_TYPE_PRECOMPUTE_INIT
10153 | OPTI_TYPE_EARLY_SKIP
10154 | OPTI_TYPE_NOT_ITERATED
10155 | OPTI_TYPE_PREPENDED_SALT;
10156 dgst_pos0 = 3;
10157 dgst_pos1 = 4;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 1;
10160 break;
10161
10162 case 7700: hash_type = HASH_TYPE_SAPB;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_PT_UPPER
10167 | OPTS_TYPE_ST_UPPER;
10168 kern_type = KERN_TYPE_SAPB;
10169 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10170 parse_func = sapb_parse_hash;
10171 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10172 opti_type = OPTI_TYPE_ZERO_BYTE
10173 | OPTI_TYPE_PRECOMPUTE_INIT
10174 | OPTI_TYPE_NOT_ITERATED;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 7800: hash_type = HASH_TYPE_SAPG;
10182 salt_type = SALT_TYPE_EMBEDDED;
10183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_BE
10185 | OPTS_TYPE_ST_ADD80
10186 | OPTS_TYPE_ST_UPPER;
10187 kern_type = KERN_TYPE_SAPG;
10188 dgst_size = DGST_SIZE_4_5;
10189 parse_func = sapg_parse_hash;
10190 sort_by_digest = sort_by_digest_4_5;
10191 opti_type = OPTI_TYPE_ZERO_BYTE
10192 | OPTI_TYPE_PRECOMPUTE_INIT
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 3;
10195 dgst_pos1 = 4;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 1;
10198 break;
10199
10200 case 7900: hash_type = HASH_TYPE_SHA512;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10204 kern_type = KERN_TYPE_DRUPAL7;
10205 dgst_size = DGST_SIZE_8_8;
10206 parse_func = drupal7_parse_hash;
10207 sort_by_digest = sort_by_digest_8_8;
10208 opti_type = OPTI_TYPE_ZERO_BYTE
10209 | OPTI_TYPE_USES_BITS_64;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 8000: hash_type = HASH_TYPE_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_BE
10220 | OPTS_TYPE_PT_UNICODE
10221 | OPTS_TYPE_ST_ADD80
10222 | OPTS_TYPE_ST_HEX;
10223 kern_type = KERN_TYPE_SYBASEASE;
10224 dgst_size = DGST_SIZE_4_8;
10225 parse_func = sybasease_parse_hash;
10226 sort_by_digest = sort_by_digest_4_8;
10227 opti_type = OPTI_TYPE_ZERO_BYTE
10228 | OPTI_TYPE_PRECOMPUTE_INIT
10229 | OPTI_TYPE_EARLY_SKIP
10230 | OPTI_TYPE_NOT_ITERATED
10231 | OPTI_TYPE_RAW_HASH;
10232 dgst_pos0 = 3;
10233 dgst_pos1 = 7;
10234 dgst_pos2 = 2;
10235 dgst_pos3 = 6;
10236 break;
10237
10238 case 8100: hash_type = HASH_TYPE_SHA1;
10239 salt_type = SALT_TYPE_EMBEDDED;
10240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10241 opts_type = OPTS_TYPE_PT_GENERATE_BE;
10242 kern_type = KERN_TYPE_NETSCALER;
10243 dgst_size = DGST_SIZE_4_5;
10244 parse_func = netscaler_parse_hash;
10245 sort_by_digest = sort_by_digest_4_5;
10246 opti_type = OPTI_TYPE_ZERO_BYTE
10247 | OPTI_TYPE_PRECOMPUTE_INIT
10248 | OPTI_TYPE_PRECOMPUTE_MERKLE
10249 | OPTI_TYPE_EARLY_SKIP
10250 | OPTI_TYPE_NOT_ITERATED
10251 | OPTI_TYPE_PREPENDED_SALT
10252 | OPTI_TYPE_RAW_HASH;
10253 dgst_pos0 = 3;
10254 dgst_pos1 = 4;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 1;
10257 break;
10258
10259 case 8200: hash_type = HASH_TYPE_SHA256;
10260 salt_type = SALT_TYPE_EMBEDDED;
10261 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10262 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10263 kern_type = KERN_TYPE_CLOUDKEY;
10264 dgst_size = DGST_SIZE_4_8;
10265 parse_func = cloudkey_parse_hash;
10266 sort_by_digest = sort_by_digest_4_8;
10267 opti_type = OPTI_TYPE_ZERO_BYTE;
10268 dgst_pos0 = 0;
10269 dgst_pos1 = 1;
10270 dgst_pos2 = 2;
10271 dgst_pos3 = 3;
10272 break;
10273
10274 case 8300: hash_type = HASH_TYPE_SHA1;
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_HEX
10279 | OPTS_TYPE_ST_ADD80;
10280 kern_type = KERN_TYPE_NSEC3;
10281 dgst_size = DGST_SIZE_4_5;
10282 parse_func = nsec3_parse_hash;
10283 sort_by_digest = sort_by_digest_4_5;
10284 opti_type = OPTI_TYPE_ZERO_BYTE;
10285 dgst_pos0 = 3;
10286 dgst_pos1 = 4;
10287 dgst_pos2 = 2;
10288 dgst_pos3 = 1;
10289 break;
10290
10291 case 8400: hash_type = HASH_TYPE_SHA1;
10292 salt_type = SALT_TYPE_INTERN;
10293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10294 opts_type = OPTS_TYPE_PT_GENERATE_BE
10295 | OPTS_TYPE_PT_ADD80
10296 | OPTS_TYPE_PT_ADDBITS15;
10297 kern_type = KERN_TYPE_WBB3;
10298 dgst_size = DGST_SIZE_4_5;
10299 parse_func = wbb3_parse_hash;
10300 sort_by_digest = sort_by_digest_4_5;
10301 opti_type = OPTI_TYPE_ZERO_BYTE
10302 | OPTI_TYPE_PRECOMPUTE_INIT
10303 | OPTI_TYPE_NOT_ITERATED;
10304 dgst_pos0 = 3;
10305 dgst_pos1 = 4;
10306 dgst_pos2 = 2;
10307 dgst_pos3 = 1;
10308 break;
10309
10310 case 8500: hash_type = HASH_TYPE_DESRACF;
10311 salt_type = SALT_TYPE_EMBEDDED;
10312 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10313 opts_type = OPTS_TYPE_PT_GENERATE_LE
10314 | OPTS_TYPE_ST_UPPER;
10315 kern_type = KERN_TYPE_RACF;
10316 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10317 parse_func = racf_parse_hash;
10318 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10319 opti_type = OPTI_TYPE_ZERO_BYTE
10320 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10321 dgst_pos0 = 0;
10322 dgst_pos1 = 1;
10323 dgst_pos2 = 2;
10324 dgst_pos3 = 3;
10325 break;
10326
10327 case 8600: hash_type = HASH_TYPE_LOTUS5;
10328 salt_type = SALT_TYPE_NONE;
10329 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10331 kern_type = KERN_TYPE_LOTUS5;
10332 dgst_size = DGST_SIZE_4_4;
10333 parse_func = lotus5_parse_hash;
10334 sort_by_digest = sort_by_digest_4_4;
10335 opti_type = OPTI_TYPE_EARLY_SKIP
10336 | OPTI_TYPE_NOT_ITERATED
10337 | OPTI_TYPE_NOT_SALTED
10338 | OPTI_TYPE_RAW_HASH;
10339 dgst_pos0 = 0;
10340 dgst_pos1 = 1;
10341 dgst_pos2 = 2;
10342 dgst_pos3 = 3;
10343 break;
10344
10345 case 8700: hash_type = HASH_TYPE_LOTUS6;
10346 salt_type = SALT_TYPE_EMBEDDED;
10347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10349 kern_type = KERN_TYPE_LOTUS6;
10350 dgst_size = DGST_SIZE_4_4;
10351 parse_func = lotus6_parse_hash;
10352 sort_by_digest = sort_by_digest_4_4;
10353 opti_type = OPTI_TYPE_EARLY_SKIP
10354 | OPTI_TYPE_NOT_ITERATED
10355 | OPTI_TYPE_RAW_HASH;
10356 dgst_pos0 = 0;
10357 dgst_pos1 = 1;
10358 dgst_pos2 = 2;
10359 dgst_pos3 = 3;
10360 break;
10361
10362 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10363 salt_type = SALT_TYPE_EMBEDDED;
10364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10365 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10366 kern_type = KERN_TYPE_ANDROIDFDE;
10367 dgst_size = DGST_SIZE_4_4;
10368 parse_func = androidfde_parse_hash;
10369 sort_by_digest = sort_by_digest_4_4;
10370 opti_type = OPTI_TYPE_ZERO_BYTE;
10371 dgst_pos0 = 0;
10372 dgst_pos1 = 1;
10373 dgst_pos2 = 2;
10374 dgst_pos3 = 3;
10375 break;
10376
10377 case 8900: hash_type = HASH_TYPE_SCRYPT;
10378 salt_type = SALT_TYPE_EMBEDDED;
10379 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10381 kern_type = KERN_TYPE_SCRYPT;
10382 dgst_size = DGST_SIZE_4_8;
10383 parse_func = scrypt_parse_hash;
10384 sort_by_digest = sort_by_digest_4_8;
10385 opti_type = OPTI_TYPE_ZERO_BYTE;
10386 dgst_pos0 = 0;
10387 dgst_pos1 = 1;
10388 dgst_pos2 = 2;
10389 dgst_pos3 = 3;
10390 break;
10391
10392 case 9000: hash_type = HASH_TYPE_SHA1;
10393 salt_type = SALT_TYPE_EMBEDDED;
10394 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10395 opts_type = OPTS_TYPE_PT_GENERATE_LE
10396 | OPTS_TYPE_ST_GENERATE_LE;
10397 kern_type = KERN_TYPE_PSAFE2;
10398 dgst_size = DGST_SIZE_4_5;
10399 parse_func = psafe2_parse_hash;
10400 sort_by_digest = sort_by_digest_4_5;
10401 opti_type = OPTI_TYPE_ZERO_BYTE;
10402 dgst_pos0 = 0;
10403 dgst_pos1 = 1;
10404 dgst_pos2 = 2;
10405 dgst_pos3 = 3;
10406 break;
10407
10408 case 9100: hash_type = HASH_TYPE_LOTUS8;
10409 salt_type = SALT_TYPE_EMBEDDED;
10410 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10411 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10412 kern_type = KERN_TYPE_LOTUS8;
10413 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10414 parse_func = lotus8_parse_hash;
10415 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10416 opti_type = OPTI_TYPE_ZERO_BYTE;
10417 dgst_pos0 = 0;
10418 dgst_pos1 = 1;
10419 dgst_pos2 = 2;
10420 dgst_pos3 = 3;
10421 break;
10422
10423 case 9200: hash_type = HASH_TYPE_SHA256;
10424 salt_type = SALT_TYPE_EMBEDDED;
10425 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10426 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10427 kern_type = KERN_TYPE_PBKDF2_SHA256;
10428 dgst_size = DGST_SIZE_4_32;
10429 parse_func = cisco8_parse_hash;
10430 sort_by_digest = sort_by_digest_4_32;
10431 opti_type = OPTI_TYPE_ZERO_BYTE
10432 | OPTI_TYPE_SLOW_HASH_SIMD;
10433 dgst_pos0 = 0;
10434 dgst_pos1 = 1;
10435 dgst_pos2 = 2;
10436 dgst_pos3 = 3;
10437 break;
10438
10439 case 9300: hash_type = HASH_TYPE_SCRYPT;
10440 salt_type = SALT_TYPE_EMBEDDED;
10441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10443 kern_type = KERN_TYPE_SCRYPT;
10444 dgst_size = DGST_SIZE_4_8;
10445 parse_func = cisco9_parse_hash;
10446 sort_by_digest = sort_by_digest_4_8;
10447 opti_type = OPTI_TYPE_ZERO_BYTE;
10448 dgst_pos0 = 0;
10449 dgst_pos1 = 1;
10450 dgst_pos2 = 2;
10451 dgst_pos3 = 3;
10452 break;
10453
10454 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10455 salt_type = SALT_TYPE_EMBEDDED;
10456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10458 kern_type = KERN_TYPE_OFFICE2007;
10459 dgst_size = DGST_SIZE_4_4;
10460 parse_func = office2007_parse_hash;
10461 sort_by_digest = sort_by_digest_4_4;
10462 opti_type = OPTI_TYPE_ZERO_BYTE;
10463 dgst_pos0 = 0;
10464 dgst_pos1 = 1;
10465 dgst_pos2 = 2;
10466 dgst_pos3 = 3;
10467 break;
10468
10469 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10470 salt_type = SALT_TYPE_EMBEDDED;
10471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10473 kern_type = KERN_TYPE_OFFICE2010;
10474 dgst_size = DGST_SIZE_4_4;
10475 parse_func = office2010_parse_hash;
10476 sort_by_digest = sort_by_digest_4_4;
10477 opti_type = OPTI_TYPE_ZERO_BYTE;
10478 dgst_pos0 = 0;
10479 dgst_pos1 = 1;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 3;
10482 break;
10483
10484 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10488 kern_type = KERN_TYPE_OFFICE2013;
10489 dgst_size = DGST_SIZE_4_4;
10490 parse_func = office2013_parse_hash;
10491 sort_by_digest = sort_by_digest_4_4;
10492 opti_type = OPTI_TYPE_ZERO_BYTE;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 1;
10495 dgst_pos2 = 2;
10496 dgst_pos3 = 3;
10497 break;
10498
10499 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE
10503 | OPTS_TYPE_PT_ADD80
10504 | OPTS_TYPE_PT_UNICODE;
10505 kern_type = KERN_TYPE_OLDOFFICE01;
10506 dgst_size = DGST_SIZE_4_4;
10507 parse_func = oldoffice01_parse_hash;
10508 sort_by_digest = sort_by_digest_4_4;
10509 opti_type = OPTI_TYPE_ZERO_BYTE
10510 | OPTI_TYPE_PRECOMPUTE_INIT
10511 | OPTI_TYPE_NOT_ITERATED;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 1;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 3;
10516 break;
10517
10518 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10519 salt_type = SALT_TYPE_EMBEDDED;
10520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE
10522 | OPTS_TYPE_PT_ADD80;
10523 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10524 dgst_size = DGST_SIZE_4_4;
10525 parse_func = oldoffice01cm1_parse_hash;
10526 sort_by_digest = sort_by_digest_4_4;
10527 opti_type = OPTI_TYPE_ZERO_BYTE
10528 | OPTI_TYPE_PRECOMPUTE_INIT
10529 | OPTI_TYPE_NOT_ITERATED;
10530 dgst_pos0 = 0;
10531 dgst_pos1 = 1;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 3;
10534 break;
10535
10536 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE
10540 | OPTS_TYPE_PT_ADD80
10541 | OPTS_TYPE_PT_UNICODE
10542 | OPTS_TYPE_PT_NEVERCRACK;
10543 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10544 dgst_size = DGST_SIZE_4_4;
10545 parse_func = oldoffice01cm2_parse_hash;
10546 sort_by_digest = sort_by_digest_4_4;
10547 opti_type = OPTI_TYPE_ZERO_BYTE
10548 | OPTI_TYPE_PRECOMPUTE_INIT
10549 | OPTI_TYPE_NOT_ITERATED;
10550 dgst_pos0 = 0;
10551 dgst_pos1 = 1;
10552 dgst_pos2 = 2;
10553 dgst_pos3 = 3;
10554 break;
10555
10556 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10557 salt_type = SALT_TYPE_EMBEDDED;
10558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10559 opts_type = OPTS_TYPE_PT_GENERATE_BE
10560 | OPTS_TYPE_PT_ADD80
10561 | OPTS_TYPE_PT_UNICODE;
10562 kern_type = KERN_TYPE_OLDOFFICE34;
10563 dgst_size = DGST_SIZE_4_4;
10564 parse_func = oldoffice34_parse_hash;
10565 sort_by_digest = sort_by_digest_4_4;
10566 opti_type = OPTI_TYPE_ZERO_BYTE
10567 | OPTI_TYPE_PRECOMPUTE_INIT
10568 | OPTI_TYPE_NOT_ITERATED;
10569 dgst_pos0 = 0;
10570 dgst_pos1 = 1;
10571 dgst_pos2 = 2;
10572 dgst_pos3 = 3;
10573 break;
10574
10575 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10576 salt_type = SALT_TYPE_EMBEDDED;
10577 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10578 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10579 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10580 dgst_size = DGST_SIZE_4_4;
10581 parse_func = oldoffice34cm1_parse_hash;
10582 sort_by_digest = sort_by_digest_4_4;
10583 opti_type = OPTI_TYPE_ZERO_BYTE
10584 | OPTI_TYPE_PRECOMPUTE_INIT
10585 | OPTI_TYPE_NOT_ITERATED;
10586 dgst_pos0 = 0;
10587 dgst_pos1 = 1;
10588 dgst_pos2 = 2;
10589 dgst_pos3 = 3;
10590 break;
10591
10592 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10593 salt_type = SALT_TYPE_EMBEDDED;
10594 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10595 opts_type = OPTS_TYPE_PT_GENERATE_BE
10596 | OPTS_TYPE_PT_ADD80
10597 | OPTS_TYPE_PT_UNICODE
10598 | OPTS_TYPE_PT_NEVERCRACK;
10599 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10600 dgst_size = DGST_SIZE_4_4;
10601 parse_func = oldoffice34cm2_parse_hash;
10602 sort_by_digest = sort_by_digest_4_4;
10603 opti_type = OPTI_TYPE_ZERO_BYTE
10604 | OPTI_TYPE_PRECOMPUTE_INIT
10605 | OPTI_TYPE_NOT_ITERATED;
10606 dgst_pos0 = 0;
10607 dgst_pos1 = 1;
10608 dgst_pos2 = 2;
10609 dgst_pos3 = 3;
10610 break;
10611
10612 case 9900: hash_type = HASH_TYPE_MD5;
10613 salt_type = SALT_TYPE_NONE;
10614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10616 kern_type = KERN_TYPE_RADMIN2;
10617 dgst_size = DGST_SIZE_4_4;
10618 parse_func = radmin2_parse_hash;
10619 sort_by_digest = sort_by_digest_4_4;
10620 opti_type = OPTI_TYPE_ZERO_BYTE
10621 | OPTI_TYPE_PRECOMPUTE_INIT
10622 | OPTI_TYPE_EARLY_SKIP
10623 | OPTI_TYPE_NOT_ITERATED
10624 | OPTI_TYPE_NOT_SALTED;
10625 dgst_pos0 = 0;
10626 dgst_pos1 = 3;
10627 dgst_pos2 = 2;
10628 dgst_pos3 = 1;
10629 break;
10630
10631 case 10000: hash_type = HASH_TYPE_SHA256;
10632 salt_type = SALT_TYPE_EMBEDDED;
10633 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10634 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10635 kern_type = KERN_TYPE_PBKDF2_SHA256;
10636 dgst_size = DGST_SIZE_4_32;
10637 parse_func = djangopbkdf2_parse_hash;
10638 sort_by_digest = sort_by_digest_4_32;
10639 opti_type = OPTI_TYPE_ZERO_BYTE
10640 | OPTI_TYPE_SLOW_HASH_SIMD;
10641 dgst_pos0 = 0;
10642 dgst_pos1 = 1;
10643 dgst_pos2 = 2;
10644 dgst_pos3 = 3;
10645 break;
10646
10647 case 10100: hash_type = HASH_TYPE_SIPHASH;
10648 salt_type = SALT_TYPE_EMBEDDED;
10649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10650 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10651 kern_type = KERN_TYPE_SIPHASH;
10652 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10653 parse_func = siphash_parse_hash;
10654 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10655 opti_type = OPTI_TYPE_ZERO_BYTE
10656 | OPTI_TYPE_NOT_ITERATED
10657 | OPTI_TYPE_RAW_HASH;
10658 dgst_pos0 = 0;
10659 dgst_pos1 = 1;
10660 dgst_pos2 = 2;
10661 dgst_pos3 = 3;
10662 break;
10663
10664 case 10200: hash_type = HASH_TYPE_MD5;
10665 salt_type = SALT_TYPE_EMBEDDED;
10666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10667 opts_type = OPTS_TYPE_PT_GENERATE_LE
10668 | OPTS_TYPE_ST_ADD80
10669 | OPTS_TYPE_ST_ADDBITS14;
10670 kern_type = KERN_TYPE_HMACMD5_PW;
10671 dgst_size = DGST_SIZE_4_4;
10672 parse_func = crammd5_parse_hash;
10673 sort_by_digest = sort_by_digest_4_4;
10674 opti_type = OPTI_TYPE_ZERO_BYTE
10675 | OPTI_TYPE_NOT_ITERATED;
10676 dgst_pos0 = 0;
10677 dgst_pos1 = 3;
10678 dgst_pos2 = 2;
10679 dgst_pos3 = 1;
10680 break;
10681
10682 case 10300: hash_type = HASH_TYPE_SHA1;
10683 salt_type = SALT_TYPE_EMBEDDED;
10684 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10685 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10686 kern_type = KERN_TYPE_SAPH_SHA1;
10687 dgst_size = DGST_SIZE_4_5;
10688 parse_func = saph_sha1_parse_hash;
10689 sort_by_digest = sort_by_digest_4_5;
10690 opti_type = OPTI_TYPE_ZERO_BYTE;
10691 dgst_pos0 = 0;
10692 dgst_pos1 = 1;
10693 dgst_pos2 = 2;
10694 dgst_pos3 = 3;
10695 break;
10696
10697 case 10400: hash_type = HASH_TYPE_PDFU16;
10698 salt_type = SALT_TYPE_EMBEDDED;
10699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10700 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10701 kern_type = KERN_TYPE_PDF11;
10702 dgst_size = DGST_SIZE_4_4;
10703 parse_func = pdf11_parse_hash;
10704 sort_by_digest = sort_by_digest_4_4;
10705 opti_type = OPTI_TYPE_ZERO_BYTE
10706 | OPTI_TYPE_NOT_ITERATED;
10707 dgst_pos0 = 0;
10708 dgst_pos1 = 1;
10709 dgst_pos2 = 2;
10710 dgst_pos3 = 3;
10711 break;
10712
10713 case 10410: hash_type = HASH_TYPE_PDFU16;
10714 salt_type = SALT_TYPE_EMBEDDED;
10715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10716 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10717 kern_type = KERN_TYPE_PDF11CM1;
10718 dgst_size = DGST_SIZE_4_4;
10719 parse_func = pdf11cm1_parse_hash;
10720 sort_by_digest = sort_by_digest_4_4;
10721 opti_type = OPTI_TYPE_ZERO_BYTE
10722 | OPTI_TYPE_NOT_ITERATED;
10723 dgst_pos0 = 0;
10724 dgst_pos1 = 1;
10725 dgst_pos2 = 2;
10726 dgst_pos3 = 3;
10727 break;
10728
10729 case 10420: hash_type = HASH_TYPE_PDFU16;
10730 salt_type = SALT_TYPE_EMBEDDED;
10731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10733 kern_type = KERN_TYPE_PDF11CM2;
10734 dgst_size = DGST_SIZE_4_4;
10735 parse_func = pdf11cm2_parse_hash;
10736 sort_by_digest = sort_by_digest_4_4;
10737 opti_type = OPTI_TYPE_ZERO_BYTE
10738 | OPTI_TYPE_NOT_ITERATED;
10739 dgst_pos0 = 0;
10740 dgst_pos1 = 1;
10741 dgst_pos2 = 2;
10742 dgst_pos3 = 3;
10743 break;
10744
10745 case 10500: hash_type = HASH_TYPE_PDFU16;
10746 salt_type = SALT_TYPE_EMBEDDED;
10747 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10749 kern_type = KERN_TYPE_PDF14;
10750 dgst_size = DGST_SIZE_4_4;
10751 parse_func = pdf14_parse_hash;
10752 sort_by_digest = sort_by_digest_4_4;
10753 opti_type = OPTI_TYPE_ZERO_BYTE
10754 | OPTI_TYPE_NOT_ITERATED;
10755 dgst_pos0 = 0;
10756 dgst_pos1 = 1;
10757 dgst_pos2 = 2;
10758 dgst_pos3 = 3;
10759 break;
10760
10761 case 10600: hash_type = HASH_TYPE_SHA256;
10762 salt_type = SALT_TYPE_EMBEDDED;
10763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10764 opts_type = OPTS_TYPE_PT_GENERATE_BE
10765 | OPTS_TYPE_ST_ADD80
10766 | OPTS_TYPE_ST_ADDBITS15
10767 | OPTS_TYPE_HASH_COPY;
10768 kern_type = KERN_TYPE_SHA256_PWSLT;
10769 dgst_size = DGST_SIZE_4_8;
10770 parse_func = pdf17l3_parse_hash;
10771 sort_by_digest = sort_by_digest_4_8;
10772 opti_type = OPTI_TYPE_ZERO_BYTE
10773 | OPTI_TYPE_PRECOMPUTE_INIT
10774 | OPTI_TYPE_PRECOMPUTE_MERKLE
10775 | OPTI_TYPE_EARLY_SKIP
10776 | OPTI_TYPE_NOT_ITERATED
10777 | OPTI_TYPE_APPENDED_SALT
10778 | OPTI_TYPE_RAW_HASH;
10779 dgst_pos0 = 3;
10780 dgst_pos1 = 7;
10781 dgst_pos2 = 2;
10782 dgst_pos3 = 6;
10783 break;
10784
10785 case 10700: hash_type = HASH_TYPE_PDFU32;
10786 salt_type = SALT_TYPE_EMBEDDED;
10787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10788 opts_type = OPTS_TYPE_PT_GENERATE_LE
10789 | OPTS_TYPE_HASH_COPY;
10790 kern_type = KERN_TYPE_PDF17L8;
10791 dgst_size = DGST_SIZE_4_8;
10792 parse_func = pdf17l8_parse_hash;
10793 sort_by_digest = sort_by_digest_4_8;
10794 opti_type = OPTI_TYPE_ZERO_BYTE
10795 | OPTI_TYPE_NOT_ITERATED;
10796 dgst_pos0 = 0;
10797 dgst_pos1 = 1;
10798 dgst_pos2 = 2;
10799 dgst_pos3 = 3;
10800 break;
10801
10802 case 10800: hash_type = HASH_TYPE_SHA384;
10803 salt_type = SALT_TYPE_NONE;
10804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10805 opts_type = OPTS_TYPE_PT_GENERATE_BE
10806 | OPTS_TYPE_PT_ADD80
10807 | OPTS_TYPE_PT_ADDBITS15;
10808 kern_type = KERN_TYPE_SHA384;
10809 dgst_size = DGST_SIZE_8_8;
10810 parse_func = sha384_parse_hash;
10811 sort_by_digest = sort_by_digest_8_8;
10812 opti_type = OPTI_TYPE_ZERO_BYTE
10813 | OPTI_TYPE_PRECOMPUTE_INIT
10814 | OPTI_TYPE_PRECOMPUTE_MERKLE
10815 | OPTI_TYPE_EARLY_SKIP
10816 | OPTI_TYPE_NOT_ITERATED
10817 | OPTI_TYPE_NOT_SALTED
10818 | OPTI_TYPE_USES_BITS_64
10819 | OPTI_TYPE_RAW_HASH;
10820 dgst_pos0 = 6;
10821 dgst_pos1 = 7;
10822 dgst_pos2 = 4;
10823 dgst_pos3 = 5;
10824 break;
10825
10826 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10827 salt_type = SALT_TYPE_EMBEDDED;
10828 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10829 opts_type = OPTS_TYPE_PT_GENERATE_LE
10830 | OPTS_TYPE_ST_BASE64
10831 | OPTS_TYPE_HASH_COPY;
10832 kern_type = KERN_TYPE_PBKDF2_SHA256;
10833 dgst_size = DGST_SIZE_4_32;
10834 parse_func = pbkdf2_sha256_parse_hash;
10835 sort_by_digest = sort_by_digest_4_32;
10836 opti_type = OPTI_TYPE_ZERO_BYTE
10837 | OPTI_TYPE_SLOW_HASH_SIMD;
10838 dgst_pos0 = 0;
10839 dgst_pos1 = 1;
10840 dgst_pos2 = 2;
10841 dgst_pos3 = 3;
10842 break;
10843
10844 case 11000: hash_type = HASH_TYPE_MD5;
10845 salt_type = SALT_TYPE_INTERN;
10846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10847 opts_type = OPTS_TYPE_PT_GENERATE_LE
10848 | OPTS_TYPE_PT_ADD80;
10849 kern_type = KERN_TYPE_PRESTASHOP;
10850 dgst_size = DGST_SIZE_4_4;
10851 parse_func = prestashop_parse_hash;
10852 sort_by_digest = sort_by_digest_4_4;
10853 opti_type = OPTI_TYPE_ZERO_BYTE
10854 | OPTI_TYPE_PRECOMPUTE_INIT
10855 | OPTI_TYPE_NOT_ITERATED
10856 | OPTI_TYPE_PREPENDED_SALT;
10857 dgst_pos0 = 0;
10858 dgst_pos1 = 3;
10859 dgst_pos2 = 2;
10860 dgst_pos3 = 1;
10861 break;
10862
10863 case 11100: hash_type = HASH_TYPE_MD5;
10864 salt_type = SALT_TYPE_EMBEDDED;
10865 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10866 opts_type = OPTS_TYPE_PT_GENERATE_LE
10867 | OPTS_TYPE_ST_ADD80;
10868 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10869 dgst_size = DGST_SIZE_4_4;
10870 parse_func = postgresql_auth_parse_hash;
10871 sort_by_digest = sort_by_digest_4_4;
10872 opti_type = OPTI_TYPE_ZERO_BYTE
10873 | OPTI_TYPE_PRECOMPUTE_INIT
10874 | OPTI_TYPE_PRECOMPUTE_MERKLE
10875 | OPTI_TYPE_EARLY_SKIP;
10876 dgst_pos0 = 0;
10877 dgst_pos1 = 3;
10878 dgst_pos2 = 2;
10879 dgst_pos3 = 1;
10880 break;
10881
10882 case 11200: hash_type = HASH_TYPE_SHA1;
10883 salt_type = SALT_TYPE_EMBEDDED;
10884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10885 opts_type = OPTS_TYPE_PT_GENERATE_BE
10886 | OPTS_TYPE_PT_ADD80
10887 | OPTS_TYPE_ST_HEX;
10888 kern_type = KERN_TYPE_MYSQL_AUTH;
10889 dgst_size = DGST_SIZE_4_5;
10890 parse_func = mysql_auth_parse_hash;
10891 sort_by_digest = sort_by_digest_4_5;
10892 opti_type = OPTI_TYPE_ZERO_BYTE
10893 | OPTI_TYPE_EARLY_SKIP;
10894 dgst_pos0 = 3;
10895 dgst_pos1 = 4;
10896 dgst_pos2 = 2;
10897 dgst_pos3 = 1;
10898 break;
10899
10900 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10901 salt_type = SALT_TYPE_EMBEDDED;
10902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10903 opts_type = OPTS_TYPE_PT_GENERATE_LE
10904 | OPTS_TYPE_ST_HEX
10905 | OPTS_TYPE_ST_ADD80;
10906 kern_type = KERN_TYPE_BITCOIN_WALLET;
10907 dgst_size = DGST_SIZE_4_4;
10908 parse_func = bitcoin_wallet_parse_hash;
10909 sort_by_digest = sort_by_digest_4_4;
10910 opti_type = OPTI_TYPE_ZERO_BYTE;
10911 dgst_pos0 = 0;
10912 dgst_pos1 = 1;
10913 dgst_pos2 = 2;
10914 dgst_pos3 = 3;
10915 break;
10916
10917 case 11400: hash_type = HASH_TYPE_MD5;
10918 salt_type = SALT_TYPE_EMBEDDED;
10919 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10920 opts_type = OPTS_TYPE_PT_GENERATE_LE
10921 | OPTS_TYPE_PT_ADD80
10922 | OPTS_TYPE_HASH_COPY;
10923 kern_type = KERN_TYPE_SIP_AUTH;
10924 dgst_size = DGST_SIZE_4_4;
10925 parse_func = sip_auth_parse_hash;
10926 sort_by_digest = sort_by_digest_4_4;
10927 opti_type = OPTI_TYPE_ZERO_BYTE;
10928 dgst_pos0 = 0;
10929 dgst_pos1 = 3;
10930 dgst_pos2 = 2;
10931 dgst_pos3 = 1;
10932 break;
10933
10934 case 11500: hash_type = HASH_TYPE_CRC32;
10935 salt_type = SALT_TYPE_INTERN;
10936 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10937 opts_type = OPTS_TYPE_PT_GENERATE_LE
10938 | OPTS_TYPE_ST_GENERATE_LE
10939 | OPTS_TYPE_ST_HEX;
10940 kern_type = KERN_TYPE_CRC32;
10941 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10942 parse_func = crc32_parse_hash;
10943 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10944 opti_type = OPTI_TYPE_ZERO_BYTE;
10945 dgst_pos0 = 0;
10946 dgst_pos1 = 1;
10947 dgst_pos2 = 2;
10948 dgst_pos3 = 3;
10949 break;
10950
10951 case 11600: hash_type = HASH_TYPE_AES;
10952 salt_type = SALT_TYPE_EMBEDDED;
10953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10954 opts_type = OPTS_TYPE_PT_GENERATE_LE
10955 | OPTS_TYPE_PT_NEVERCRACK;
10956 kern_type = KERN_TYPE_SEVEN_ZIP;
10957 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10958 parse_func = seven_zip_parse_hash;
10959 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
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 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10968 salt_type = SALT_TYPE_NONE;
10969 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10970 opts_type = OPTS_TYPE_PT_GENERATE_LE
10971 | OPTS_TYPE_PT_ADD01;
10972 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10973 dgst_size = DGST_SIZE_4_8;
10974 parse_func = gost2012sbog_256_parse_hash;
10975 sort_by_digest = sort_by_digest_4_8;
10976 opti_type = OPTI_TYPE_ZERO_BYTE;
10977 dgst_pos0 = 0;
10978 dgst_pos1 = 1;
10979 dgst_pos2 = 2;
10980 dgst_pos3 = 3;
10981 break;
10982
10983 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10984 salt_type = SALT_TYPE_NONE;
10985 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10986 opts_type = OPTS_TYPE_PT_GENERATE_LE
10987 | OPTS_TYPE_PT_ADD01;
10988 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10989 dgst_size = DGST_SIZE_4_16;
10990 parse_func = gost2012sbog_512_parse_hash;
10991 sort_by_digest = sort_by_digest_4_16;
10992 opti_type = OPTI_TYPE_ZERO_BYTE;
10993 dgst_pos0 = 0;
10994 dgst_pos1 = 1;
10995 dgst_pos2 = 2;
10996 dgst_pos3 = 3;
10997 break;
10998
10999 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
11000 salt_type = SALT_TYPE_EMBEDDED;
11001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11002 opts_type = OPTS_TYPE_PT_GENERATE_LE
11003 | OPTS_TYPE_ST_BASE64
11004 | OPTS_TYPE_HASH_COPY;
11005 kern_type = KERN_TYPE_PBKDF2_MD5;
11006 dgst_size = DGST_SIZE_4_32;
11007 parse_func = pbkdf2_md5_parse_hash;
11008 sort_by_digest = sort_by_digest_4_32;
11009 opti_type = OPTI_TYPE_ZERO_BYTE
11010 | OPTI_TYPE_SLOW_HASH_SIMD;
11011 dgst_pos0 = 0;
11012 dgst_pos1 = 1;
11013 dgst_pos2 = 2;
11014 dgst_pos3 = 3;
11015 break;
11016
11017 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
11018 salt_type = SALT_TYPE_EMBEDDED;
11019 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11020 opts_type = OPTS_TYPE_PT_GENERATE_LE
11021 | OPTS_TYPE_ST_BASE64
11022 | OPTS_TYPE_HASH_COPY;
11023 kern_type = KERN_TYPE_PBKDF2_SHA1;
11024 dgst_size = DGST_SIZE_4_32;
11025 parse_func = pbkdf2_sha1_parse_hash;
11026 sort_by_digest = sort_by_digest_4_32;
11027 opti_type = OPTI_TYPE_ZERO_BYTE
11028 | OPTI_TYPE_SLOW_HASH_SIMD;
11029 dgst_pos0 = 0;
11030 dgst_pos1 = 1;
11031 dgst_pos2 = 2;
11032 dgst_pos3 = 3;
11033 break;
11034
11035 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
11036 salt_type = SALT_TYPE_EMBEDDED;
11037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11038 opts_type = OPTS_TYPE_PT_GENERATE_LE
11039 | OPTS_TYPE_ST_BASE64
11040 | OPTS_TYPE_HASH_COPY;
11041 kern_type = KERN_TYPE_PBKDF2_SHA512;
11042 dgst_size = DGST_SIZE_8_16;
11043 parse_func = pbkdf2_sha512_parse_hash;
11044 sort_by_digest = sort_by_digest_8_16;
11045 opti_type = OPTI_TYPE_ZERO_BYTE
11046 | OPTI_TYPE_USES_BITS_64
11047 | OPTI_TYPE_SLOW_HASH_SIMD;
11048 dgst_pos0 = 0;
11049 dgst_pos1 = 1;
11050 dgst_pos2 = 2;
11051 dgst_pos3 = 3;
11052 break;
11053
11054 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
11055 salt_type = SALT_TYPE_EMBEDDED;
11056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11057 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11058 kern_type = KERN_TYPE_ECRYPTFS;
11059 dgst_size = DGST_SIZE_8_8;
11060 parse_func = ecryptfs_parse_hash;
11061 sort_by_digest = sort_by_digest_8_8;
11062 opti_type = OPTI_TYPE_ZERO_BYTE
11063 | OPTI_TYPE_USES_BITS_64;
11064 dgst_pos0 = 0;
11065 dgst_pos1 = 1;
11066 dgst_pos2 = 2;
11067 dgst_pos3 = 3;
11068 break;
11069
11070 case 12300: hash_type = HASH_TYPE_ORACLET;
11071 salt_type = SALT_TYPE_EMBEDDED;
11072 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11073 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11074 kern_type = KERN_TYPE_ORACLET;
11075 dgst_size = DGST_SIZE_8_16;
11076 parse_func = oraclet_parse_hash;
11077 sort_by_digest = sort_by_digest_8_16;
11078 opti_type = OPTI_TYPE_ZERO_BYTE
11079 | OPTI_TYPE_USES_BITS_64;
11080 dgst_pos0 = 0;
11081 dgst_pos1 = 1;
11082 dgst_pos2 = 2;
11083 dgst_pos3 = 3;
11084 break;
11085
11086 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
11087 salt_type = SALT_TYPE_EMBEDDED;
11088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11090 kern_type = KERN_TYPE_BSDICRYPT;
11091 dgst_size = DGST_SIZE_4_4;
11092 parse_func = bsdicrypt_parse_hash;
11093 sort_by_digest = sort_by_digest_4_4;
11094 opti_type = OPTI_TYPE_ZERO_BYTE
11095 | OPTI_TYPE_PRECOMPUTE_PERMUT;
11096 dgst_pos0 = 0;
11097 dgst_pos1 = 1;
11098 dgst_pos2 = 2;
11099 dgst_pos3 = 3;
11100 break;
11101
11102 case 12500: hash_type = HASH_TYPE_RAR3HP;
11103 salt_type = SALT_TYPE_EMBEDDED;
11104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11106 kern_type = KERN_TYPE_RAR3;
11107 dgst_size = DGST_SIZE_4_4;
11108 parse_func = rar3hp_parse_hash;
11109 sort_by_digest = sort_by_digest_4_4;
11110 opti_type = OPTI_TYPE_ZERO_BYTE;
11111 dgst_pos0 = 0;
11112 dgst_pos1 = 1;
11113 dgst_pos2 = 2;
11114 dgst_pos3 = 3;
11115 break;
11116
11117 case 12600: hash_type = HASH_TYPE_SHA256;
11118 salt_type = SALT_TYPE_INTERN;
11119 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11120 opts_type = OPTS_TYPE_PT_GENERATE_BE
11121 | OPTS_TYPE_PT_ADD80;
11122 kern_type = KERN_TYPE_CF10;
11123 dgst_size = DGST_SIZE_4_8;
11124 parse_func = cf10_parse_hash;
11125 sort_by_digest = sort_by_digest_4_8;
11126 opti_type = OPTI_TYPE_ZERO_BYTE
11127 | OPTI_TYPE_PRECOMPUTE_INIT
11128 | OPTI_TYPE_EARLY_SKIP
11129 | OPTI_TYPE_NOT_ITERATED;
11130 dgst_pos0 = 3;
11131 dgst_pos1 = 7;
11132 dgst_pos2 = 2;
11133 dgst_pos3 = 6;
11134 break;
11135
11136 case 12700: hash_type = HASH_TYPE_AES;
11137 salt_type = SALT_TYPE_EMBEDDED;
11138 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11139 opts_type = OPTS_TYPE_PT_GENERATE_LE
11140 | OPTS_TYPE_HASH_COPY;
11141 kern_type = KERN_TYPE_MYWALLET;
11142 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
11143 parse_func = mywallet_parse_hash;
11144 sort_by_digest = sort_by_digest_4_5;
11145 opti_type = OPTI_TYPE_ZERO_BYTE;
11146 dgst_pos0 = 0;
11147 dgst_pos1 = 1;
11148 dgst_pos2 = 2;
11149 dgst_pos3 = 3;
11150 break;
11151
11152 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
11153 salt_type = SALT_TYPE_EMBEDDED;
11154 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11155 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11156 kern_type = KERN_TYPE_MS_DRSR;
11157 dgst_size = DGST_SIZE_4_8;
11158 parse_func = ms_drsr_parse_hash;
11159 sort_by_digest = sort_by_digest_4_8;
11160 opti_type = OPTI_TYPE_ZERO_BYTE;
11161 dgst_pos0 = 0;
11162 dgst_pos1 = 1;
11163 dgst_pos2 = 2;
11164 dgst_pos3 = 3;
11165 break;
11166
11167 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
11168 salt_type = SALT_TYPE_EMBEDDED;
11169 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11171 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
11172 dgst_size = DGST_SIZE_4_8;
11173 parse_func = androidfde_samsung_parse_hash;
11174 sort_by_digest = sort_by_digest_4_8;
11175 opti_type = OPTI_TYPE_ZERO_BYTE;
11176 dgst_pos0 = 0;
11177 dgst_pos1 = 1;
11178 dgst_pos2 = 2;
11179 dgst_pos3 = 3;
11180 break;
11181
11182 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
11183 salt_type = SALT_TYPE_EMBEDDED;
11184 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11185 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11186 kern_type = KERN_TYPE_RAR5;
11187 dgst_size = DGST_SIZE_4_4;
11188 parse_func = rar5_parse_hash;
11189 sort_by_digest = sort_by_digest_4_4;
11190 opti_type = OPTI_TYPE_ZERO_BYTE;
11191 dgst_pos0 = 0;
11192 dgst_pos1 = 1;
11193 dgst_pos2 = 2;
11194 dgst_pos3 = 3;
11195 break;
11196
11197 case 13100: hash_type = HASH_TYPE_KRB5TGS;
11198 salt_type = SALT_TYPE_EMBEDDED;
11199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11200 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11201 kern_type = KERN_TYPE_KRB5TGS;
11202 dgst_size = DGST_SIZE_4_4;
11203 parse_func = krb5tgs_parse_hash;
11204 sort_by_digest = sort_by_digest_4_4;
11205 opti_type = OPTI_TYPE_ZERO_BYTE
11206 | OPTI_TYPE_NOT_ITERATED;
11207 dgst_pos0 = 0;
11208 dgst_pos1 = 1;
11209 dgst_pos2 = 2;
11210 dgst_pos3 = 3;
11211 break;
11212
11213 case 13200: hash_type = HASH_TYPE_AES;
11214 salt_type = SALT_TYPE_EMBEDDED;
11215 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11216 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11217 kern_type = KERN_TYPE_AXCRYPT;
11218 dgst_size = DGST_SIZE_4_4;
11219 parse_func = axcrypt_parse_hash;
11220 sort_by_digest = sort_by_digest_4_4;
11221 opti_type = OPTI_TYPE_ZERO_BYTE;
11222 dgst_pos0 = 0;
11223 dgst_pos1 = 1;
11224 dgst_pos2 = 2;
11225 dgst_pos3 = 3;
11226 break;
11227
11228 case 13300: hash_type = HASH_TYPE_SHA1;
11229 salt_type = SALT_TYPE_NONE;
11230 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11231 opts_type = OPTS_TYPE_PT_GENERATE_BE
11232 | OPTS_TYPE_PT_ADD80
11233 | OPTS_TYPE_PT_ADDBITS15;
11234 kern_type = KERN_TYPE_SHA1_AXCRYPT;
11235 dgst_size = DGST_SIZE_4_5;
11236 parse_func = sha1axcrypt_parse_hash;
11237 sort_by_digest = sort_by_digest_4_5;
11238 opti_type = OPTI_TYPE_ZERO_BYTE
11239 | OPTI_TYPE_PRECOMPUTE_INIT
11240 | OPTI_TYPE_EARLY_SKIP
11241 | OPTI_TYPE_NOT_ITERATED
11242 | OPTI_TYPE_NOT_SALTED;
11243 dgst_pos0 = 0;
11244 dgst_pos1 = 4;
11245 dgst_pos2 = 3;
11246 dgst_pos3 = 2;
11247 break;
11248
11249 case 13400: hash_type = HASH_TYPE_AES;
11250 salt_type = SALT_TYPE_EMBEDDED;
11251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11253 kern_type = KERN_TYPE_KEEPASS;
11254 dgst_size = DGST_SIZE_4_4;
11255 parse_func = keepass_parse_hash;
11256 sort_by_digest = sort_by_digest_4_4;
11257 opti_type = OPTI_TYPE_ZERO_BYTE;
11258 dgst_pos0 = 0;
11259 dgst_pos1 = 1;
11260 dgst_pos2 = 2;
11261 dgst_pos3 = 3;
11262 break;
11263
11264 case 13500: hash_type = HASH_TYPE_SHA1;
11265 salt_type = SALT_TYPE_EMBEDDED;
11266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11267 opts_type = OPTS_TYPE_PT_GENERATE_BE
11268 | OPTS_TYPE_PT_UNICODE
11269 | OPTS_TYPE_PT_ADD80;
11270 kern_type = KERN_TYPE_PSTOKEN;
11271 dgst_size = DGST_SIZE_4_5;
11272 parse_func = pstoken_parse_hash;
11273 sort_by_digest = sort_by_digest_4_5;
11274 opti_type = OPTI_TYPE_ZERO_BYTE
11275 | OPTI_TYPE_PRECOMPUTE_INIT
11276 | OPTI_TYPE_EARLY_SKIP
11277 | OPTI_TYPE_NOT_ITERATED
11278 | OPTI_TYPE_PREPENDED_SALT
11279 | OPTI_TYPE_RAW_HASH;
11280 dgst_pos0 = 3;
11281 dgst_pos1 = 4;
11282 dgst_pos2 = 2;
11283 dgst_pos3 = 1;
11284 break;
11285
11286 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
11287 salt_type = SALT_TYPE_EMBEDDED;
11288 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11289 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11290 kern_type = KERN_TYPE_ZIP2;
11291 dgst_size = DGST_SIZE_4_4;
11292 parse_func = zip2_parse_hash;
11293 sort_by_digest = sort_by_digest_4_4;
11294 opti_type = OPTI_TYPE_ZERO_BYTE;
11295 dgst_pos0 = 0;
11296 dgst_pos1 = 1;
11297 dgst_pos2 = 2;
11298 dgst_pos3 = 3;
11299 break;
11300
11301 case 13711: hash_type = HASH_TYPE_RIPEMD160;
11302 salt_type = SALT_TYPE_EMBEDDED;
11303 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11304 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11305 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11306 dgst_size = DGST_SIZE_4_5;
11307 parse_func = veracrypt_parse_hash_655331;
11308 sort_by_digest = sort_by_digest_4_5;
11309 opti_type = OPTI_TYPE_ZERO_BYTE;
11310 dgst_pos0 = 0;
11311 dgst_pos1 = 1;
11312 dgst_pos2 = 2;
11313 dgst_pos3 = 3;
11314 break;
11315
11316 case 13712: hash_type = HASH_TYPE_RIPEMD160;
11317 salt_type = SALT_TYPE_EMBEDDED;
11318 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11319 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11320 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11321 dgst_size = DGST_SIZE_4_5;
11322 parse_func = veracrypt_parse_hash_655331;
11323 sort_by_digest = sort_by_digest_4_5;
11324 opti_type = OPTI_TYPE_ZERO_BYTE;
11325 dgst_pos0 = 0;
11326 dgst_pos1 = 1;
11327 dgst_pos2 = 2;
11328 dgst_pos3 = 3;
11329 break;
11330
11331 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11332 salt_type = SALT_TYPE_EMBEDDED;
11333 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11334 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11335 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11336 dgst_size = DGST_SIZE_4_5;
11337 parse_func = veracrypt_parse_hash_655331;
11338 sort_by_digest = sort_by_digest_4_5;
11339 opti_type = OPTI_TYPE_ZERO_BYTE;
11340 dgst_pos0 = 0;
11341 dgst_pos1 = 1;
11342 dgst_pos2 = 2;
11343 dgst_pos3 = 3;
11344 break;
11345
11346 case 13721: hash_type = HASH_TYPE_SHA512;
11347 salt_type = SALT_TYPE_EMBEDDED;
11348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11349 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11350 kern_type = KERN_TYPE_TCSHA512_XTS512;
11351 dgst_size = DGST_SIZE_8_8;
11352 parse_func = veracrypt_parse_hash_500000;
11353 sort_by_digest = sort_by_digest_8_8;
11354 opti_type = OPTI_TYPE_ZERO_BYTE
11355 | OPTI_TYPE_USES_BITS_64;
11356 dgst_pos0 = 0;
11357 dgst_pos1 = 1;
11358 dgst_pos2 = 2;
11359 dgst_pos3 = 3;
11360 break;
11361
11362 case 13722: hash_type = HASH_TYPE_SHA512;
11363 salt_type = SALT_TYPE_EMBEDDED;
11364 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11365 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11366 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11367 dgst_size = DGST_SIZE_8_8;
11368 parse_func = veracrypt_parse_hash_500000;
11369 sort_by_digest = sort_by_digest_8_8;
11370 opti_type = OPTI_TYPE_ZERO_BYTE
11371 | OPTI_TYPE_USES_BITS_64;
11372 dgst_pos0 = 0;
11373 dgst_pos1 = 1;
11374 dgst_pos2 = 2;
11375 dgst_pos3 = 3;
11376 break;
11377
11378 case 13723: hash_type = HASH_TYPE_SHA512;
11379 salt_type = SALT_TYPE_EMBEDDED;
11380 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11381 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11382 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11383 dgst_size = DGST_SIZE_8_8;
11384 parse_func = veracrypt_parse_hash_500000;
11385 sort_by_digest = sort_by_digest_8_8;
11386 opti_type = OPTI_TYPE_ZERO_BYTE
11387 | OPTI_TYPE_USES_BITS_64;
11388 dgst_pos0 = 0;
11389 dgst_pos1 = 1;
11390 dgst_pos2 = 2;
11391 dgst_pos3 = 3;
11392 break;
11393
11394 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11395 salt_type = SALT_TYPE_EMBEDDED;
11396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11398 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11399 dgst_size = DGST_SIZE_4_8;
11400 parse_func = veracrypt_parse_hash_500000;
11401 sort_by_digest = sort_by_digest_4_8;
11402 opti_type = OPTI_TYPE_ZERO_BYTE;
11403 dgst_pos0 = 0;
11404 dgst_pos1 = 1;
11405 dgst_pos2 = 2;
11406 dgst_pos3 = 3;
11407 break;
11408
11409 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11410 salt_type = SALT_TYPE_EMBEDDED;
11411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11413 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11414 dgst_size = DGST_SIZE_4_8;
11415 parse_func = veracrypt_parse_hash_500000;
11416 sort_by_digest = sort_by_digest_4_8;
11417 opti_type = OPTI_TYPE_ZERO_BYTE;
11418 dgst_pos0 = 0;
11419 dgst_pos1 = 1;
11420 dgst_pos2 = 2;
11421 dgst_pos3 = 3;
11422 break;
11423
11424 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11425 salt_type = SALT_TYPE_EMBEDDED;
11426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11427 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11428 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11429 dgst_size = DGST_SIZE_4_8;
11430 parse_func = veracrypt_parse_hash_500000;
11431 sort_by_digest = sort_by_digest_4_8;
11432 opti_type = OPTI_TYPE_ZERO_BYTE;
11433 dgst_pos0 = 0;
11434 dgst_pos1 = 1;
11435 dgst_pos2 = 2;
11436 dgst_pos3 = 3;
11437 break;
11438
11439 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11440 salt_type = SALT_TYPE_EMBEDDED;
11441 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11442 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11443 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11444 dgst_size = DGST_SIZE_4_5;
11445 parse_func = veracrypt_parse_hash_327661;
11446 sort_by_digest = sort_by_digest_4_5;
11447 opti_type = OPTI_TYPE_ZERO_BYTE;
11448 dgst_pos0 = 0;
11449 dgst_pos1 = 1;
11450 dgst_pos2 = 2;
11451 dgst_pos3 = 3;
11452 break;
11453
11454 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11455 salt_type = SALT_TYPE_EMBEDDED;
11456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11458 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11459 dgst_size = DGST_SIZE_4_5;
11460 parse_func = veracrypt_parse_hash_327661;
11461 sort_by_digest = sort_by_digest_4_5;
11462 opti_type = OPTI_TYPE_ZERO_BYTE;
11463 dgst_pos0 = 0;
11464 dgst_pos1 = 1;
11465 dgst_pos2 = 2;
11466 dgst_pos3 = 3;
11467 break;
11468
11469 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11470 salt_type = SALT_TYPE_EMBEDDED;
11471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11473 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11474 dgst_size = DGST_SIZE_4_5;
11475 parse_func = veracrypt_parse_hash_327661;
11476 sort_by_digest = sort_by_digest_4_5;
11477 opti_type = OPTI_TYPE_ZERO_BYTE;
11478 dgst_pos0 = 0;
11479 dgst_pos1 = 1;
11480 dgst_pos2 = 2;
11481 dgst_pos3 = 3;
11482 break;
11483
11484 case 13751: hash_type = HASH_TYPE_SHA256;
11485 salt_type = SALT_TYPE_EMBEDDED;
11486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11487 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11488 kern_type = KERN_TYPE_VCSHA256_XTS512;
11489 dgst_size = DGST_SIZE_4_8;
11490 parse_func = veracrypt_parse_hash_500000;
11491 sort_by_digest = sort_by_digest_4_8;
11492 opti_type = OPTI_TYPE_ZERO_BYTE;
11493 dgst_pos0 = 0;
11494 dgst_pos1 = 1;
11495 dgst_pos2 = 2;
11496 dgst_pos3 = 3;
11497 break;
11498
11499 case 13752: hash_type = HASH_TYPE_SHA256;
11500 salt_type = SALT_TYPE_EMBEDDED;
11501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11502 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11503 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11504 dgst_size = DGST_SIZE_4_8;
11505 parse_func = veracrypt_parse_hash_500000;
11506 sort_by_digest = sort_by_digest_4_8;
11507 opti_type = OPTI_TYPE_ZERO_BYTE;
11508 dgst_pos0 = 0;
11509 dgst_pos1 = 1;
11510 dgst_pos2 = 2;
11511 dgst_pos3 = 3;
11512 break;
11513
11514 case 13753: hash_type = HASH_TYPE_SHA256;
11515 salt_type = SALT_TYPE_EMBEDDED;
11516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11517 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11518 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11519 dgst_size = DGST_SIZE_4_8;
11520 parse_func = veracrypt_parse_hash_500000;
11521 sort_by_digest = sort_by_digest_4_8;
11522 opti_type = OPTI_TYPE_ZERO_BYTE;
11523 dgst_pos0 = 0;
11524 dgst_pos1 = 1;
11525 dgst_pos2 = 2;
11526 dgst_pos3 = 3;
11527 break;
11528
11529 case 13761: hash_type = HASH_TYPE_SHA256;
11530 salt_type = SALT_TYPE_EMBEDDED;
11531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11532 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11533 kern_type = KERN_TYPE_VCSHA256_XTS512;
11534 dgst_size = DGST_SIZE_4_8;
11535 parse_func = veracrypt_parse_hash_200000;
11536 sort_by_digest = sort_by_digest_4_8;
11537 opti_type = OPTI_TYPE_ZERO_BYTE;
11538 dgst_pos0 = 0;
11539 dgst_pos1 = 1;
11540 dgst_pos2 = 2;
11541 dgst_pos3 = 3;
11542 break;
11543
11544 case 13762: hash_type = HASH_TYPE_SHA256;
11545 salt_type = SALT_TYPE_EMBEDDED;
11546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11547 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11548 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11549 dgst_size = DGST_SIZE_4_8;
11550 parse_func = veracrypt_parse_hash_200000;
11551 sort_by_digest = sort_by_digest_4_8;
11552 opti_type = OPTI_TYPE_ZERO_BYTE;
11553 dgst_pos0 = 0;
11554 dgst_pos1 = 1;
11555 dgst_pos2 = 2;
11556 dgst_pos3 = 3;
11557 break;
11558
11559 case 13763: hash_type = HASH_TYPE_SHA256;
11560 salt_type = SALT_TYPE_EMBEDDED;
11561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11563 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11564 dgst_size = DGST_SIZE_4_8;
11565 parse_func = veracrypt_parse_hash_200000;
11566 sort_by_digest = sort_by_digest_4_8;
11567 opti_type = OPTI_TYPE_ZERO_BYTE;
11568 dgst_pos0 = 0;
11569 dgst_pos1 = 1;
11570 dgst_pos2 = 2;
11571 dgst_pos3 = 3;
11572 break;
11573
11574 case 13800: hash_type = HASH_TYPE_SHA256;
11575 salt_type = SALT_TYPE_EMBEDDED;
11576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11577 opts_type = OPTS_TYPE_PT_GENERATE_BE
11578 | OPTS_TYPE_PT_UNICODE;
11579 kern_type = KERN_TYPE_WIN8PHONE;
11580 dgst_size = DGST_SIZE_4_8;
11581 parse_func = win8phone_parse_hash;
11582 sort_by_digest = sort_by_digest_4_8;
11583 opti_type = OPTI_TYPE_ZERO_BYTE
11584 | OPTI_TYPE_PRECOMPUTE_INIT
11585 | OPTI_TYPE_EARLY_SKIP
11586 | OPTI_TYPE_NOT_ITERATED
11587 | OPTI_TYPE_RAW_HASH;
11588 dgst_pos0 = 3;
11589 dgst_pos1 = 7;
11590 dgst_pos2 = 2;
11591 dgst_pos3 = 6;
11592 break;
11593
11594 default: usage_mini_print (PROGNAME); return -1;
11595 }
11596
11597 /**
11598 * parser
11599 */
11600
11601 data.parse_func = parse_func;
11602
11603 /**
11604 * misc stuff
11605 */
11606
11607 if (hex_salt)
11608 {
11609 if (salt_type == SALT_TYPE_INTERN)
11610 {
11611 opts_type |= OPTS_TYPE_ST_HEX;
11612 }
11613 else
11614 {
11615 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11616
11617 return -1;
11618 }
11619 }
11620
11621 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11622 | (salt_type == SALT_TYPE_EXTERN)
11623 | (salt_type == SALT_TYPE_EMBEDDED)
11624 | (salt_type == SALT_TYPE_VIRTUAL));
11625
11626 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11627
11628 data.hash_type = hash_type;
11629 data.attack_mode = attack_mode;
11630 data.attack_kern = attack_kern;
11631 data.attack_exec = attack_exec;
11632 data.kern_type = kern_type;
11633 data.opts_type = opts_type;
11634 data.dgst_size = dgst_size;
11635 data.salt_type = salt_type;
11636 data.isSalted = isSalted;
11637 data.sort_by_digest = sort_by_digest;
11638 data.dgst_pos0 = dgst_pos0;
11639 data.dgst_pos1 = dgst_pos1;
11640 data.dgst_pos2 = dgst_pos2;
11641 data.dgst_pos3 = dgst_pos3;
11642
11643 esalt_size = 0;
11644
11645 switch (hash_mode)
11646 {
11647 case 2500: esalt_size = sizeof (wpa_t); break;
11648 case 5300: esalt_size = sizeof (ikepsk_t); break;
11649 case 5400: esalt_size = sizeof (ikepsk_t); break;
11650 case 5500: esalt_size = sizeof (netntlm_t); break;
11651 case 5600: esalt_size = sizeof (netntlm_t); break;
11652 case 6211: esalt_size = sizeof (tc_t); break;
11653 case 6212: esalt_size = sizeof (tc_t); break;
11654 case 6213: esalt_size = sizeof (tc_t); break;
11655 case 6221: esalt_size = sizeof (tc_t); break;
11656 case 6222: esalt_size = sizeof (tc_t); break;
11657 case 6223: esalt_size = sizeof (tc_t); break;
11658 case 6231: esalt_size = sizeof (tc_t); break;
11659 case 6232: esalt_size = sizeof (tc_t); break;
11660 case 6233: esalt_size = sizeof (tc_t); break;
11661 case 6241: esalt_size = sizeof (tc_t); break;
11662 case 6242: esalt_size = sizeof (tc_t); break;
11663 case 6243: esalt_size = sizeof (tc_t); break;
11664 case 6600: esalt_size = sizeof (agilekey_t); break;
11665 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11666 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11667 case 7300: esalt_size = sizeof (rakp_t); break;
11668 case 7500: esalt_size = sizeof (krb5pa_t); break;
11669 case 8200: esalt_size = sizeof (cloudkey_t); break;
11670 case 8800: esalt_size = sizeof (androidfde_t); break;
11671 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11672 case 9400: esalt_size = sizeof (office2007_t); break;
11673 case 9500: esalt_size = sizeof (office2010_t); break;
11674 case 9600: esalt_size = sizeof (office2013_t); break;
11675 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11676 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11677 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11678 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11679 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11680 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11681 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11682 case 10200: esalt_size = sizeof (cram_md5_t); break;
11683 case 10400: esalt_size = sizeof (pdf_t); break;
11684 case 10410: esalt_size = sizeof (pdf_t); break;
11685 case 10420: esalt_size = sizeof (pdf_t); break;
11686 case 10500: esalt_size = sizeof (pdf_t); break;
11687 case 10600: esalt_size = sizeof (pdf_t); break;
11688 case 10700: esalt_size = sizeof (pdf_t); break;
11689 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11690 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11691 case 11400: esalt_size = sizeof (sip_t); break;
11692 case 11600: esalt_size = sizeof (seven_zip_t); break;
11693 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11694 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11695 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11696 case 13000: esalt_size = sizeof (rar5_t); break;
11697 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11698 case 13400: esalt_size = sizeof (keepass_t); break;
11699 case 13500: esalt_size = sizeof (pstoken_t); break;
11700 case 13600: esalt_size = sizeof (zip2_t); break;
11701 case 13711: esalt_size = sizeof (tc_t); break;
11702 case 13712: esalt_size = sizeof (tc_t); break;
11703 case 13713: esalt_size = sizeof (tc_t); break;
11704 case 13721: esalt_size = sizeof (tc_t); break;
11705 case 13722: esalt_size = sizeof (tc_t); break;
11706 case 13723: esalt_size = sizeof (tc_t); break;
11707 case 13731: esalt_size = sizeof (tc_t); break;
11708 case 13732: esalt_size = sizeof (tc_t); break;
11709 case 13733: esalt_size = sizeof (tc_t); break;
11710 case 13741: esalt_size = sizeof (tc_t); break;
11711 case 13742: esalt_size = sizeof (tc_t); break;
11712 case 13743: esalt_size = sizeof (tc_t); break;
11713 case 13751: esalt_size = sizeof (tc_t); break;
11714 case 13752: esalt_size = sizeof (tc_t); break;
11715 case 13753: esalt_size = sizeof (tc_t); break;
11716 case 13761: esalt_size = sizeof (tc_t); break;
11717 case 13762: esalt_size = sizeof (tc_t); break;
11718 case 13763: esalt_size = sizeof (tc_t); break;
11719 case 13800: esalt_size = sizeof (win8phone_t); break;
11720 }
11721
11722 data.esalt_size = esalt_size;
11723
11724 /**
11725 * choose dictionary parser
11726 */
11727
11728 if (hash_type == HASH_TYPE_LM)
11729 {
11730 get_next_word_func = get_next_word_lm;
11731 }
11732 else if (opts_type & OPTS_TYPE_PT_UPPER)
11733 {
11734 get_next_word_func = get_next_word_uc;
11735 }
11736 else
11737 {
11738 get_next_word_func = get_next_word_std;
11739 }
11740
11741 /**
11742 * dictstat
11743 */
11744
11745 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11746
11747 #ifdef _POSIX
11748 size_t dictstat_nmemb = 0;
11749 #endif
11750
11751 #ifdef _WIN
11752 uint dictstat_nmemb = 0;
11753 #endif
11754
11755 char dictstat[256] = { 0 };
11756
11757 FILE *dictstat_fp = NULL;
11758
11759 if (keyspace == 0)
11760 {
11761 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11762
11763 dictstat_fp = fopen (dictstat, "rb");
11764
11765 if (dictstat_fp)
11766 {
11767 #ifdef _POSIX
11768 struct stat tmpstat;
11769
11770 fstat (fileno (dictstat_fp), &tmpstat);
11771 #endif
11772
11773 #ifdef _WIN
11774 struct stat64 tmpstat;
11775
11776 _fstat64 (fileno (dictstat_fp), &tmpstat);
11777 #endif
11778
11779 if (tmpstat.st_mtime < COMPTIME)
11780 {
11781 /* with v0.15 the format changed so we have to ensure user is using a good version
11782 since there is no version-header in the dictstat file */
11783
11784 fclose (dictstat_fp);
11785
11786 unlink (dictstat);
11787 }
11788 else
11789 {
11790 while (!feof (dictstat_fp))
11791 {
11792 dictstat_t d;
11793
11794 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11795
11796 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11797
11798 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11799 {
11800 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11801
11802 return -1;
11803 }
11804 }
11805
11806 fclose (dictstat_fp);
11807 }
11808 }
11809 }
11810
11811 /**
11812 * potfile
11813 */
11814
11815 char potfile[256] = { 0 };
11816
11817 if (potfile_path == NULL)
11818 {
11819 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11820 }
11821 else
11822 {
11823 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11824 }
11825
11826 data.pot_fp = NULL;
11827
11828 FILE *out_fp = NULL;
11829 FILE *pot_fp = NULL;
11830
11831 if (show == 1 || left == 1)
11832 {
11833 pot_fp = fopen (potfile, "rb");
11834
11835 if (pot_fp == NULL)
11836 {
11837 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11838
11839 return -1;
11840 }
11841
11842 if (outfile != NULL)
11843 {
11844 if ((out_fp = fopen (outfile, "ab")) == NULL)
11845 {
11846 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11847
11848 fclose (pot_fp);
11849
11850 return -1;
11851 }
11852 }
11853 else
11854 {
11855 out_fp = stdout;
11856 }
11857 }
11858 else
11859 {
11860 if (potfile_disable == 0)
11861 {
11862 pot_fp = fopen (potfile, "ab");
11863
11864 if (pot_fp == NULL)
11865 {
11866 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11867
11868 return -1;
11869 }
11870
11871 data.pot_fp = pot_fp;
11872 }
11873 }
11874
11875 pot_t *pot = NULL;
11876
11877 uint pot_cnt = 0;
11878 uint pot_avail = 0;
11879
11880 if (show == 1 || left == 1)
11881 {
11882 SUPPRESS_OUTPUT = 1;
11883
11884 pot_avail = count_lines (pot_fp);
11885
11886 rewind (pot_fp);
11887
11888 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11889
11890 uint pot_hashes_avail = 0;
11891
11892 uint line_num = 0;
11893
11894 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11895
11896 while (!feof (pot_fp))
11897 {
11898 line_num++;
11899
11900 int line_len = fgetl (pot_fp, line_buf);
11901
11902 if (line_len == 0) continue;
11903
11904 char *plain_buf = line_buf + line_len;
11905
11906 pot_t *pot_ptr = &pot[pot_cnt];
11907
11908 hash_t *hashes_buf = &pot_ptr->hash;
11909
11910 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11911 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11912
11913 if (pot_cnt == pot_hashes_avail)
11914 {
11915 uint pos = 0;
11916
11917 for (pos = 0; pos < INCR_POT; pos++)
11918 {
11919 if ((pot_cnt + pos) >= pot_avail) break;
11920
11921 pot_t *tmp_pot = &pot[pot_cnt + pos];
11922
11923 hash_t *tmp_hash = &tmp_pot->hash;
11924
11925 tmp_hash->digest = mymalloc (dgst_size);
11926
11927 if (isSalted)
11928 {
11929 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11930 }
11931
11932 if (esalt_size)
11933 {
11934 tmp_hash->esalt = mymalloc (esalt_size);
11935 }
11936
11937 pot_hashes_avail++;
11938 }
11939 }
11940
11941 int plain_len = 0;
11942
11943 int parser_status;
11944
11945 int iter = MAX_CUT_TRIES;
11946
11947 do
11948 {
11949 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11950 {
11951 if (line_buf[i] == ':')
11952 {
11953 line_len--;
11954
11955 break;
11956 }
11957 }
11958
11959 if (data.hash_mode != 2500)
11960 {
11961 parser_status = parse_func (line_buf, line_len, hashes_buf);
11962 }
11963 else
11964 {
11965 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11966
11967 if (line_len > max_salt_size)
11968 {
11969 parser_status = PARSER_GLOBAL_LENGTH;
11970 }
11971 else
11972 {
11973 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11974
11975 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11976
11977 hashes_buf->salt->salt_len = line_len;
11978
11979 parser_status = PARSER_OK;
11980 }
11981 }
11982
11983 // if NOT parsed without error, we add the ":" to the plain
11984
11985 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11986 {
11987 plain_len++;
11988 plain_buf--;
11989 }
11990
11991 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11992
11993 if (parser_status < PARSER_GLOBAL_ZERO)
11994 {
11995 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11996
11997 continue;
11998 }
11999
12000 if (plain_len >= 255) continue;
12001
12002 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
12003
12004 pot_ptr->plain_len = plain_len;
12005
12006 pot_cnt++;
12007 }
12008
12009 myfree (line_buf);
12010
12011 fclose (pot_fp);
12012
12013 SUPPRESS_OUTPUT = 0;
12014
12015 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
12016 }
12017
12018 /**
12019 * word len
12020 */
12021
12022 uint pw_min = PW_MIN;
12023 uint pw_max = PW_MAX;
12024
12025 switch (hash_mode)
12026 {
12027 case 125: if (pw_max > 32) pw_max = 32;
12028 break;
12029 case 400: if (pw_max > 40) pw_max = 40;
12030 break;
12031 case 500: if (pw_max > 16) pw_max = 16;
12032 break;
12033 case 1500: if (pw_max > 8) pw_max = 8;
12034 break;
12035 case 1600: if (pw_max > 16) pw_max = 16;
12036 break;
12037 case 1800: if (pw_max > 16) pw_max = 16;
12038 break;
12039 case 2100: if (pw_max > 16) pw_max = 16;
12040 break;
12041 case 2500: if (pw_min < 8) pw_min = 8;
12042 break;
12043 case 3000: if (pw_max > 7) pw_max = 7;
12044 break;
12045 case 5200: if (pw_max > 24) pw_max = 24;
12046 break;
12047 case 5800: if (pw_max > 16) pw_max = 16;
12048 break;
12049 case 6300: if (pw_max > 16) pw_max = 16;
12050 break;
12051 case 7400: if (pw_max > 16) pw_max = 16;
12052 break;
12053 case 7700: if (pw_max > 8) pw_max = 8;
12054 break;
12055 case 7900: if (pw_max > 48) pw_max = 48;
12056 break;
12057 case 8500: if (pw_max > 8) pw_max = 8;
12058 break;
12059 case 8600: if (pw_max > 16) pw_max = 16;
12060 break;
12061 case 9710: pw_min = 5;
12062 pw_max = 5;
12063 break;
12064 case 9810: pw_min = 5;
12065 pw_max = 5;
12066 break;
12067 case 10410: pw_min = 5;
12068 pw_max = 5;
12069 break;
12070 case 10300: if (pw_max < 3) pw_min = 3;
12071 if (pw_max > 40) pw_max = 40;
12072 break;
12073 case 10500: if (pw_max < 3) pw_min = 3;
12074 if (pw_max > 40) pw_max = 40;
12075 break;
12076 case 10700: if (pw_max > 16) pw_max = 16;
12077 break;
12078 case 11300: if (pw_max > 40) pw_max = 40;
12079 break;
12080 case 11600: if (pw_max > 32) pw_max = 32;
12081 break;
12082 case 12500: if (pw_max > 20) pw_max = 20;
12083 break;
12084 case 12800: if (pw_max > 24) pw_max = 24;
12085 break;
12086 }
12087
12088 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12089 {
12090 switch (attack_kern)
12091 {
12092 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12093 break;
12094 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12095 break;
12096 }
12097 }
12098
12099 /**
12100 * charsets : keep them together for more easy maintainnce
12101 */
12102
12103 cs_t mp_sys[6] = { { { 0 }, 0 } };
12104 cs_t mp_usr[4] = { { { 0 }, 0 } };
12105
12106 mp_setup_sys (mp_sys);
12107
12108 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
12109 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
12110 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
12111 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
12112
12113 /**
12114 * load hashes, part I: find input mode, count hashes
12115 */
12116
12117 uint hashlist_mode = 0;
12118 uint hashlist_format = HLFMT_HASHCAT;
12119
12120 uint hashes_avail = 0;
12121
12122 if ((benchmark == 0) && (stdout_flag == 0))
12123 {
12124 struct stat f;
12125
12126 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
12127
12128 if ((hash_mode == 2500) ||
12129 (hash_mode == 5200) ||
12130 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
12131 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
12132 (hash_mode == 9000))
12133 {
12134 hashlist_mode = HL_MODE_ARG;
12135
12136 char *hashfile = myargv[optind];
12137
12138 data.hashfile = hashfile;
12139
12140 logfile_top_var_string ("target", hashfile);
12141 }
12142
12143 if (hashlist_mode == HL_MODE_ARG)
12144 {
12145 if (hash_mode == 2500)
12146 {
12147 struct stat st;
12148
12149 if (stat (data.hashfile, &st) == -1)
12150 {
12151 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
12152
12153 return -1;
12154 }
12155
12156 hashes_avail = st.st_size / sizeof (hccap_t);
12157 }
12158 else
12159 {
12160 hashes_avail = 1;
12161 }
12162 }
12163 else if (hashlist_mode == HL_MODE_FILE)
12164 {
12165 char *hashfile = myargv[optind];
12166
12167 data.hashfile = hashfile;
12168
12169 logfile_top_var_string ("target", hashfile);
12170
12171 FILE *fp = NULL;
12172
12173 if ((fp = fopen (hashfile, "rb")) == NULL)
12174 {
12175 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12176
12177 return -1;
12178 }
12179
12180 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
12181
12182 hashes_avail = count_lines (fp);
12183
12184 rewind (fp);
12185
12186 if (hashes_avail == 0)
12187 {
12188 log_error ("ERROR: hashfile is empty or corrupt");
12189
12190 fclose (fp);
12191
12192 return -1;
12193 }
12194
12195 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
12196
12197 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
12198 {
12199 log_error ("ERROR: remove not supported in native hashfile-format mode");
12200
12201 fclose (fp);
12202
12203 return -1;
12204 }
12205
12206 fclose (fp);
12207 }
12208 }
12209 else
12210 {
12211 hashlist_mode = HL_MODE_ARG;
12212
12213 hashes_avail = 1;
12214 }
12215
12216 if (hash_mode == 3000) hashes_avail *= 2;
12217
12218 data.hashlist_mode = hashlist_mode;
12219 data.hashlist_format = hashlist_format;
12220
12221 logfile_top_uint (hashlist_mode);
12222 logfile_top_uint (hashlist_format);
12223
12224 /**
12225 * load hashes, part II: allocate required memory, set pointers
12226 */
12227
12228 hash_t *hashes_buf = NULL;
12229 void *digests_buf = NULL;
12230 salt_t *salts_buf = NULL;
12231 void *esalts_buf = NULL;
12232
12233 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
12234
12235 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
12236
12237 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12238 {
12239 u32 hash_pos;
12240
12241 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12242 {
12243 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
12244
12245 hashes_buf[hash_pos].hash_info = hash_info;
12246
12247 if (username && (remove || show || left))
12248 {
12249 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
12250 }
12251
12252 if (benchmark)
12253 {
12254 hash_info->orighash = (char *) mymalloc (256);
12255 }
12256 }
12257 }
12258
12259 if (isSalted)
12260 {
12261 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12262
12263 if (esalt_size)
12264 {
12265 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
12266 }
12267 }
12268 else
12269 {
12270 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
12271 }
12272
12273 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12274 {
12275 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
12276
12277 if (isSalted)
12278 {
12279 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
12280
12281 if (esalt_size)
12282 {
12283 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
12284 }
12285 }
12286 else
12287 {
12288 hashes_buf[hash_pos].salt = &salts_buf[0];
12289 }
12290 }
12291
12292 /**
12293 * load hashes, part III: parse hashes or generate them if benchmark
12294 */
12295
12296 uint hashes_cnt = 0;
12297
12298 if (benchmark == 0)
12299 {
12300 if (keyspace == 1)
12301 {
12302 // useless to read hash file for keyspace, cheat a little bit w/ optind
12303 }
12304 else if (stdout_flag == 1)
12305 {
12306 // useless to read hash file for stdout, cheat a little bit w/ optind
12307 }
12308 else if (hashes_avail == 0)
12309 {
12310 }
12311 else if (hashlist_mode == HL_MODE_ARG)
12312 {
12313 char *input_buf = myargv[optind];
12314
12315 uint input_len = strlen (input_buf);
12316
12317 logfile_top_var_string ("target", input_buf);
12318
12319 char *hash_buf = NULL;
12320 int hash_len = 0;
12321
12322 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
12323
12324 bool hash_fmt_error = 0;
12325
12326 if (hash_len < 1) hash_fmt_error = 1;
12327 if (hash_buf == NULL) hash_fmt_error = 1;
12328
12329 if (hash_fmt_error)
12330 {
12331 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12332 }
12333 else
12334 {
12335 if (opts_type & OPTS_TYPE_HASH_COPY)
12336 {
12337 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12338
12339 hash_info_tmp->orighash = mystrdup (hash_buf);
12340 }
12341
12342 if (isSalted)
12343 {
12344 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12345 }
12346
12347 int parser_status = PARSER_OK;
12348
12349 if (hash_mode == 2500)
12350 {
12351 if (hash_len == 0)
12352 {
12353 log_error ("ERROR: hccap file not specified");
12354
12355 return -1;
12356 }
12357
12358 hashlist_mode = HL_MODE_FILE;
12359
12360 data.hashlist_mode = hashlist_mode;
12361
12362 FILE *fp = fopen (hash_buf, "rb");
12363
12364 if (fp == NULL)
12365 {
12366 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12367
12368 return -1;
12369 }
12370
12371 if (hashes_avail < 1)
12372 {
12373 log_error ("ERROR: hccap file is empty or corrupt");
12374
12375 fclose (fp);
12376
12377 return -1;
12378 }
12379
12380 uint hccap_size = sizeof (hccap_t);
12381
12382 char *in = (char *) mymalloc (hccap_size);
12383
12384 while (!feof (fp))
12385 {
12386 int n = fread (in, hccap_size, 1, fp);
12387
12388 if (n != 1)
12389 {
12390 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12391
12392 break;
12393 }
12394
12395 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12396
12397 if (parser_status != PARSER_OK)
12398 {
12399 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12400
12401 continue;
12402 }
12403
12404 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12405
12406 if ((show == 1) || (left == 1))
12407 {
12408 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12409
12410 char *salt_ptr = (char *) tmp_salt->salt_buf;
12411
12412 int cur_pos = tmp_salt->salt_len;
12413 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12414
12415 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12416
12417 // do the appending task
12418
12419 snprintf (salt_ptr + cur_pos,
12420 rem_len,
12421 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12422 wpa->orig_mac1[0],
12423 wpa->orig_mac1[1],
12424 wpa->orig_mac1[2],
12425 wpa->orig_mac1[3],
12426 wpa->orig_mac1[4],
12427 wpa->orig_mac1[5],
12428 wpa->orig_mac2[0],
12429 wpa->orig_mac2[1],
12430 wpa->orig_mac2[2],
12431 wpa->orig_mac2[3],
12432 wpa->orig_mac2[4],
12433 wpa->orig_mac2[5]);
12434
12435 // memset () the remaining part of the salt
12436
12437 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12438 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12439
12440 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12441
12442 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12443 }
12444
12445 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);
12446 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);
12447
12448 hashes_cnt++;
12449 }
12450
12451 fclose (fp);
12452
12453 myfree (in);
12454 }
12455 else if (hash_mode == 3000)
12456 {
12457 if (hash_len == 32)
12458 {
12459 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12460
12461 hash_t *lm_hash_left = NULL;
12462
12463 if (parser_status == PARSER_OK)
12464 {
12465 lm_hash_left = &hashes_buf[hashes_cnt];
12466
12467 hashes_cnt++;
12468 }
12469 else
12470 {
12471 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12472 }
12473
12474 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12475
12476 hash_t *lm_hash_right = NULL;
12477
12478 if (parser_status == PARSER_OK)
12479 {
12480 lm_hash_right = &hashes_buf[hashes_cnt];
12481
12482 hashes_cnt++;
12483 }
12484 else
12485 {
12486 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12487 }
12488
12489 // show / left
12490
12491 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12492 {
12493 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);
12494 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);
12495 }
12496 }
12497 else
12498 {
12499 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12500
12501 if (parser_status == PARSER_OK)
12502 {
12503 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12504 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12505 }
12506
12507 if (parser_status == PARSER_OK)
12508 {
12509 hashes_cnt++;
12510 }
12511 else
12512 {
12513 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12514 }
12515 }
12516 }
12517 else
12518 {
12519 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12520
12521 if (parser_status == PARSER_OK)
12522 {
12523 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12524 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12525 }
12526
12527 if (parser_status == PARSER_OK)
12528 {
12529 hashes_cnt++;
12530 }
12531 else
12532 {
12533 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12534 }
12535 }
12536 }
12537 }
12538 else if (hashlist_mode == HL_MODE_FILE)
12539 {
12540 char *hashfile = data.hashfile;
12541
12542 FILE *fp;
12543
12544 if ((fp = fopen (hashfile, "rb")) == NULL)
12545 {
12546 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12547
12548 return -1;
12549 }
12550
12551 uint line_num = 0;
12552
12553 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12554
12555 while (!feof (fp))
12556 {
12557 line_num++;
12558
12559 int line_len = fgetl (fp, line_buf);
12560
12561 if (line_len == 0) continue;
12562
12563 char *hash_buf = NULL;
12564 int hash_len = 0;
12565
12566 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12567
12568 bool hash_fmt_error = 0;
12569
12570 if (hash_len < 1) hash_fmt_error = 1;
12571 if (hash_buf == NULL) hash_fmt_error = 1;
12572
12573 if (hash_fmt_error)
12574 {
12575 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12576
12577 continue;
12578 }
12579
12580 if (username)
12581 {
12582 char *user_buf = NULL;
12583 int user_len = 0;
12584
12585 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12586
12587 if (remove || show)
12588 {
12589 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12590
12591 *user = (user_t *) mymalloc (sizeof (user_t));
12592
12593 user_t *user_ptr = *user;
12594
12595 if (user_buf != NULL)
12596 {
12597 user_ptr->user_name = mystrdup (user_buf);
12598 }
12599 else
12600 {
12601 user_ptr->user_name = mystrdup ("");
12602 }
12603
12604 user_ptr->user_len = user_len;
12605 }
12606 }
12607
12608 if (opts_type & OPTS_TYPE_HASH_COPY)
12609 {
12610 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12611
12612 hash_info_tmp->orighash = mystrdup (hash_buf);
12613 }
12614
12615 if (isSalted)
12616 {
12617 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12618 }
12619
12620 if (hash_mode == 3000)
12621 {
12622 if (hash_len == 32)
12623 {
12624 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12625
12626 if (parser_status < PARSER_GLOBAL_ZERO)
12627 {
12628 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12629
12630 continue;
12631 }
12632
12633 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12634
12635 hashes_cnt++;
12636
12637 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12638
12639 if (parser_status < PARSER_GLOBAL_ZERO)
12640 {
12641 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12642
12643 continue;
12644 }
12645
12646 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12647
12648 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);
12649
12650 hashes_cnt++;
12651
12652 // show / left
12653
12654 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);
12655 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);
12656 }
12657 else
12658 {
12659 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12660
12661 if (parser_status < PARSER_GLOBAL_ZERO)
12662 {
12663 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12664
12665 continue;
12666 }
12667
12668 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);
12669
12670 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12671 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12672
12673 hashes_cnt++;
12674 }
12675 }
12676 else
12677 {
12678 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12679
12680 if (parser_status < PARSER_GLOBAL_ZERO)
12681 {
12682 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12683
12684 continue;
12685 }
12686
12687 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);
12688
12689 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12690 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12691
12692 hashes_cnt++;
12693 }
12694 }
12695
12696 myfree (line_buf);
12697
12698 fclose (fp);
12699
12700 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12701
12702 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12703 }
12704 }
12705 else
12706 {
12707 if (isSalted)
12708 {
12709 hashes_buf[0].salt->salt_len = 8;
12710
12711 // special salt handling
12712
12713 switch (hash_mode)
12714 {
12715 case 1500: hashes_buf[0].salt->salt_len = 2;
12716 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12717 break;
12718 case 1731: hashes_buf[0].salt->salt_len = 4;
12719 break;
12720 case 2410: hashes_buf[0].salt->salt_len = 4;
12721 break;
12722 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12723 break;
12724 case 3100: hashes_buf[0].salt->salt_len = 1;
12725 break;
12726 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12727 break;
12728 case 5800: hashes_buf[0].salt->salt_len = 16;
12729 break;
12730 case 6800: hashes_buf[0].salt->salt_len = 32;
12731 break;
12732 case 8400: hashes_buf[0].salt->salt_len = 40;
12733 break;
12734 case 8800: hashes_buf[0].salt->salt_len = 16;
12735 break;
12736 case 8900: hashes_buf[0].salt->salt_len = 16;
12737 hashes_buf[0].salt->scrypt_N = 1024;
12738 hashes_buf[0].salt->scrypt_r = 1;
12739 hashes_buf[0].salt->scrypt_p = 1;
12740 break;
12741 case 9100: hashes_buf[0].salt->salt_len = 16;
12742 break;
12743 case 9300: hashes_buf[0].salt->salt_len = 14;
12744 hashes_buf[0].salt->scrypt_N = 16384;
12745 hashes_buf[0].salt->scrypt_r = 1;
12746 hashes_buf[0].salt->scrypt_p = 1;
12747 break;
12748 case 9400: hashes_buf[0].salt->salt_len = 16;
12749 break;
12750 case 9500: hashes_buf[0].salt->salt_len = 16;
12751 break;
12752 case 9600: hashes_buf[0].salt->salt_len = 16;
12753 break;
12754 case 9700: hashes_buf[0].salt->salt_len = 16;
12755 break;
12756 case 9710: hashes_buf[0].salt->salt_len = 16;
12757 break;
12758 case 9720: hashes_buf[0].salt->salt_len = 16;
12759 break;
12760 case 9800: hashes_buf[0].salt->salt_len = 16;
12761 break;
12762 case 9810: hashes_buf[0].salt->salt_len = 16;
12763 break;
12764 case 9820: hashes_buf[0].salt->salt_len = 16;
12765 break;
12766 case 10300: hashes_buf[0].salt->salt_len = 12;
12767 break;
12768 case 11500: hashes_buf[0].salt->salt_len = 4;
12769 break;
12770 case 11600: hashes_buf[0].salt->salt_len = 4;
12771 break;
12772 case 12400: hashes_buf[0].salt->salt_len = 4;
12773 break;
12774 case 12500: hashes_buf[0].salt->salt_len = 8;
12775 break;
12776 case 12600: hashes_buf[0].salt->salt_len = 64;
12777 break;
12778 }
12779
12780 // special esalt handling
12781
12782 switch (hash_mode)
12783 {
12784 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12785 break;
12786 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12787 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12788 break;
12789 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12790 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12791 break;
12792 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12793 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12794 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12795 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12796 break;
12797 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12798 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12799 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12800 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12801 break;
12802 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12803 break;
12804 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12805 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12806 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12807 break;
12808 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12809 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12810 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12811 break;
12812 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12813 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12814 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12815 break;
12816 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12817 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12818 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12819 break;
12820 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12821 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12822 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12823 break;
12824 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12825 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12826 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12827 break;
12828 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12829 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12830 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12831 break;
12832 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12833 break;
12834 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12835 break;
12836 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12837 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12838 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12839 break;
12840 }
12841 }
12842
12843 // set hashfile
12844
12845 switch (hash_mode)
12846 {
12847 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12848 break;
12849 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12850 break;
12851 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12852 break;
12853 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12854 break;
12855 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12856 break;
12857 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12858 break;
12859 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12860 break;
12861 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12862 break;
12863 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12864 break;
12865 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12866 break;
12867 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12868 break;
12869 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12870 break;
12871 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12872 break;
12873 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12874 break;
12875 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12876 break;
12877 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12878 break;
12879 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12880 break;
12881 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12882 break;
12883 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12884 break;
12885 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12886 break;
12887 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12888 break;
12889 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12890 break;
12891 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12892 break;
12893 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12894 break;
12895 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12896 break;
12897 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12898 break;
12899 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12900 break;
12901 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12902 break;
12903 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12904 break;
12905 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12906 break;
12907 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12908 break;
12909 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12910 break;
12911 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12912 break;
12913 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12914 break;
12915 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12916 break;
12917 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12918 break;
12919 }
12920
12921 // set default iterations
12922
12923 switch (hash_mode)
12924 {
12925 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12926 break;
12927 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12928 break;
12929 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12930 break;
12931 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12932 break;
12933 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12934 break;
12935 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12936 break;
12937 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12938 break;
12939 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12940 break;
12941 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12942 break;
12943 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12944 break;
12945 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12946 break;
12947 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12948 break;
12949 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12950 break;
12951 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12952 break;
12953 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12954 break;
12955 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12956 break;
12957 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12958 break;
12959 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12960 break;
12961 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12962 break;
12963 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12964 break;
12965 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12966 break;
12967 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12968 break;
12969 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12970 break;
12971 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12972 break;
12973 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12974 break;
12975 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12976 break;
12977 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12978 break;
12979 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12980 break;
12981 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12982 break;
12983 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12984 break;
12985 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12986 break;
12987 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12988 break;
12989 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12990 break;
12991 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12992 break;
12993 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12994 break;
12995 case 8900: hashes_buf[0].salt->salt_iter = 1;
12996 break;
12997 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12998 break;
12999 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
13000 break;
13001 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
13002 break;
13003 case 9300: hashes_buf[0].salt->salt_iter = 1;
13004 break;
13005 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
13006 break;
13007 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
13008 break;
13009 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
13010 break;
13011 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
13012 break;
13013 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
13014 break;
13015 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
13016 break;
13017 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
13018 break;
13019 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
13020 break;
13021 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
13022 break;
13023 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
13024 break;
13025 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
13026 break;
13027 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
13028 break;
13029 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
13030 break;
13031 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
13032 break;
13033 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
13034 break;
13035 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
13036 break;
13037 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
13038 break;
13039 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
13040 break;
13041 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
13042 break;
13043 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
13044 break;
13045 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
13046 break;
13047 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
13048 break;
13049 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
13050 break;
13051 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
13052 break;
13053 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13054 break;
13055 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13056 break;
13057 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13058 break;
13059 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13060 break;
13061 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13062 break;
13063 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13064 break;
13065 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13066 break;
13067 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13068 break;
13069 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13070 break;
13071 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13072 break;
13073 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13074 break;
13075 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13076 break;
13077 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13078 break;
13079 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13080 break;
13081 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13082 break;
13083 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13084 break;
13085 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13086 break;
13087 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13088 break;
13089 }
13090
13091 hashes_cnt = 1;
13092 }
13093
13094 if (show == 1 || left == 1)
13095 {
13096 for (uint i = 0; i < pot_cnt; i++)
13097 {
13098 pot_t *pot_ptr = &pot[i];
13099
13100 hash_t *hashes_buf = &pot_ptr->hash;
13101
13102 local_free (hashes_buf->digest);
13103
13104 if (isSalted)
13105 {
13106 local_free (hashes_buf->salt);
13107 }
13108 }
13109
13110 local_free (pot);
13111
13112 if (data.quiet == 0) log_info_nn ("");
13113
13114 return 0;
13115 }
13116
13117 if ((keyspace == 0) && (stdout_flag == 0))
13118 {
13119 if (hashes_cnt == 0)
13120 {
13121 log_error ("ERROR: No hashes loaded");
13122
13123 return -1;
13124 }
13125 }
13126
13127 /**
13128 * Sanity check for hashfile vs outfile (should not point to the same physical file)
13129 */
13130
13131 if (data.outfile != NULL)
13132 {
13133 if (data.hashfile != NULL)
13134 {
13135 #ifdef _POSIX
13136 struct stat tmpstat_outfile;
13137 struct stat tmpstat_hashfile;
13138 #endif
13139
13140 #ifdef _WIN
13141 struct stat64 tmpstat_outfile;
13142 struct stat64 tmpstat_hashfile;
13143 #endif
13144
13145 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
13146
13147 if (tmp_outfile_fp)
13148 {
13149 #ifdef _POSIX
13150 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
13151 #endif
13152
13153 #ifdef _WIN
13154 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
13155 #endif
13156
13157 fclose (tmp_outfile_fp);
13158 }
13159
13160 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
13161
13162 if (tmp_hashfile_fp)
13163 {
13164 #ifdef _POSIX
13165 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13166 #endif
13167
13168 #ifdef _WIN
13169 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13170 #endif
13171
13172 fclose (tmp_hashfile_fp);
13173 }
13174
13175 if (tmp_outfile_fp && tmp_outfile_fp)
13176 {
13177 tmpstat_outfile.st_mode = 0;
13178 tmpstat_outfile.st_nlink = 0;
13179 tmpstat_outfile.st_uid = 0;
13180 tmpstat_outfile.st_gid = 0;
13181 tmpstat_outfile.st_rdev = 0;
13182 tmpstat_outfile.st_atime = 0;
13183
13184 tmpstat_hashfile.st_mode = 0;
13185 tmpstat_hashfile.st_nlink = 0;
13186 tmpstat_hashfile.st_uid = 0;
13187 tmpstat_hashfile.st_gid = 0;
13188 tmpstat_hashfile.st_rdev = 0;
13189 tmpstat_hashfile.st_atime = 0;
13190
13191 #ifdef _POSIX
13192 tmpstat_outfile.st_blksize = 0;
13193 tmpstat_outfile.st_blocks = 0;
13194
13195 tmpstat_hashfile.st_blksize = 0;
13196 tmpstat_hashfile.st_blocks = 0;
13197 #endif
13198
13199 #ifdef _POSIX
13200 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
13201 {
13202 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13203
13204 return -1;
13205 }
13206 #endif
13207
13208 #ifdef _WIN
13209 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
13210 {
13211 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13212
13213 return -1;
13214 }
13215 #endif
13216 }
13217 }
13218 }
13219
13220 /**
13221 * Remove duplicates
13222 */
13223
13224 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
13225
13226 if (isSalted)
13227 {
13228 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13229 }
13230 else
13231 {
13232 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13233 }
13234
13235 uint hashes_cnt_orig = hashes_cnt;
13236
13237 hashes_cnt = 1;
13238
13239 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
13240 {
13241 if (isSalted)
13242 {
13243 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
13244 {
13245 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13246 }
13247 }
13248 else
13249 {
13250 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13251 }
13252
13253 if (hashes_pos > hashes_cnt)
13254 {
13255 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
13256 }
13257
13258 hashes_cnt++;
13259 }
13260
13261 /**
13262 * Potfile removes
13263 */
13264
13265 uint potfile_remove_cracks = 0;
13266
13267 if (potfile_disable == 0)
13268 {
13269 hash_t hash_buf;
13270
13271 hash_buf.digest = mymalloc (dgst_size);
13272 hash_buf.salt = NULL;
13273 hash_buf.esalt = NULL;
13274 hash_buf.hash_info = NULL;
13275 hash_buf.cracked = 0;
13276
13277 if (isSalted)
13278 {
13279 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
13280 }
13281
13282 if (esalt_size)
13283 {
13284 hash_buf.esalt = mymalloc (esalt_size);
13285 }
13286
13287 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
13288
13289 // no solution for these special hash types (for instane because they use hashfile in output etc)
13290 if ((hash_mode != 5200) &&
13291 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
13292 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
13293 (hash_mode != 9000))
13294 {
13295 FILE *fp = fopen (potfile, "rb");
13296
13297 if (fp != NULL)
13298 {
13299 char *line_buf = (char *) mymalloc (HCBUFSIZ);
13300
13301 // to be safe work with a copy (because of line_len loop, i etc)
13302 // moved up here because it's easier to handle continue case
13303 // it's just 64kb
13304
13305 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
13306
13307 while (!feof (fp))
13308 {
13309 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
13310
13311 if (ptr == NULL) break;
13312
13313 int line_len = strlen (line_buf);
13314
13315 if (line_len == 0) continue;
13316
13317 int iter = MAX_CUT_TRIES;
13318
13319 for (int i = line_len - 1; i && iter; i--, line_len--)
13320 {
13321 if (line_buf[i] != ':') continue;
13322
13323 if (isSalted)
13324 {
13325 memset (hash_buf.salt, 0, sizeof (salt_t));
13326 }
13327
13328 hash_t *found = NULL;
13329
13330 if (hash_mode == 6800)
13331 {
13332 if (i < 64) // 64 = 16 * uint in salt_buf[]
13333 {
13334 // manipulate salt_buf
13335 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13336
13337 hash_buf.salt->salt_len = i;
13338
13339 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13340 }
13341 }
13342 else if (hash_mode == 2500)
13343 {
13344 if (i < 64) // 64 = 16 * uint in salt_buf[]
13345 {
13346 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13347 // manipulate salt_buf
13348
13349 memset (line_buf_cpy, 0, HCBUFSIZ);
13350 memcpy (line_buf_cpy, line_buf, i);
13351
13352 char *mac2_pos = strrchr (line_buf_cpy, ':');
13353
13354 if (mac2_pos == NULL) continue;
13355
13356 mac2_pos[0] = 0;
13357 mac2_pos++;
13358
13359 if (strlen (mac2_pos) != 12) continue;
13360
13361 char *mac1_pos = strrchr (line_buf_cpy, ':');
13362
13363 if (mac1_pos == NULL) continue;
13364
13365 mac1_pos[0] = 0;
13366 mac1_pos++;
13367
13368 if (strlen (mac1_pos) != 12) continue;
13369
13370 uint essid_length = mac1_pos - line_buf_cpy - 1;
13371
13372 // here we need the ESSID
13373 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13374
13375 hash_buf.salt->salt_len = essid_length;
13376
13377 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13378
13379 if (found)
13380 {
13381 wpa_t *wpa = (wpa_t *) found->esalt;
13382
13383 // compare hex string(s) vs binary MAC address(es)
13384
13385 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13386 {
13387 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13388 {
13389 found = NULL;
13390
13391 break;
13392 }
13393 }
13394
13395 // early skip ;)
13396 if (!found) continue;
13397
13398 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13399 {
13400 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13401 {
13402 found = NULL;
13403
13404 break;
13405 }
13406 }
13407 }
13408 }
13409 }
13410 else
13411 {
13412 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13413
13414 if (parser_status == PARSER_OK)
13415 {
13416 if (isSalted)
13417 {
13418 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13419 }
13420 else
13421 {
13422 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13423 }
13424 }
13425 }
13426
13427 if (found == NULL) continue;
13428
13429 if (!found->cracked) potfile_remove_cracks++;
13430
13431 found->cracked = 1;
13432
13433 if (found) break;
13434
13435 iter--;
13436 }
13437 }
13438
13439 myfree (line_buf_cpy);
13440
13441 myfree (line_buf);
13442
13443 fclose (fp);
13444 }
13445 }
13446
13447 if (esalt_size)
13448 {
13449 local_free (hash_buf.esalt);
13450 }
13451
13452 if (isSalted)
13453 {
13454 local_free (hash_buf.salt);
13455 }
13456
13457 local_free (hash_buf.digest);
13458 }
13459
13460 /**
13461 * Now generate all the buffers required for later
13462 */
13463
13464 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13465
13466 salt_t *salts_buf_new = NULL;
13467 void *esalts_buf_new = NULL;
13468
13469 if (isSalted)
13470 {
13471 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13472
13473 if (esalt_size)
13474 {
13475 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13476 }
13477 }
13478 else
13479 {
13480 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13481 }
13482
13483 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13484
13485 uint digests_cnt = hashes_cnt;
13486 uint digests_done = 0;
13487
13488 size_t size_digests = digests_cnt * dgst_size;
13489 size_t size_shown = digests_cnt * sizeof (uint);
13490
13491 uint *digests_shown = (uint *) mymalloc (size_shown);
13492 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13493
13494 uint salts_cnt = 0;
13495 uint salts_done = 0;
13496
13497 hashinfo_t **hash_info = NULL;
13498
13499 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13500 {
13501 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13502
13503 if (username && (remove || show))
13504 {
13505 uint user_pos;
13506
13507 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13508 {
13509 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13510
13511 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13512 }
13513 }
13514 }
13515
13516 uint *salts_shown = (uint *) mymalloc (size_shown);
13517
13518 salt_t *salt_buf;
13519
13520 {
13521 // copied from inner loop
13522
13523 salt_buf = &salts_buf_new[salts_cnt];
13524
13525 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13526
13527 if (esalt_size)
13528 {
13529 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13530 }
13531
13532 salt_buf->digests_cnt = 0;
13533 salt_buf->digests_done = 0;
13534 salt_buf->digests_offset = 0;
13535
13536 salts_cnt++;
13537 }
13538
13539 if (hashes_buf[0].cracked == 1)
13540 {
13541 digests_shown[0] = 1;
13542
13543 digests_done++;
13544
13545 salt_buf->digests_done++;
13546 }
13547
13548 salt_buf->digests_cnt++;
13549
13550 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13551
13552 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13553 {
13554 hash_info[0] = hashes_buf[0].hash_info;
13555 }
13556
13557 // copy from inner loop
13558
13559 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13560 {
13561 if (isSalted)
13562 {
13563 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13564 {
13565 salt_buf = &salts_buf_new[salts_cnt];
13566
13567 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13568
13569 if (esalt_size)
13570 {
13571 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13572 }
13573
13574 salt_buf->digests_cnt = 0;
13575 salt_buf->digests_done = 0;
13576 salt_buf->digests_offset = hashes_pos;
13577
13578 salts_cnt++;
13579 }
13580 }
13581
13582 if (hashes_buf[hashes_pos].cracked == 1)
13583 {
13584 digests_shown[hashes_pos] = 1;
13585
13586 digests_done++;
13587
13588 salt_buf->digests_done++;
13589 }
13590
13591 salt_buf->digests_cnt++;
13592
13593 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13594
13595 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13596 {
13597 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13598 }
13599 }
13600
13601 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13602 {
13603 salt_t *salt_buf = &salts_buf_new[salt_pos];
13604
13605 if (salt_buf->digests_done == salt_buf->digests_cnt)
13606 {
13607 salts_shown[salt_pos] = 1;
13608
13609 salts_done++;
13610 }
13611
13612 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13613 }
13614
13615 local_free (digests_buf);
13616 local_free (salts_buf);
13617 local_free (esalts_buf);
13618
13619 digests_buf = digests_buf_new;
13620 salts_buf = salts_buf_new;
13621 esalts_buf = esalts_buf_new;
13622
13623 local_free (hashes_buf);
13624
13625 /**
13626 * special modification not set from parser
13627 */
13628
13629 switch (hash_mode)
13630 {
13631 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13632 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13633 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13634 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13635 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13636 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13637 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13638 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13639 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13640 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13641 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13642 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13643 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13644 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13645 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13646 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13647 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13648 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13649 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13650 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13651 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13652 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13653 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13654 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13655 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13656 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13657 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13658 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13659 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13660 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13661 }
13662
13663 if (truecrypt_keyfiles)
13664 {
13665 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13666
13667 char *keyfiles = strdup (truecrypt_keyfiles);
13668
13669 char *keyfile = strtok (keyfiles, ",");
13670
13671 do
13672 {
13673 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13674
13675 } while ((keyfile = strtok (NULL, ",")) != NULL);
13676
13677 free (keyfiles);
13678 }
13679
13680 if (veracrypt_keyfiles)
13681 {
13682 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13683
13684 char *keyfiles = strdup (veracrypt_keyfiles);
13685
13686 char *keyfile = strtok (keyfiles, ",");
13687
13688 do
13689 {
13690 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13691
13692 } while ((keyfile = strtok (NULL, ",")) != NULL);
13693
13694 free (keyfiles);
13695 }
13696
13697 data.digests_cnt = digests_cnt;
13698 data.digests_done = digests_done;
13699 data.digests_buf = digests_buf;
13700 data.digests_shown = digests_shown;
13701 data.digests_shown_tmp = digests_shown_tmp;
13702
13703 data.salts_cnt = salts_cnt;
13704 data.salts_done = salts_done;
13705 data.salts_buf = salts_buf;
13706 data.salts_shown = salts_shown;
13707
13708 data.esalts_buf = esalts_buf;
13709 data.hash_info = hash_info;
13710
13711 /**
13712 * Automatic Optimizers
13713 */
13714
13715 if (salts_cnt == 1)
13716 opti_type |= OPTI_TYPE_SINGLE_SALT;
13717
13718 if (digests_cnt == 1)
13719 opti_type |= OPTI_TYPE_SINGLE_HASH;
13720
13721 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13722 opti_type |= OPTI_TYPE_NOT_ITERATED;
13723
13724 if (attack_mode == ATTACK_MODE_BF)
13725 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13726
13727 data.opti_type = opti_type;
13728
13729 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13730 {
13731 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13732 {
13733 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13734 {
13735 if (opts_type & OPTS_TYPE_ST_ADD80)
13736 {
13737 opts_type &= ~OPTS_TYPE_ST_ADD80;
13738 opts_type |= OPTS_TYPE_PT_ADD80;
13739 }
13740
13741 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13742 {
13743 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13744 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13745 }
13746
13747 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13748 {
13749 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13750 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13751 }
13752 }
13753 }
13754 }
13755
13756 /**
13757 * Some algorithm, like descrypt, can benefit from JIT compilation
13758 */
13759
13760 int force_jit_compilation = -1;
13761
13762 if (hash_mode == 8900)
13763 {
13764 force_jit_compilation = 8900;
13765 }
13766 else if (hash_mode == 9300)
13767 {
13768 force_jit_compilation = 8900;
13769 }
13770 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13771 {
13772 force_jit_compilation = 1500;
13773 }
13774
13775 /**
13776 * generate bitmap tables
13777 */
13778
13779 const uint bitmap_shift1 = 5;
13780 const uint bitmap_shift2 = 13;
13781
13782 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13783
13784 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13785 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13786 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13787 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13788 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13789 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13790 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13791 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13792
13793 uint bitmap_bits;
13794 uint bitmap_nums;
13795 uint bitmap_mask;
13796 uint bitmap_size;
13797
13798 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13799 {
13800 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13801
13802 bitmap_nums = 1 << bitmap_bits;
13803
13804 bitmap_mask = bitmap_nums - 1;
13805
13806 bitmap_size = bitmap_nums * sizeof (uint);
13807
13808 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13809
13810 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;
13811 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;
13812
13813 break;
13814 }
13815
13816 bitmap_nums = 1 << bitmap_bits;
13817
13818 bitmap_mask = bitmap_nums - 1;
13819
13820 bitmap_size = bitmap_nums * sizeof (uint);
13821
13822 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);
13823 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);
13824
13825 /**
13826 * prepare quick rule
13827 */
13828
13829 data.rule_buf_l = rule_buf_l;
13830 data.rule_buf_r = rule_buf_r;
13831
13832 int rule_len_l = (int) strlen (rule_buf_l);
13833 int rule_len_r = (int) strlen (rule_buf_r);
13834
13835 data.rule_len_l = rule_len_l;
13836 data.rule_len_r = rule_len_r;
13837
13838 /**
13839 * load rules
13840 */
13841
13842 uint *all_kernel_rules_cnt = NULL;
13843
13844 kernel_rule_t **all_kernel_rules_buf = NULL;
13845
13846 if (rp_files_cnt)
13847 {
13848 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13849
13850 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13851 }
13852
13853 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13854
13855 int rule_len = 0;
13856
13857 for (uint i = 0; i < rp_files_cnt; i++)
13858 {
13859 uint kernel_rules_avail = 0;
13860
13861 uint kernel_rules_cnt = 0;
13862
13863 kernel_rule_t *kernel_rules_buf = NULL;
13864
13865 char *rp_file = rp_files[i];
13866
13867 char in[BLOCK_SIZE] = { 0 };
13868 char out[BLOCK_SIZE] = { 0 };
13869
13870 FILE *fp = NULL;
13871
13872 uint rule_line = 0;
13873
13874 if ((fp = fopen (rp_file, "rb")) == NULL)
13875 {
13876 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13877
13878 return -1;
13879 }
13880
13881 while (!feof (fp))
13882 {
13883 memset (rule_buf, 0, HCBUFSIZ);
13884
13885 rule_len = fgetl (fp, rule_buf);
13886
13887 rule_line++;
13888
13889 if (rule_len == 0) continue;
13890
13891 if (rule_buf[0] == '#') continue;
13892
13893 if (kernel_rules_avail == kernel_rules_cnt)
13894 {
13895 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13896
13897 kernel_rules_avail += INCR_RULES;
13898 }
13899
13900 memset (in, 0, BLOCK_SIZE);
13901 memset (out, 0, BLOCK_SIZE);
13902
13903 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13904
13905 if (result == -1)
13906 {
13907 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13908
13909 continue;
13910 }
13911
13912 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13913 {
13914 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13915
13916 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13917
13918 continue;
13919 }
13920
13921 /* its so slow
13922 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13923 {
13924 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13925
13926 continue;
13927 }
13928 */
13929
13930 kernel_rules_cnt++;
13931 }
13932
13933 fclose (fp);
13934
13935 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13936
13937 all_kernel_rules_buf[i] = kernel_rules_buf;
13938 }
13939
13940 /**
13941 * merge rules or automatic rule generator
13942 */
13943
13944 uint kernel_rules_cnt = 0;
13945
13946 kernel_rule_t *kernel_rules_buf = NULL;
13947
13948 if (attack_mode == ATTACK_MODE_STRAIGHT)
13949 {
13950 if (rp_files_cnt)
13951 {
13952 kernel_rules_cnt = 1;
13953
13954 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13955
13956 repeats[0] = kernel_rules_cnt;
13957
13958 for (uint i = 0; i < rp_files_cnt; i++)
13959 {
13960 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13961
13962 repeats[i + 1] = kernel_rules_cnt;
13963 }
13964
13965 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13966
13967 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13968
13969 for (uint i = 0; i < kernel_rules_cnt; i++)
13970 {
13971 uint out_pos = 0;
13972
13973 kernel_rule_t *out = &kernel_rules_buf[i];
13974
13975 for (uint j = 0; j < rp_files_cnt; j++)
13976 {
13977 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13978 uint in_pos;
13979
13980 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13981
13982 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13983 {
13984 if (out_pos == RULES_MAX - 1)
13985 {
13986 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13987
13988 break;
13989 }
13990
13991 out->cmds[out_pos] = in->cmds[in_pos];
13992 }
13993 }
13994 }
13995
13996 local_free (repeats);
13997 }
13998 else if (rp_gen)
13999 {
14000 uint kernel_rules_avail = 0;
14001
14002 while (kernel_rules_cnt < rp_gen)
14003 {
14004 if (kernel_rules_avail == kernel_rules_cnt)
14005 {
14006 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
14007
14008 kernel_rules_avail += INCR_RULES;
14009 }
14010
14011 memset (rule_buf, 0, HCBUFSIZ);
14012
14013 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
14014
14015 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
14016
14017 kernel_rules_cnt++;
14018 }
14019 }
14020 }
14021
14022 myfree (rule_buf);
14023
14024 /**
14025 * generate NOP rules
14026 */
14027
14028 if ((rp_files_cnt == 0) && (rp_gen == 0))
14029 {
14030 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
14031
14032 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
14033
14034 kernel_rules_cnt++;
14035 }
14036
14037 data.kernel_rules_cnt = kernel_rules_cnt;
14038 data.kernel_rules_buf = kernel_rules_buf;
14039
14040 if (kernel_rules_cnt == 0)
14041 {
14042 log_error ("ERROR: No valid rules left");
14043
14044 return -1;
14045 }
14046
14047 /**
14048 * OpenCL platforms: detect
14049 */
14050
14051 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
14052 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
14053
14054 cl_uint platforms_cnt = 0;
14055 cl_uint platform_devices_cnt = 0;
14056
14057 if (keyspace == 0)
14058 {
14059 cl_int CL_err = hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
14060
14061 if (CL_err != CL_SUCCESS)
14062 {
14063 log_error ("ERROR: clGetPlatformIDs(): %s\n", val2cstr_cl (CL_err));
14064
14065 return -1;
14066 }
14067
14068 if (platforms_cnt == 0)
14069 {
14070 log_info ("");
14071 log_info ("ATTENTION! No OpenCL compatible platform found");
14072 log_info ("");
14073 log_info ("You're probably missing the OpenCL runtime installation");
14074 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
14075 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
14076 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
14077 log_info ("");
14078
14079 return -1;
14080 }
14081
14082 if (opencl_platforms_filter != (uint) -1)
14083 {
14084 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
14085
14086 if (opencl_platforms_filter > platform_cnt_mask)
14087 {
14088 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
14089
14090 return -1;
14091 }
14092 }
14093 }
14094
14095 if (opencl_device_types == NULL)
14096 {
14097 /**
14098 * OpenCL device types:
14099 * 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.
14100 */
14101
14102 cl_device_type device_types_all = 0;
14103
14104 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14105 {
14106 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
14107
14108 cl_platform_id platform = platforms[platform_id];
14109
14110 cl_int CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14111
14112 if (CL_err != CL_SUCCESS)
14113 {
14114 //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14115
14116 //return -1;
14117
14118 // Silently ignore at this point, it will be reused later and create a note for the user at that point
14119
14120 continue;
14121 }
14122
14123 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14124 {
14125 cl_device_id device = platform_devices[platform_devices_id];
14126
14127 cl_device_type device_type;
14128
14129 cl_int CL_err = hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14130
14131 if (CL_err != CL_SUCCESS)
14132 {
14133 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14134
14135 return -1;
14136 }
14137
14138 device_types_all |= device_type;
14139 }
14140 }
14141
14142 // In such a case, automatically enable CPU device type support, since it's disabled by default.
14143
14144 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
14145 {
14146 device_types_filter |= CL_DEVICE_TYPE_CPU;
14147 }
14148
14149 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
14150 // If we have a CPU device, force it to be used
14151
14152 if (stdout_flag == 1)
14153 {
14154 if (device_types_all & CL_DEVICE_TYPE_CPU)
14155 {
14156 device_types_filter = CL_DEVICE_TYPE_CPU;
14157 }
14158 }
14159 }
14160
14161 /**
14162 * OpenCL devices: simply push all devices from all platforms into the same device array
14163 */
14164
14165 int need_adl = 0;
14166 int need_nvapi = 0;
14167 int need_nvml = 0;
14168 int need_xnvctrl = 0;
14169
14170 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
14171
14172 data.devices_param = devices_param;
14173
14174 uint devices_cnt = 0;
14175
14176 uint devices_active = 0;
14177
14178 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14179 {
14180 cl_int CL_err = CL_SUCCESS;
14181
14182 cl_platform_id platform = platforms[platform_id];
14183
14184 char platform_vendor[INFOSZ] = { 0 };
14185
14186 CL_err = hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
14187
14188 if (CL_err != CL_SUCCESS)
14189 {
14190 log_error ("ERROR: clGetPlatformInfo(): %s\n", val2cstr_cl (CL_err));
14191
14192 return -1;
14193 }
14194
14195 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
14196 // this causes trouble with vendor id based macros
14197 // we'll assign generic to those without special optimization available
14198
14199 cl_uint platform_vendor_id = 0;
14200
14201 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
14202 {
14203 platform_vendor_id = VENDOR_ID_AMD;
14204 }
14205 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14206 {
14207 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14208 }
14209 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
14210 {
14211 platform_vendor_id = VENDOR_ID_APPLE;
14212 }
14213 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14214 {
14215 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14216 }
14217 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
14218 {
14219 platform_vendor_id = VENDOR_ID_INTEL_SDK;
14220 }
14221 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
14222 {
14223 platform_vendor_id = VENDOR_ID_MESA;
14224 }
14225 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
14226 {
14227 platform_vendor_id = VENDOR_ID_NV;
14228 }
14229 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
14230 {
14231 platform_vendor_id = VENDOR_ID_POCL;
14232 }
14233 else
14234 {
14235 platform_vendor_id = VENDOR_ID_GENERIC;
14236 }
14237
14238 uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
14239
14240 CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14241
14242 if (CL_err != CL_SUCCESS)
14243 {
14244 //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14245
14246 //return -1;
14247
14248 platform_skipped = 2;
14249 }
14250
14251 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14252 {
14253 if (machine_readable == 0)
14254 {
14255 if (platform_skipped == 0)
14256 {
14257 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
14258
14259 char line[256] = { 0 };
14260
14261 for (int i = 0; i < len; i++) line[i] = '=';
14262
14263 log_info (line);
14264 }
14265 else if (platform_skipped == 1)
14266 {
14267 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
14268 log_info ("");
14269 }
14270 else if (platform_skipped == 2)
14271 {
14272 log_info ("OpenCL Platform #%u: %s, skipped! No OpenCL compatible devices found", platform_id + 1, platform_vendor);
14273 log_info ("");
14274 }
14275 }
14276 }
14277
14278 if (platform_skipped == 1) continue;
14279
14280 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14281 {
14282 size_t param_value_size = 0;
14283
14284 const uint device_id = devices_cnt;
14285
14286 hc_device_param_t *device_param = &data.devices_param[device_id];
14287
14288 device_param->platform_vendor_id = platform_vendor_id;
14289
14290 device_param->device = platform_devices[platform_devices_id];
14291
14292 device_param->device_id = device_id;
14293
14294 device_param->platform_devices_id = platform_devices_id;
14295
14296 device_param->platform = platform;
14297
14298 // device_type
14299
14300 cl_device_type device_type;
14301
14302 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14303
14304 if (CL_err != CL_SUCCESS)
14305 {
14306 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14307
14308 return -1;
14309 }
14310
14311 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
14312
14313 device_param->device_type = device_type;
14314
14315 // device_name
14316
14317 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
14318
14319 if (CL_err != CL_SUCCESS)
14320 {
14321 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14322
14323 return -1;
14324 }
14325
14326 char *device_name = (char *) mymalloc (param_value_size);
14327
14328 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
14329
14330 if (CL_err != CL_SUCCESS)
14331 {
14332 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14333
14334 return -1;
14335 }
14336
14337 device_param->device_name = device_name;
14338
14339 // device_vendor
14340
14341 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
14342
14343 if (CL_err != CL_SUCCESS)
14344 {
14345 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14346
14347 return -1;
14348 }
14349
14350 char *device_vendor = (char *) mymalloc (param_value_size);
14351
14352 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
14353
14354 if (CL_err != CL_SUCCESS)
14355 {
14356 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14357
14358 return -1;
14359 }
14360
14361 device_param->device_vendor = device_vendor;
14362
14363 cl_uint device_vendor_id = 0;
14364
14365 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
14366 {
14367 device_vendor_id = VENDOR_ID_AMD;
14368 }
14369 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14370 {
14371 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14372 }
14373 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
14374 {
14375 device_vendor_id = VENDOR_ID_APPLE;
14376 }
14377 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14378 {
14379 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14380 }
14381 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
14382 {
14383 device_vendor_id = VENDOR_ID_INTEL_SDK;
14384 }
14385 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
14386 {
14387 device_vendor_id = VENDOR_ID_MESA;
14388 }
14389 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
14390 {
14391 device_vendor_id = VENDOR_ID_NV;
14392 }
14393 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
14394 {
14395 device_vendor_id = VENDOR_ID_POCL;
14396 }
14397 else
14398 {
14399 device_vendor_id = VENDOR_ID_GENERIC;
14400 }
14401
14402 device_param->device_vendor_id = device_vendor_id;
14403
14404 // tuning db
14405
14406 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14407
14408 // device_version
14409
14410 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14411
14412 if (CL_err != CL_SUCCESS)
14413 {
14414 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14415
14416 return -1;
14417 }
14418
14419 char *device_version = (char *) mymalloc (param_value_size);
14420
14421 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14422
14423 if (CL_err != CL_SUCCESS)
14424 {
14425 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14426
14427 return -1;
14428 }
14429
14430 device_param->device_version = device_version;
14431
14432 // device_opencl_version
14433
14434 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14435
14436 if (CL_err != CL_SUCCESS)
14437 {
14438 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14439
14440 return -1;
14441 }
14442
14443 char *device_opencl_version = (char *) mymalloc (param_value_size);
14444
14445 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14446
14447 if (CL_err != CL_SUCCESS)
14448 {
14449 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14450
14451 return -1;
14452 }
14453
14454 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14455
14456 myfree (device_opencl_version);
14457
14458 // vector_width
14459
14460 cl_uint vector_width;
14461
14462 if (opencl_vector_width_chgd == 0)
14463 {
14464 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14465 {
14466 if (opti_type & OPTI_TYPE_USES_BITS_64)
14467 {
14468 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14469
14470 if (CL_err != CL_SUCCESS)
14471 {
14472 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14473
14474 return -1;
14475 }
14476 }
14477 else
14478 {
14479 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14480
14481 if (CL_err != CL_SUCCESS)
14482 {
14483 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14484
14485 return -1;
14486 }
14487 }
14488 }
14489 else
14490 {
14491 vector_width = (cl_uint) tuningdb_entry->vector_width;
14492 }
14493 }
14494 else
14495 {
14496 vector_width = opencl_vector_width;
14497 }
14498
14499 if (vector_width > 16) vector_width = 16;
14500
14501 device_param->vector_width = vector_width;
14502
14503 // max_compute_units
14504
14505 cl_uint device_processors;
14506
14507 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14508
14509 if (CL_err != CL_SUCCESS)
14510 {
14511 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14512
14513 return -1;
14514 }
14515
14516 device_param->device_processors = device_processors;
14517
14518 // device_maxmem_alloc
14519 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14520
14521 cl_ulong device_maxmem_alloc;
14522
14523 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14524
14525 if (CL_err != CL_SUCCESS)
14526 {
14527 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14528
14529 return -1;
14530 }
14531
14532 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14533
14534 // device_global_mem
14535
14536 cl_ulong device_global_mem;
14537
14538 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14539
14540 if (CL_err != CL_SUCCESS)
14541 {
14542 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14543
14544 return -1;
14545 }
14546
14547 device_param->device_global_mem = device_global_mem;
14548
14549 // max_work_group_size
14550
14551 size_t device_maxworkgroup_size;
14552
14553 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14554
14555 if (CL_err != CL_SUCCESS)
14556 {
14557 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14558
14559 return -1;
14560 }
14561
14562 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14563
14564 // max_clock_frequency
14565
14566 cl_uint device_maxclock_frequency;
14567
14568 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14569
14570 if (CL_err != CL_SUCCESS)
14571 {
14572 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14573
14574 return -1;
14575 }
14576
14577 device_param->device_maxclock_frequency = device_maxclock_frequency;
14578
14579 // device_endian_little
14580
14581 cl_bool device_endian_little;
14582
14583 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14584
14585 if (CL_err != CL_SUCCESS)
14586 {
14587 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14588
14589 return -1;
14590 }
14591
14592 if (device_endian_little == CL_FALSE)
14593 {
14594 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14595
14596 device_param->skipped = 1;
14597 }
14598
14599 // device_available
14600
14601 cl_bool device_available;
14602
14603 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14604
14605 if (CL_err != CL_SUCCESS)
14606 {
14607 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14608
14609 return -1;
14610 }
14611
14612 if (device_available == CL_FALSE)
14613 {
14614 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14615
14616 device_param->skipped = 1;
14617 }
14618
14619 // device_compiler_available
14620
14621 cl_bool device_compiler_available;
14622
14623 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14624
14625 if (CL_err != CL_SUCCESS)
14626 {
14627 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14628
14629 return -1;
14630 }
14631
14632 if (device_compiler_available == CL_FALSE)
14633 {
14634 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14635
14636 device_param->skipped = 1;
14637 }
14638
14639 // device_execution_capabilities
14640
14641 cl_device_exec_capabilities device_execution_capabilities;
14642
14643 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14644
14645 if (CL_err != CL_SUCCESS)
14646 {
14647 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14648
14649 return -1;
14650 }
14651
14652 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14653 {
14654 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14655
14656 device_param->skipped = 1;
14657 }
14658
14659 // device_extensions
14660
14661 size_t device_extensions_size;
14662
14663 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14664
14665 if (CL_err != CL_SUCCESS)
14666 {
14667 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14668
14669 return -1;
14670 }
14671
14672 char *device_extensions = mymalloc (device_extensions_size + 1);
14673
14674 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14675
14676 if (CL_err != CL_SUCCESS)
14677 {
14678 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14679
14680 return -1;
14681 }
14682
14683 if (strstr (device_extensions, "base_atomics") == 0)
14684 {
14685 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14686
14687 device_param->skipped = 1;
14688 }
14689
14690 if (strstr (device_extensions, "byte_addressable_store") == 0)
14691 {
14692 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14693
14694 device_param->skipped = 1;
14695 }
14696
14697 myfree (device_extensions);
14698
14699 // device_local_mem_size
14700
14701 cl_ulong device_local_mem_size;
14702
14703 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14704
14705 if (CL_err != CL_SUCCESS)
14706 {
14707 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14708
14709 return -1;
14710 }
14711
14712 if (device_local_mem_size < 32768)
14713 {
14714 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14715
14716 device_param->skipped = 1;
14717 }
14718
14719 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14720 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14721 // This results in both utilizing it for 50%
14722 // However, Intel has much better SIMD control over their own hardware
14723 // It makes sense to give them full control over their own hardware
14724
14725 if (device_type & CL_DEVICE_TYPE_CPU)
14726 {
14727 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14728 {
14729 if (data.force == 0)
14730 {
14731 if (algorithm_pos == 0)
14732 {
14733 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14734 log_info (" You can use --force to override this but do not post error reports if you do so");
14735 }
14736
14737 device_param->skipped = 1;
14738 }
14739 }
14740 }
14741
14742 // skipped
14743
14744 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14745 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14746
14747 // driver_version
14748
14749 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14750
14751 if (CL_err != CL_SUCCESS)
14752 {
14753 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14754
14755 return -1;
14756 }
14757
14758 char *driver_version = (char *) mymalloc (param_value_size);
14759
14760 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14761
14762 if (CL_err != CL_SUCCESS)
14763 {
14764 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14765
14766 return -1;
14767 }
14768
14769 device_param->driver_version = driver_version;
14770
14771 // device_name_chksum
14772
14773 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14774
14775 #if __x86_64__
14776 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);
14777 #else
14778 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);
14779 #endif
14780
14781 uint device_name_digest[4] = { 0 };
14782
14783 md5_64 ((uint *) device_name_chksum, device_name_digest);
14784
14785 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14786
14787 device_param->device_name_chksum = device_name_chksum;
14788
14789 // vendor specific
14790
14791 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14792 {
14793 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14794 {
14795 need_adl = 1;
14796 }
14797
14798 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14799 {
14800 need_nvml = 1;
14801
14802 #ifdef __linux__
14803 need_xnvctrl = 1;
14804 #endif
14805
14806 #ifdef WIN
14807 need_nvapi = 1;
14808 #endif
14809 }
14810 }
14811
14812 if (device_type & CL_DEVICE_TYPE_GPU)
14813 {
14814 if (device_vendor_id == VENDOR_ID_NV)
14815 {
14816 cl_uint kernel_exec_timeout = 0;
14817
14818 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14819
14820 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14821
14822 if (CL_err != CL_SUCCESS)
14823 {
14824 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14825
14826 return -1;
14827 }
14828
14829 device_param->kernel_exec_timeout = kernel_exec_timeout;
14830
14831 cl_uint sm_minor = 0;
14832 cl_uint sm_major = 0;
14833
14834 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14835 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14836
14837 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14838
14839 if (CL_err != CL_SUCCESS)
14840 {
14841 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14842
14843 return -1;
14844 }
14845
14846 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14847
14848 if (CL_err != CL_SUCCESS)
14849 {
14850 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14851
14852 return -1;
14853 }
14854
14855 device_param->sm_minor = sm_minor;
14856 device_param->sm_major = sm_major;
14857
14858 // CPU burning loop damper
14859 // Value is given as number between 0-100
14860 // By default 100%
14861
14862 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14863
14864 if (nvidia_spin_damp_chgd == 0)
14865 {
14866 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14867 {
14868 /**
14869 * the workaround is not a friend of rule based attacks
14870 * the words from the wordlist combined with fast and slow rules cause
14871 * fluctuations which cause inaccurate wait time estimations
14872 * using a reduced damping percentage almost compensates this
14873 */
14874
14875 device_param->nvidia_spin_damp = 64;
14876 }
14877 }
14878
14879 device_param->nvidia_spin_damp /= 100;
14880 }
14881 }
14882
14883 // display results
14884
14885 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14886 {
14887 if (machine_readable == 0)
14888 {
14889 if (device_param->skipped == 0)
14890 {
14891 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14892 device_id + 1,
14893 device_name,
14894 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14895 (unsigned int) (device_global_mem / 1024 / 1024),
14896 (unsigned int) device_processors);
14897 }
14898 else
14899 {
14900 log_info ("- Device #%u: %s, skipped",
14901 device_id + 1,
14902 device_name);
14903 }
14904 }
14905 }
14906
14907 // common driver check
14908
14909 if (device_param->skipped == 0)
14910 {
14911 if (device_type & CL_DEVICE_TYPE_GPU)
14912 {
14913 if (platform_vendor_id == VENDOR_ID_AMD)
14914 {
14915 int catalyst_check = (force == 1) ? 0 : 1;
14916
14917 int catalyst_warn = 0;
14918
14919 int catalyst_broken = 0;
14920
14921 if (catalyst_check == 1)
14922 {
14923 catalyst_warn = 1;
14924
14925 // v14.9 and higher
14926 if (atoi (device_param->driver_version) >= 1573)
14927 {
14928 catalyst_warn = 0;
14929 }
14930
14931 catalyst_check = 0;
14932 }
14933
14934 if (catalyst_broken == 1)
14935 {
14936 log_info ("");
14937 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14938 log_info ("It passes over cracked hashes and will not report them as cracked");
14939 log_info ("You are STRONGLY encouraged not to use it");
14940 log_info ("You can use --force to override this but do not post error reports if you do so");
14941 log_info ("");
14942
14943 return -1;
14944 }
14945
14946 if (catalyst_warn == 1)
14947 {
14948 log_info ("");
14949 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14950 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14951 log_info ("See hashcat's homepage for official supported catalyst drivers");
14952 #ifdef _WIN
14953 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14954 #endif
14955 log_info ("You can use --force to override this but do not post error reports if you do so");
14956 log_info ("");
14957
14958 return -1;
14959 }
14960 }
14961 else if (platform_vendor_id == VENDOR_ID_NV)
14962 {
14963 if (device_param->kernel_exec_timeout != 0)
14964 {
14965 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);
14966 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14967 }
14968 }
14969 }
14970
14971 /* turns out pocl still creates segfaults (because of llvm)
14972 if (device_type & CL_DEVICE_TYPE_CPU)
14973 {
14974 if (platform_vendor_id == VENDOR_ID_AMD)
14975 {
14976 if (force == 0)
14977 {
14978 log_info ("");
14979 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14980 log_info ("You are STRONGLY encouraged not to use it");
14981 log_info ("You can use --force to override this but do not post error reports if you do so");
14982 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14983 log_info ("");
14984
14985 return -1;
14986 }
14987 }
14988 }
14989 */
14990
14991 /**
14992 * kernel accel and loops tuning db adjustment
14993 */
14994
14995 device_param->kernel_accel_min = 1;
14996 device_param->kernel_accel_max = 1024;
14997
14998 device_param->kernel_loops_min = 1;
14999 device_param->kernel_loops_max = 1024;
15000
15001 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
15002
15003 if (tuningdb_entry)
15004 {
15005 u32 _kernel_accel = tuningdb_entry->kernel_accel;
15006 u32 _kernel_loops = tuningdb_entry->kernel_loops;
15007
15008 if (_kernel_accel)
15009 {
15010 device_param->kernel_accel_min = _kernel_accel;
15011 device_param->kernel_accel_max = _kernel_accel;
15012 }
15013
15014 if (_kernel_loops)
15015 {
15016 if (workload_profile == 1)
15017 {
15018 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
15019 }
15020 else if (workload_profile == 2)
15021 {
15022 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
15023 }
15024
15025 device_param->kernel_loops_min = _kernel_loops;
15026 device_param->kernel_loops_max = _kernel_loops;
15027 }
15028 }
15029
15030 // commandline parameters overwrite tuningdb entries
15031
15032 if (kernel_accel)
15033 {
15034 device_param->kernel_accel_min = kernel_accel;
15035 device_param->kernel_accel_max = kernel_accel;
15036 }
15037
15038 if (kernel_loops)
15039 {
15040 device_param->kernel_loops_min = kernel_loops;
15041 device_param->kernel_loops_max = kernel_loops;
15042 }
15043
15044 /**
15045 * activate device
15046 */
15047
15048 devices_active++;
15049 }
15050
15051 // next please
15052
15053 devices_cnt++;
15054 }
15055
15056 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
15057 {
15058 if (machine_readable == 0)
15059 {
15060 log_info ("");
15061 }
15062 }
15063 }
15064
15065 if (keyspace == 0 && devices_active == 0)
15066 {
15067 log_error ("ERROR: No devices found/left");
15068
15069 return -1;
15070 }
15071
15072 // 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)
15073
15074 if (devices_filter != (uint) -1)
15075 {
15076 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
15077
15078 if (devices_filter > devices_cnt_mask)
15079 {
15080 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
15081
15082 return -1;
15083 }
15084 }
15085
15086 data.devices_cnt = devices_cnt;
15087
15088 data.devices_active = devices_active;
15089
15090 /**
15091 * HM devices: init
15092 */
15093
15094 #ifdef HAVE_HWMON
15095 hm_attrs_t hm_adapters_adl[DEVICES_MAX];
15096 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
15097 hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
15098 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
15099
15100 memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl));
15101 memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi));
15102 memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml));
15103 memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
15104
15105 if (gpu_temp_disable == 0)
15106 {
15107 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
15108 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
15109 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
15110 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
15111
15112 data.hm_adl = NULL;
15113 data.hm_nvapi = NULL;
15114 data.hm_nvml = NULL;
15115 data.hm_xnvctrl = NULL;
15116
15117 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
15118 {
15119 data.hm_nvml = nvml;
15120 }
15121
15122 if (data.hm_nvml)
15123 {
15124 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
15125 {
15126 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
15127
15128 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
15129
15130 int tmp_out = 0;
15131
15132 for (int i = 0; i < tmp_in; i++)
15133 {
15134 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
15135 }
15136
15137 for (int i = 0; i < tmp_out; i++)
15138 {
15139 unsigned int speed;
15140
15141 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
15142
15143 // doesn't seem to create any advantages
15144 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
15145 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
15146 }
15147 }
15148 }
15149
15150 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
15151 {
15152 data.hm_nvapi = nvapi;
15153 }
15154
15155 if (data.hm_nvapi)
15156 {
15157 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
15158 {
15159 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
15160
15161 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
15162
15163 int tmp_out = 0;
15164
15165 for (int i = 0; i < tmp_in; i++)
15166 {
15167 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
15168 }
15169 }
15170 }
15171
15172 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
15173 {
15174 data.hm_xnvctrl = xnvctrl;
15175 }
15176
15177 if (data.hm_xnvctrl)
15178 {
15179 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
15180 {
15181 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15182 {
15183 hc_device_param_t *device_param = &data.devices_param[device_id];
15184
15185 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15186
15187 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
15188
15189 int speed = 0;
15190
15191 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
15192 }
15193 }
15194 }
15195
15196 if ((need_adl == 1) && (adl_init (adl) == 0))
15197 {
15198 data.hm_adl = adl;
15199 }
15200
15201 if (data.hm_adl)
15202 {
15203 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
15204 {
15205 // total number of adapters
15206
15207 int hm_adapters_num;
15208
15209 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1;
15210
15211 // adapter info
15212
15213 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
15214
15215 if (lpAdapterInfo == NULL) return -1;
15216
15217 // get a list (of ids of) valid/usable adapters
15218
15219 int num_adl_adapters = 0;
15220
15221 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
15222
15223 if (num_adl_adapters > 0)
15224 {
15225 hc_thread_mutex_lock (mux_adl);
15226
15227 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
15228
15229 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15230
15231 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15232 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15233
15234 hc_thread_mutex_unlock (mux_adl);
15235 }
15236
15237 myfree (valid_adl_device_list);
15238 myfree (lpAdapterInfo);
15239 }
15240 }
15241
15242 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15243 {
15244 gpu_temp_disable = 1;
15245 }
15246 }
15247
15248 /**
15249 * OpenCL devices: allocate buffer for device specific information
15250 */
15251
15252 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
15253
15254 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
15255
15256 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
15257
15258 /**
15259 * User-defined GPU temp handling
15260 */
15261
15262 if (gpu_temp_disable == 1)
15263 {
15264 gpu_temp_abort = 0;
15265 gpu_temp_retain = 0;
15266 }
15267
15268 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
15269 {
15270 if (gpu_temp_abort < gpu_temp_retain)
15271 {
15272 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
15273
15274 return -1;
15275 }
15276 }
15277
15278 data.gpu_temp_disable = gpu_temp_disable;
15279 data.gpu_temp_abort = gpu_temp_abort;
15280 data.gpu_temp_retain = gpu_temp_retain;
15281 #endif
15282
15283 /**
15284 * enable custom signal handler(s)
15285 */
15286
15287 if (benchmark == 0)
15288 {
15289 hc_signal (sigHandler_default);
15290 }
15291 else
15292 {
15293 hc_signal (sigHandler_benchmark);
15294 }
15295
15296 /**
15297 * inform the user
15298 */
15299
15300 if (data.quiet == 0)
15301 {
15302 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
15303
15304 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);
15305
15306 if (attack_mode == ATTACK_MODE_STRAIGHT)
15307 {
15308 log_info ("Rules: %u", kernel_rules_cnt);
15309 }
15310
15311 if (opti_type)
15312 {
15313 log_info ("Applicable Optimizers:");
15314
15315 for (uint i = 0; i < 32; i++)
15316 {
15317 const uint opti_bit = 1u << i;
15318
15319 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
15320 }
15321 }
15322
15323 /**
15324 * Watchdog and Temperature balance
15325 */
15326
15327 #ifdef HAVE_HWMON
15328 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15329 {
15330 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
15331 }
15332
15333 if (gpu_temp_abort == 0)
15334 {
15335 log_info ("Watchdog: Temperature abort trigger disabled");
15336 }
15337 else
15338 {
15339 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
15340 }
15341
15342 if (gpu_temp_retain == 0)
15343 {
15344 log_info ("Watchdog: Temperature retain trigger disabled");
15345 }
15346 else
15347 {
15348 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
15349 }
15350
15351 if (data.quiet == 0) log_info ("");
15352 #endif
15353 }
15354
15355 #ifdef HAVE_HWMON
15356
15357 /**
15358 * HM devices: copy
15359 */
15360
15361 if (gpu_temp_disable == 0)
15362 {
15363 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15364 {
15365 hc_device_param_t *device_param = &data.devices_param[device_id];
15366
15367 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15368
15369 if (device_param->skipped) continue;
15370
15371 const uint platform_devices_id = device_param->platform_devices_id;
15372
15373 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15374 {
15375 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
15376 data.hm_device[device_id].nvapi = 0;
15377 data.hm_device[device_id].nvml = 0;
15378 data.hm_device[device_id].xnvctrl = 0;
15379 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
15380 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
15381 data.hm_device[device_id].fan_set_supported = 0;
15382 }
15383
15384 if (device_param->device_vendor_id == VENDOR_ID_NV)
15385 {
15386 data.hm_device[device_id].adl = 0;
15387 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
15388 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
15389 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
15390 data.hm_device[device_id].od_version = 0;
15391 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
15392 data.hm_device[device_id].fan_set_supported = 0;
15393 }
15394 }
15395 }
15396
15397 /**
15398 * powertune on user request
15399 */
15400
15401 if (powertune_enable == 1)
15402 {
15403 hc_thread_mutex_lock (mux_adl);
15404
15405 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15406 {
15407 hc_device_param_t *device_param = &data.devices_param[device_id];
15408
15409 if (device_param->skipped) continue;
15410
15411 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
15412 {
15413 /**
15414 * Temporary fix:
15415 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
15416 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
15417 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
15418 * Driver / ADL bug?
15419 */
15420
15421 if (data.hm_device[device_id].od_version == 6)
15422 {
15423 int ADL_rc;
15424
15425 // check powertune capabilities first, if not available then skip device
15426
15427 int powertune_supported = 0;
15428
15429 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
15430 {
15431 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15432
15433 return -1;
15434 }
15435
15436 // first backup current value, we will restore it later
15437
15438 if (powertune_supported != 0)
15439 {
15440 // powercontrol settings
15441
15442 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15443
15444 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
15445 {
15446 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
15447 }
15448
15449 if (ADL_rc != ADL_OK)
15450 {
15451 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15452
15453 return -1;
15454 }
15455
15456 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15457 {
15458 log_error ("ERROR: Failed to set new ADL PowerControl values");
15459
15460 return -1;
15461 }
15462
15463 // clocks
15464
15465 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15466
15467 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15468
15469 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)
15470 {
15471 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15472
15473 return -1;
15474 }
15475
15476 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15477
15478 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15479
15480 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
15481 {
15482 log_error ("ERROR: Failed to get ADL device capabilities");
15483
15484 return -1;
15485 }
15486
15487 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15488 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15489
15490 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15491 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15492
15493 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15494 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15495
15496 // warning if profile has too low max values
15497
15498 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15499 {
15500 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15501 }
15502
15503 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15504 {
15505 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15506 }
15507
15508 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15509
15510 performance_state->iNumberOfPerformanceLevels = 2;
15511
15512 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15513 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15514 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15515 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15516
15517 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)
15518 {
15519 log_info ("ERROR: Failed to set ADL performance state");
15520
15521 return -1;
15522 }
15523
15524 local_free (performance_state);
15525 }
15526
15527 // set powertune value only
15528
15529 if (powertune_supported != 0)
15530 {
15531 // powertune set
15532 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15533
15534 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
15535 {
15536 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15537
15538 return -1;
15539 }
15540
15541 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15542 {
15543 log_error ("ERROR: Failed to set new ADL PowerControl values");
15544
15545 return -1;
15546 }
15547 }
15548 }
15549 }
15550
15551 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
15552 {
15553 // first backup current value, we will restore it later
15554
15555 unsigned int limit;
15556
15557 int powertune_supported = 0;
15558
15559 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
15560 {
15561 powertune_supported = 1;
15562 }
15563
15564 // if backup worked, activate the maximum allowed
15565
15566 if (powertune_supported != 0)
15567 {
15568 unsigned int minLimit;
15569 unsigned int maxLimit;
15570
15571 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15572 {
15573 if (maxLimit > 0)
15574 {
15575 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15576 {
15577 // now we can be sure we need to reset later
15578
15579 nvml_power_limit[device_id] = limit;
15580 }
15581 }
15582 }
15583 }
15584 }
15585 }
15586
15587 hc_thread_mutex_unlock (mux_adl);
15588 }
15589
15590 #endif // HAVE_HWMON
15591
15592 #ifdef DEBUG
15593 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15594 #endif
15595
15596 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15597
15598 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15599 {
15600 cl_int CL_err = CL_SUCCESS;
15601
15602 /**
15603 * host buffer
15604 */
15605
15606 hc_device_param_t *device_param = &data.devices_param[device_id];
15607
15608 if (device_param->skipped) continue;
15609
15610 /**
15611 * device properties
15612 */
15613
15614 const char *device_name_chksum = device_param->device_name_chksum;
15615 const u32 device_processors = device_param->device_processors;
15616
15617 /**
15618 * create context for each device
15619 */
15620
15621 cl_context_properties properties[3];
15622
15623 properties[0] = CL_CONTEXT_PLATFORM;
15624 properties[1] = (cl_context_properties) device_param->platform;
15625 properties[2] = 0;
15626
15627 CL_err = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL, &device_param->context);
15628
15629 if (CL_err != CL_SUCCESS)
15630 {
15631 log_error ("ERROR: clCreateContext(): %s\n", val2cstr_cl (CL_err));
15632
15633 return -1;
15634 }
15635
15636 /**
15637 * create command-queue
15638 */
15639
15640 // not supported with NV
15641 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15642
15643 CL_err = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE, &device_param->command_queue);
15644
15645 if (CL_err != CL_SUCCESS)
15646 {
15647 log_error ("ERROR: clCreateCommandQueue(): %s\n", val2cstr_cl (CL_err));
15648
15649 return -1;
15650 }
15651
15652 /**
15653 * kernel threads: some algorithms need a fixed kernel-threads count
15654 * because of shared memory usage or bitslice
15655 * there needs to be some upper limit, otherwise there's too much overhead
15656 */
15657
15658 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15659
15660 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15661 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15662
15663 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15664 {
15665 kernel_threads = KERNEL_THREADS_MAX_CPU;
15666 }
15667
15668 if (hash_mode == 1500) kernel_threads = 64; // DES
15669 if (hash_mode == 3000) kernel_threads = 64; // DES
15670 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15671 if (hash_mode == 7500) kernel_threads = 64; // RC4
15672 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15673 if (hash_mode == 9700) kernel_threads = 64; // RC4
15674 if (hash_mode == 9710) kernel_threads = 64; // RC4
15675 if (hash_mode == 9800) kernel_threads = 64; // RC4
15676 if (hash_mode == 9810) kernel_threads = 64; // RC4
15677 if (hash_mode == 10400) kernel_threads = 64; // RC4
15678 if (hash_mode == 10410) kernel_threads = 64; // RC4
15679 if (hash_mode == 10500) kernel_threads = 64; // RC4
15680 if (hash_mode == 13100) kernel_threads = 64; // RC4
15681
15682 device_param->kernel_threads = kernel_threads;
15683
15684 device_param->hardware_power = device_processors * kernel_threads;
15685
15686 /**
15687 * create input buffers on device : calculate size of fixed memory buffers
15688 */
15689
15690 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15691 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15692
15693 device_param->size_root_css = size_root_css;
15694 device_param->size_markov_css = size_markov_css;
15695
15696 size_t size_results = sizeof (uint);
15697
15698 device_param->size_results = size_results;
15699
15700 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15701 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15702
15703 size_t size_plains = digests_cnt * sizeof (plain_t);
15704 size_t size_salts = salts_cnt * sizeof (salt_t);
15705 size_t size_esalts = salts_cnt * esalt_size;
15706
15707 device_param->size_plains = size_plains;
15708 device_param->size_digests = size_digests;
15709 device_param->size_shown = size_shown;
15710 device_param->size_salts = size_salts;
15711
15712 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15713 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15714 size_t size_tm = 32 * sizeof (bs_word_t);
15715
15716 // scryptV stuff
15717
15718 size_t size_scrypt = 4;
15719
15720 if ((hash_mode == 8900) || (hash_mode == 9300))
15721 {
15722 // we need to check that all hashes have the same scrypt settings
15723
15724 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15725 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15726 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15727
15728 for (uint i = 1; i < salts_cnt; i++)
15729 {
15730 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15731 || (data.salts_buf[i].scrypt_r != scrypt_r)
15732 || (data.salts_buf[i].scrypt_p != scrypt_p))
15733 {
15734 log_error ("ERROR: Mixed scrypt settings not supported");
15735
15736 return -1;
15737 }
15738 }
15739
15740 uint tmto_start = 0;
15741 uint tmto_stop = 10;
15742
15743 if (scrypt_tmto)
15744 {
15745 tmto_start = scrypt_tmto;
15746 }
15747 else
15748 {
15749 // in case the user did not specify the tmto manually
15750 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15751
15752 if (hash_mode == 8900)
15753 {
15754 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15755 {
15756 tmto_start = 3;
15757 }
15758 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15759 {
15760 tmto_start = 2;
15761 }
15762 }
15763 else if (hash_mode == 9300)
15764 {
15765 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15766 {
15767 tmto_start = 2;
15768 }
15769 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15770 {
15771 tmto_start = 4;
15772 }
15773 }
15774 }
15775
15776 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15777
15778 device_param->kernel_accel_min = 1;
15779 device_param->kernel_accel_max = 8;
15780
15781 uint tmto;
15782
15783 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15784 {
15785 size_scrypt = (128 * scrypt_r) * scrypt_N;
15786
15787 size_scrypt /= 1 << tmto;
15788
15789 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15790
15791 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15792 {
15793 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15794
15795 continue;
15796 }
15797
15798 if (size_scrypt > device_param->device_global_mem)
15799 {
15800 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15801
15802 continue;
15803 }
15804
15805 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15806 {
15807 data.scrypt_tmto_final = tmto;
15808 }
15809
15810 break;
15811 }
15812
15813 if (tmto == tmto_stop)
15814 {
15815 log_error ("ERROR: Can't allocate enough device memory");
15816
15817 return -1;
15818 }
15819
15820 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %llu\n", data.scrypt_tmto_final, (unsigned long long int) size_scrypt);
15821 }
15822
15823 size_t size_scrypt4 = size_scrypt / 4;
15824
15825 /**
15826 * some algorithms need a fixed kernel-loops count
15827 */
15828
15829 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15830 {
15831 const u32 kernel_loops_fixed = 1024;
15832
15833 device_param->kernel_loops_min = kernel_loops_fixed;
15834 device_param->kernel_loops_max = kernel_loops_fixed;
15835 }
15836
15837 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15838 {
15839 const u32 kernel_loops_fixed = 1024;
15840
15841 device_param->kernel_loops_min = kernel_loops_fixed;
15842 device_param->kernel_loops_max = kernel_loops_fixed;
15843 }
15844
15845 if (hash_mode == 8900)
15846 {
15847 const u32 kernel_loops_fixed = 1;
15848
15849 device_param->kernel_loops_min = kernel_loops_fixed;
15850 device_param->kernel_loops_max = kernel_loops_fixed;
15851 }
15852
15853 if (hash_mode == 9300)
15854 {
15855 const u32 kernel_loops_fixed = 1;
15856
15857 device_param->kernel_loops_min = kernel_loops_fixed;
15858 device_param->kernel_loops_max = kernel_loops_fixed;
15859 }
15860
15861 if (hash_mode == 12500)
15862 {
15863 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15864
15865 device_param->kernel_loops_min = kernel_loops_fixed;
15866 device_param->kernel_loops_max = kernel_loops_fixed;
15867 }
15868
15869 /**
15870 * some algorithms have a maximum kernel-loops count
15871 */
15872
15873 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15874 {
15875 u32 innerloop_cnt = 0;
15876
15877 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15878 {
15879 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15880 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15881 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15882 }
15883 else
15884 {
15885 innerloop_cnt = data.salts_buf[0].salt_iter;
15886 }
15887
15888 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15889 (innerloop_cnt <= device_param->kernel_loops_max))
15890 {
15891 device_param->kernel_loops_max = innerloop_cnt;
15892 }
15893 }
15894
15895 u32 kernel_accel_min = device_param->kernel_accel_min;
15896 u32 kernel_accel_max = device_param->kernel_accel_max;
15897
15898 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15899
15900 size_t size_pws = 4;
15901 size_t size_tmps = 4;
15902 size_t size_hooks = 4;
15903
15904 while (kernel_accel_max >= kernel_accel_min)
15905 {
15906 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15907
15908 // size_pws
15909
15910 size_pws = kernel_power_max * sizeof (pw_t);
15911
15912 // size_tmps
15913
15914 switch (hash_mode)
15915 {
15916 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15917 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15918 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15919 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15920 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15921 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15922 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15923 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15924 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15925 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15926 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15927 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15928 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15929 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15930 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15931 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15932 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15933 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15934 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15935 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15936 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15937 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15938 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15939 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15940 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15941 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15942 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15943 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15944 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15945 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15946 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15947 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15948 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15949 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15950 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15951 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15952 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15953 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15954 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15955 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15956 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15957 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15958 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15959 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15960 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15961 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15962 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15963 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15964 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15965 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15966 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15967 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15968 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15969 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15970 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15971 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15972 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15973 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15974 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15975 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15976 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15977 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15978 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15979 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15980 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15981 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15982 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15983 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15984 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15985 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15986 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15987 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15988 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15989 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15990 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15991 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15992 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15993 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15994 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15995 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15996 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15997 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15998 };
15999
16000 // size_hooks
16001
16002 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
16003 {
16004 switch (hash_mode)
16005 {
16006 }
16007 }
16008
16009 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
16010 // if not, decrease amplifier and try again
16011
16012 int memory_limit_hit = 0;
16013
16014 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16015 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16016 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16017
16018 const u64 size_total
16019 = bitmap_size
16020 + bitmap_size
16021 + bitmap_size
16022 + bitmap_size
16023 + bitmap_size
16024 + bitmap_size
16025 + bitmap_size
16026 + bitmap_size
16027 + size_bfs
16028 + size_combs
16029 + size_digests
16030 + size_esalts
16031 + size_hooks
16032 + size_markov_css
16033 + size_plains
16034 + size_pws
16035 + size_pws // not a bug
16036 + size_results
16037 + size_root_css
16038 + size_rules
16039 + size_rules_c
16040 + size_salts
16041 + size_scrypt4
16042 + size_scrypt4
16043 + size_scrypt4
16044 + size_scrypt4
16045 + size_shown
16046 + size_tm
16047 + size_tmps;
16048
16049 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
16050
16051 if (memory_limit_hit == 1)
16052 {
16053 kernel_accel_max--;
16054
16055 continue;
16056 }
16057
16058 break;
16059 }
16060
16061 if (kernel_accel_max < kernel_accel_min)
16062 {
16063 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
16064
16065 return -1;
16066 }
16067
16068 device_param->kernel_accel_min = kernel_accel_min;
16069 device_param->kernel_accel_max = kernel_accel_max;
16070
16071 /*
16072 if (kernel_accel_max < kernel_accel)
16073 {
16074 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
16075
16076 device_param->kernel_accel = kernel_accel_max;
16077 }
16078 */
16079
16080 device_param->size_bfs = size_bfs;
16081 device_param->size_combs = size_combs;
16082 device_param->size_rules = size_rules;
16083 device_param->size_rules_c = size_rules_c;
16084 device_param->size_pws = size_pws;
16085 device_param->size_tmps = size_tmps;
16086 device_param->size_hooks = size_hooks;
16087
16088 /**
16089 * default building options
16090 */
16091
16092 char cpath[1024] = { 0 };
16093
16094 char build_opts[1024] = { 0 };
16095
16096 #if _WIN
16097
16098 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
16099
16100 char *cpath_real = mymalloc (MAX_PATH);
16101
16102 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
16103 {
16104 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
16105
16106 return -1;
16107 }
16108
16109 naive_replace (cpath_real, '\\', '/');
16110
16111 // not escaping here, windows has quotes
16112
16113 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
16114
16115 #else
16116
16117 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
16118
16119 char *cpath_real = mymalloc (PATH_MAX);
16120
16121 if (realpath (cpath, cpath_real) == NULL)
16122 {
16123 log_error ("ERROR: %s: %s", cpath, strerror (errno));
16124
16125 return -1;
16126 }
16127
16128 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
16129
16130 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
16131
16132 #endif
16133
16134 // include check
16135 // this test needs to be done manually because of osx opencl runtime
16136 // if there's a problem with permission, its not reporting back and erroring out silently
16137
16138 #define files_cnt 15
16139
16140 const char *files_names[files_cnt] =
16141 {
16142 "inc_cipher_aes256.cl",
16143 "inc_cipher_serpent256.cl",
16144 "inc_cipher_twofish256.cl",
16145 "inc_common.cl",
16146 "inc_comp_multi_bs.cl",
16147 "inc_comp_multi.cl",
16148 "inc_comp_single_bs.cl",
16149 "inc_comp_single.cl",
16150 "inc_hash_constants.h",
16151 "inc_hash_functions.cl",
16152 "inc_rp.cl",
16153 "inc_rp.h",
16154 "inc_simd.cl",
16155 "inc_types.cl",
16156 "inc_vendor.cl",
16157 };
16158
16159 if (chdir (cpath_real) == -1)
16160 {
16161 log_error ("ERROR: %s: %s", cpath_real, strerror (errno));
16162
16163 return -1;
16164 }
16165
16166 for (int i = 0; i < files_cnt; i++)
16167 {
16168 FILE *fd = fopen (files_names[i], "r");
16169
16170 if (fd == NULL)
16171 {
16172 log_error ("ERROR: %s: fopen(): %s", files_names[i], strerror (errno));
16173
16174 return -1;
16175 }
16176
16177 char buf[1];
16178
16179 size_t n = fread (buf, 1, 1, fd);
16180
16181 if (n != 1)
16182 {
16183 log_error ("ERROR: %s: fread(): %s", files_names[i], strerror (errno));
16184
16185 return -1;
16186 }
16187
16188 fclose (fd);
16189 }
16190
16191 myfree (cpath_real);
16192
16193 // we don't have sm_* on vendors not NV but it doesn't matter
16194
16195 char build_opts_new[1024] = { 0 };
16196
16197 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_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, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type);
16198
16199 strncpy (build_opts, build_opts_new, sizeof (build_opts));
16200
16201 #ifdef DEBUG
16202 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
16203 #endif
16204
16205 /**
16206 * main kernel
16207 */
16208
16209 {
16210 /**
16211 * kernel source filename
16212 */
16213
16214 char source_file[256] = { 0 };
16215
16216 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
16217
16218 struct stat sst;
16219
16220 if (stat (source_file, &sst) == -1)
16221 {
16222 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16223
16224 return -1;
16225 }
16226
16227 /**
16228 * kernel cached filename
16229 */
16230
16231 char cached_file[256] = { 0 };
16232
16233 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
16234
16235 int cached = 1;
16236
16237 struct stat cst;
16238
16239 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
16240 {
16241 cached = 0;
16242 }
16243
16244 /**
16245 * kernel compile or load
16246 */
16247
16248 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16249
16250 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16251
16252 if (force_jit_compilation == -1)
16253 {
16254 if (cached == 0)
16255 {
16256 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
16257
16258 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16259
16260 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16261
16262 if (CL_err != CL_SUCCESS)
16263 {
16264 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16265
16266 return -1;
16267 }
16268
16269 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16270
16271 if (CL_err != CL_SUCCESS)
16272 {
16273 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16274
16275 //return -1;
16276 }
16277
16278 #ifdef DEBUG
16279 size_t build_log_size = 0;
16280
16281 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16282
16283 if (CL_err != CL_SUCCESS)
16284 {
16285 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16286
16287 return -1;
16288 }
16289
16290 if (build_log_size > 1)
16291 {
16292 char *build_log = (char *) mymalloc (build_log_size + 1);
16293
16294 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16295
16296 if (CL_err != CL_SUCCESS)
16297 {
16298 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16299
16300 return -1;
16301 }
16302
16303 puts (build_log);
16304
16305 myfree (build_log);
16306 }
16307 #endif
16308
16309 if (CL_err != CL_SUCCESS)
16310 {
16311 device_param->skipped = true;
16312
16313 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16314
16315 continue;
16316 }
16317
16318 size_t binary_size;
16319
16320 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16321
16322 if (CL_err != CL_SUCCESS)
16323 {
16324 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16325
16326 return -1;
16327 }
16328
16329 u8 *binary = (u8 *) mymalloc (binary_size);
16330
16331 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16332
16333 if (CL_err != CL_SUCCESS)
16334 {
16335 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16336
16337 return -1;
16338 }
16339
16340 writeProgramBin (cached_file, binary, binary_size);
16341
16342 local_free (binary);
16343 }
16344 else
16345 {
16346 #ifdef DEBUG
16347 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16348 #endif
16349
16350 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16351
16352 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program);
16353
16354 if (CL_err != CL_SUCCESS)
16355 {
16356 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16357
16358 return -1;
16359 }
16360
16361 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16362
16363 if (CL_err != CL_SUCCESS)
16364 {
16365 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16366
16367 return -1;
16368 }
16369 }
16370 }
16371 else
16372 {
16373 #ifdef DEBUG
16374 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
16375 #endif
16376
16377 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16378
16379 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16380
16381 if (CL_err != CL_SUCCESS)
16382 {
16383 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16384
16385 return -1;
16386 }
16387
16388 char build_opts_update[1024] = { 0 };
16389
16390 if (force_jit_compilation == 1500)
16391 {
16392 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
16393 }
16394 else if (force_jit_compilation == 8900)
16395 {
16396 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16);
16397 }
16398 else
16399 {
16400 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
16401 }
16402
16403 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
16404
16405 if (CL_err != CL_SUCCESS)
16406 {
16407 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16408
16409 //return -1;
16410 }
16411
16412 #ifdef DEBUG
16413 size_t build_log_size = 0;
16414
16415 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16416
16417 if (CL_err != CL_SUCCESS)
16418 {
16419 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16420
16421 return -1;
16422 }
16423
16424 if (build_log_size > 1)
16425 {
16426 char *build_log = (char *) mymalloc (build_log_size + 1);
16427
16428 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16429
16430 if (CL_err != CL_SUCCESS)
16431 {
16432 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16433
16434 return -1;
16435 }
16436
16437 puts (build_log);
16438
16439 myfree (build_log);
16440 }
16441 #endif
16442
16443 if (CL_err != CL_SUCCESS)
16444 {
16445 device_param->skipped = true;
16446
16447 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16448 }
16449 }
16450
16451 local_free (kernel_lengths);
16452 local_free (kernel_sources[0]);
16453 local_free (kernel_sources);
16454 }
16455
16456 /**
16457 * word generator kernel
16458 */
16459
16460 if (attack_mode != ATTACK_MODE_STRAIGHT)
16461 {
16462 /**
16463 * kernel mp source filename
16464 */
16465
16466 char source_file[256] = { 0 };
16467
16468 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
16469
16470 struct stat sst;
16471
16472 if (stat (source_file, &sst) == -1)
16473 {
16474 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16475
16476 return -1;
16477 }
16478
16479 /**
16480 * kernel mp cached filename
16481 */
16482
16483 char cached_file[256] = { 0 };
16484
16485 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
16486
16487 int cached = 1;
16488
16489 struct stat cst;
16490
16491 if (stat (cached_file, &cst) == -1)
16492 {
16493 cached = 0;
16494 }
16495
16496 /**
16497 * kernel compile or load
16498 */
16499
16500 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16501
16502 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16503
16504 if (cached == 0)
16505 {
16506 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
16507 if (quiet == 0) log_info ("");
16508
16509 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16510
16511 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_mp);
16512
16513 if (CL_err != CL_SUCCESS)
16514 {
16515 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16516
16517 return -1;
16518 }
16519
16520 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16521
16522 if (CL_err != CL_SUCCESS)
16523 {
16524 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16525
16526 //return -1;
16527 }
16528
16529 if (CL_err != CL_SUCCESS)
16530 {
16531 device_param->skipped = true;
16532
16533 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16534
16535 continue;
16536 }
16537
16538 size_t binary_size;
16539
16540 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16541
16542 if (CL_err != CL_SUCCESS)
16543 {
16544 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16545
16546 return -1;
16547 }
16548
16549 u8 *binary = (u8 *) mymalloc (binary_size);
16550
16551 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16552
16553 if (CL_err != CL_SUCCESS)
16554 {
16555 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16556
16557 return -1;
16558 }
16559
16560 writeProgramBin (cached_file, binary, binary_size);
16561
16562 local_free (binary);
16563 }
16564 else
16565 {
16566 #ifdef DEBUG
16567 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16568 #endif
16569
16570 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16571
16572 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_mp);
16573
16574 if (CL_err != CL_SUCCESS)
16575 {
16576 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16577
16578 return -1;
16579 }
16580
16581 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16582
16583 if (CL_err != CL_SUCCESS)
16584 {
16585 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16586
16587 return -1;
16588 }
16589 }
16590
16591 local_free (kernel_lengths);
16592 local_free (kernel_sources[0]);
16593 local_free (kernel_sources);
16594 }
16595
16596 /**
16597 * amplifier kernel
16598 */
16599
16600 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16601 {
16602
16603 }
16604 else
16605 {
16606 /**
16607 * kernel amp source filename
16608 */
16609
16610 char source_file[256] = { 0 };
16611
16612 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
16613
16614 struct stat sst;
16615
16616 if (stat (source_file, &sst) == -1)
16617 {
16618 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16619
16620 return -1;
16621 }
16622
16623 /**
16624 * kernel amp cached filename
16625 */
16626
16627 char cached_file[256] = { 0 };
16628
16629 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
16630
16631 int cached = 1;
16632
16633 struct stat cst;
16634
16635 if (stat (cached_file, &cst) == -1)
16636 {
16637 cached = 0;
16638 }
16639
16640 /**
16641 * kernel compile or load
16642 */
16643
16644 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16645
16646 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16647
16648 if (cached == 0)
16649 {
16650 if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
16651 if (quiet == 0) log_info ("");
16652
16653 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16654
16655 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_amp);
16656
16657 if (CL_err != CL_SUCCESS)
16658 {
16659 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16660
16661 return -1;
16662 }
16663
16664 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16665
16666 if (CL_err != CL_SUCCESS)
16667 {
16668 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16669
16670 //return -1;
16671 }
16672
16673 if (CL_err != CL_SUCCESS)
16674 {
16675 device_param->skipped = true;
16676
16677 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
16678
16679 continue;
16680 }
16681
16682 size_t binary_size;
16683
16684 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16685
16686 if (CL_err != CL_SUCCESS)
16687 {
16688 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16689
16690 return -1;
16691 }
16692
16693 u8 *binary = (u8 *) mymalloc (binary_size);
16694
16695 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16696
16697 if (CL_err != CL_SUCCESS)
16698 {
16699 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16700
16701 return -1;
16702 }
16703
16704 writeProgramBin (cached_file, binary, binary_size);
16705
16706 local_free (binary);
16707 }
16708 else
16709 {
16710 #ifdef DEBUG
16711 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16712 #endif
16713
16714 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16715
16716 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_amp);
16717
16718 if (CL_err != CL_SUCCESS)
16719 {
16720 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16721
16722 return -1;
16723 }
16724
16725 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16726
16727 if (CL_err != CL_SUCCESS)
16728 {
16729 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16730
16731 return -1;
16732 }
16733 }
16734
16735 local_free (kernel_lengths);
16736 local_free (kernel_sources[0]);
16737 local_free (kernel_sources);
16738 }
16739
16740 // return back to the folder we came from initially (workaround)
16741
16742 if (chdir (cwd) == -1)
16743 {
16744 log_error ("ERROR: %s: %s", cwd, strerror (errno));
16745
16746 return -1;
16747 }
16748
16749 // some algorithm collide too fast, make that impossible
16750
16751 if (benchmark == 1)
16752 {
16753 ((uint *) digests_buf)[0] = -1;
16754 ((uint *) digests_buf)[1] = -1;
16755 ((uint *) digests_buf)[2] = -1;
16756 ((uint *) digests_buf)[3] = -1;
16757 }
16758
16759 /**
16760 * global buffers
16761 */
16762
16763 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_buf);
16764 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_amp_buf);
16765 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL, &device_param->d_tmps);
16766 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL, &device_param->d_hooks);
16767 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_a);
16768 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_b);
16769 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_c);
16770 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_d);
16771 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_a);
16772 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_b);
16773 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_c);
16774 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_d);
16775 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL, &device_param->d_plain_bufs);
16776 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL, &device_param->d_digests_buf);
16777 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL, &device_param->d_digests_shown);
16778 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL, &device_param->d_salt_bufs);
16779 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL, &device_param->d_result);
16780 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV0_buf);
16781 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV1_buf);
16782 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV2_buf);
16783 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV3_buf);
16784
16785 if (CL_err != CL_SUCCESS)
16786 {
16787 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16788
16789 return -1;
16790 }
16791
16792 CL_err |= 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);
16793 CL_err |= 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);
16794 CL_err |= 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);
16795 CL_err |= 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);
16796 CL_err |= 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);
16797 CL_err |= 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);
16798 CL_err |= 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);
16799 CL_err |= 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);
16800 CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
16801 CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
16802 CL_err |= hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
16803
16804 if (CL_err != CL_SUCCESS)
16805 {
16806 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16807
16808 return -1;
16809 }
16810
16811 /**
16812 * special buffers
16813 */
16814
16815 if (attack_kern == ATTACK_KERN_STRAIGHT)
16816 {
16817 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL, &device_param->d_rules);
16818 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL, &device_param->d_rules_c);
16819
16820 if (CL_err != CL_SUCCESS)
16821 {
16822 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16823
16824 return -1;
16825 }
16826
16827 CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
16828
16829 if (CL_err != CL_SUCCESS)
16830 {
16831 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16832
16833 return -1;
16834 }
16835 }
16836 else if (attack_kern == ATTACK_KERN_COMBI)
16837 {
16838 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs);
16839 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs_c);
16840 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16841 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16842
16843 if (CL_err != CL_SUCCESS)
16844 {
16845 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16846
16847 return -1;
16848 }
16849 }
16850 else if (attack_kern == ATTACK_KERN_BF)
16851 {
16852 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs);
16853 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs_c);
16854 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL, &device_param->d_tm_c);
16855 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16856 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16857
16858 if (CL_err != CL_SUCCESS)
16859 {
16860 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16861
16862 return -1;
16863 }
16864 }
16865
16866 if (size_esalts)
16867 {
16868 CL_err = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL, &device_param->d_esalt_bufs);
16869
16870 if (CL_err != CL_SUCCESS)
16871 {
16872 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16873
16874 return -1;
16875 }
16876
16877 CL_err = hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
16878
16879 if (CL_err != CL_SUCCESS)
16880 {
16881 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16882
16883 return -1;
16884 }
16885 }
16886
16887 /**
16888 * main host data
16889 */
16890
16891 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16892
16893 device_param->pws_buf = pws_buf;
16894
16895 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16896
16897 device_param->combs_buf = combs_buf;
16898
16899 void *hooks_buf = mymalloc (size_hooks);
16900
16901 device_param->hooks_buf = hooks_buf;
16902
16903 /**
16904 * kernel args
16905 */
16906
16907 device_param->kernel_params_buf32[24] = bitmap_mask;
16908 device_param->kernel_params_buf32[25] = bitmap_shift1;
16909 device_param->kernel_params_buf32[26] = bitmap_shift2;
16910 device_param->kernel_params_buf32[27] = 0; // salt_pos
16911 device_param->kernel_params_buf32[28] = 0; // loop_pos
16912 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16913 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16914 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16915 device_param->kernel_params_buf32[32] = 0; // digests_offset
16916 device_param->kernel_params_buf32[33] = 0; // combs_mode
16917 device_param->kernel_params_buf32[34] = 0; // gid_max
16918
16919 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16920 ? &device_param->d_pws_buf
16921 : &device_param->d_pws_amp_buf;
16922 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16923 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16924 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16925 device_param->kernel_params[ 4] = &device_param->d_tmps;
16926 device_param->kernel_params[ 5] = &device_param->d_hooks;
16927 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16928 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16929 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16930 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16931 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16932 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16933 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16934 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16935 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16936 device_param->kernel_params[15] = &device_param->d_digests_buf;
16937 device_param->kernel_params[16] = &device_param->d_digests_shown;
16938 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16939 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16940 device_param->kernel_params[19] = &device_param->d_result;
16941 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16942 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16943 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16944 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16945 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16946 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16947 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16948 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16949 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16950 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16951 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16952 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16953 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16954 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16955 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16956
16957 device_param->kernel_params_mp_buf64[3] = 0;
16958 device_param->kernel_params_mp_buf32[4] = 0;
16959 device_param->kernel_params_mp_buf32[5] = 0;
16960 device_param->kernel_params_mp_buf32[6] = 0;
16961 device_param->kernel_params_mp_buf32[7] = 0;
16962 device_param->kernel_params_mp_buf32[8] = 0;
16963
16964 device_param->kernel_params_mp[0] = NULL;
16965 device_param->kernel_params_mp[1] = NULL;
16966 device_param->kernel_params_mp[2] = NULL;
16967 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16968 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16969 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16970 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16971 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16972 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16973
16974 device_param->kernel_params_mp_l_buf64[3] = 0;
16975 device_param->kernel_params_mp_l_buf32[4] = 0;
16976 device_param->kernel_params_mp_l_buf32[5] = 0;
16977 device_param->kernel_params_mp_l_buf32[6] = 0;
16978 device_param->kernel_params_mp_l_buf32[7] = 0;
16979 device_param->kernel_params_mp_l_buf32[8] = 0;
16980 device_param->kernel_params_mp_l_buf32[9] = 0;
16981
16982 device_param->kernel_params_mp_l[0] = NULL;
16983 device_param->kernel_params_mp_l[1] = NULL;
16984 device_param->kernel_params_mp_l[2] = NULL;
16985 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16986 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16987 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16988 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16989 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16990 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16991 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16992
16993 device_param->kernel_params_mp_r_buf64[3] = 0;
16994 device_param->kernel_params_mp_r_buf32[4] = 0;
16995 device_param->kernel_params_mp_r_buf32[5] = 0;
16996 device_param->kernel_params_mp_r_buf32[6] = 0;
16997 device_param->kernel_params_mp_r_buf32[7] = 0;
16998 device_param->kernel_params_mp_r_buf32[8] = 0;
16999
17000 device_param->kernel_params_mp_r[0] = NULL;
17001 device_param->kernel_params_mp_r[1] = NULL;
17002 device_param->kernel_params_mp_r[2] = NULL;
17003 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
17004 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
17005 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
17006 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
17007 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
17008 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
17009
17010 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
17011 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
17012
17013 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
17014 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
17015 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
17016 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
17017 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
17018 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
17019 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
17020
17021 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
17022 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
17023
17024 device_param->kernel_params_memset_buf32[1] = 0; // value
17025 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
17026
17027 device_param->kernel_params_memset[0] = NULL;
17028 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
17029 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
17030
17031 /**
17032 * kernel name
17033 */
17034
17035 size_t kernel_wgs_tmp;
17036
17037 char kernel_name[64] = { 0 };
17038
17039 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17040 {
17041 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17042 {
17043 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
17044
17045 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17046
17047 if (CL_err != CL_SUCCESS)
17048 {
17049 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17050
17051 return -1;
17052 }
17053
17054 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
17055
17056 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17057
17058 if (CL_err != CL_SUCCESS)
17059 {
17060 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17061
17062 return -1;
17063 }
17064
17065 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
17066
17067 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17068
17069 if (CL_err != CL_SUCCESS)
17070 {
17071 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17072
17073 return -1;
17074 }
17075 }
17076 else
17077 {
17078 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
17079
17080 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17081
17082 if (CL_err != CL_SUCCESS)
17083 {
17084 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17085
17086 return -1;
17087 }
17088
17089 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
17090
17091 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17092
17093 if (CL_err != CL_SUCCESS)
17094 {
17095 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17096
17097 return -1;
17098 }
17099
17100 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
17101
17102 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17103
17104 if (CL_err != CL_SUCCESS)
17105 {
17106 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17107
17108 return -1;
17109 }
17110 }
17111
17112 if (data.attack_mode == ATTACK_MODE_BF)
17113 {
17114 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17115 {
17116 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
17117
17118 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel_tm);
17119
17120 if (CL_err != CL_SUCCESS)
17121 {
17122 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17123
17124 return -1;
17125 }
17126
17127 CL_err = 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);
17128
17129 if (CL_err != CL_SUCCESS)
17130 {
17131 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17132
17133 return -1;
17134 }
17135 }
17136 }
17137 }
17138 else
17139 {
17140 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
17141
17142 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17143
17144 if (CL_err != CL_SUCCESS)
17145 {
17146 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17147
17148 return -1;
17149 }
17150
17151 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
17152
17153 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17154
17155 if (CL_err != CL_SUCCESS)
17156 {
17157 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17158
17159 return -1;
17160 }
17161
17162 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
17163
17164 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17165
17166 if (CL_err != CL_SUCCESS)
17167 {
17168 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17169
17170 return -1;
17171 }
17172
17173 if (opts_type & OPTS_TYPE_HOOK12)
17174 {
17175 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
17176
17177 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel12);
17178
17179 if (CL_err != CL_SUCCESS)
17180 {
17181 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17182
17183 return -1;
17184 }
17185
17186 CL_err = 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);
17187
17188 if (CL_err != CL_SUCCESS)
17189 {
17190 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17191
17192 return -1;
17193 }
17194 }
17195
17196 if (opts_type & OPTS_TYPE_HOOK23)
17197 {
17198 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
17199
17200 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel23);
17201
17202 if (CL_err != CL_SUCCESS)
17203 {
17204 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17205
17206 return -1;
17207 }
17208
17209 CL_err = 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);
17210
17211 if (CL_err != CL_SUCCESS)
17212 {
17213 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17214
17215 return -1;
17216 }
17217 }
17218 }
17219
17220 CL_err |= 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);
17221 CL_err |= 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);
17222 CL_err |= 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);
17223
17224 if (CL_err != CL_SUCCESS)
17225 {
17226 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17227
17228 return -1;
17229 }
17230
17231 for (uint i = 0; i <= 23; i++)
17232 {
17233 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
17234 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
17235 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
17236
17237 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
17238 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
17239
17240 if (CL_err != CL_SUCCESS)
17241 {
17242 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17243
17244 return -1;
17245 }
17246 }
17247
17248 for (uint i = 24; i <= 34; i++)
17249 {
17250 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
17251 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
17252 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
17253
17254 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
17255 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
17256
17257 if (CL_err != CL_SUCCESS)
17258 {
17259 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17260
17261 return -1;
17262 }
17263 }
17264
17265 // GPU memset
17266
17267 CL_err = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset", &device_param->kernel_memset);
17268
17269 if (CL_err != CL_SUCCESS)
17270 {
17271 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17272
17273 return -1;
17274 }
17275
17276 CL_err = 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);
17277
17278 if (CL_err != CL_SUCCESS)
17279 {
17280 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17281
17282 return -1;
17283 }
17284
17285 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
17286 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
17287 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
17288
17289 if (CL_err != CL_SUCCESS)
17290 {
17291 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17292
17293 return -1;
17294 }
17295
17296 // MP start
17297
17298 if (attack_mode == ATTACK_MODE_BF)
17299 {
17300 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov", &device_param->kernel_mp_l);
17301 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov", &device_param->kernel_mp_r);
17302
17303 if (CL_err != CL_SUCCESS)
17304 {
17305 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17306
17307 return -1;
17308 }
17309
17310 CL_err |= 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);
17311 CL_err |= 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);
17312
17313 if (CL_err != CL_SUCCESS)
17314 {
17315 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17316
17317 return -1;
17318 }
17319
17320 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17321 {
17322 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
17323 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
17324
17325 if (CL_err != CL_SUCCESS)
17326 {
17327 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17328
17329 return -1;
17330 }
17331 }
17332 }
17333 else if (attack_mode == ATTACK_MODE_HYBRID1)
17334 {
17335 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17336
17337 if (CL_err != CL_SUCCESS)
17338 {
17339 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17340
17341 return -1;
17342 }
17343
17344 CL_err = 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);
17345
17346 if (CL_err != CL_SUCCESS)
17347 {
17348 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17349
17350 return -1;
17351 }
17352 }
17353 else if (attack_mode == ATTACK_MODE_HYBRID2)
17354 {
17355 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17356
17357 if (CL_err != CL_SUCCESS)
17358 {
17359 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17360
17361 return -1;
17362 }
17363
17364 CL_err = 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);
17365
17366 if (CL_err != CL_SUCCESS)
17367 {
17368 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17369
17370 return -1;
17371 }
17372 }
17373
17374 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17375 {
17376 // nothing to do
17377 }
17378 else
17379 {
17380 CL_err = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp", &device_param->kernel_amp);
17381
17382 if (CL_err != CL_SUCCESS)
17383 {
17384 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17385
17386 return -1;
17387 }
17388
17389 CL_err = 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);
17390
17391 if (CL_err != CL_SUCCESS)
17392 {
17393 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17394
17395 return -1;
17396 }
17397 }
17398
17399 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17400 {
17401 // nothing to do
17402 }
17403 else
17404 {
17405 for (uint i = 0; i < 5; i++)
17406 {
17407 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
17408
17409 if (CL_err != CL_SUCCESS)
17410 {
17411 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17412
17413 return -1;
17414 }
17415 }
17416
17417 for (uint i = 5; i < 7; i++)
17418 {
17419 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
17420
17421 if (CL_err != CL_SUCCESS)
17422 {
17423 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17424
17425 return -1;
17426 }
17427 }
17428 }
17429
17430 // maybe this has been updated by clGetKernelWorkGroupInfo()
17431 // value can only be decreased, so we don't need to reallocate buffers
17432
17433 device_param->kernel_threads = kernel_threads;
17434
17435 // zero some data buffers
17436
17437 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
17438 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
17439 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
17440 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
17441 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
17442 run_kernel_bzero (device_param, device_param->d_result, size_results);
17443
17444 /**
17445 * special buffers
17446 */
17447
17448 if (attack_kern == ATTACK_KERN_STRAIGHT)
17449 {
17450 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
17451 }
17452 else if (attack_kern == ATTACK_KERN_COMBI)
17453 {
17454 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
17455 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
17456 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17457 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17458 }
17459 else if (attack_kern == ATTACK_KERN_BF)
17460 {
17461 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
17462 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
17463 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
17464 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17465 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17466 }
17467
17468 #if defined(HAVE_HWMON)
17469
17470 /**
17471 * Store initial fanspeed if gpu_temp_retain is enabled
17472 */
17473
17474 if (gpu_temp_disable == 0)
17475 {
17476 if (gpu_temp_retain != 0)
17477 {
17478 hc_thread_mutex_lock (mux_adl);
17479
17480 if (data.hm_device[device_id].fan_get_supported == 1)
17481 {
17482 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
17483 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
17484
17485 // we also set it to tell the OS we take control over the fan and it's automatic controller
17486 // if it was set to automatic. we do not control user-defined fanspeeds.
17487
17488 if (fanpolicy == 1)
17489 {
17490 data.hm_device[device_id].fan_set_supported = 1;
17491
17492 int rc = -1;
17493
17494 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17495 {
17496 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
17497 }
17498 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17499 {
17500 #ifdef __linux__
17501 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
17502 #endif
17503
17504 #ifdef WIN
17505 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
17506 #endif
17507 }
17508
17509 if (rc == 0)
17510 {
17511 data.hm_device[device_id].fan_set_supported = 1;
17512 }
17513 else
17514 {
17515 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
17516
17517 data.hm_device[device_id].fan_set_supported = 0;
17518 }
17519 }
17520 else
17521 {
17522 data.hm_device[device_id].fan_set_supported = 0;
17523 }
17524 }
17525
17526 hc_thread_mutex_unlock (mux_adl);
17527 }
17528 }
17529
17530 #endif // HAVE_HWMON
17531 }
17532
17533 if (data.quiet == 0) log_info_nn ("");
17534
17535 /**
17536 * In benchmark-mode, inform user which algorithm is checked
17537 */
17538
17539 if (benchmark == 1)
17540 {
17541 if (machine_readable == 0)
17542 {
17543 quiet = 0;
17544
17545 data.quiet = quiet;
17546
17547 char *hash_type = strhashtype (data.hash_mode); // not a bug
17548
17549 log_info ("Hashtype: %s", hash_type);
17550 log_info ("");
17551 }
17552 }
17553
17554 /**
17555 * keep track of the progress
17556 */
17557
17558 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17559 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17560 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17561
17562 /**
17563 * open filehandles
17564 */
17565
17566 #if _WIN
17567 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
17568 {
17569 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
17570
17571 return -1;
17572 }
17573
17574 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
17575 {
17576 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
17577
17578 return -1;
17579 }
17580
17581 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
17582 {
17583 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
17584
17585 return -1;
17586 }
17587 #endif
17588
17589 /**
17590 * dictionary pad
17591 */
17592
17593 segment_size *= (1024 * 1024);
17594
17595 data.segment_size = segment_size;
17596
17597 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
17598
17599 wl_data->buf = (char *) mymalloc (segment_size);
17600 wl_data->avail = segment_size;
17601 wl_data->incr = segment_size;
17602 wl_data->cnt = 0;
17603 wl_data->pos = 0;
17604
17605 cs_t *css_buf = NULL;
17606 uint css_cnt = 0;
17607 uint dictcnt = 0;
17608 uint maskcnt = 1;
17609 char **masks = NULL;
17610 char **dictfiles = NULL;
17611
17612 uint mask_from_file = 0;
17613
17614 if (attack_mode == ATTACK_MODE_STRAIGHT)
17615 {
17616 if (wordlist_mode == WL_MODE_FILE)
17617 {
17618 int wls_left = myargc - (optind + 1);
17619
17620 for (int i = 0; i < wls_left; i++)
17621 {
17622 char *l0_filename = myargv[optind + 1 + i];
17623
17624 struct stat l0_stat;
17625
17626 if (stat (l0_filename, &l0_stat) == -1)
17627 {
17628 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
17629
17630 return -1;
17631 }
17632
17633 uint is_dir = S_ISDIR (l0_stat.st_mode);
17634
17635 if (is_dir == 0)
17636 {
17637 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17638
17639 dictcnt++;
17640
17641 dictfiles[dictcnt - 1] = l0_filename;
17642 }
17643 else
17644 {
17645 // do not allow --keyspace w/ a directory
17646
17647 if (keyspace == 1)
17648 {
17649 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17650
17651 return -1;
17652 }
17653
17654 char **dictionary_files = NULL;
17655
17656 dictionary_files = scan_directory (l0_filename);
17657
17658 if (dictionary_files != NULL)
17659 {
17660 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17661
17662 for (int d = 0; dictionary_files[d] != NULL; d++)
17663 {
17664 char *l1_filename = dictionary_files[d];
17665
17666 struct stat l1_stat;
17667
17668 if (stat (l1_filename, &l1_stat) == -1)
17669 {
17670 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17671
17672 return -1;
17673 }
17674
17675 if (S_ISREG (l1_stat.st_mode))
17676 {
17677 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17678
17679 dictcnt++;
17680
17681 dictfiles[dictcnt - 1] = strdup (l1_filename);
17682 }
17683 }
17684 }
17685
17686 local_free (dictionary_files);
17687 }
17688 }
17689
17690 if (dictcnt < 1)
17691 {
17692 log_error ("ERROR: No usable dictionary file found.");
17693
17694 return -1;
17695 }
17696 }
17697 else if (wordlist_mode == WL_MODE_STDIN)
17698 {
17699 dictcnt = 1;
17700 }
17701 }
17702 else if (attack_mode == ATTACK_MODE_COMBI)
17703 {
17704 // display
17705
17706 char *dictfile1 = myargv[optind + 1 + 0];
17707 char *dictfile2 = myargv[optind + 1 + 1];
17708
17709 // find the bigger dictionary and use as base
17710
17711 FILE *fp1 = NULL;
17712 FILE *fp2 = NULL;
17713
17714 struct stat tmp_stat;
17715
17716 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
17717 {
17718 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17719
17720 return -1;
17721 }
17722
17723 if (stat (dictfile1, &tmp_stat) == -1)
17724 {
17725 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17726
17727 fclose (fp1);
17728
17729 return -1;
17730 }
17731
17732 if (S_ISDIR (tmp_stat.st_mode))
17733 {
17734 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
17735
17736 fclose (fp1);
17737
17738 return -1;
17739 }
17740
17741 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
17742 {
17743 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17744
17745 fclose (fp1);
17746
17747 return -1;
17748 }
17749
17750 if (stat (dictfile2, &tmp_stat) == -1)
17751 {
17752 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17753
17754 fclose (fp1);
17755 fclose (fp2);
17756
17757 return -1;
17758 }
17759
17760 if (S_ISDIR (tmp_stat.st_mode))
17761 {
17762 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
17763
17764 fclose (fp1);
17765 fclose (fp2);
17766
17767 return -1;
17768 }
17769
17770 data.combs_cnt = 1;
17771
17772 data.quiet = 1;
17773
17774 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
17775
17776 data.quiet = quiet;
17777
17778 if (words1_cnt == 0)
17779 {
17780 log_error ("ERROR: %s: empty file", dictfile1);
17781
17782 fclose (fp1);
17783 fclose (fp2);
17784
17785 return -1;
17786 }
17787
17788 data.combs_cnt = 1;
17789
17790 data.quiet = 1;
17791
17792 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
17793
17794 data.quiet = quiet;
17795
17796 if (words2_cnt == 0)
17797 {
17798 log_error ("ERROR: %s: empty file", dictfile2);
17799
17800 fclose (fp1);
17801 fclose (fp2);
17802
17803 return -1;
17804 }
17805
17806 fclose (fp1);
17807 fclose (fp2);
17808
17809 data.dictfile = dictfile1;
17810 data.dictfile2 = dictfile2;
17811
17812 if (words1_cnt >= words2_cnt)
17813 {
17814 data.combs_cnt = words2_cnt;
17815 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
17816
17817 dictfiles = &data.dictfile;
17818
17819 dictcnt = 1;
17820 }
17821 else
17822 {
17823 data.combs_cnt = words1_cnt;
17824 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17825
17826 dictfiles = &data.dictfile2;
17827
17828 dictcnt = 1;
17829
17830 // we also have to switch wordlist related rules!
17831
17832 char *tmpc = data.rule_buf_l;
17833
17834 data.rule_buf_l = data.rule_buf_r;
17835 data.rule_buf_r = tmpc;
17836
17837 int tmpi = data.rule_len_l;
17838
17839 data.rule_len_l = data.rule_len_r;
17840 data.rule_len_r = tmpi;
17841 }
17842 }
17843 else if (attack_mode == ATTACK_MODE_BF)
17844 {
17845 char *mask = NULL;
17846
17847 maskcnt = 0;
17848
17849 if (benchmark == 0)
17850 {
17851 mask = myargv[optind + 1];
17852
17853 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
17854
17855 if ((optind + 2) <= myargc)
17856 {
17857 struct stat file_stat;
17858
17859 if (stat (mask, &file_stat) == -1)
17860 {
17861 maskcnt = 1;
17862
17863 masks[maskcnt - 1] = mystrdup (mask);
17864 }
17865 else
17866 {
17867 int wls_left = myargc - (optind + 1);
17868
17869 uint masks_avail = INCR_MASKS;
17870
17871 for (int i = 0; i < wls_left; i++)
17872 {
17873 if (i != 0)
17874 {
17875 mask = myargv[optind + 1 + i];
17876
17877 if (stat (mask, &file_stat) == -1)
17878 {
17879 log_error ("ERROR: %s: %s", mask, strerror (errno));
17880
17881 return -1;
17882 }
17883 }
17884
17885 uint is_file = S_ISREG (file_stat.st_mode);
17886
17887 if (is_file == 1)
17888 {
17889 FILE *mask_fp;
17890
17891 if ((mask_fp = fopen (mask, "r")) == NULL)
17892 {
17893 log_error ("ERROR: %s: %s", mask, strerror (errno));
17894
17895 return -1;
17896 }
17897
17898 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17899
17900 while (!feof (mask_fp))
17901 {
17902 memset (line_buf, 0, HCBUFSIZ);
17903
17904 int line_len = fgetl (mask_fp, line_buf);
17905
17906 if (line_len == 0) continue;
17907
17908 if (line_buf[0] == '#') continue;
17909
17910 if (masks_avail == maskcnt)
17911 {
17912 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17913
17914 masks_avail += INCR_MASKS;
17915 }
17916
17917 masks[maskcnt] = mystrdup (line_buf);
17918
17919 maskcnt++;
17920 }
17921
17922 myfree (line_buf);
17923
17924 fclose (mask_fp);
17925 }
17926 else
17927 {
17928 log_error ("ERROR: %s: unsupported file-type", mask);
17929
17930 return -1;
17931 }
17932 }
17933
17934 mask_from_file = 1;
17935 }
17936 }
17937 else
17938 {
17939 custom_charset_1 = (char *) "?l?d?u";
17940 custom_charset_2 = (char *) "?l?d";
17941 custom_charset_3 = (char *) "?l?d*!$@_";
17942
17943 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17944 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17945 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17946
17947 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
17948
17949 wordlist_mode = WL_MODE_MASK;
17950
17951 data.wordlist_mode = wordlist_mode;
17952
17953 increment = 1;
17954
17955 maskcnt = 1;
17956 }
17957 }
17958 else
17959 {
17960 /**
17961 * generate full masks and charsets
17962 */
17963
17964 masks = (char **) mymalloc (sizeof (char *));
17965
17966 switch (hash_mode)
17967 {
17968 case 1731: pw_min = 5;
17969 pw_max = 5;
17970 mask = mystrdup ("?b?b?b?b?b");
17971 break;
17972 case 12500: pw_min = 5;
17973 pw_max = 5;
17974 mask = mystrdup ("?b?b?b?b?b");
17975 break;
17976 default: pw_min = 7;
17977 pw_max = 7;
17978 mask = mystrdup ("?b?b?b?b?b?b?b");
17979 break;
17980 }
17981
17982 maskcnt = 1;
17983
17984 masks[maskcnt - 1] = mystrdup (mask);
17985
17986 wordlist_mode = WL_MODE_MASK;
17987
17988 data.wordlist_mode = wordlist_mode;
17989
17990 increment = 1;
17991 }
17992
17993 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
17994
17995 if (increment)
17996 {
17997 if (increment_min > pw_min) pw_min = increment_min;
17998
17999 if (increment_max < pw_max) pw_max = increment_max;
18000 }
18001 }
18002 else if (attack_mode == ATTACK_MODE_HYBRID1)
18003 {
18004 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
18005
18006 // display
18007
18008 char *mask = myargv[myargc - 1];
18009
18010 maskcnt = 0;
18011
18012 masks = (char **) mymalloc (1 * sizeof (char *));
18013
18014 // mod
18015
18016 struct stat file_stat;
18017
18018 if (stat (mask, &file_stat) == -1)
18019 {
18020 maskcnt = 1;
18021
18022 masks[maskcnt - 1] = mystrdup (mask);
18023 }
18024 else
18025 {
18026 uint is_file = S_ISREG (file_stat.st_mode);
18027
18028 if (is_file == 1)
18029 {
18030 FILE *mask_fp;
18031
18032 if ((mask_fp = fopen (mask, "r")) == NULL)
18033 {
18034 log_error ("ERROR: %s: %s", mask, strerror (errno));
18035
18036 return -1;
18037 }
18038
18039 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18040
18041 uint masks_avail = 1;
18042
18043 while (!feof (mask_fp))
18044 {
18045 memset (line_buf, 0, HCBUFSIZ);
18046
18047 int line_len = fgetl (mask_fp, line_buf);
18048
18049 if (line_len == 0) continue;
18050
18051 if (line_buf[0] == '#') continue;
18052
18053 if (masks_avail == maskcnt)
18054 {
18055 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18056
18057 masks_avail += INCR_MASKS;
18058 }
18059
18060 masks[maskcnt] = mystrdup (line_buf);
18061
18062 maskcnt++;
18063 }
18064
18065 myfree (line_buf);
18066
18067 fclose (mask_fp);
18068
18069 mask_from_file = 1;
18070 }
18071 else
18072 {
18073 maskcnt = 1;
18074
18075 masks[maskcnt - 1] = mystrdup (mask);
18076 }
18077 }
18078
18079 // base
18080
18081 int wls_left = myargc - (optind + 2);
18082
18083 for (int i = 0; i < wls_left; i++)
18084 {
18085 char *filename = myargv[optind + 1 + i];
18086
18087 struct stat file_stat;
18088
18089 if (stat (filename, &file_stat) == -1)
18090 {
18091 log_error ("ERROR: %s: %s", filename, strerror (errno));
18092
18093 return -1;
18094 }
18095
18096 uint is_dir = S_ISDIR (file_stat.st_mode);
18097
18098 if (is_dir == 0)
18099 {
18100 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18101
18102 dictcnt++;
18103
18104 dictfiles[dictcnt - 1] = filename;
18105 }
18106 else
18107 {
18108 // do not allow --keyspace w/ a directory
18109
18110 if (keyspace == 1)
18111 {
18112 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18113
18114 return -1;
18115 }
18116
18117 char **dictionary_files = NULL;
18118
18119 dictionary_files = scan_directory (filename);
18120
18121 if (dictionary_files != NULL)
18122 {
18123 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18124
18125 for (int d = 0; dictionary_files[d] != NULL; d++)
18126 {
18127 char *l1_filename = dictionary_files[d];
18128
18129 struct stat l1_stat;
18130
18131 if (stat (l1_filename, &l1_stat) == -1)
18132 {
18133 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18134
18135 return -1;
18136 }
18137
18138 if (S_ISREG (l1_stat.st_mode))
18139 {
18140 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18141
18142 dictcnt++;
18143
18144 dictfiles[dictcnt - 1] = strdup (l1_filename);
18145 }
18146 }
18147 }
18148
18149 local_free (dictionary_files);
18150 }
18151 }
18152
18153 if (dictcnt < 1)
18154 {
18155 log_error ("ERROR: No usable dictionary file found.");
18156
18157 return -1;
18158 }
18159
18160 if (increment)
18161 {
18162 maskcnt = 0;
18163
18164 uint mask_min = increment_min; // we can't reject smaller masks here
18165 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18166
18167 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18168 {
18169 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18170
18171 if (cur_mask == NULL) break;
18172
18173 masks[maskcnt] = cur_mask;
18174
18175 maskcnt++;
18176
18177 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18178 }
18179 }
18180 }
18181 else if (attack_mode == ATTACK_MODE_HYBRID2)
18182 {
18183 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
18184
18185 // display
18186
18187 char *mask = myargv[optind + 1 + 0];
18188
18189 maskcnt = 0;
18190
18191 masks = (char **) mymalloc (1 * sizeof (char *));
18192
18193 // mod
18194
18195 struct stat file_stat;
18196
18197 if (stat (mask, &file_stat) == -1)
18198 {
18199 maskcnt = 1;
18200
18201 masks[maskcnt - 1] = mystrdup (mask);
18202 }
18203 else
18204 {
18205 uint is_file = S_ISREG (file_stat.st_mode);
18206
18207 if (is_file == 1)
18208 {
18209 FILE *mask_fp;
18210
18211 if ((mask_fp = fopen (mask, "r")) == NULL)
18212 {
18213 log_error ("ERROR: %s: %s", mask, strerror (errno));
18214
18215 return -1;
18216 }
18217
18218 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18219
18220 uint masks_avail = 1;
18221
18222 while (!feof (mask_fp))
18223 {
18224 memset (line_buf, 0, HCBUFSIZ);
18225
18226 int line_len = fgetl (mask_fp, line_buf);
18227
18228 if (line_len == 0) continue;
18229
18230 if (line_buf[0] == '#') continue;
18231
18232 if (masks_avail == maskcnt)
18233 {
18234 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18235
18236 masks_avail += INCR_MASKS;
18237 }
18238
18239 masks[maskcnt] = mystrdup (line_buf);
18240
18241 maskcnt++;
18242 }
18243
18244 myfree (line_buf);
18245
18246 fclose (mask_fp);
18247
18248 mask_from_file = 1;
18249 }
18250 else
18251 {
18252 maskcnt = 1;
18253
18254 masks[maskcnt - 1] = mystrdup (mask);
18255 }
18256 }
18257
18258 // base
18259
18260 int wls_left = myargc - (optind + 2);
18261
18262 for (int i = 0; i < wls_left; i++)
18263 {
18264 char *filename = myargv[optind + 2 + i];
18265
18266 struct stat file_stat;
18267
18268 if (stat (filename, &file_stat) == -1)
18269 {
18270 log_error ("ERROR: %s: %s", filename, strerror (errno));
18271
18272 return -1;
18273 }
18274
18275 uint is_dir = S_ISDIR (file_stat.st_mode);
18276
18277 if (is_dir == 0)
18278 {
18279 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18280
18281 dictcnt++;
18282
18283 dictfiles[dictcnt - 1] = filename;
18284 }
18285 else
18286 {
18287 // do not allow --keyspace w/ a directory
18288
18289 if (keyspace == 1)
18290 {
18291 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18292
18293 return -1;
18294 }
18295
18296 char **dictionary_files = NULL;
18297
18298 dictionary_files = scan_directory (filename);
18299
18300 if (dictionary_files != NULL)
18301 {
18302 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18303
18304 for (int d = 0; dictionary_files[d] != NULL; d++)
18305 {
18306 char *l1_filename = dictionary_files[d];
18307
18308 struct stat l1_stat;
18309
18310 if (stat (l1_filename, &l1_stat) == -1)
18311 {
18312 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18313
18314 return -1;
18315 }
18316
18317 if (S_ISREG (l1_stat.st_mode))
18318 {
18319 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18320
18321 dictcnt++;
18322
18323 dictfiles[dictcnt - 1] = strdup (l1_filename);
18324 }
18325 }
18326 }
18327
18328 local_free (dictionary_files);
18329 }
18330 }
18331
18332 if (dictcnt < 1)
18333 {
18334 log_error ("ERROR: No usable dictionary file found.");
18335
18336 return -1;
18337 }
18338
18339 if (increment)
18340 {
18341 maskcnt = 0;
18342
18343 uint mask_min = increment_min; // we can't reject smaller masks here
18344 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18345
18346 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18347 {
18348 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18349
18350 if (cur_mask == NULL) break;
18351
18352 masks[maskcnt] = cur_mask;
18353
18354 maskcnt++;
18355
18356 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18357 }
18358 }
18359 }
18360
18361 data.pw_min = pw_min;
18362 data.pw_max = pw_max;
18363
18364 /**
18365 * weak hash check
18366 */
18367
18368 if (weak_hash_threshold >= salts_cnt)
18369 {
18370 hc_device_param_t *device_param = NULL;
18371
18372 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18373 {
18374 device_param = &data.devices_param[device_id];
18375
18376 if (device_param->skipped) continue;
18377
18378 break;
18379 }
18380
18381 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
18382
18383 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
18384 {
18385 weak_hash_check (device_param, salt_pos);
18386 }
18387
18388 // Display hack, guarantee that there is at least one \r before real start
18389
18390 //if (data.quiet == 0) log_info ("");
18391 }
18392
18393 /**
18394 * status and monitor threads
18395 */
18396
18397 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18398 {
18399 data.devices_status = STATUS_STARTING;
18400 }
18401
18402 uint inner_threads_cnt = 0;
18403
18404 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
18405
18406 data.shutdown_inner = 0;
18407
18408 /**
18409 * Outfile remove
18410 */
18411
18412 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
18413 {
18414 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
18415
18416 inner_threads_cnt++;
18417
18418 if (outfile_check_timer != 0)
18419 {
18420 if (data.outfile_check_directory != NULL)
18421 {
18422 if ((hash_mode != 5200) &&
18423 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
18424 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
18425 (hash_mode != 9000))
18426 {
18427 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
18428
18429 inner_threads_cnt++;
18430 }
18431 else
18432 {
18433 outfile_check_timer = 0;
18434 }
18435 }
18436 else
18437 {
18438 outfile_check_timer = 0;
18439 }
18440 }
18441 }
18442
18443 /**
18444 * Inform the user if we got some hashes remove because of the pot file remove feature
18445 */
18446
18447 if (data.quiet == 0)
18448 {
18449 if (potfile_remove_cracks > 0)
18450 {
18451 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
18452 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
18453 }
18454 }
18455
18456 data.outfile_check_timer = outfile_check_timer;
18457
18458 /**
18459 * main loop
18460 */
18461
18462 char **induction_dictionaries = NULL;
18463
18464 int induction_dictionaries_cnt = 0;
18465
18466 hcstat_table_t *root_table_buf = NULL;
18467 hcstat_table_t *markov_table_buf = NULL;
18468
18469 uint initial_restore_done = 0;
18470
18471 data.maskcnt = maskcnt;
18472
18473 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
18474 {
18475 if (data.devices_status == STATUS_CRACKED) continue;
18476 if (data.devices_status == STATUS_ABORTED) continue;
18477 if (data.devices_status == STATUS_QUIT) continue;
18478
18479 if (maskpos > rd->maskpos)
18480 {
18481 rd->dictpos = 0;
18482 }
18483
18484 rd->maskpos = maskpos;
18485 data.maskpos = maskpos;
18486
18487 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
18488 {
18489 char *mask = masks[maskpos];
18490
18491 if (mask_from_file == 1)
18492 {
18493 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
18494
18495 char *str_ptr;
18496 uint str_pos;
18497
18498 uint mask_offset = 0;
18499
18500 uint separator_cnt;
18501
18502 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
18503 {
18504 str_ptr = strstr (mask + mask_offset, ",");
18505
18506 if (str_ptr == NULL) break;
18507
18508 str_pos = str_ptr - mask;
18509
18510 // escaped separator, i.e. "\,"
18511
18512 if (str_pos > 0)
18513 {
18514 if (mask[str_pos - 1] == '\\')
18515 {
18516 separator_cnt --;
18517
18518 mask_offset = str_pos + 1;
18519
18520 continue;
18521 }
18522 }
18523
18524 // reset the offset
18525
18526 mask_offset = 0;
18527
18528 mask[str_pos] = '\0';
18529
18530 switch (separator_cnt)
18531 {
18532 case 0:
18533 mp_reset_usr (mp_usr, 0);
18534
18535 custom_charset_1 = mask;
18536 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
18537 break;
18538
18539 case 1:
18540 mp_reset_usr (mp_usr, 1);
18541
18542 custom_charset_2 = mask;
18543 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
18544 break;
18545
18546 case 2:
18547 mp_reset_usr (mp_usr, 2);
18548
18549 custom_charset_3 = mask;
18550 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
18551 break;
18552
18553 case 3:
18554 mp_reset_usr (mp_usr, 3);
18555
18556 custom_charset_4 = mask;
18557 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
18558 break;
18559 }
18560
18561 mask = mask + str_pos + 1;
18562 }
18563
18564 /**
18565 * What follows is a very special case where "\," is within the mask field of a line in a .hcmask file only because otherwise (without the "\")
18566 * it would be interpreted as a custom charset definition.
18567 *
18568 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
18569 * Note: "\\" is not needed to replace all "\" within the mask! The meaning of "\\" within a line containing the string "\\," is just to allow "\" followed by ","
18570 */
18571
18572 uint mask_len_cur = strlen (mask);
18573
18574 uint mask_out_pos = 0;
18575 char mask_prev = 0;
18576
18577 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
18578 {
18579 if (mask[mask_iter] == ',')
18580 {
18581 if (mask_prev == '\\')
18582 {
18583 mask_out_pos -= 1; // this means: skip the previous "\"
18584 }
18585 }
18586
18587 mask_prev = mask[mask_iter];
18588
18589 mask[mask_out_pos] = mask[mask_iter];
18590 }
18591
18592 mask[mask_out_pos] = '\0';
18593 }
18594
18595 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18596 {
18597 if (maskpos > 0)
18598 {
18599 local_free (css_buf);
18600 local_free (data.root_css_buf);
18601 local_free (data.markov_css_buf);
18602
18603 local_free (masks[maskpos - 1]);
18604 }
18605
18606 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18607
18608 data.mask = mask;
18609 data.css_cnt = css_cnt;
18610 data.css_buf = css_buf;
18611
18612 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18613
18614 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18615
18616 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
18617 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18618
18619 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18620
18621 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18622
18623 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18624 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18625
18626 data.root_css_buf = root_css_buf;
18627 data.markov_css_buf = markov_css_buf;
18628
18629 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18630
18631 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18632
18633 local_free (root_table_buf);
18634 local_free (markov_table_buf);
18635
18636 // args
18637
18638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18639 {
18640 hc_device_param_t *device_param = &data.devices_param[device_id];
18641
18642 if (device_param->skipped) continue;
18643
18644 device_param->kernel_params_mp[0] = &device_param->d_combs;
18645 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
18646 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
18647
18648 device_param->kernel_params_mp_buf64[3] = 0;
18649 device_param->kernel_params_mp_buf32[4] = css_cnt;
18650 device_param->kernel_params_mp_buf32[5] = 0;
18651 device_param->kernel_params_mp_buf32[6] = 0;
18652 device_param->kernel_params_mp_buf32[7] = 0;
18653
18654 if (attack_mode == ATTACK_MODE_HYBRID1)
18655 {
18656 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
18657 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
18658 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
18659 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
18660 }
18661 else if (attack_mode == ATTACK_MODE_HYBRID2)
18662 {
18663 device_param->kernel_params_mp_buf32[5] = 0;
18664 device_param->kernel_params_mp_buf32[6] = 0;
18665 device_param->kernel_params_mp_buf32[7] = 0;
18666 }
18667
18668 cl_int CL_err = CL_SUCCESS;
18669
18670 for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
18671 for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
18672 for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
18673
18674 if (CL_err != CL_SUCCESS)
18675 {
18676 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
18677
18678 return -1;
18679 }
18680
18681 CL_err |= 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);
18682 CL_err |= 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);
18683
18684 if (CL_err != CL_SUCCESS)
18685 {
18686 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
18687
18688 return -1;
18689 }
18690 }
18691 }
18692 else if (attack_mode == ATTACK_MODE_BF)
18693 {
18694 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
18695
18696 if (increment)
18697 {
18698 for (uint i = 0; i < dictcnt; i++)
18699 {
18700 local_free (dictfiles[i]);
18701 }
18702
18703 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
18704 {
18705 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
18706
18707 if (l1_filename == NULL) break;
18708
18709 dictcnt++;
18710
18711 dictfiles[dictcnt - 1] = l1_filename;
18712 }
18713 }
18714 else
18715 {
18716 dictcnt++;
18717
18718 dictfiles[dictcnt - 1] = mask;
18719 }
18720
18721 if (dictcnt == 0)
18722 {
18723 log_error ("ERROR: Mask is too small");
18724
18725 return -1;
18726 }
18727 }
18728 }
18729
18730 free (induction_dictionaries);
18731
18732 // induction_dictionaries_cnt = 0; // implied
18733
18734 if (attack_mode != ATTACK_MODE_BF)
18735 {
18736 if (keyspace == 0)
18737 {
18738 induction_dictionaries = scan_directory (induction_directory);
18739
18740 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18741 }
18742 }
18743
18744 if (induction_dictionaries_cnt)
18745 {
18746 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18747 }
18748
18749 /**
18750 * prevent the user from using --keyspace together w/ maskfile and or dictfile
18751 */
18752 if (keyspace == 1)
18753 {
18754 if ((maskcnt > 1) || (dictcnt > 1))
18755 {
18756 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
18757
18758 return -1;
18759 }
18760 }
18761
18762 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
18763 {
18764 if (data.devices_status == STATUS_CRACKED) continue;
18765 if (data.devices_status == STATUS_ABORTED) continue;
18766 if (data.devices_status == STATUS_QUIT) continue;
18767
18768 rd->dictpos = dictpos;
18769
18770 char *subid = logfile_generate_subid ();
18771
18772 data.subid = subid;
18773
18774 logfile_sub_msg ("START");
18775
18776 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18777 {
18778 data.devices_status = STATUS_INIT;
18779 }
18780
18781 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
18782 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
18783 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
18784
18785 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
18786
18787 data.cpt_pos = 0;
18788
18789 data.cpt_start = time (NULL);
18790
18791 data.cpt_total = 0;
18792
18793 if (data.restore == 0)
18794 {
18795 rd->words_cur = skip;
18796
18797 skip = 0;
18798
18799 data.skip = 0;
18800 }
18801
18802 data.ms_paused = 0;
18803
18804 data.kernel_power_final = 0;
18805
18806 data.words_cur = rd->words_cur;
18807
18808 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18809 {
18810 hc_device_param_t *device_param = &data.devices_param[device_id];
18811
18812 if (device_param->skipped) continue;
18813
18814 device_param->speed_pos = 0;
18815
18816 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
18817 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
18818
18819 device_param->exec_pos = 0;
18820
18821 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
18822
18823 device_param->outerloop_pos = 0;
18824 device_param->outerloop_left = 0;
18825 device_param->innerloop_pos = 0;
18826 device_param->innerloop_left = 0;
18827
18828 // some more resets:
18829
18830 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
18831
18832 device_param->pws_cnt = 0;
18833
18834 device_param->words_off = 0;
18835 device_param->words_done = 0;
18836 }
18837
18838 // figure out some workload
18839
18840 if (attack_mode == ATTACK_MODE_STRAIGHT)
18841 {
18842 if (data.wordlist_mode == WL_MODE_FILE)
18843 {
18844 char *dictfile = NULL;
18845
18846 if (induction_dictionaries_cnt)
18847 {
18848 dictfile = induction_dictionaries[0];
18849 }
18850 else
18851 {
18852 dictfile = dictfiles[dictpos];
18853 }
18854
18855 data.dictfile = dictfile;
18856
18857 logfile_sub_string (dictfile);
18858
18859 for (uint i = 0; i < rp_files_cnt; i++)
18860 {
18861 logfile_sub_var_string ("rulefile", rp_files[i]);
18862 }
18863
18864 FILE *fd2 = fopen (dictfile, "rb");
18865
18866 if (fd2 == NULL)
18867 {
18868 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18869
18870 return -1;
18871 }
18872
18873 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18874
18875 fclose (fd2);
18876
18877 if (data.words_cnt == 0)
18878 {
18879 logfile_sub_msg ("STOP");
18880
18881 continue;
18882 }
18883 }
18884 }
18885 else if (attack_mode == ATTACK_MODE_COMBI)
18886 {
18887 char *dictfile = data.dictfile;
18888 char *dictfile2 = data.dictfile2;
18889
18890 logfile_sub_string (dictfile);
18891 logfile_sub_string (dictfile2);
18892
18893 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
18894 {
18895 FILE *fd2 = fopen (dictfile, "rb");
18896
18897 if (fd2 == NULL)
18898 {
18899 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18900
18901 return -1;
18902 }
18903
18904 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18905
18906 fclose (fd2);
18907 }
18908 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
18909 {
18910 FILE *fd2 = fopen (dictfile2, "rb");
18911
18912 if (fd2 == NULL)
18913 {
18914 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
18915
18916 return -1;
18917 }
18918
18919 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
18920
18921 fclose (fd2);
18922 }
18923
18924 if (data.words_cnt == 0)
18925 {
18926 logfile_sub_msg ("STOP");
18927
18928 continue;
18929 }
18930 }
18931 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18932 {
18933 char *dictfile = NULL;
18934
18935 if (induction_dictionaries_cnt)
18936 {
18937 dictfile = induction_dictionaries[0];
18938 }
18939 else
18940 {
18941 dictfile = dictfiles[dictpos];
18942 }
18943
18944 data.dictfile = dictfile;
18945
18946 char *mask = data.mask;
18947
18948 logfile_sub_string (dictfile);
18949 logfile_sub_string (mask);
18950
18951 FILE *fd2 = fopen (dictfile, "rb");
18952
18953 if (fd2 == NULL)
18954 {
18955 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18956
18957 return -1;
18958 }
18959
18960 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18961
18962 fclose (fd2);
18963
18964 if (data.words_cnt == 0)
18965 {
18966 logfile_sub_msg ("STOP");
18967
18968 continue;
18969 }
18970 }
18971 else if (attack_mode == ATTACK_MODE_BF)
18972 {
18973 local_free (css_buf);
18974 local_free (data.root_css_buf);
18975 local_free (data.markov_css_buf);
18976
18977 char *mask = dictfiles[dictpos];
18978
18979 logfile_sub_string (mask);
18980
18981 // base
18982
18983 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18984
18985 if (opts_type & OPTS_TYPE_PT_UNICODE)
18986 {
18987 uint css_cnt_unicode = css_cnt * 2;
18988
18989 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
18990
18991 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
18992 {
18993 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
18994
18995 css_buf_unicode[j + 1].cs_buf[0] = 0;
18996 css_buf_unicode[j + 1].cs_len = 1;
18997 }
18998
18999 free (css_buf);
19000
19001 css_buf = css_buf_unicode;
19002 css_cnt = css_cnt_unicode;
19003 }
19004
19005 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
19006
19007 uint mask_min = pw_min;
19008 uint mask_max = pw_max;
19009
19010 if (opts_type & OPTS_TYPE_PT_UNICODE)
19011 {
19012 mask_min *= 2;
19013 mask_max *= 2;
19014 }
19015
19016 if ((css_cnt < mask_min) || (css_cnt > mask_max))
19017 {
19018 if (css_cnt < mask_min)
19019 {
19020 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
19021 }
19022
19023 if (css_cnt > mask_max)
19024 {
19025 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
19026 }
19027
19028 // skip to next mask
19029
19030 logfile_sub_msg ("STOP");
19031
19032 continue;
19033 }
19034
19035 uint save_css_cnt = css_cnt;
19036
19037 if (opti_type & OPTI_TYPE_SINGLE_HASH)
19038 {
19039 if (opti_type & OPTI_TYPE_APPENDED_SALT)
19040 {
19041 uint salt_len = (uint) data.salts_buf[0].salt_len;
19042 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
19043
19044 uint css_cnt_salt = css_cnt + salt_len;
19045
19046 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
19047
19048 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
19049
19050 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
19051 {
19052 css_buf_salt[j].cs_buf[0] = salt_buf[i];
19053 css_buf_salt[j].cs_len = 1;
19054 }
19055
19056 free (css_buf);
19057
19058 css_buf = css_buf_salt;
19059 css_cnt = css_cnt_salt;
19060 }
19061 }
19062
19063 data.mask = mask;
19064 data.css_cnt = css_cnt;
19065 data.css_buf = css_buf;
19066
19067 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
19068
19069 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
19070
19071 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
19072
19073 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
19074 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
19075
19076 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
19077
19078 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
19079
19080 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
19081 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
19082
19083 data.root_css_buf = root_css_buf;
19084 data.markov_css_buf = markov_css_buf;
19085
19086 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
19087
19088 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
19089
19090 local_free (root_table_buf);
19091 local_free (markov_table_buf);
19092
19093 // copy + args
19094
19095 uint css_cnt_l = css_cnt;
19096 uint css_cnt_r;
19097
19098 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
19099 {
19100 if (save_css_cnt < 6)
19101 {
19102 css_cnt_r = 1;
19103 }
19104 else if (save_css_cnt == 6)
19105 {
19106 css_cnt_r = 2;
19107 }
19108 else
19109 {
19110 if (opts_type & OPTS_TYPE_PT_UNICODE)
19111 {
19112 if (save_css_cnt == 8 || save_css_cnt == 10)
19113 {
19114 css_cnt_r = 2;
19115 }
19116 else
19117 {
19118 css_cnt_r = 4;
19119 }
19120 }
19121 else
19122 {
19123 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
19124 {
19125 css_cnt_r = 3;
19126 }
19127 else
19128 {
19129 css_cnt_r = 4;
19130 }
19131 }
19132 }
19133 }
19134 else
19135 {
19136 css_cnt_r = 1;
19137
19138 /* unfinished code?
19139 int sum = css_buf[css_cnt_r - 1].cs_len;
19140
19141 for (uint i = 1; i < 4 && i < css_cnt; i++)
19142 {
19143 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
19144
19145 css_cnt_r++;
19146
19147 sum *= css_buf[css_cnt_r - 1].cs_len;
19148 }
19149 */
19150 }
19151
19152 css_cnt_l -= css_cnt_r;
19153
19154 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
19155
19156 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19157 {
19158 hc_device_param_t *device_param = &data.devices_param[device_id];
19159
19160 if (device_param->skipped) continue;
19161
19162 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
19163 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
19164 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
19165
19166 device_param->kernel_params_mp_l_buf64[3] = 0;
19167 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
19168 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
19169 device_param->kernel_params_mp_l_buf32[6] = 0;
19170 device_param->kernel_params_mp_l_buf32[7] = 0;
19171 device_param->kernel_params_mp_l_buf32[8] = 0;
19172
19173 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
19174 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
19175 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
19176 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
19177
19178 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
19179 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
19180 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
19181
19182 device_param->kernel_params_mp_r_buf64[3] = 0;
19183 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
19184 device_param->kernel_params_mp_r_buf32[5] = 0;
19185 device_param->kernel_params_mp_r_buf32[6] = 0;
19186 device_param->kernel_params_mp_r_buf32[7] = 0;
19187
19188 cl_int CL_err = CL_SUCCESS;
19189
19190 for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
19191 for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
19192 for (uint i = 4; i < 9; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
19193
19194 for (uint i = 0; i < 3; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
19195 for (uint i = 3; i < 4; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
19196 for (uint i = 4; i < 8; i++) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
19197
19198 if (CL_err != CL_SUCCESS)
19199 {
19200 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
19201
19202 return -1;
19203 }
19204
19205 CL_err |= 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);
19206 CL_err |= 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);
19207
19208 if (CL_err != CL_SUCCESS)
19209 {
19210 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
19211
19212 return -1;
19213 }
19214 }
19215 }
19216
19217 u64 words_base = data.words_cnt;
19218
19219 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19220 {
19221 if (data.kernel_rules_cnt)
19222 {
19223 words_base /= data.kernel_rules_cnt;
19224 }
19225 }
19226 else if (data.attack_kern == ATTACK_KERN_COMBI)
19227 {
19228 if (data.combs_cnt)
19229 {
19230 words_base /= data.combs_cnt;
19231 }
19232 }
19233 else if (data.attack_kern == ATTACK_KERN_BF)
19234 {
19235 if (data.bfs_cnt)
19236 {
19237 words_base /= data.bfs_cnt;
19238 }
19239 }
19240
19241 data.words_base = words_base;
19242
19243 if (keyspace == 1)
19244 {
19245 log_info ("%llu", (unsigned long long int) words_base);
19246
19247 return 0;
19248 }
19249
19250 if (data.words_cur > data.words_base)
19251 {
19252 log_error ("ERROR: Restore value greater keyspace");
19253
19254 return -1;
19255 }
19256
19257 if (data.words_cur)
19258 {
19259 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19260 {
19261 for (uint i = 0; i < data.salts_cnt; i++)
19262 {
19263 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
19264 }
19265 }
19266 else if (data.attack_kern == ATTACK_KERN_COMBI)
19267 {
19268 for (uint i = 0; i < data.salts_cnt; i++)
19269 {
19270 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
19271 }
19272 }
19273 else if (data.attack_kern == ATTACK_KERN_BF)
19274 {
19275 for (uint i = 0; i < data.salts_cnt; i++)
19276 {
19277 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
19278 }
19279 }
19280 }
19281
19282 /*
19283 * Update loopback file
19284 */
19285
19286 if (loopback == 1)
19287 {
19288 time_t now;
19289
19290 time (&now);
19291
19292 uint random_num = get_random_num (0, 9999);
19293
19294 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
19295
19296 data.loopback_file = loopback_file;
19297 }
19298
19299 /*
19300 * Update dictionary statistic
19301 */
19302
19303 if (keyspace == 0)
19304 {
19305 dictstat_fp = fopen (dictstat, "wb");
19306
19307 if (dictstat_fp)
19308 {
19309 lock_file (dictstat_fp);
19310
19311 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
19312
19313 fclose (dictstat_fp);
19314 }
19315 }
19316
19317 /**
19318 * create autotune threads
19319 */
19320
19321 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
19322
19323 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19324 {
19325 data.devices_status = STATUS_AUTOTUNE;
19326 }
19327
19328 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19329 {
19330 hc_device_param_t *device_param = &devices_param[device_id];
19331
19332 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
19333 }
19334
19335 hc_thread_wait (data.devices_cnt, c_threads);
19336
19337 /*
19338 * Inform user about possible slow speeds
19339 */
19340
19341 uint hardware_power_all = 0;
19342
19343 uint kernel_power_all = 0;
19344
19345 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19346 {
19347 hc_device_param_t *device_param = &devices_param[device_id];
19348
19349 hardware_power_all += device_param->hardware_power;
19350
19351 kernel_power_all += device_param->kernel_power;
19352 }
19353
19354 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
19355
19356 data.kernel_power_all = kernel_power_all;
19357
19358 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19359 {
19360 if (data.words_base < kernel_power_all)
19361 {
19362 if (quiet == 0)
19363 {
19364 clear_prompt ();
19365
19366 log_info ("ATTENTION!");
19367 log_info (" The wordlist or mask you are using is too small.");
19368 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
19369 log_info (" The cracking speed will drop.");
19370 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
19371 log_info ("");
19372 }
19373 }
19374 }
19375
19376 /**
19377 * create cracker threads
19378 */
19379
19380 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19381 {
19382 data.devices_status = STATUS_RUNNING;
19383 }
19384
19385 if (initial_restore_done == 0)
19386 {
19387 if (data.restore_disable == 0) cycle_restore ();
19388
19389 initial_restore_done = 1;
19390 }
19391
19392 hc_timer_set (&data.timer_running);
19393
19394 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19395 {
19396 if ((quiet == 0) && (status == 0) && (benchmark == 0))
19397 {
19398 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
19399 if (quiet == 0) fflush (stdout);
19400 }
19401 }
19402 else if (wordlist_mode == WL_MODE_STDIN)
19403 {
19404 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
19405 if (data.quiet == 0) log_info ("");
19406 }
19407
19408 time_t runtime_start;
19409
19410 time (&runtime_start);
19411
19412 data.runtime_start = runtime_start;
19413
19414 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19415 {
19416 hc_device_param_t *device_param = &devices_param[device_id];
19417
19418 if (wordlist_mode == WL_MODE_STDIN)
19419 {
19420 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
19421 }
19422 else
19423 {
19424 hc_thread_create (c_threads[device_id], thread_calc, device_param);
19425 }
19426 }
19427
19428 hc_thread_wait (data.devices_cnt, c_threads);
19429
19430 local_free (c_threads);
19431
19432 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19433 {
19434 data.devices_status = STATUS_EXHAUSTED;
19435 }
19436
19437 logfile_sub_var_uint ("status-after-work", data.devices_status);
19438
19439 data.restore = 0;
19440
19441 if (induction_dictionaries_cnt)
19442 {
19443 unlink (induction_dictionaries[0]);
19444 }
19445
19446 free (induction_dictionaries);
19447
19448 if (attack_mode != ATTACK_MODE_BF)
19449 {
19450 induction_dictionaries = scan_directory (induction_directory);
19451
19452 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
19453 }
19454
19455 if (benchmark == 1)
19456 {
19457 status_benchmark ();
19458
19459 if (machine_readable == 0)
19460 {
19461 log_info ("");
19462 }
19463 }
19464 else
19465 {
19466 if (quiet == 0)
19467 {
19468 clear_prompt ();
19469
19470 log_info ("");
19471
19472 status_display ();
19473
19474 log_info ("");
19475 }
19476 else
19477 {
19478 if (status == 1)
19479 {
19480 status_display ();
19481 }
19482 }
19483 }
19484
19485 if (induction_dictionaries_cnt)
19486 {
19487 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
19488
19489 // yeah, this next statement is a little hack to make sure that --loopback runs correctly (because with it we guarantee that the loop iterates one more time)
19490
19491 dictpos--;
19492 }
19493
19494 time_t runtime_stop;
19495
19496 time (&runtime_stop);
19497
19498 data.runtime_stop = runtime_stop;
19499
19500 logfile_sub_uint (runtime_start);
19501 logfile_sub_uint (runtime_stop);
19502
19503 logfile_sub_msg ("STOP");
19504
19505 global_free (subid);
19506
19507 // from this point we handle bypass as running
19508
19509 if (data.devices_status == STATUS_BYPASS)
19510 {
19511 data.devices_status = STATUS_RUNNING;
19512 }
19513
19514 // and overwrite benchmark aborts as well
19515
19516 if (data.benchmark == 1)
19517 {
19518 if (data.devices_status == STATUS_ABORTED)
19519 {
19520 data.devices_status = STATUS_RUNNING;
19521 }
19522 }
19523
19524 // finalize task
19525
19526 if (data.devices_status == STATUS_CRACKED) break;
19527 if (data.devices_status == STATUS_ABORTED) break;
19528 if (data.devices_status == STATUS_QUIT) break;
19529 }
19530
19531 if (data.devices_status == STATUS_CRACKED) break;
19532 if (data.devices_status == STATUS_ABORTED) break;
19533 if (data.devices_status == STATUS_QUIT) break;
19534 }
19535
19536 // 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
19537 if (attack_mode == ATTACK_MODE_STRAIGHT)
19538 {
19539 if (data.wordlist_mode == WL_MODE_FILE)
19540 {
19541 if (data.dictfile == NULL)
19542 {
19543 if (dictfiles != NULL)
19544 {
19545 data.dictfile = dictfiles[0];
19546
19547 hc_timer_set (&data.timer_running);
19548 }
19549 }
19550 }
19551 }
19552 // NOTE: combi is okay because it is already set beforehand
19553 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
19554 {
19555 if (data.dictfile == NULL)
19556 {
19557 if (dictfiles != NULL)
19558 {
19559 hc_timer_set (&data.timer_running);
19560
19561 data.dictfile = dictfiles[0];
19562 }
19563 }
19564 }
19565 else if (attack_mode == ATTACK_MODE_BF)
19566 {
19567 if (data.mask == NULL)
19568 {
19569 hc_timer_set (&data.timer_running);
19570
19571 data.mask = masks[0];
19572 }
19573 }
19574
19575 // if cracked / aborted remove last induction dictionary
19576
19577 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
19578 {
19579 struct stat induct_stat;
19580
19581 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
19582 {
19583 unlink (induction_dictionaries[file_pos]);
19584 }
19585 }
19586
19587 // wait for inner threads
19588
19589 data.shutdown_inner = 1;
19590
19591 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
19592 {
19593 hc_thread_wait (1, &inner_threads[thread_idx]);
19594 }
19595
19596 local_free (inner_threads);
19597
19598 // we dont need restore file anymore
19599 if (data.restore_disable == 0)
19600 {
19601 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
19602 {
19603 unlink (eff_restore_file);
19604 unlink (new_restore_file);
19605 }
19606 else
19607 {
19608 cycle_restore ();
19609 }
19610 }
19611
19612 // finally save left hashes
19613
19614 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
19615 {
19616 save_hash ();
19617 }
19618
19619 /**
19620 * Clean up
19621 */
19622
19623 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19624 {
19625 hc_device_param_t *device_param = &data.devices_param[device_id];
19626
19627 if (device_param->skipped) continue;
19628
19629 cl_int CL_err = CL_SUCCESS;
19630
19631 local_free (device_param->combs_buf);
19632 local_free (device_param->hooks_buf);
19633 local_free (device_param->device_name);
19634 local_free (device_param->device_name_chksum);
19635 local_free (device_param->device_version);
19636 local_free (device_param->driver_version);
19637
19638 if (device_param->pws_buf) myfree (device_param->pws_buf);
19639
19640 if (device_param->d_pws_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
19641 if (device_param->d_pws_amp_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
19642 if (device_param->d_rules) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules);
19643 if (device_param->d_rules_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
19644 if (device_param->d_combs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs);
19645 if (device_param->d_combs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
19646 if (device_param->d_bfs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
19647 if (device_param->d_bfs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
19648 if (device_param->d_bitmap_s1_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
19649 if (device_param->d_bitmap_s1_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
19650 if (device_param->d_bitmap_s1_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
19651 if (device_param->d_bitmap_s1_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
19652 if (device_param->d_bitmap_s2_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
19653 if (device_param->d_bitmap_s2_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
19654 if (device_param->d_bitmap_s2_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
19655 if (device_param->d_bitmap_s2_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
19656 if (device_param->d_plain_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
19657 if (device_param->d_digests_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
19658 if (device_param->d_digests_shown) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
19659 if (device_param->d_salt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
19660 if (device_param->d_esalt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
19661 if (device_param->d_tmps) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
19662 if (device_param->d_hooks) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
19663 if (device_param->d_result) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_result);
19664 if (device_param->d_scryptV0_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
19665 if (device_param->d_scryptV1_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
19666 if (device_param->d_scryptV2_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
19667 if (device_param->d_scryptV3_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
19668 if (device_param->d_root_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
19669 if (device_param->d_markov_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
19670 if (device_param->d_tm_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
19671
19672 if (CL_err != CL_SUCCESS)
19673 {
19674 log_error ("ERROR: clReleaseMemObject(): %s\n", val2cstr_cl (CL_err));
19675
19676 return -1;
19677 }
19678
19679 if (device_param->kernel1) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel1);
19680 if (device_param->kernel12) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel12);
19681 if (device_param->kernel2) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel2);
19682 if (device_param->kernel23) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel23);
19683 if (device_param->kernel3) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel3);
19684 if (device_param->kernel_mp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
19685 if (device_param->kernel_mp_l) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
19686 if (device_param->kernel_mp_r) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
19687 if (device_param->kernel_tm) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
19688 if (device_param->kernel_amp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
19689 if (device_param->kernel_memset) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
19690
19691 if (CL_err != CL_SUCCESS)
19692 {
19693 log_error ("ERROR: clReleaseKernel(): %s\n", val2cstr_cl (CL_err));
19694
19695 return -1;
19696 }
19697
19698 if (device_param->program) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program);
19699 if (device_param->program_mp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_mp);
19700 if (device_param->program_amp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_amp);
19701
19702 if (CL_err != CL_SUCCESS)
19703 {
19704 log_error ("ERROR: clReleaseProgram(): %s\n", val2cstr_cl (CL_err));
19705
19706 return -1;
19707 }
19708
19709 if (device_param->command_queue) CL_err |= hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
19710
19711 if (CL_err != CL_SUCCESS)
19712 {
19713 log_error ("ERROR: clReleaseCommandQueue(): %s\n", val2cstr_cl (CL_err));
19714
19715 return -1;
19716 }
19717
19718 if (device_param->context) CL_err |= hc_clReleaseContext (data.ocl, device_param->context);
19719
19720 if (CL_err != CL_SUCCESS)
19721 {
19722 log_error ("ERROR: hc_clReleaseContext(): %s\n", val2cstr_cl (CL_err));
19723
19724 return -1;
19725 }
19726 }
19727
19728 // reset default fan speed
19729
19730 #ifdef HAVE_HWMON
19731 if (gpu_temp_disable == 0)
19732 {
19733 if (gpu_temp_retain != 0)
19734 {
19735 hc_thread_mutex_lock (mux_adl);
19736
19737 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19738 {
19739 hc_device_param_t *device_param = &data.devices_param[device_id];
19740
19741 if (device_param->skipped) continue;
19742
19743 if (data.hm_device[device_id].fan_set_supported == 1)
19744 {
19745 int rc = -1;
19746
19747 if (device_param->device_vendor_id == VENDOR_ID_AMD)
19748 {
19749 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
19750 }
19751 else if (device_param->device_vendor_id == VENDOR_ID_NV)
19752 {
19753 #ifdef __linux__
19754 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
19755 #endif
19756
19757 #ifdef WIN
19758 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
19759 #endif
19760 }
19761
19762 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
19763 }
19764 }
19765
19766 hc_thread_mutex_unlock (mux_adl);
19767 }
19768 }
19769
19770 // reset power tuning
19771
19772 if (powertune_enable == 1)
19773 {
19774 hc_thread_mutex_lock (mux_adl);
19775
19776 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19777 {
19778 hc_device_param_t *device_param = &data.devices_param[device_id];
19779
19780 if (device_param->skipped) continue;
19781
19782 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
19783 {
19784 if (data.hm_device[device_id].od_version == 6)
19785 {
19786 // check powertune capabilities first, if not available then skip device
19787
19788 int powertune_supported = 0;
19789
19790 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
19791 {
19792 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
19793
19794 return -1;
19795 }
19796
19797 if (powertune_supported != 0)
19798 {
19799 // powercontrol settings
19800
19801 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
19802 {
19803 log_info ("ERROR: Failed to restore the ADL PowerControl values");
19804
19805 return -1;
19806 }
19807
19808 // clocks
19809
19810 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
19811
19812 performance_state->iNumberOfPerformanceLevels = 2;
19813
19814 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
19815 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
19816 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
19817 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
19818
19819 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
19820 {
19821 log_info ("ERROR: Failed to restore ADL performance state");
19822
19823 return -1;
19824 }
19825
19826 local_free (performance_state);
19827 }
19828 }
19829 }
19830
19831 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
19832 {
19833 unsigned int limit = nvml_power_limit[device_id];
19834
19835 if (limit > 0)
19836 {
19837 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
19838 }
19839 }
19840 }
19841
19842 hc_thread_mutex_unlock (mux_adl);
19843 }
19844
19845 if (gpu_temp_disable == 0)
19846 {
19847 if (data.hm_nvml)
19848 {
19849 hm_NVML_nvmlShutdown (data.hm_nvml);
19850
19851 nvml_close (data.hm_nvml);
19852
19853 data.hm_nvml = NULL;
19854 }
19855
19856 if (data.hm_nvapi)
19857 {
19858 hm_NvAPI_Unload (data.hm_nvapi);
19859
19860 nvapi_close (data.hm_nvapi);
19861
19862 data.hm_nvapi = NULL;
19863 }
19864
19865 if (data.hm_xnvctrl)
19866 {
19867 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
19868
19869 xnvctrl_close (data.hm_xnvctrl);
19870
19871 data.hm_xnvctrl = NULL;
19872 }
19873
19874 if (data.hm_adl)
19875 {
19876 hm_ADL_Main_Control_Destroy (data.hm_adl);
19877
19878 adl_close (data.hm_adl);
19879
19880 data.hm_adl = NULL;
19881 }
19882 }
19883 #endif // HAVE_HWMON
19884
19885 // free memory
19886
19887 local_free (masks);
19888
19889 local_free (dictstat_base);
19890
19891 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
19892 {
19893 pot_t *pot_ptr = &pot[pot_pos];
19894
19895 hash_t *hash = &pot_ptr->hash;
19896
19897 local_free (hash->digest);
19898
19899 if (isSalted)
19900 {
19901 local_free (hash->salt);
19902 }
19903 }
19904
19905 local_free (pot);
19906
19907 local_free (all_kernel_rules_cnt);
19908 local_free (all_kernel_rules_buf);
19909
19910 local_free (wl_data->buf);
19911 local_free (wl_data);
19912
19913 local_free (bitmap_s1_a);
19914 local_free (bitmap_s1_b);
19915 local_free (bitmap_s1_c);
19916 local_free (bitmap_s1_d);
19917 local_free (bitmap_s2_a);
19918 local_free (bitmap_s2_b);
19919 local_free (bitmap_s2_c);
19920 local_free (bitmap_s2_d);
19921
19922 #ifdef HAVE_HWMON
19923 local_free (od_clock_mem_status);
19924 local_free (od_power_control_status);
19925 local_free (nvml_power_limit);
19926 #endif
19927
19928 global_free (devices_param);
19929
19930 global_free (kernel_rules_buf);
19931
19932 global_free (root_css_buf);
19933 global_free (markov_css_buf);
19934
19935 global_free (digests_buf);
19936 global_free (digests_shown);
19937 global_free (digests_shown_tmp);
19938
19939 global_free (salts_buf);
19940 global_free (salts_shown);
19941
19942 global_free (esalts_buf);
19943
19944 global_free (words_progress_done);
19945 global_free (words_progress_rejected);
19946 global_free (words_progress_restored);
19947
19948 if (pot_fp) fclose (pot_fp);
19949
19950 if (data.devices_status == STATUS_QUIT) break;
19951 }
19952
19953 // wait for outer threads
19954
19955 data.shutdown_outer = 1;
19956
19957 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
19958 {
19959 hc_thread_wait (1, &outer_threads[thread_idx]);
19960 }
19961
19962 local_free (outer_threads);
19963
19964 // destroy others mutex
19965
19966 hc_thread_mutex_delete (mux_dispatcher);
19967 hc_thread_mutex_delete (mux_counter);
19968 hc_thread_mutex_delete (mux_display);
19969 hc_thread_mutex_delete (mux_adl);
19970
19971 // free memory
19972
19973 local_free (eff_restore_file);
19974 local_free (new_restore_file);
19975
19976 local_free (rd);
19977
19978 // tuning db
19979
19980 tuning_db_destroy (tuning_db);
19981
19982 // loopback
19983
19984 local_free (loopback_file);
19985
19986 if (loopback == 1) unlink (loopback_file);
19987
19988 // induction directory
19989
19990 if (induction_dir == NULL)
19991 {
19992 if (attack_mode != ATTACK_MODE_BF)
19993 {
19994 if (rmdir (induction_directory) == -1)
19995 {
19996 if (errno == ENOENT)
19997 {
19998 // good, we can ignore
19999 }
20000 else if (errno == ENOTEMPTY)
20001 {
20002 // good, we can ignore
20003 }
20004 else
20005 {
20006 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
20007
20008 return -1;
20009 }
20010 }
20011
20012 local_free (induction_directory);
20013 }
20014 }
20015
20016 // outfile-check directory
20017
20018 if (outfile_check_dir == NULL)
20019 {
20020 if (rmdir (outfile_check_directory) == -1)
20021 {
20022 if (errno == ENOENT)
20023 {
20024 // good, we can ignore
20025 }
20026 else if (errno == ENOTEMPTY)
20027 {
20028 // good, we can ignore
20029 }
20030 else
20031 {
20032 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
20033
20034 return -1;
20035 }
20036 }
20037
20038 local_free (outfile_check_directory);
20039 }
20040
20041 time_t proc_stop;
20042
20043 time (&proc_stop);
20044
20045 logfile_top_uint (proc_start);
20046 logfile_top_uint (proc_stop);
20047
20048 logfile_top_msg ("STOP");
20049
20050 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
20051 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
20052
20053 if (data.ocl) ocl_close (data.ocl);
20054
20055 if (data.devices_status == STATUS_ABORTED) return 2;
20056 if (data.devices_status == STATUS_QUIT) return 2;
20057 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
20058 if (data.devices_status == STATUS_EXHAUSTED) return 1;
20059 if (data.devices_status == STATUS_CRACKED) return 0;
20060
20061 return -1;
20062 }
Hashcat additions to support pwdhash