projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Workaround for OpenCL runtimes which do accept -I parameter in the OpenCL kernel...
[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 * There's alot of problem related to bad support -I parameters when building the kernel.
6568 * Each OpenCL runtime handles it slightly different.
6569 * The most problematic is with new AMD drivers on Windows, which can not handle quote characters!
6570 * The best workaround found so far is to modify the TMP variable (only inside hashcat process) before the runtime is load
6571 */
6572
6573 char cpath[1024] = { 0 };
6574
6575 #if _WIN
6576
6577 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
6578
6579 char *cpath_real = mymalloc (MAX_PATH);
6580
6581 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
6582 {
6583 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
6584
6585 return -1;
6586 }
6587
6588 #else
6589
6590 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
6591
6592 char *cpath_real = mymalloc (PATH_MAX);
6593
6594 if (realpath (cpath, cpath_real) == NULL)
6595 {
6596 log_error ("ERROR: %s: %s", cpath, strerror (errno));
6597
6598 return -1;
6599 }
6600
6601 #endif
6602
6603 if (getenv ("TMP") == NULL)
6604 {
6605 char tmp[1000];
6606
6607 snprintf (tmp, sizeof (tmp) - 1, "TMP=%s", cpath_real);
6608
6609 putenv (tmp);
6610 }
6611
6612 #if _WIN
6613
6614 naive_replace (cpath_real, '\\', '/');
6615
6616 // not escaping here, windows using quotes later
6617 // naive_escape (cpath_real, PATH_MAX, ' ', '\\');
6618
6619 #else
6620
6621 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
6622
6623 #endif
6624
6625 /**
6626 * kernel cache, we need to make sure folder exist
6627 */
6628
6629 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6630
6631 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6632
6633 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6634
6635 mkdir (kernels_folder, 0700);
6636
6637 myfree (kernels_folder);
6638
6639 /**
6640 * session
6641 */
6642
6643 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6644
6645 data.session = session;
6646
6647 char *eff_restore_file = (char *) mymalloc (session_size);
6648 char *new_restore_file = (char *) mymalloc (session_size);
6649
6650 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6651 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6652
6653 data.eff_restore_file = eff_restore_file;
6654 data.new_restore_file = new_restore_file;
6655
6656 if (((show == 1) || (left == 1)) && (restore == 1))
6657 {
6658 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6659 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6660
6661 return -1;
6662 }
6663
6664 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6665 if ((show == 1) || (left == 1))
6666 {
6667 restore_disable = 1;
6668
6669 restore = 0;
6670 }
6671
6672 data.restore_disable = restore_disable;
6673
6674 restore_data_t *rd = init_restore (argc, argv);
6675
6676 data.rd = rd;
6677
6678 /**
6679 * restore file
6680 */
6681
6682 if (restore == 1)
6683 {
6684 read_restore (eff_restore_file, rd);
6685
6686 if (rd->version_bin < RESTORE_MIN)
6687 {
6688 log_error ("ERROR: Incompatible restore-file version");
6689
6690 return -1;
6691 }
6692
6693 myargc = rd->argc;
6694 myargv = rd->argv;
6695
6696 #ifdef _POSIX
6697 rd->pid = getpid ();
6698 #elif _WIN
6699 rd->pid = GetCurrentProcessId ();
6700 #endif
6701 }
6702
6703 uint hash_mode_chgd = 0;
6704 uint runtime_chgd = 0;
6705 uint kernel_loops_chgd = 0;
6706 uint kernel_accel_chgd = 0;
6707 uint nvidia_spin_damp_chgd = 0;
6708 uint attack_mode_chgd = 0;
6709 uint outfile_format_chgd = 0;
6710 uint rp_gen_seed_chgd = 0;
6711 uint remove_timer_chgd = 0;
6712 uint increment_min_chgd = 0;
6713 uint increment_max_chgd = 0;
6714 uint workload_profile_chgd = 0;
6715 uint opencl_vector_width_chgd = 0;
6716
6717 optind = 1;
6718 optopt = 0;
6719 option_index = 0;
6720
6721 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6722 {
6723 switch (c)
6724 {
6725 //case IDX_HELP: usage = 1; break;
6726 //case IDX_VERSION: version = 1; break;
6727 //case IDX_RESTORE: restore = 1; break;
6728 case IDX_QUIET: quiet = 1; break;
6729 //case IDX_SHOW: show = 1; break;
6730 case IDX_SHOW: break;
6731 //case IDX_LEFT: left = 1; break;
6732 case IDX_LEFT: break;
6733 case IDX_USERNAME: username = 1; break;
6734 case IDX_REMOVE: remove = 1; break;
6735 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6736 remove_timer_chgd = 1; break;
6737 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6738 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6739 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6740 case IDX_DEBUG_FILE: debug_file = optarg; break;
6741 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6742 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6743 case IDX_FORCE: force = 1; break;
6744 case IDX_SKIP: skip = atoll (optarg); break;
6745 case IDX_LIMIT: limit = atoll (optarg); break;
6746 case IDX_KEYSPACE: keyspace = 1; break;
6747 case IDX_BENCHMARK: benchmark = 1; break;
6748 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6749 case IDX_RESTORE: break;
6750 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6751 case IDX_STATUS: status = 1; break;
6752 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6753 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6754 case IDX_LOOPBACK: loopback = 1; break;
6755 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6756 //case IDX_SESSION: session = optarg; break;
6757 case IDX_SESSION: break;
6758 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6759 hash_mode_chgd = 1; break;
6760 case IDX_RUNTIME: runtime = atoi (optarg);
6761 runtime_chgd = 1; break;
6762 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6763 attack_mode_chgd = 1; break;
6764 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6765 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6766 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6767 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6768 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6769 rp_gen_seed_chgd = 1; break;
6770 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6771 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6772 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6773 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6774 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6775 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6776 case IDX_OUTFILE: outfile = optarg; break;
6777 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6778 outfile_format_chgd = 1; break;
6779 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6780 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6781 case IDX_HEX_CHARSET: hex_charset = 1; break;
6782 case IDX_HEX_SALT: hex_salt = 1; break;
6783 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6784 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6785 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6786 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6787 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6788 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6789 opencl_vector_width_chgd = 1; break;
6790 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6791 workload_profile_chgd = 1; break;
6792 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6793 kernel_accel_chgd = 1; break;
6794 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6795 kernel_loops_chgd = 1; break;
6796 case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg);
6797 nvidia_spin_damp_chgd = 1; break;
6798 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6799 #ifdef HAVE_HWMON
6800 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6801 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6802 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6803 #endif // HAVE_HWMON
6804 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6805 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6806 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6807 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6808 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6809 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6810 case IDX_SEPARATOR: separator = optarg[0]; break;
6811 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6812 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6813 case IDX_INCREMENT: increment = 1; break;
6814 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6815 increment_min_chgd = 1; break;
6816 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6817 increment_max_chgd = 1; break;
6818 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6819 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6820 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6821 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6822
6823 default:
6824 log_error ("ERROR: Invalid argument specified");
6825 return -1;
6826 }
6827 }
6828
6829 if (optopt != 0)
6830 {
6831 log_error ("ERROR: Invalid argument specified");
6832
6833 return -1;
6834 }
6835
6836 /**
6837 * Inform user things getting started,
6838 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6839 * - we do not need to check algorithm_pos
6840 */
6841
6842 if (quiet == 0)
6843 {
6844 if (benchmark == 1)
6845 {
6846 if (machine_readable == 0)
6847 {
6848 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6849 log_info ("");
6850 }
6851 else
6852 {
6853 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6854 }
6855 }
6856 else if (restore == 1)
6857 {
6858 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6859 log_info ("");
6860 }
6861 else if (stdout_flag == 1)
6862 {
6863 // do nothing
6864 }
6865 else if (keyspace == 1)
6866 {
6867 // do nothing
6868 }
6869 else
6870 {
6871 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6872 log_info ("");
6873 }
6874 }
6875
6876 /**
6877 * sanity check
6878 */
6879
6880 if (attack_mode > 7)
6881 {
6882 log_error ("ERROR: Invalid attack-mode specified");
6883
6884 return -1;
6885 }
6886
6887 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6888 {
6889 log_error ("ERROR: Invalid runtime specified");
6890
6891 return -1;
6892 }
6893
6894 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6895 {
6896 log_error ("ERROR: Invalid hash-type specified");
6897
6898 return -1;
6899 }
6900
6901 // renamed hash modes
6902
6903 if (hash_mode_chgd)
6904 {
6905 int n = -1;
6906
6907 switch (hash_mode)
6908 {
6909 case 123: n = 124;
6910 break;
6911 }
6912
6913 if (n >= 0)
6914 {
6915 log_error ("Old -m specified, use -m %d instead", n);
6916
6917 return -1;
6918 }
6919 }
6920
6921 if (username == 1)
6922 {
6923 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6924 {
6925 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6926
6927 return -1;
6928 }
6929 }
6930
6931 if (outfile_format > 16)
6932 {
6933 log_error ("ERROR: Invalid outfile-format specified");
6934
6935 return -1;
6936 }
6937
6938 if (left == 1)
6939 {
6940 if (outfile_format_chgd == 1)
6941 {
6942 if (outfile_format > 1)
6943 {
6944 log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
6945
6946 return -1;
6947 }
6948 }
6949 else
6950 {
6951 outfile_format = OUTFILE_FMT_HASH;
6952 }
6953 }
6954
6955 if (show == 1)
6956 {
6957 if (outfile_format_chgd == 1)
6958 {
6959 if ((outfile_format > 7) && (outfile_format < 16))
6960 {
6961 log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
6962
6963 return -1;
6964 }
6965 }
6966 }
6967
6968 if (increment_min < INCREMENT_MIN)
6969 {
6970 log_error ("ERROR: Invalid increment-min specified");
6971
6972 return -1;
6973 }
6974
6975 if (increment_max > INCREMENT_MAX)
6976 {
6977 log_error ("ERROR: Invalid increment-max specified");
6978
6979 return -1;
6980 }
6981
6982 if (increment_min > increment_max)
6983 {
6984 log_error ("ERROR: Invalid increment-min specified");
6985
6986 return -1;
6987 }
6988
6989 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6990 {
6991 log_error ("ERROR: Increment is not allowed in attack-mode 0");
6992
6993 return -1;
6994 }
6995
6996 if ((increment == 0) && (increment_min_chgd == 1))
6997 {
6998 log_error ("ERROR: Increment-min is only supported combined with increment switch");
6999
7000 return -1;
7001 }
7002
7003 if ((increment == 0) && (increment_max_chgd == 1))
7004 {
7005 log_error ("ERROR: Increment-max is only supported combined with increment switch");
7006
7007 return -1;
7008 }
7009
7010 if (rp_files_cnt && rp_gen)
7011 {
7012 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
7013
7014 return -1;
7015 }
7016
7017 if (rp_files_cnt || rp_gen)
7018 {
7019 if (attack_mode != ATTACK_MODE_STRAIGHT)
7020 {
7021 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
7022
7023 return -1;
7024 }
7025 }
7026
7027 if (rp_gen_func_min > rp_gen_func_max)
7028 {
7029 log_error ("ERROR: Invalid rp-gen-func-min specified");
7030
7031 return -1;
7032 }
7033
7034 if (kernel_accel_chgd == 1)
7035 {
7036 if (force == 0)
7037 {
7038 log_info ("The manual use of the -n option (or --kernel-accel) is outdated");
7039 log_info ("Please consider using the -w option instead");
7040 log_info ("You can use --force to override this but do not post error reports if you do so");
7041 log_info ("");
7042
7043 return -1;
7044 }
7045
7046 if (kernel_accel < 1)
7047 {
7048 log_error ("ERROR: Invalid kernel-accel specified");
7049
7050 return -1;
7051 }
7052
7053 if (kernel_accel > 1024)
7054 {
7055 log_error ("ERROR: Invalid kernel-accel specified");
7056
7057 return -1;
7058 }
7059 }
7060
7061 if (kernel_loops_chgd == 1)
7062 {
7063 if (force == 0)
7064 {
7065 log_info ("The manual use of the -u option (or --kernel-loops) is outdated");
7066 log_info ("Please consider using the -w option instead");
7067 log_info ("You can use --force to override this but do not post error reports if you do so");
7068 log_info ("");
7069
7070 return -1;
7071 }
7072
7073 if (kernel_loops < 1)
7074 {
7075 log_error ("ERROR: Invalid kernel-loops specified");
7076
7077 return -1;
7078 }
7079
7080 if (kernel_loops > 1024)
7081 {
7082 log_error ("ERROR: Invalid kernel-loops specified");
7083
7084 return -1;
7085 }
7086 }
7087
7088 if ((workload_profile < 1) || (workload_profile > 4))
7089 {
7090 log_error ("ERROR: workload-profile %i not available", workload_profile);
7091
7092 return -1;
7093 }
7094
7095 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
7096 {
7097 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
7098
7099 return -1;
7100 }
7101
7102 if (show == 1 || left == 1)
7103 {
7104 attack_mode = ATTACK_MODE_NONE;
7105
7106 if (remove == 1)
7107 {
7108 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
7109
7110 return -1;
7111 }
7112
7113 if (potfile_disable == 1)
7114 {
7115 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
7116
7117 return -1;
7118 }
7119 }
7120
7121 uint attack_kern = ATTACK_KERN_NONE;
7122
7123 switch (attack_mode)
7124 {
7125 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
7126 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
7127 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
7128 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
7129 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
7130 }
7131
7132 if (benchmark == 1)
7133 {
7134 if (myargv[optind] != 0)
7135 {
7136 log_error ("ERROR: Invalid argument for benchmark mode specified");
7137
7138 return -1;
7139 }
7140
7141 if (attack_mode_chgd == 1)
7142 {
7143 if (attack_mode != ATTACK_MODE_BF)
7144 {
7145 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
7146
7147 return -1;
7148 }
7149 }
7150 }
7151 else
7152 {
7153 if (stdout_flag == 1) // no hash here
7154 {
7155 optind--;
7156 }
7157
7158 if (keyspace == 1)
7159 {
7160 int num_additional_params = 1;
7161
7162 if (attack_kern == ATTACK_KERN_COMBI)
7163 {
7164 num_additional_params = 2;
7165 }
7166
7167 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
7168
7169 if (keyspace_wordlist_specified == 0) optind--;
7170 }
7171
7172 if (attack_kern == ATTACK_KERN_NONE)
7173 {
7174 if ((optind + 1) != myargc)
7175 {
7176 usage_mini_print (myargv[0]);
7177
7178 return -1;
7179 }
7180 }
7181 else if (attack_kern == ATTACK_KERN_STRAIGHT)
7182 {
7183 if ((optind + 1) > myargc)
7184 {
7185 usage_mini_print (myargv[0]);
7186
7187 return -1;
7188 }
7189 }
7190 else if (attack_kern == ATTACK_KERN_COMBI)
7191 {
7192 if ((optind + 3) != myargc)
7193 {
7194 usage_mini_print (myargv[0]);
7195
7196 return -1;
7197 }
7198 }
7199 else if (attack_kern == ATTACK_KERN_BF)
7200 {
7201 if ((optind + 1) > myargc)
7202 {
7203 usage_mini_print (myargv[0]);
7204
7205 return -1;
7206 }
7207 }
7208 else
7209 {
7210 usage_mini_print (myargv[0]);
7211
7212 return -1;
7213 }
7214 }
7215
7216 if (skip != 0 && limit != 0)
7217 {
7218 limit += skip;
7219 }
7220
7221 if (keyspace == 1)
7222 {
7223 if (show == 1)
7224 {
7225 log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
7226
7227 return -1;
7228 }
7229 else if (left == 1)
7230 {
7231 log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
7232
7233 return -1;
7234 }
7235
7236 potfile_disable = 1;
7237
7238 restore_disable = 1;
7239
7240 restore = 0;
7241
7242 weak_hash_threshold = 0;
7243
7244 quiet = 1;
7245 }
7246
7247 if (stdout_flag == 1)
7248 {
7249 status_timer = 0;
7250 restore_timer = 0;
7251 restore_disable = 1;
7252 restore = 0;
7253 potfile_disable = 1;
7254 weak_hash_threshold = 0;
7255 gpu_temp_disable = 1;
7256 hash_mode = 2000;
7257 quiet = 1;
7258 outfile_format = OUTFILE_FMT_PLAIN;
7259 kernel_accel = 1024;
7260 kernel_loops = 1024;
7261 force = 1;
7262 outfile_check_timer = 0;
7263 session = "stdout";
7264 opencl_vector_width = 1;
7265 }
7266
7267 if (remove_timer_chgd == 1)
7268 {
7269 if (remove == 0)
7270 {
7271 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
7272
7273 return -1;
7274 }
7275
7276 if (remove_timer < 1)
7277 {
7278 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
7279
7280 return -1;
7281 }
7282 }
7283
7284 if (loopback == 1)
7285 {
7286 if (attack_mode == ATTACK_MODE_STRAIGHT)
7287 {
7288 if ((rp_files_cnt == 0) && (rp_gen == 0))
7289 {
7290 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
7291
7292 return -1;
7293 }
7294 }
7295 else
7296 {
7297 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
7298
7299 return -1;
7300 }
7301 }
7302
7303 if (debug_mode > 0)
7304 {
7305 if (attack_mode != ATTACK_MODE_STRAIGHT)
7306 {
7307 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
7308
7309 return -1;
7310 }
7311
7312 if ((rp_files_cnt == 0) && (rp_gen == 0))
7313 {
7314 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
7315
7316 return -1;
7317 }
7318 }
7319
7320 if (debug_mode > 4)
7321 {
7322 log_error ("ERROR: Invalid debug-mode specified");
7323
7324 return -1;
7325 }
7326
7327 if (debug_file != NULL)
7328 {
7329 if (debug_mode < 1)
7330 {
7331 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
7332
7333 return -1;
7334 }
7335 }
7336
7337 if (induction_dir != NULL)
7338 {
7339 if (attack_mode == ATTACK_MODE_BF)
7340 {
7341 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
7342
7343 return -1;
7344 }
7345 }
7346
7347 if (attack_mode != ATTACK_MODE_STRAIGHT)
7348 {
7349 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
7350 {
7351 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
7352
7353 return -1;
7354 }
7355
7356 weak_hash_threshold = 0;
7357 }
7358
7359 if (nvidia_spin_damp > 100)
7360 {
7361 log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)");
7362
7363 return -1;
7364 }
7365
7366
7367 /**
7368 * induction directory
7369 */
7370
7371 char *induction_directory = NULL;
7372
7373 if (attack_mode != ATTACK_MODE_BF)
7374 {
7375 if (induction_dir == NULL)
7376 {
7377 induction_directory = (char *) mymalloc (session_size);
7378
7379 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
7380
7381 // create induction folder if it does not already exist
7382
7383 if (keyspace == 0)
7384 {
7385 if (rmdir (induction_directory) == -1)
7386 {
7387 if (errno == ENOENT)
7388 {
7389 // good, we can ignore
7390 }
7391 else if (errno == ENOTEMPTY)
7392 {
7393 char *induction_directory_mv = (char *) mymalloc (session_size);
7394
7395 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
7396
7397 if (rename (induction_directory, induction_directory_mv) != 0)
7398 {
7399 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
7400
7401 return -1;
7402 }
7403 }
7404 else
7405 {
7406 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7407
7408 return -1;
7409 }
7410 }
7411
7412 if (mkdir (induction_directory, 0700) == -1)
7413 {
7414 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
7415
7416 return -1;
7417 }
7418 }
7419 }
7420 else
7421 {
7422 induction_directory = induction_dir;
7423 }
7424 }
7425
7426 data.induction_directory = induction_directory;
7427
7428 /**
7429 * loopback
7430 */
7431
7432 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
7433
7434 char *loopback_file = (char *) mymalloc (loopback_size);
7435
7436 /**
7437 * tuning db
7438 */
7439
7440 char tuning_db_file[256] = { 0 };
7441
7442 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
7443
7444 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
7445
7446 /**
7447 * outfile-check directory
7448 */
7449
7450 char *outfile_check_directory = NULL;
7451
7452 if (outfile_check_dir == NULL)
7453 {
7454 outfile_check_directory = (char *) mymalloc (session_size);
7455
7456 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
7457 }
7458 else
7459 {
7460 outfile_check_directory = outfile_check_dir;
7461 }
7462
7463 data.outfile_check_directory = outfile_check_directory;
7464
7465 if (keyspace == 0)
7466 {
7467 struct stat outfile_check_stat;
7468
7469 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
7470 {
7471 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
7472
7473 if (is_dir == 0)
7474 {
7475 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
7476
7477 return -1;
7478 }
7479 }
7480 else if (outfile_check_dir == NULL)
7481 {
7482 if (mkdir (outfile_check_directory, 0700) == -1)
7483 {
7484 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
7485
7486 return -1;
7487 }
7488 }
7489 }
7490
7491 /**
7492 * special other stuff
7493 */
7494
7495 if (hash_mode == 9710)
7496 {
7497 outfile_format = 5;
7498 outfile_format_chgd = 1;
7499 }
7500
7501 if (hash_mode == 9810)
7502 {
7503 outfile_format = 5;
7504 outfile_format_chgd = 1;
7505 }
7506
7507 if (hash_mode == 10410)
7508 {
7509 outfile_format = 5;
7510 outfile_format_chgd = 1;
7511 }
7512
7513 /**
7514 * store stuff
7515 */
7516
7517 data.hash_mode = hash_mode;
7518 data.restore = restore;
7519 data.restore_timer = restore_timer;
7520 data.restore_disable = restore_disable;
7521 data.status = status;
7522 data.status_timer = status_timer;
7523 data.machine_readable = machine_readable;
7524 data.loopback = loopback;
7525 data.runtime = runtime;
7526 data.remove = remove;
7527 data.remove_timer = remove_timer;
7528 data.debug_mode = debug_mode;
7529 data.debug_file = debug_file;
7530 data.username = username;
7531 data.quiet = quiet;
7532 data.outfile = outfile;
7533 data.outfile_format = outfile_format;
7534 data.outfile_autohex = outfile_autohex;
7535 data.hex_charset = hex_charset;
7536 data.hex_salt = hex_salt;
7537 data.hex_wordlist = hex_wordlist;
7538 data.separator = separator;
7539 data.rp_files = rp_files;
7540 data.rp_files_cnt = rp_files_cnt;
7541 data.rp_gen = rp_gen;
7542 data.rp_gen_seed = rp_gen_seed;
7543 data.force = force;
7544 data.benchmark = benchmark;
7545 data.skip = skip;
7546 data.limit = limit;
7547 #ifdef HAVE_HWMON
7548 data.powertune_enable = powertune_enable;
7549 #endif
7550 data.logfile_disable = logfile_disable;
7551 data.truecrypt_keyfiles = truecrypt_keyfiles;
7552 data.veracrypt_keyfiles = veracrypt_keyfiles;
7553 data.veracrypt_pim = veracrypt_pim;
7554 data.scrypt_tmto = scrypt_tmto;
7555 data.workload_profile = workload_profile;
7556
7557 /**
7558 * cpu affinity
7559 */
7560
7561 if (cpu_affinity)
7562 {
7563 set_cpu_affinity (cpu_affinity);
7564 }
7565
7566 if (rp_gen_seed_chgd == 0)
7567 {
7568 srand (proc_start);
7569 }
7570 else
7571 {
7572 srand (rp_gen_seed);
7573 }
7574
7575 /**
7576 * logfile init
7577 */
7578
7579 if (logfile_disable == 0)
7580 {
7581 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7582
7583 char *logfile = (char *) mymalloc (logfile_size);
7584
7585 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7586
7587 data.logfile = logfile;
7588
7589 char *topid = logfile_generate_topid ();
7590
7591 data.topid = topid;
7592 }
7593
7594 // logfile_append() checks for logfile_disable internally to make it easier from here
7595
7596 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7597 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7598 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7599 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7600 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7601 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7602 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7603 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7604 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7605 #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));
7606
7607 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7608 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7609 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7610 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7611 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7612 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7613 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7614 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7615
7616 logfile_top_msg ("START");
7617
7618 logfile_top_uint (attack_mode);
7619 logfile_top_uint (attack_kern);
7620 logfile_top_uint (benchmark);
7621 logfile_top_uint (stdout_flag);
7622 logfile_top_uint (bitmap_min);
7623 logfile_top_uint (bitmap_max);
7624 logfile_top_uint (debug_mode);
7625 logfile_top_uint (force);
7626 logfile_top_uint (kernel_accel);
7627 logfile_top_uint (kernel_loops);
7628 logfile_top_uint (nvidia_spin_damp);
7629 logfile_top_uint (gpu_temp_disable);
7630 #ifdef HAVE_HWMON
7631 logfile_top_uint (gpu_temp_abort);
7632 logfile_top_uint (gpu_temp_retain);
7633 #endif
7634 logfile_top_uint (hash_mode);
7635 logfile_top_uint (hex_charset);
7636 logfile_top_uint (hex_salt);
7637 logfile_top_uint (hex_wordlist);
7638 logfile_top_uint (increment);
7639 logfile_top_uint (increment_max);
7640 logfile_top_uint (increment_min);
7641 logfile_top_uint (keyspace);
7642 logfile_top_uint (left);
7643 logfile_top_uint (logfile_disable);
7644 logfile_top_uint (loopback);
7645 logfile_top_uint (markov_classic);
7646 logfile_top_uint (markov_disable);
7647 logfile_top_uint (markov_threshold);
7648 logfile_top_uint (outfile_autohex);
7649 logfile_top_uint (outfile_check_timer);
7650 logfile_top_uint (outfile_format);
7651 logfile_top_uint (potfile_disable);
7652 logfile_top_string (potfile_path);
7653 #if defined(HAVE_HWMON)
7654 logfile_top_uint (powertune_enable);
7655 #endif
7656 logfile_top_uint (scrypt_tmto);
7657 logfile_top_uint (quiet);
7658 logfile_top_uint (remove);
7659 logfile_top_uint (remove_timer);
7660 logfile_top_uint (restore);
7661 logfile_top_uint (restore_disable);
7662 logfile_top_uint (restore_timer);
7663 logfile_top_uint (rp_gen);
7664 logfile_top_uint (rp_gen_func_max);
7665 logfile_top_uint (rp_gen_func_min);
7666 logfile_top_uint (rp_gen_seed);
7667 logfile_top_uint (runtime);
7668 logfile_top_uint (segment_size);
7669 logfile_top_uint (show);
7670 logfile_top_uint (status);
7671 logfile_top_uint (machine_readable);
7672 logfile_top_uint (status_timer);
7673 logfile_top_uint (usage);
7674 logfile_top_uint (username);
7675 logfile_top_uint (version);
7676 logfile_top_uint (weak_hash_threshold);
7677 logfile_top_uint (workload_profile);
7678 logfile_top_uint64 (limit);
7679 logfile_top_uint64 (skip);
7680 logfile_top_char (separator);
7681 logfile_top_string (cpu_affinity);
7682 logfile_top_string (custom_charset_1);
7683 logfile_top_string (custom_charset_2);
7684 logfile_top_string (custom_charset_3);
7685 logfile_top_string (custom_charset_4);
7686 logfile_top_string (debug_file);
7687 logfile_top_string (opencl_devices);
7688 logfile_top_string (opencl_platforms);
7689 logfile_top_string (opencl_device_types);
7690 logfile_top_uint (opencl_vector_width);
7691 logfile_top_string (induction_dir);
7692 logfile_top_string (markov_hcstat);
7693 logfile_top_string (outfile);
7694 logfile_top_string (outfile_check_dir);
7695 logfile_top_string (rule_buf_l);
7696 logfile_top_string (rule_buf_r);
7697 logfile_top_string (session);
7698 logfile_top_string (truecrypt_keyfiles);
7699 logfile_top_string (veracrypt_keyfiles);
7700 logfile_top_uint (veracrypt_pim);
7701
7702 /**
7703 * Init OpenCL library loader
7704 */
7705
7706 if (keyspace == 0)
7707 {
7708 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7709
7710 ocl_init (ocl);
7711
7712 data.ocl = ocl;
7713 }
7714
7715 /**
7716 * OpenCL platform selection
7717 */
7718
7719 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7720
7721 /**
7722 * OpenCL device selection
7723 */
7724
7725 u32 devices_filter = setup_devices_filter (opencl_devices);
7726
7727 /**
7728 * OpenCL device type selection
7729 */
7730
7731 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7732
7733 /**
7734 * benchmark
7735 */
7736
7737 if (benchmark == 1)
7738 {
7739 /**
7740 * disable useless stuff for benchmark
7741 */
7742
7743 status_timer = 0;
7744 restore_timer = 0;
7745 restore_disable = 1;
7746 potfile_disable = 1;
7747 weak_hash_threshold = 0;
7748 nvidia_spin_damp = 0;
7749 gpu_temp_disable = 1;
7750 outfile_check_timer = 0;
7751
7752 #ifdef HAVE_HWMON
7753 if (powertune_enable == 1)
7754 {
7755 gpu_temp_disable = 0;
7756 }
7757 #endif
7758
7759 data.status_timer = status_timer;
7760 data.restore_timer = restore_timer;
7761 data.restore_disable = restore_disable;
7762 data.outfile_check_timer = outfile_check_timer;
7763
7764 /**
7765 * force attack mode to be bruteforce
7766 */
7767
7768 attack_mode = ATTACK_MODE_BF;
7769 attack_kern = ATTACK_KERN_BF;
7770
7771 if (workload_profile_chgd == 0)
7772 {
7773 workload_profile = 3;
7774
7775 data.workload_profile = workload_profile;
7776 }
7777 }
7778
7779 /**
7780 * status, monitor and outfile remove threads
7781 */
7782
7783 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
7784
7785 data.wordlist_mode = wordlist_mode;
7786
7787 if (wordlist_mode == WL_MODE_STDIN)
7788 {
7789 status = 1;
7790
7791 data.status = status;
7792 }
7793
7794 uint outer_threads_cnt = 0;
7795
7796 hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
7797
7798 data.shutdown_outer = 0;
7799
7800 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
7801 {
7802 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
7803 {
7804 hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL);
7805
7806 outer_threads_cnt++;
7807 }
7808 }
7809
7810 /**
7811 * config
7812 */
7813
7814 uint hash_type = 0;
7815 uint salt_type = 0;
7816 uint attack_exec = 0;
7817 uint opts_type = 0;
7818 uint kern_type = 0;
7819 uint dgst_size = 0;
7820 uint esalt_size = 0;
7821 uint opti_type = 0;
7822 uint dgst_pos0 = -1;
7823 uint dgst_pos1 = -1;
7824 uint dgst_pos2 = -1;
7825 uint dgst_pos3 = -1;
7826
7827 int (*parse_func) (char *, uint, hash_t *);
7828 int (*sort_by_digest) (const void *, const void *);
7829
7830 uint algorithm_pos = 0;
7831 uint algorithm_max = 1;
7832
7833 uint *algorithms = default_benchmark_algorithms;
7834
7835 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7836
7837 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7838 {
7839 /*
7840 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7841 * the following algos are skipped entirely
7842 */
7843
7844 if (algorithm_pos > 0)
7845 {
7846 local_free (rd);
7847
7848 rd = init_restore (argc, argv);
7849
7850 data.rd = rd;
7851 }
7852
7853 /**
7854 * update hash_mode in case of multihash benchmark
7855 */
7856
7857 if (benchmark == 1)
7858 {
7859 if (hash_mode_chgd == 0)
7860 {
7861 hash_mode = algorithms[algorithm_pos];
7862
7863 data.hash_mode = hash_mode;
7864 }
7865
7866 quiet = 1;
7867
7868 data.quiet = quiet;
7869 }
7870
7871 switch (hash_mode)
7872 {
7873 case 0: hash_type = HASH_TYPE_MD5;
7874 salt_type = SALT_TYPE_NONE;
7875 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7876 opts_type = OPTS_TYPE_PT_GENERATE_LE
7877 | OPTS_TYPE_PT_ADD80
7878 | OPTS_TYPE_PT_ADDBITS14;
7879 kern_type = KERN_TYPE_MD5;
7880 dgst_size = DGST_SIZE_4_4;
7881 parse_func = md5_parse_hash;
7882 sort_by_digest = sort_by_digest_4_4;
7883 opti_type = OPTI_TYPE_ZERO_BYTE
7884 | OPTI_TYPE_PRECOMPUTE_INIT
7885 | OPTI_TYPE_PRECOMPUTE_MERKLE
7886 | OPTI_TYPE_MEET_IN_MIDDLE
7887 | OPTI_TYPE_EARLY_SKIP
7888 | OPTI_TYPE_NOT_ITERATED
7889 | OPTI_TYPE_NOT_SALTED
7890 | OPTI_TYPE_RAW_HASH;
7891 dgst_pos0 = 0;
7892 dgst_pos1 = 3;
7893 dgst_pos2 = 2;
7894 dgst_pos3 = 1;
7895 break;
7896
7897 case 10: hash_type = HASH_TYPE_MD5;
7898 salt_type = SALT_TYPE_INTERN;
7899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7900 opts_type = OPTS_TYPE_PT_GENERATE_LE
7901 | OPTS_TYPE_ST_ADD80
7902 | OPTS_TYPE_ST_ADDBITS14;
7903 kern_type = KERN_TYPE_MD5_PWSLT;
7904 dgst_size = DGST_SIZE_4_4;
7905 parse_func = md5s_parse_hash;
7906 sort_by_digest = sort_by_digest_4_4;
7907 opti_type = OPTI_TYPE_ZERO_BYTE
7908 | OPTI_TYPE_PRECOMPUTE_INIT
7909 | OPTI_TYPE_PRECOMPUTE_MERKLE
7910 | OPTI_TYPE_MEET_IN_MIDDLE
7911 | OPTI_TYPE_EARLY_SKIP
7912 | OPTI_TYPE_NOT_ITERATED
7913 | OPTI_TYPE_APPENDED_SALT
7914 | OPTI_TYPE_RAW_HASH;
7915 dgst_pos0 = 0;
7916 dgst_pos1 = 3;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 1;
7919 break;
7920
7921 case 11: hash_type = HASH_TYPE_MD5;
7922 salt_type = SALT_TYPE_INTERN;
7923 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_LE
7925 | OPTS_TYPE_ST_ADD80
7926 | OPTS_TYPE_ST_ADDBITS14;
7927 kern_type = KERN_TYPE_MD5_PWSLT;
7928 dgst_size = DGST_SIZE_4_4;
7929 parse_func = joomla_parse_hash;
7930 sort_by_digest = sort_by_digest_4_4;
7931 opti_type = OPTI_TYPE_ZERO_BYTE
7932 | OPTI_TYPE_PRECOMPUTE_INIT
7933 | OPTI_TYPE_PRECOMPUTE_MERKLE
7934 | OPTI_TYPE_MEET_IN_MIDDLE
7935 | OPTI_TYPE_EARLY_SKIP
7936 | OPTI_TYPE_NOT_ITERATED
7937 | OPTI_TYPE_APPENDED_SALT
7938 | OPTI_TYPE_RAW_HASH;
7939 dgst_pos0 = 0;
7940 dgst_pos1 = 3;
7941 dgst_pos2 = 2;
7942 dgst_pos3 = 1;
7943 break;
7944
7945 case 12: hash_type = HASH_TYPE_MD5;
7946 salt_type = SALT_TYPE_INTERN;
7947 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7948 opts_type = OPTS_TYPE_PT_GENERATE_LE
7949 | OPTS_TYPE_ST_ADD80
7950 | OPTS_TYPE_ST_ADDBITS14;
7951 kern_type = KERN_TYPE_MD5_PWSLT;
7952 dgst_size = DGST_SIZE_4_4;
7953 parse_func = postgresql_parse_hash;
7954 sort_by_digest = sort_by_digest_4_4;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_PRECOMPUTE_INIT
7957 | OPTI_TYPE_PRECOMPUTE_MERKLE
7958 | OPTI_TYPE_MEET_IN_MIDDLE
7959 | OPTI_TYPE_EARLY_SKIP
7960 | OPTI_TYPE_NOT_ITERATED
7961 | OPTI_TYPE_APPENDED_SALT
7962 | OPTI_TYPE_RAW_HASH;
7963 dgst_pos0 = 0;
7964 dgst_pos1 = 3;
7965 dgst_pos2 = 2;
7966 dgst_pos3 = 1;
7967 break;
7968
7969 case 20: hash_type = HASH_TYPE_MD5;
7970 salt_type = SALT_TYPE_INTERN;
7971 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7972 opts_type = OPTS_TYPE_PT_GENERATE_LE
7973 | OPTS_TYPE_PT_ADD80
7974 | OPTS_TYPE_PT_ADDBITS14;
7975 kern_type = KERN_TYPE_MD5_SLTPW;
7976 dgst_size = DGST_SIZE_4_4;
7977 parse_func = md5s_parse_hash;
7978 sort_by_digest = sort_by_digest_4_4;
7979 opti_type = OPTI_TYPE_ZERO_BYTE
7980 | OPTI_TYPE_PRECOMPUTE_INIT
7981 | OPTI_TYPE_PRECOMPUTE_MERKLE
7982 | OPTI_TYPE_EARLY_SKIP
7983 | OPTI_TYPE_NOT_ITERATED
7984 | OPTI_TYPE_PREPENDED_SALT
7985 | OPTI_TYPE_RAW_HASH;
7986 dgst_pos0 = 0;
7987 dgst_pos1 = 3;
7988 dgst_pos2 = 2;
7989 dgst_pos3 = 1;
7990 break;
7991
7992 case 21: hash_type = HASH_TYPE_MD5;
7993 salt_type = SALT_TYPE_INTERN;
7994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7995 opts_type = OPTS_TYPE_PT_GENERATE_LE
7996 | OPTS_TYPE_PT_ADD80
7997 | OPTS_TYPE_PT_ADDBITS14;
7998 kern_type = KERN_TYPE_MD5_SLTPW;
7999 dgst_size = DGST_SIZE_4_4;
8000 parse_func = osc_parse_hash;
8001 sort_by_digest = sort_by_digest_4_4;
8002 opti_type = OPTI_TYPE_ZERO_BYTE
8003 | OPTI_TYPE_PRECOMPUTE_INIT
8004 | OPTI_TYPE_PRECOMPUTE_MERKLE
8005 | OPTI_TYPE_EARLY_SKIP
8006 | OPTI_TYPE_NOT_ITERATED
8007 | OPTI_TYPE_PREPENDED_SALT
8008 | OPTI_TYPE_RAW_HASH;
8009 dgst_pos0 = 0;
8010 dgst_pos1 = 3;
8011 dgst_pos2 = 2;
8012 dgst_pos3 = 1;
8013 break;
8014
8015 case 22: hash_type = HASH_TYPE_MD5;
8016 salt_type = SALT_TYPE_EMBEDDED;
8017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8018 opts_type = OPTS_TYPE_PT_GENERATE_LE
8019 | OPTS_TYPE_PT_ADD80
8020 | OPTS_TYPE_PT_ADDBITS14;
8021 kern_type = KERN_TYPE_MD5_SLTPW;
8022 dgst_size = DGST_SIZE_4_4;
8023 parse_func = netscreen_parse_hash;
8024 sort_by_digest = sort_by_digest_4_4;
8025 opti_type = OPTI_TYPE_ZERO_BYTE
8026 | OPTI_TYPE_PRECOMPUTE_INIT
8027 | OPTI_TYPE_PRECOMPUTE_MERKLE
8028 | OPTI_TYPE_EARLY_SKIP
8029 | OPTI_TYPE_NOT_ITERATED
8030 | OPTI_TYPE_PREPENDED_SALT
8031 | OPTI_TYPE_RAW_HASH;
8032 dgst_pos0 = 0;
8033 dgst_pos1 = 3;
8034 dgst_pos2 = 2;
8035 dgst_pos3 = 1;
8036 break;
8037
8038 case 23: hash_type = HASH_TYPE_MD5;
8039 salt_type = SALT_TYPE_EMBEDDED;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_LE
8042 | OPTS_TYPE_PT_ADD80
8043 | OPTS_TYPE_PT_ADDBITS14;
8044 kern_type = KERN_TYPE_MD5_SLTPW;
8045 dgst_size = DGST_SIZE_4_4;
8046 parse_func = skype_parse_hash;
8047 sort_by_digest = sort_by_digest_4_4;
8048 opti_type = OPTI_TYPE_ZERO_BYTE
8049 | OPTI_TYPE_PRECOMPUTE_INIT
8050 | OPTI_TYPE_PRECOMPUTE_MERKLE
8051 | OPTI_TYPE_EARLY_SKIP
8052 | OPTI_TYPE_NOT_ITERATED
8053 | OPTI_TYPE_PREPENDED_SALT
8054 | OPTI_TYPE_RAW_HASH;
8055 dgst_pos0 = 0;
8056 dgst_pos1 = 3;
8057 dgst_pos2 = 2;
8058 dgst_pos3 = 1;
8059 break;
8060
8061 case 30: hash_type = HASH_TYPE_MD5;
8062 salt_type = SALT_TYPE_INTERN;
8063 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8064 opts_type = OPTS_TYPE_PT_GENERATE_LE
8065 | OPTS_TYPE_PT_UNICODE
8066 | OPTS_TYPE_ST_ADD80
8067 | OPTS_TYPE_ST_ADDBITS14;
8068 kern_type = KERN_TYPE_MD5_PWUSLT;
8069 dgst_size = DGST_SIZE_4_4;
8070 parse_func = md5s_parse_hash;
8071 sort_by_digest = sort_by_digest_4_4;
8072 opti_type = OPTI_TYPE_ZERO_BYTE
8073 | OPTI_TYPE_PRECOMPUTE_INIT
8074 | OPTI_TYPE_PRECOMPUTE_MERKLE
8075 | OPTI_TYPE_MEET_IN_MIDDLE
8076 | OPTI_TYPE_EARLY_SKIP
8077 | OPTI_TYPE_NOT_ITERATED
8078 | OPTI_TYPE_APPENDED_SALT
8079 | OPTI_TYPE_RAW_HASH;
8080 dgst_pos0 = 0;
8081 dgst_pos1 = 3;
8082 dgst_pos2 = 2;
8083 dgst_pos3 = 1;
8084 break;
8085
8086 case 40: hash_type = HASH_TYPE_MD5;
8087 salt_type = SALT_TYPE_INTERN;
8088 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8089 opts_type = OPTS_TYPE_PT_GENERATE_LE
8090 | OPTS_TYPE_PT_ADD80
8091 | OPTS_TYPE_PT_ADDBITS14
8092 | OPTS_TYPE_PT_UNICODE;
8093 kern_type = KERN_TYPE_MD5_SLTPWU;
8094 dgst_size = DGST_SIZE_4_4;
8095 parse_func = md5s_parse_hash;
8096 sort_by_digest = sort_by_digest_4_4;
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_PREPENDED_SALT
8103 | OPTI_TYPE_RAW_HASH;
8104 dgst_pos0 = 0;
8105 dgst_pos1 = 3;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 1;
8108 break;
8109
8110 case 50: hash_type = HASH_TYPE_MD5;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_LE
8114 | OPTS_TYPE_ST_ADD80
8115 | OPTS_TYPE_ST_ADDBITS14;
8116 kern_type = KERN_TYPE_HMACMD5_PW;
8117 dgst_size = DGST_SIZE_4_4;
8118 parse_func = hmacmd5_parse_hash;
8119 sort_by_digest = sort_by_digest_4_4;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_NOT_ITERATED;
8122 dgst_pos0 = 0;
8123 dgst_pos1 = 3;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 1;
8126 break;
8127
8128 case 60: hash_type = HASH_TYPE_MD5;
8129 salt_type = SALT_TYPE_INTERN;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_ADD80
8133 | OPTS_TYPE_PT_ADDBITS14;
8134 kern_type = KERN_TYPE_HMACMD5_SLT;
8135 dgst_size = DGST_SIZE_4_4;
8136 parse_func = hmacmd5_parse_hash;
8137 sort_by_digest = sort_by_digest_4_4;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_NOT_ITERATED;
8140 dgst_pos0 = 0;
8141 dgst_pos1 = 3;
8142 dgst_pos2 = 2;
8143 dgst_pos3 = 1;
8144 break;
8145
8146 case 100: hash_type = HASH_TYPE_SHA1;
8147 salt_type = SALT_TYPE_NONE;
8148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149 opts_type = OPTS_TYPE_PT_GENERATE_BE
8150 | OPTS_TYPE_PT_ADD80
8151 | OPTS_TYPE_PT_ADDBITS15;
8152 kern_type = KERN_TYPE_SHA1;
8153 dgst_size = DGST_SIZE_4_5;
8154 parse_func = sha1_parse_hash;
8155 sort_by_digest = sort_by_digest_4_5;
8156 opti_type = OPTI_TYPE_ZERO_BYTE
8157 | OPTI_TYPE_PRECOMPUTE_INIT
8158 | OPTI_TYPE_PRECOMPUTE_MERKLE
8159 | OPTI_TYPE_EARLY_SKIP
8160 | OPTI_TYPE_NOT_ITERATED
8161 | OPTI_TYPE_NOT_SALTED
8162 | OPTI_TYPE_RAW_HASH;
8163 dgst_pos0 = 3;
8164 dgst_pos1 = 4;
8165 dgst_pos2 = 2;
8166 dgst_pos3 = 1;
8167 break;
8168
8169 case 101: hash_type = HASH_TYPE_SHA1;
8170 salt_type = SALT_TYPE_NONE;
8171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8172 opts_type = OPTS_TYPE_PT_GENERATE_BE
8173 | OPTS_TYPE_PT_ADD80
8174 | OPTS_TYPE_PT_ADDBITS15;
8175 kern_type = KERN_TYPE_SHA1;
8176 dgst_size = DGST_SIZE_4_5;
8177 parse_func = sha1b64_parse_hash;
8178 sort_by_digest = sort_by_digest_4_5;
8179 opti_type = OPTI_TYPE_ZERO_BYTE
8180 | OPTI_TYPE_PRECOMPUTE_INIT
8181 | OPTI_TYPE_PRECOMPUTE_MERKLE
8182 | OPTI_TYPE_EARLY_SKIP
8183 | OPTI_TYPE_NOT_ITERATED
8184 | OPTI_TYPE_NOT_SALTED
8185 | OPTI_TYPE_RAW_HASH;
8186 dgst_pos0 = 3;
8187 dgst_pos1 = 4;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 1;
8190 break;
8191
8192 case 110: hash_type = HASH_TYPE_SHA1;
8193 salt_type = SALT_TYPE_INTERN;
8194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_BE
8196 | OPTS_TYPE_ST_ADD80
8197 | OPTS_TYPE_ST_ADDBITS15;
8198 kern_type = KERN_TYPE_SHA1_PWSLT;
8199 dgst_size = DGST_SIZE_4_5;
8200 parse_func = sha1s_parse_hash;
8201 sort_by_digest = sort_by_digest_4_5;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_PRECOMPUTE_INIT
8204 | OPTI_TYPE_PRECOMPUTE_MERKLE
8205 | OPTI_TYPE_EARLY_SKIP
8206 | OPTI_TYPE_NOT_ITERATED
8207 | OPTI_TYPE_APPENDED_SALT
8208 | OPTI_TYPE_RAW_HASH;
8209 dgst_pos0 = 3;
8210 dgst_pos1 = 4;
8211 dgst_pos2 = 2;
8212 dgst_pos3 = 1;
8213 break;
8214
8215 case 111: hash_type = HASH_TYPE_SHA1;
8216 salt_type = SALT_TYPE_EMBEDDED;
8217 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8218 opts_type = OPTS_TYPE_PT_GENERATE_BE
8219 | OPTS_TYPE_ST_ADD80
8220 | OPTS_TYPE_ST_ADDBITS15;
8221 kern_type = KERN_TYPE_SHA1_PWSLT;
8222 dgst_size = DGST_SIZE_4_5;
8223 parse_func = sha1b64s_parse_hash;
8224 sort_by_digest = sort_by_digest_4_5;
8225 opti_type = OPTI_TYPE_ZERO_BYTE
8226 | OPTI_TYPE_PRECOMPUTE_INIT
8227 | OPTI_TYPE_PRECOMPUTE_MERKLE
8228 | OPTI_TYPE_EARLY_SKIP
8229 | OPTI_TYPE_NOT_ITERATED
8230 | OPTI_TYPE_APPENDED_SALT
8231 | OPTI_TYPE_RAW_HASH;
8232 dgst_pos0 = 3;
8233 dgst_pos1 = 4;
8234 dgst_pos2 = 2;
8235 dgst_pos3 = 1;
8236 break;
8237
8238 case 112: hash_type = HASH_TYPE_SHA1;
8239 salt_type = SALT_TYPE_INTERN;
8240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8241 opts_type = OPTS_TYPE_PT_GENERATE_BE
8242 | OPTS_TYPE_ST_ADD80
8243 | OPTS_TYPE_ST_ADDBITS15
8244 | OPTS_TYPE_ST_HEX;
8245 kern_type = KERN_TYPE_SHA1_PWSLT;
8246 dgst_size = DGST_SIZE_4_5;
8247 parse_func = oracles_parse_hash;
8248 sort_by_digest = sort_by_digest_4_5;
8249 opti_type = OPTI_TYPE_ZERO_BYTE
8250 | OPTI_TYPE_PRECOMPUTE_INIT
8251 | OPTI_TYPE_PRECOMPUTE_MERKLE
8252 | OPTI_TYPE_EARLY_SKIP
8253 | OPTI_TYPE_NOT_ITERATED
8254 | OPTI_TYPE_APPENDED_SALT
8255 | OPTI_TYPE_RAW_HASH;
8256 dgst_pos0 = 3;
8257 dgst_pos1 = 4;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 120: hash_type = HASH_TYPE_SHA1;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_BE
8266 | OPTS_TYPE_PT_ADD80
8267 | OPTS_TYPE_PT_ADDBITS15;
8268 kern_type = KERN_TYPE_SHA1_SLTPW;
8269 dgst_size = DGST_SIZE_4_5;
8270 parse_func = sha1s_parse_hash;
8271 sort_by_digest = sort_by_digest_4_5;
8272 opti_type = OPTI_TYPE_ZERO_BYTE
8273 | OPTI_TYPE_PRECOMPUTE_INIT
8274 | OPTI_TYPE_PRECOMPUTE_MERKLE
8275 | OPTI_TYPE_EARLY_SKIP
8276 | OPTI_TYPE_NOT_ITERATED
8277 | OPTI_TYPE_PREPENDED_SALT
8278 | OPTI_TYPE_RAW_HASH;
8279 dgst_pos0 = 3;
8280 dgst_pos1 = 4;
8281 dgst_pos2 = 2;
8282 dgst_pos3 = 1;
8283 break;
8284
8285 case 121: hash_type = HASH_TYPE_SHA1;
8286 salt_type = SALT_TYPE_INTERN;
8287 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8288 opts_type = OPTS_TYPE_PT_GENERATE_BE
8289 | OPTS_TYPE_PT_ADD80
8290 | OPTS_TYPE_PT_ADDBITS15
8291 | OPTS_TYPE_ST_LOWER;
8292 kern_type = KERN_TYPE_SHA1_SLTPW;
8293 dgst_size = DGST_SIZE_4_5;
8294 parse_func = smf_parse_hash;
8295 sort_by_digest = sort_by_digest_4_5;
8296 opti_type = OPTI_TYPE_ZERO_BYTE
8297 | OPTI_TYPE_PRECOMPUTE_INIT
8298 | OPTI_TYPE_PRECOMPUTE_MERKLE
8299 | OPTI_TYPE_EARLY_SKIP
8300 | OPTI_TYPE_NOT_ITERATED
8301 | OPTI_TYPE_PREPENDED_SALT
8302 | OPTI_TYPE_RAW_HASH;
8303 dgst_pos0 = 3;
8304 dgst_pos1 = 4;
8305 dgst_pos2 = 2;
8306 dgst_pos3 = 1;
8307 break;
8308
8309 case 122: hash_type = HASH_TYPE_SHA1;
8310 salt_type = SALT_TYPE_EMBEDDED;
8311 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8312 opts_type = OPTS_TYPE_PT_GENERATE_BE
8313 | OPTS_TYPE_PT_ADD80
8314 | OPTS_TYPE_PT_ADDBITS15
8315 | OPTS_TYPE_ST_HEX;
8316 kern_type = KERN_TYPE_SHA1_SLTPW;
8317 dgst_size = DGST_SIZE_4_5;
8318 parse_func = osx1_parse_hash;
8319 sort_by_digest = sort_by_digest_4_5;
8320 opti_type = OPTI_TYPE_ZERO_BYTE
8321 | OPTI_TYPE_PRECOMPUTE_INIT
8322 | OPTI_TYPE_PRECOMPUTE_MERKLE
8323 | OPTI_TYPE_EARLY_SKIP
8324 | OPTI_TYPE_NOT_ITERATED
8325 | OPTI_TYPE_PREPENDED_SALT
8326 | OPTI_TYPE_RAW_HASH;
8327 dgst_pos0 = 3;
8328 dgst_pos1 = 4;
8329 dgst_pos2 = 2;
8330 dgst_pos3 = 1;
8331 break;
8332
8333 case 124: hash_type = HASH_TYPE_SHA1;
8334 salt_type = SALT_TYPE_EMBEDDED;
8335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8336 opts_type = OPTS_TYPE_PT_GENERATE_BE
8337 | OPTS_TYPE_PT_ADD80
8338 | OPTS_TYPE_PT_ADDBITS15;
8339 kern_type = KERN_TYPE_SHA1_SLTPW;
8340 dgst_size = DGST_SIZE_4_5;
8341 parse_func = djangosha1_parse_hash;
8342 sort_by_digest = sort_by_digest_4_5;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_RAW_HASH;
8350 dgst_pos0 = 3;
8351 dgst_pos1 = 4;
8352 dgst_pos2 = 2;
8353 dgst_pos3 = 1;
8354 break;
8355
8356 case 125: hash_type = HASH_TYPE_SHA1;
8357 salt_type = SALT_TYPE_EMBEDDED;
8358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8359 opts_type = OPTS_TYPE_PT_GENERATE_BE
8360 | OPTS_TYPE_PT_ADD80
8361 | OPTS_TYPE_PT_ADDBITS15
8362 | OPTS_TYPE_ST_HEX;
8363 kern_type = KERN_TYPE_SHA1_SLTPW;
8364 dgst_size = DGST_SIZE_4_5;
8365 parse_func = arubaos_parse_hash;
8366 sort_by_digest = sort_by_digest_4_5;
8367 opti_type = OPTI_TYPE_ZERO_BYTE
8368 | OPTI_TYPE_PRECOMPUTE_INIT
8369 | OPTI_TYPE_PRECOMPUTE_MERKLE
8370 | OPTI_TYPE_EARLY_SKIP
8371 | OPTI_TYPE_NOT_ITERATED
8372 | OPTI_TYPE_PREPENDED_SALT
8373 | OPTI_TYPE_RAW_HASH;
8374 dgst_pos0 = 3;
8375 dgst_pos1 = 4;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 1;
8378 break;
8379
8380 case 130: hash_type = HASH_TYPE_SHA1;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_BE
8384 | OPTS_TYPE_PT_UNICODE
8385 | OPTS_TYPE_ST_ADD80
8386 | OPTS_TYPE_ST_ADDBITS15;
8387 kern_type = KERN_TYPE_SHA1_PWUSLT;
8388 dgst_size = DGST_SIZE_4_5;
8389 parse_func = sha1s_parse_hash;
8390 sort_by_digest = sort_by_digest_4_5;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_PRECOMPUTE_MERKLE
8394 | OPTI_TYPE_EARLY_SKIP
8395 | OPTI_TYPE_NOT_ITERATED
8396 | OPTI_TYPE_APPENDED_SALT
8397 | OPTI_TYPE_RAW_HASH;
8398 dgst_pos0 = 3;
8399 dgst_pos1 = 4;
8400 dgst_pos2 = 2;
8401 dgst_pos3 = 1;
8402 break;
8403
8404 case 131: hash_type = HASH_TYPE_SHA1;
8405 salt_type = SALT_TYPE_EMBEDDED;
8406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8407 opts_type = OPTS_TYPE_PT_GENERATE_BE
8408 | OPTS_TYPE_PT_UNICODE
8409 | OPTS_TYPE_PT_UPPER
8410 | OPTS_TYPE_ST_ADD80
8411 | OPTS_TYPE_ST_ADDBITS15
8412 | OPTS_TYPE_ST_HEX;
8413 kern_type = KERN_TYPE_SHA1_PWUSLT;
8414 dgst_size = DGST_SIZE_4_5;
8415 parse_func = mssql2000_parse_hash;
8416 sort_by_digest = sort_by_digest_4_5;
8417 opti_type = OPTI_TYPE_ZERO_BYTE
8418 | OPTI_TYPE_PRECOMPUTE_INIT
8419 | OPTI_TYPE_PRECOMPUTE_MERKLE
8420 | OPTI_TYPE_EARLY_SKIP
8421 | OPTI_TYPE_NOT_ITERATED
8422 | OPTI_TYPE_APPENDED_SALT
8423 | OPTI_TYPE_RAW_HASH;
8424 dgst_pos0 = 3;
8425 dgst_pos1 = 4;
8426 dgst_pos2 = 2;
8427 dgst_pos3 = 1;
8428 break;
8429
8430 case 132: hash_type = HASH_TYPE_SHA1;
8431 salt_type = SALT_TYPE_EMBEDDED;
8432 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8433 opts_type = OPTS_TYPE_PT_GENERATE_BE
8434 | OPTS_TYPE_PT_UNICODE
8435 | OPTS_TYPE_ST_ADD80
8436 | OPTS_TYPE_ST_ADDBITS15
8437 | OPTS_TYPE_ST_HEX;
8438 kern_type = KERN_TYPE_SHA1_PWUSLT;
8439 dgst_size = DGST_SIZE_4_5;
8440 parse_func = mssql2005_parse_hash;
8441 sort_by_digest = sort_by_digest_4_5;
8442 opti_type = OPTI_TYPE_ZERO_BYTE
8443 | OPTI_TYPE_PRECOMPUTE_INIT
8444 | OPTI_TYPE_PRECOMPUTE_MERKLE
8445 | OPTI_TYPE_EARLY_SKIP
8446 | OPTI_TYPE_NOT_ITERATED
8447 | OPTI_TYPE_APPENDED_SALT
8448 | OPTI_TYPE_RAW_HASH;
8449 dgst_pos0 = 3;
8450 dgst_pos1 = 4;
8451 dgst_pos2 = 2;
8452 dgst_pos3 = 1;
8453 break;
8454
8455 case 133: hash_type = HASH_TYPE_SHA1;
8456 salt_type = SALT_TYPE_EMBEDDED;
8457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8458 opts_type = OPTS_TYPE_PT_GENERATE_BE
8459 | OPTS_TYPE_PT_UNICODE
8460 | OPTS_TYPE_ST_ADD80
8461 | OPTS_TYPE_ST_ADDBITS15;
8462 kern_type = KERN_TYPE_SHA1_PWUSLT;
8463 dgst_size = DGST_SIZE_4_5;
8464 parse_func = peoplesoft_parse_hash;
8465 sort_by_digest = sort_by_digest_4_5;
8466 opti_type = OPTI_TYPE_ZERO_BYTE
8467 | OPTI_TYPE_PRECOMPUTE_INIT
8468 | OPTI_TYPE_PRECOMPUTE_MERKLE
8469 | OPTI_TYPE_EARLY_SKIP
8470 | OPTI_TYPE_NOT_ITERATED
8471 | OPTI_TYPE_APPENDED_SALT
8472 | OPTI_TYPE_RAW_HASH;
8473 dgst_pos0 = 3;
8474 dgst_pos1 = 4;
8475 dgst_pos2 = 2;
8476 dgst_pos3 = 1;
8477 break;
8478
8479 case 140: hash_type = HASH_TYPE_SHA1;
8480 salt_type = SALT_TYPE_INTERN;
8481 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8482 opts_type = OPTS_TYPE_PT_GENERATE_BE
8483 | OPTS_TYPE_PT_ADD80
8484 | OPTS_TYPE_PT_ADDBITS15
8485 | OPTS_TYPE_PT_UNICODE;
8486 kern_type = KERN_TYPE_SHA1_SLTPWU;
8487 dgst_size = DGST_SIZE_4_5;
8488 parse_func = sha1s_parse_hash;
8489 sort_by_digest = sort_by_digest_4_5;
8490 opti_type = OPTI_TYPE_ZERO_BYTE
8491 | OPTI_TYPE_PRECOMPUTE_INIT
8492 | OPTI_TYPE_PRECOMPUTE_MERKLE
8493 | OPTI_TYPE_EARLY_SKIP
8494 | OPTI_TYPE_NOT_ITERATED
8495 | OPTI_TYPE_PREPENDED_SALT
8496 | OPTI_TYPE_RAW_HASH;
8497 dgst_pos0 = 3;
8498 dgst_pos1 = 4;
8499 dgst_pos2 = 2;
8500 dgst_pos3 = 1;
8501 break;
8502
8503 case 141: hash_type = HASH_TYPE_SHA1;
8504 salt_type = SALT_TYPE_EMBEDDED;
8505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8506 opts_type = OPTS_TYPE_PT_GENERATE_BE
8507 | OPTS_TYPE_PT_ADD80
8508 | OPTS_TYPE_PT_ADDBITS15
8509 | OPTS_TYPE_PT_UNICODE
8510 | OPTS_TYPE_ST_BASE64;
8511 kern_type = KERN_TYPE_SHA1_SLTPWU;
8512 dgst_size = DGST_SIZE_4_5;
8513 parse_func = episerver_parse_hash;
8514 sort_by_digest = sort_by_digest_4_5;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP
8519 | OPTI_TYPE_NOT_ITERATED
8520 | OPTI_TYPE_PREPENDED_SALT
8521 | OPTI_TYPE_RAW_HASH;
8522 dgst_pos0 = 3;
8523 dgst_pos1 = 4;
8524 dgst_pos2 = 2;
8525 dgst_pos3 = 1;
8526 break;
8527
8528 case 150: hash_type = HASH_TYPE_SHA1;
8529 salt_type = SALT_TYPE_INTERN;
8530 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8531 opts_type = OPTS_TYPE_PT_GENERATE_BE
8532 | OPTS_TYPE_ST_ADD80
8533 | OPTS_TYPE_ST_ADDBITS15;
8534 kern_type = KERN_TYPE_HMACSHA1_PW;
8535 dgst_size = DGST_SIZE_4_5;
8536 parse_func = hmacsha1_parse_hash;
8537 sort_by_digest = sort_by_digest_4_5;
8538 opti_type = OPTI_TYPE_ZERO_BYTE
8539 | OPTI_TYPE_NOT_ITERATED;
8540 dgst_pos0 = 3;
8541 dgst_pos1 = 4;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 1;
8544 break;
8545
8546 case 160: hash_type = HASH_TYPE_SHA1;
8547 salt_type = SALT_TYPE_INTERN;
8548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_BE
8550 | OPTS_TYPE_PT_ADD80
8551 | OPTS_TYPE_PT_ADDBITS15;
8552 kern_type = KERN_TYPE_HMACSHA1_SLT;
8553 dgst_size = DGST_SIZE_4_5;
8554 parse_func = hmacsha1_parse_hash;
8555 sort_by_digest = sort_by_digest_4_5;
8556 opti_type = OPTI_TYPE_ZERO_BYTE
8557 | OPTI_TYPE_NOT_ITERATED;
8558 dgst_pos0 = 3;
8559 dgst_pos1 = 4;
8560 dgst_pos2 = 2;
8561 dgst_pos3 = 1;
8562 break;
8563
8564 case 200: hash_type = HASH_TYPE_MYSQL;
8565 salt_type = SALT_TYPE_NONE;
8566 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8567 opts_type = 0;
8568 kern_type = KERN_TYPE_MYSQL;
8569 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8570 parse_func = mysql323_parse_hash;
8571 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8572 opti_type = OPTI_TYPE_ZERO_BYTE;
8573 dgst_pos0 = 0;
8574 dgst_pos1 = 1;
8575 dgst_pos2 = 2;
8576 dgst_pos3 = 3;
8577 break;
8578
8579 case 300: hash_type = HASH_TYPE_SHA1;
8580 salt_type = SALT_TYPE_NONE;
8581 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8582 opts_type = OPTS_TYPE_PT_GENERATE_BE
8583 | OPTS_TYPE_PT_ADD80
8584 | OPTS_TYPE_PT_ADDBITS15;
8585 kern_type = KERN_TYPE_MYSQL41;
8586 dgst_size = DGST_SIZE_4_5;
8587 parse_func = sha1_parse_hash;
8588 sort_by_digest = sort_by_digest_4_5;
8589 opti_type = OPTI_TYPE_ZERO_BYTE
8590 | OPTI_TYPE_PRECOMPUTE_INIT
8591 | OPTI_TYPE_PRECOMPUTE_MERKLE
8592 | OPTI_TYPE_EARLY_SKIP
8593 | OPTI_TYPE_NOT_ITERATED
8594 | OPTI_TYPE_NOT_SALTED;
8595 dgst_pos0 = 3;
8596 dgst_pos1 = 4;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 1;
8599 break;
8600
8601 case 400: hash_type = HASH_TYPE_MD5;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8605 kern_type = KERN_TYPE_PHPASS;
8606 dgst_size = DGST_SIZE_4_4;
8607 parse_func = phpass_parse_hash;
8608 sort_by_digest = sort_by_digest_4_4;
8609 opti_type = OPTI_TYPE_ZERO_BYTE
8610 | OPTI_TYPE_SLOW_HASH_SIMD;
8611 dgst_pos0 = 0;
8612 dgst_pos1 = 1;
8613 dgst_pos2 = 2;
8614 dgst_pos3 = 3;
8615 break;
8616
8617 case 500: hash_type = HASH_TYPE_MD5;
8618 salt_type = SALT_TYPE_EMBEDDED;
8619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8620 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8621 kern_type = KERN_TYPE_MD5CRYPT;
8622 dgst_size = DGST_SIZE_4_4;
8623 parse_func = md5crypt_parse_hash;
8624 sort_by_digest = sort_by_digest_4_4;
8625 opti_type = OPTI_TYPE_ZERO_BYTE;
8626 dgst_pos0 = 0;
8627 dgst_pos1 = 1;
8628 dgst_pos2 = 2;
8629 dgst_pos3 = 3;
8630 break;
8631
8632 case 501: hash_type = HASH_TYPE_MD5;
8633 salt_type = SALT_TYPE_EMBEDDED;
8634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8635 opts_type = OPTS_TYPE_PT_GENERATE_LE
8636 | OPTS_TYPE_HASH_COPY;
8637 kern_type = KERN_TYPE_MD5CRYPT;
8638 dgst_size = DGST_SIZE_4_4;
8639 parse_func = juniper_parse_hash;
8640 sort_by_digest = sort_by_digest_4_4;
8641 opti_type = OPTI_TYPE_ZERO_BYTE;
8642 dgst_pos0 = 0;
8643 dgst_pos1 = 1;
8644 dgst_pos2 = 2;
8645 dgst_pos3 = 3;
8646 break;
8647
8648 case 900: hash_type = HASH_TYPE_MD4;
8649 salt_type = SALT_TYPE_NONE;
8650 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8651 opts_type = OPTS_TYPE_PT_GENERATE_LE
8652 | OPTS_TYPE_PT_ADD80
8653 | OPTS_TYPE_PT_ADDBITS14;
8654 kern_type = KERN_TYPE_MD4;
8655 dgst_size = DGST_SIZE_4_4;
8656 parse_func = md4_parse_hash;
8657 sort_by_digest = sort_by_digest_4_4;
8658 opti_type = OPTI_TYPE_ZERO_BYTE
8659 | OPTI_TYPE_PRECOMPUTE_INIT
8660 | OPTI_TYPE_PRECOMPUTE_MERKLE
8661 | OPTI_TYPE_MEET_IN_MIDDLE
8662 | OPTI_TYPE_EARLY_SKIP
8663 | OPTI_TYPE_NOT_ITERATED
8664 | OPTI_TYPE_NOT_SALTED
8665 | OPTI_TYPE_RAW_HASH;
8666 dgst_pos0 = 0;
8667 dgst_pos1 = 3;
8668 dgst_pos2 = 2;
8669 dgst_pos3 = 1;
8670 break;
8671
8672 case 1000: hash_type = HASH_TYPE_MD4;
8673 salt_type = SALT_TYPE_NONE;
8674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8675 opts_type = OPTS_TYPE_PT_GENERATE_LE
8676 | OPTS_TYPE_PT_ADD80
8677 | OPTS_TYPE_PT_ADDBITS14
8678 | OPTS_TYPE_PT_UNICODE;
8679 kern_type = KERN_TYPE_MD4_PWU;
8680 dgst_size = DGST_SIZE_4_4;
8681 parse_func = md4_parse_hash;
8682 sort_by_digest = sort_by_digest_4_4;
8683 opti_type = OPTI_TYPE_ZERO_BYTE
8684 | OPTI_TYPE_PRECOMPUTE_INIT
8685 | OPTI_TYPE_PRECOMPUTE_MERKLE
8686 | OPTI_TYPE_MEET_IN_MIDDLE
8687 | OPTI_TYPE_EARLY_SKIP
8688 | OPTI_TYPE_NOT_ITERATED
8689 | OPTI_TYPE_NOT_SALTED
8690 | OPTI_TYPE_RAW_HASH;
8691 dgst_pos0 = 0;
8692 dgst_pos1 = 3;
8693 dgst_pos2 = 2;
8694 dgst_pos3 = 1;
8695 break;
8696
8697 case 1100: hash_type = HASH_TYPE_MD4;
8698 salt_type = SALT_TYPE_INTERN;
8699 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8700 opts_type = OPTS_TYPE_PT_GENERATE_LE
8701 | OPTS_TYPE_PT_ADD80
8702 | OPTS_TYPE_PT_ADDBITS14
8703 | OPTS_TYPE_PT_UNICODE
8704 | OPTS_TYPE_ST_ADD80
8705 | OPTS_TYPE_ST_UNICODE
8706 | OPTS_TYPE_ST_LOWER;
8707 kern_type = KERN_TYPE_MD44_PWUSLT;
8708 dgst_size = DGST_SIZE_4_4;
8709 parse_func = dcc_parse_hash;
8710 sort_by_digest = sort_by_digest_4_4;
8711 opti_type = OPTI_TYPE_ZERO_BYTE
8712 | OPTI_TYPE_PRECOMPUTE_INIT
8713 | OPTI_TYPE_PRECOMPUTE_MERKLE
8714 | OPTI_TYPE_EARLY_SKIP
8715 | OPTI_TYPE_NOT_ITERATED;
8716 dgst_pos0 = 0;
8717 dgst_pos1 = 3;
8718 dgst_pos2 = 2;
8719 dgst_pos3 = 1;
8720 break;
8721
8722 case 1400: hash_type = HASH_TYPE_SHA256;
8723 salt_type = SALT_TYPE_NONE;
8724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8725 opts_type = OPTS_TYPE_PT_GENERATE_BE
8726 | OPTS_TYPE_PT_ADD80
8727 | OPTS_TYPE_PT_ADDBITS15;
8728 kern_type = KERN_TYPE_SHA256;
8729 dgst_size = DGST_SIZE_4_8;
8730 parse_func = sha256_parse_hash;
8731 sort_by_digest = sort_by_digest_4_8;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_PRECOMPUTE_INIT
8734 | OPTI_TYPE_PRECOMPUTE_MERKLE
8735 | OPTI_TYPE_EARLY_SKIP
8736 | OPTI_TYPE_NOT_ITERATED
8737 | OPTI_TYPE_NOT_SALTED
8738 | OPTI_TYPE_RAW_HASH;
8739 dgst_pos0 = 3;
8740 dgst_pos1 = 7;
8741 dgst_pos2 = 2;
8742 dgst_pos3 = 6;
8743 break;
8744
8745 case 1410: hash_type = HASH_TYPE_SHA256;
8746 salt_type = SALT_TYPE_INTERN;
8747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8748 opts_type = OPTS_TYPE_PT_GENERATE_BE
8749 | OPTS_TYPE_ST_ADD80
8750 | OPTS_TYPE_ST_ADDBITS15;
8751 kern_type = KERN_TYPE_SHA256_PWSLT;
8752 dgst_size = DGST_SIZE_4_8;
8753 parse_func = sha256s_parse_hash;
8754 sort_by_digest = sort_by_digest_4_8;
8755 opti_type = OPTI_TYPE_ZERO_BYTE
8756 | OPTI_TYPE_PRECOMPUTE_INIT
8757 | OPTI_TYPE_PRECOMPUTE_MERKLE
8758 | OPTI_TYPE_EARLY_SKIP
8759 | OPTI_TYPE_NOT_ITERATED
8760 | OPTI_TYPE_APPENDED_SALT
8761 | OPTI_TYPE_RAW_HASH;
8762 dgst_pos0 = 3;
8763 dgst_pos1 = 7;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 6;
8766 break;
8767
8768 case 1420: hash_type = HASH_TYPE_SHA256;
8769 salt_type = SALT_TYPE_INTERN;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE
8772 | OPTS_TYPE_PT_ADD80
8773 | OPTS_TYPE_PT_ADDBITS15;
8774 kern_type = KERN_TYPE_SHA256_SLTPW;
8775 dgst_size = DGST_SIZE_4_8;
8776 parse_func = sha256s_parse_hash;
8777 sort_by_digest = sort_by_digest_4_8;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_PRECOMPUTE_MERKLE
8781 | OPTI_TYPE_EARLY_SKIP
8782 | OPTI_TYPE_NOT_ITERATED
8783 | OPTI_TYPE_PREPENDED_SALT
8784 | OPTI_TYPE_RAW_HASH;
8785 dgst_pos0 = 3;
8786 dgst_pos1 = 7;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 6;
8789 break;
8790
8791 case 1421: hash_type = HASH_TYPE_SHA256;
8792 salt_type = SALT_TYPE_EMBEDDED;
8793 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_BE
8795 | OPTS_TYPE_PT_ADD80
8796 | OPTS_TYPE_PT_ADDBITS15;
8797 kern_type = KERN_TYPE_SHA256_SLTPW;
8798 dgst_size = DGST_SIZE_4_8;
8799 parse_func = hmailserver_parse_hash;
8800 sort_by_digest = sort_by_digest_4_8;
8801 opti_type = OPTI_TYPE_ZERO_BYTE
8802 | OPTI_TYPE_PRECOMPUTE_INIT
8803 | OPTI_TYPE_PRECOMPUTE_MERKLE
8804 | OPTI_TYPE_EARLY_SKIP
8805 | OPTI_TYPE_NOT_ITERATED
8806 | OPTI_TYPE_PREPENDED_SALT
8807 | OPTI_TYPE_RAW_HASH;
8808 dgst_pos0 = 3;
8809 dgst_pos1 = 7;
8810 dgst_pos2 = 2;
8811 dgst_pos3 = 6;
8812 break;
8813
8814 case 1430: hash_type = HASH_TYPE_SHA256;
8815 salt_type = SALT_TYPE_INTERN;
8816 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8817 opts_type = OPTS_TYPE_PT_GENERATE_BE
8818 | OPTS_TYPE_PT_UNICODE
8819 | OPTS_TYPE_ST_ADD80
8820 | OPTS_TYPE_ST_ADDBITS15;
8821 kern_type = KERN_TYPE_SHA256_PWUSLT;
8822 dgst_size = DGST_SIZE_4_8;
8823 parse_func = sha256s_parse_hash;
8824 sort_by_digest = sort_by_digest_4_8;
8825 opti_type = OPTI_TYPE_ZERO_BYTE
8826 | OPTI_TYPE_PRECOMPUTE_INIT
8827 | OPTI_TYPE_PRECOMPUTE_MERKLE
8828 | OPTI_TYPE_EARLY_SKIP
8829 | OPTI_TYPE_NOT_ITERATED
8830 | OPTI_TYPE_APPENDED_SALT
8831 | OPTI_TYPE_RAW_HASH;
8832 dgst_pos0 = 3;
8833 dgst_pos1 = 7;
8834 dgst_pos2 = 2;
8835 dgst_pos3 = 6;
8836 break;
8837
8838 case 1440: hash_type = HASH_TYPE_SHA256;
8839 salt_type = SALT_TYPE_INTERN;
8840 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8841 opts_type = OPTS_TYPE_PT_GENERATE_BE
8842 | OPTS_TYPE_PT_ADD80
8843 | OPTS_TYPE_PT_ADDBITS15
8844 | OPTS_TYPE_PT_UNICODE;
8845 kern_type = KERN_TYPE_SHA256_SLTPWU;
8846 dgst_size = DGST_SIZE_4_8;
8847 parse_func = sha256s_parse_hash;
8848 sort_by_digest = sort_by_digest_4_8;
8849 opti_type = OPTI_TYPE_ZERO_BYTE
8850 | OPTI_TYPE_PRECOMPUTE_INIT
8851 | OPTI_TYPE_PRECOMPUTE_MERKLE
8852 | OPTI_TYPE_EARLY_SKIP
8853 | OPTI_TYPE_NOT_ITERATED
8854 | OPTI_TYPE_PREPENDED_SALT
8855 | OPTI_TYPE_RAW_HASH;
8856 dgst_pos0 = 3;
8857 dgst_pos1 = 7;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 6;
8860 break;
8861
8862 case 1441: hash_type = HASH_TYPE_SHA256;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_BE
8866 | OPTS_TYPE_PT_ADD80
8867 | OPTS_TYPE_PT_ADDBITS15
8868 | OPTS_TYPE_PT_UNICODE
8869 | OPTS_TYPE_ST_BASE64;
8870 kern_type = KERN_TYPE_SHA256_SLTPWU;
8871 dgst_size = DGST_SIZE_4_8;
8872 parse_func = episerver4_parse_hash;
8873 sort_by_digest = sort_by_digest_4_8;
8874 opti_type = OPTI_TYPE_ZERO_BYTE
8875 | OPTI_TYPE_PRECOMPUTE_INIT
8876 | OPTI_TYPE_PRECOMPUTE_MERKLE
8877 | OPTI_TYPE_EARLY_SKIP
8878 | OPTI_TYPE_NOT_ITERATED
8879 | OPTI_TYPE_PREPENDED_SALT
8880 | OPTI_TYPE_RAW_HASH;
8881 dgst_pos0 = 3;
8882 dgst_pos1 = 7;
8883 dgst_pos2 = 2;
8884 dgst_pos3 = 6;
8885 break;
8886
8887 case 1450: hash_type = HASH_TYPE_SHA256;
8888 salt_type = SALT_TYPE_INTERN;
8889 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8890 opts_type = OPTS_TYPE_PT_GENERATE_BE
8891 | OPTS_TYPE_ST_ADD80;
8892 kern_type = KERN_TYPE_HMACSHA256_PW;
8893 dgst_size = DGST_SIZE_4_8;
8894 parse_func = hmacsha256_parse_hash;
8895 sort_by_digest = sort_by_digest_4_8;
8896 opti_type = OPTI_TYPE_ZERO_BYTE
8897 | OPTI_TYPE_NOT_ITERATED;
8898 dgst_pos0 = 3;
8899 dgst_pos1 = 7;
8900 dgst_pos2 = 2;
8901 dgst_pos3 = 6;
8902 break;
8903
8904 case 1460: hash_type = HASH_TYPE_SHA256;
8905 salt_type = SALT_TYPE_INTERN;
8906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8907 opts_type = OPTS_TYPE_PT_GENERATE_BE
8908 | OPTS_TYPE_PT_ADD80
8909 | OPTS_TYPE_PT_ADDBITS15;
8910 kern_type = KERN_TYPE_HMACSHA256_SLT;
8911 dgst_size = DGST_SIZE_4_8;
8912 parse_func = hmacsha256_parse_hash;
8913 sort_by_digest = sort_by_digest_4_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE
8915 | OPTI_TYPE_NOT_ITERATED;
8916 dgst_pos0 = 3;
8917 dgst_pos1 = 7;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 6;
8920 break;
8921
8922 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE
8926 | OPTS_TYPE_PT_BITSLICE;
8927 kern_type = KERN_TYPE_DESCRYPT;
8928 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8929 parse_func = descrypt_parse_hash;
8930 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8931 opti_type = OPTI_TYPE_ZERO_BYTE
8932 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 1600: hash_type = HASH_TYPE_MD5;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_APR1CRYPT;
8944 dgst_size = DGST_SIZE_4_4;
8945 parse_func = md5apr1_parse_hash;
8946 sort_by_digest = sort_by_digest_4_4;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 1700: hash_type = HASH_TYPE_SHA512;
8955 salt_type = SALT_TYPE_NONE;
8956 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_BE
8958 | OPTS_TYPE_PT_ADD80
8959 | OPTS_TYPE_PT_ADDBITS15;
8960 kern_type = KERN_TYPE_SHA512;
8961 dgst_size = DGST_SIZE_8_8;
8962 parse_func = sha512_parse_hash;
8963 sort_by_digest = sort_by_digest_8_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE
8965 | OPTI_TYPE_PRECOMPUTE_INIT
8966 | OPTI_TYPE_PRECOMPUTE_MERKLE
8967 | OPTI_TYPE_EARLY_SKIP
8968 | OPTI_TYPE_NOT_ITERATED
8969 | OPTI_TYPE_NOT_SALTED
8970 | OPTI_TYPE_USES_BITS_64
8971 | OPTI_TYPE_RAW_HASH;
8972 dgst_pos0 = 14;
8973 dgst_pos1 = 15;
8974 dgst_pos2 = 6;
8975 dgst_pos3 = 7;
8976 break;
8977
8978 case 1710: hash_type = HASH_TYPE_SHA512;
8979 salt_type = SALT_TYPE_INTERN;
8980 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_BE
8982 | OPTS_TYPE_ST_ADD80
8983 | OPTS_TYPE_ST_ADDBITS15;
8984 kern_type = KERN_TYPE_SHA512_PWSLT;
8985 dgst_size = DGST_SIZE_8_8;
8986 parse_func = sha512s_parse_hash;
8987 sort_by_digest = sort_by_digest_8_8;
8988 opti_type = OPTI_TYPE_ZERO_BYTE
8989 | OPTI_TYPE_PRECOMPUTE_INIT
8990 | OPTI_TYPE_PRECOMPUTE_MERKLE
8991 | OPTI_TYPE_EARLY_SKIP
8992 | OPTI_TYPE_NOT_ITERATED
8993 | OPTI_TYPE_APPENDED_SALT
8994 | OPTI_TYPE_USES_BITS_64
8995 | OPTI_TYPE_RAW_HASH;
8996 dgst_pos0 = 14;
8997 dgst_pos1 = 15;
8998 dgst_pos2 = 6;
8999 dgst_pos3 = 7;
9000 break;
9001
9002 case 1711: hash_type = HASH_TYPE_SHA512;
9003 salt_type = SALT_TYPE_EMBEDDED;
9004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9005 opts_type = OPTS_TYPE_PT_GENERATE_BE
9006 | OPTS_TYPE_ST_ADD80
9007 | OPTS_TYPE_ST_ADDBITS15;
9008 kern_type = KERN_TYPE_SHA512_PWSLT;
9009 dgst_size = DGST_SIZE_8_8;
9010 parse_func = sha512b64s_parse_hash;
9011 sort_by_digest = sort_by_digest_8_8;
9012 opti_type = OPTI_TYPE_ZERO_BYTE
9013 | OPTI_TYPE_PRECOMPUTE_INIT
9014 | OPTI_TYPE_PRECOMPUTE_MERKLE
9015 | OPTI_TYPE_EARLY_SKIP
9016 | OPTI_TYPE_NOT_ITERATED
9017 | OPTI_TYPE_APPENDED_SALT
9018 | OPTI_TYPE_USES_BITS_64
9019 | OPTI_TYPE_RAW_HASH;
9020 dgst_pos0 = 14;
9021 dgst_pos1 = 15;
9022 dgst_pos2 = 6;
9023 dgst_pos3 = 7;
9024 break;
9025
9026 case 1720: hash_type = HASH_TYPE_SHA512;
9027 salt_type = SALT_TYPE_INTERN;
9028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9029 opts_type = OPTS_TYPE_PT_GENERATE_BE
9030 | OPTS_TYPE_PT_ADD80
9031 | OPTS_TYPE_PT_ADDBITS15;
9032 kern_type = KERN_TYPE_SHA512_SLTPW;
9033 dgst_size = DGST_SIZE_8_8;
9034 parse_func = sha512s_parse_hash;
9035 sort_by_digest = sort_by_digest_8_8;
9036 opti_type = OPTI_TYPE_ZERO_BYTE
9037 | OPTI_TYPE_PRECOMPUTE_INIT
9038 | OPTI_TYPE_PRECOMPUTE_MERKLE
9039 | OPTI_TYPE_EARLY_SKIP
9040 | OPTI_TYPE_NOT_ITERATED
9041 | OPTI_TYPE_PREPENDED_SALT
9042 | OPTI_TYPE_USES_BITS_64
9043 | OPTI_TYPE_RAW_HASH;
9044 dgst_pos0 = 14;
9045 dgst_pos1 = 15;
9046 dgst_pos2 = 6;
9047 dgst_pos3 = 7;
9048 break;
9049
9050 case 1722: hash_type = HASH_TYPE_SHA512;
9051 salt_type = SALT_TYPE_EMBEDDED;
9052 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9053 opts_type = OPTS_TYPE_PT_GENERATE_BE
9054 | OPTS_TYPE_PT_ADD80
9055 | OPTS_TYPE_PT_ADDBITS15
9056 | OPTS_TYPE_ST_HEX;
9057 kern_type = KERN_TYPE_SHA512_SLTPW;
9058 dgst_size = DGST_SIZE_8_8;
9059 parse_func = osx512_parse_hash;
9060 sort_by_digest = sort_by_digest_8_8;
9061 opti_type = OPTI_TYPE_ZERO_BYTE
9062 | OPTI_TYPE_PRECOMPUTE_INIT
9063 | OPTI_TYPE_PRECOMPUTE_MERKLE
9064 | OPTI_TYPE_EARLY_SKIP
9065 | OPTI_TYPE_NOT_ITERATED
9066 | OPTI_TYPE_PREPENDED_SALT
9067 | OPTI_TYPE_USES_BITS_64
9068 | OPTI_TYPE_RAW_HASH;
9069 dgst_pos0 = 14;
9070 dgst_pos1 = 15;
9071 dgst_pos2 = 6;
9072 dgst_pos3 = 7;
9073 break;
9074
9075 case 1730: hash_type = HASH_TYPE_SHA512;
9076 salt_type = SALT_TYPE_INTERN;
9077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_BE
9079 | OPTS_TYPE_PT_UNICODE
9080 | OPTS_TYPE_ST_ADD80
9081 | OPTS_TYPE_ST_ADDBITS15;
9082 kern_type = KERN_TYPE_SHA512_PWSLTU;
9083 dgst_size = DGST_SIZE_8_8;
9084 parse_func = sha512s_parse_hash;
9085 sort_by_digest = sort_by_digest_8_8;
9086 opti_type = OPTI_TYPE_ZERO_BYTE
9087 | OPTI_TYPE_PRECOMPUTE_INIT
9088 | OPTI_TYPE_PRECOMPUTE_MERKLE
9089 | OPTI_TYPE_EARLY_SKIP
9090 | OPTI_TYPE_NOT_ITERATED
9091 | OPTI_TYPE_APPENDED_SALT
9092 | OPTI_TYPE_USES_BITS_64
9093 | OPTI_TYPE_RAW_HASH;
9094 dgst_pos0 = 14;
9095 dgst_pos1 = 15;
9096 dgst_pos2 = 6;
9097 dgst_pos3 = 7;
9098 break;
9099
9100 case 1731: hash_type = HASH_TYPE_SHA512;
9101 salt_type = SALT_TYPE_EMBEDDED;
9102 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9103 opts_type = OPTS_TYPE_PT_GENERATE_BE
9104 | OPTS_TYPE_PT_UNICODE
9105 | OPTS_TYPE_ST_ADD80
9106 | OPTS_TYPE_ST_ADDBITS15
9107 | OPTS_TYPE_ST_HEX;
9108 kern_type = KERN_TYPE_SHA512_PWSLTU;
9109 dgst_size = DGST_SIZE_8_8;
9110 parse_func = mssql2012_parse_hash;
9111 sort_by_digest = sort_by_digest_8_8;
9112 opti_type = OPTI_TYPE_ZERO_BYTE
9113 | OPTI_TYPE_PRECOMPUTE_INIT
9114 | OPTI_TYPE_PRECOMPUTE_MERKLE
9115 | OPTI_TYPE_EARLY_SKIP
9116 | OPTI_TYPE_NOT_ITERATED
9117 | OPTI_TYPE_APPENDED_SALT
9118 | OPTI_TYPE_USES_BITS_64
9119 | OPTI_TYPE_RAW_HASH;
9120 dgst_pos0 = 14;
9121 dgst_pos1 = 15;
9122 dgst_pos2 = 6;
9123 dgst_pos3 = 7;
9124 break;
9125
9126 case 1740: hash_type = HASH_TYPE_SHA512;
9127 salt_type = SALT_TYPE_INTERN;
9128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9129 opts_type = OPTS_TYPE_PT_GENERATE_BE
9130 | OPTS_TYPE_PT_ADD80
9131 | OPTS_TYPE_PT_ADDBITS15
9132 | OPTS_TYPE_PT_UNICODE;
9133 kern_type = KERN_TYPE_SHA512_SLTPWU;
9134 dgst_size = DGST_SIZE_8_8;
9135 parse_func = sha512s_parse_hash;
9136 sort_by_digest = sort_by_digest_8_8;
9137 opti_type = OPTI_TYPE_ZERO_BYTE
9138 | OPTI_TYPE_PRECOMPUTE_INIT
9139 | OPTI_TYPE_PRECOMPUTE_MERKLE
9140 | OPTI_TYPE_EARLY_SKIP
9141 | OPTI_TYPE_NOT_ITERATED
9142 | OPTI_TYPE_PREPENDED_SALT
9143 | OPTI_TYPE_USES_BITS_64
9144 | OPTI_TYPE_RAW_HASH;
9145 dgst_pos0 = 14;
9146 dgst_pos1 = 15;
9147 dgst_pos2 = 6;
9148 dgst_pos3 = 7;
9149 break;
9150
9151 case 1750: hash_type = HASH_TYPE_SHA512;
9152 salt_type = SALT_TYPE_INTERN;
9153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9154 opts_type = OPTS_TYPE_PT_GENERATE_BE
9155 | OPTS_TYPE_ST_ADD80;
9156 kern_type = KERN_TYPE_HMACSHA512_PW;
9157 dgst_size = DGST_SIZE_8_8;
9158 parse_func = hmacsha512_parse_hash;
9159 sort_by_digest = sort_by_digest_8_8;
9160 opti_type = OPTI_TYPE_ZERO_BYTE
9161 | OPTI_TYPE_USES_BITS_64
9162 | OPTI_TYPE_NOT_ITERATED;
9163 dgst_pos0 = 14;
9164 dgst_pos1 = 15;
9165 dgst_pos2 = 6;
9166 dgst_pos3 = 7;
9167 break;
9168
9169 case 1760: hash_type = HASH_TYPE_SHA512;
9170 salt_type = SALT_TYPE_INTERN;
9171 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9172 opts_type = OPTS_TYPE_PT_GENERATE_BE
9173 | OPTS_TYPE_PT_ADD80
9174 | OPTS_TYPE_PT_ADDBITS15;
9175 kern_type = KERN_TYPE_HMACSHA512_SLT;
9176 dgst_size = DGST_SIZE_8_8;
9177 parse_func = hmacsha512_parse_hash;
9178 sort_by_digest = sort_by_digest_8_8;
9179 opti_type = OPTI_TYPE_ZERO_BYTE
9180 | OPTI_TYPE_USES_BITS_64
9181 | OPTI_TYPE_NOT_ITERATED;
9182 dgst_pos0 = 14;
9183 dgst_pos1 = 15;
9184 dgst_pos2 = 6;
9185 dgst_pos3 = 7;
9186 break;
9187
9188 case 1800: hash_type = HASH_TYPE_SHA512;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9192 kern_type = KERN_TYPE_SHA512CRYPT;
9193 dgst_size = DGST_SIZE_8_8;
9194 parse_func = sha512crypt_parse_hash;
9195 sort_by_digest = sort_by_digest_8_8;
9196 opti_type = OPTI_TYPE_ZERO_BYTE
9197 | OPTI_TYPE_USES_BITS_64;
9198 dgst_pos0 = 0;
9199 dgst_pos1 = 1;
9200 dgst_pos2 = 2;
9201 dgst_pos3 = 3;
9202 break;
9203
9204 case 2000: hash_type = HASH_TYPE_STDOUT;
9205 salt_type = SALT_TYPE_NONE;
9206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9208 kern_type = KERN_TYPE_STDOUT;
9209 dgst_size = DGST_SIZE_4_4;
9210 parse_func = NULL;
9211 sort_by_digest = NULL;
9212 opti_type = 0;
9213 dgst_pos0 = 0;
9214 dgst_pos1 = 0;
9215 dgst_pos2 = 0;
9216 dgst_pos3 = 0;
9217 break;
9218
9219 case 2100: hash_type = HASH_TYPE_DCC2;
9220 salt_type = SALT_TYPE_EMBEDDED;
9221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9222 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9223 | OPTS_TYPE_ST_LOWER
9224 | OPTS_TYPE_ST_UNICODE;
9225 kern_type = KERN_TYPE_DCC2;
9226 dgst_size = DGST_SIZE_4_4;
9227 parse_func = dcc2_parse_hash;
9228 sort_by_digest = sort_by_digest_4_4;
9229 opti_type = OPTI_TYPE_ZERO_BYTE
9230 | OPTI_TYPE_SLOW_HASH_SIMD;
9231 dgst_pos0 = 0;
9232 dgst_pos1 = 1;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 3;
9235 break;
9236
9237 case 2400: hash_type = HASH_TYPE_MD5;
9238 salt_type = SALT_TYPE_NONE;
9239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9241 kern_type = KERN_TYPE_MD5PIX;
9242 dgst_size = DGST_SIZE_4_4;
9243 parse_func = md5pix_parse_hash;
9244 sort_by_digest = sort_by_digest_4_4;
9245 opti_type = OPTI_TYPE_ZERO_BYTE
9246 | OPTI_TYPE_PRECOMPUTE_INIT
9247 | OPTI_TYPE_PRECOMPUTE_MERKLE
9248 | OPTI_TYPE_EARLY_SKIP
9249 | OPTI_TYPE_NOT_ITERATED
9250 | OPTI_TYPE_NOT_SALTED;
9251 dgst_pos0 = 0;
9252 dgst_pos1 = 3;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 1;
9255 break;
9256
9257 case 2410: hash_type = HASH_TYPE_MD5;
9258 salt_type = SALT_TYPE_INTERN;
9259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9261 kern_type = KERN_TYPE_MD5ASA;
9262 dgst_size = DGST_SIZE_4_4;
9263 parse_func = md5asa_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 | OPTI_TYPE_NOT_ITERATED;
9270 dgst_pos0 = 0;
9271 dgst_pos1 = 3;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 1;
9274 break;
9275
9276 case 2500: hash_type = HASH_TYPE_WPA;
9277 salt_type = SALT_TYPE_EMBEDDED;
9278 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9280 kern_type = KERN_TYPE_WPA;
9281 dgst_size = DGST_SIZE_4_4;
9282 parse_func = wpa_parse_hash;
9283 sort_by_digest = sort_by_digest_4_4;
9284 opti_type = OPTI_TYPE_ZERO_BYTE
9285 | OPTI_TYPE_SLOW_HASH_SIMD;
9286 dgst_pos0 = 0;
9287 dgst_pos1 = 1;
9288 dgst_pos2 = 2;
9289 dgst_pos3 = 3;
9290 break;
9291
9292 case 2600: hash_type = HASH_TYPE_MD5;
9293 salt_type = SALT_TYPE_VIRTUAL;
9294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9295 opts_type = OPTS_TYPE_PT_GENERATE_LE
9296 | OPTS_TYPE_PT_ADD80
9297 | OPTS_TYPE_PT_ADDBITS14
9298 | OPTS_TYPE_ST_ADD80;
9299 kern_type = KERN_TYPE_MD55_PWSLT1;
9300 dgst_size = DGST_SIZE_4_4;
9301 parse_func = md5md5_parse_hash;
9302 sort_by_digest = sort_by_digest_4_4;
9303 opti_type = OPTI_TYPE_ZERO_BYTE
9304 | OPTI_TYPE_PRECOMPUTE_INIT
9305 | OPTI_TYPE_PRECOMPUTE_MERKLE
9306 | OPTI_TYPE_EARLY_SKIP;
9307 dgst_pos0 = 0;
9308 dgst_pos1 = 3;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 1;
9311 break;
9312
9313 case 2611: hash_type = HASH_TYPE_MD5;
9314 salt_type = SALT_TYPE_INTERN;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_LE
9317 | OPTS_TYPE_PT_ADD80
9318 | OPTS_TYPE_PT_ADDBITS14
9319 | OPTS_TYPE_ST_ADD80;
9320 kern_type = KERN_TYPE_MD55_PWSLT1;
9321 dgst_size = DGST_SIZE_4_4;
9322 parse_func = vb3_parse_hash;
9323 sort_by_digest = sort_by_digest_4_4;
9324 opti_type = OPTI_TYPE_ZERO_BYTE
9325 | OPTI_TYPE_PRECOMPUTE_INIT
9326 | OPTI_TYPE_PRECOMPUTE_MERKLE
9327 | OPTI_TYPE_EARLY_SKIP;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 3;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 1;
9332 break;
9333
9334 case 2612: hash_type = HASH_TYPE_MD5;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE
9338 | OPTS_TYPE_PT_ADD80
9339 | OPTS_TYPE_PT_ADDBITS14
9340 | OPTS_TYPE_ST_ADD80
9341 | OPTS_TYPE_ST_HEX;
9342 kern_type = KERN_TYPE_MD55_PWSLT1;
9343 dgst_size = DGST_SIZE_4_4;
9344 parse_func = phps_parse_hash;
9345 sort_by_digest = sort_by_digest_4_4;
9346 opti_type = OPTI_TYPE_ZERO_BYTE
9347 | OPTI_TYPE_PRECOMPUTE_INIT
9348 | OPTI_TYPE_PRECOMPUTE_MERKLE
9349 | OPTI_TYPE_EARLY_SKIP;
9350 dgst_pos0 = 0;
9351 dgst_pos1 = 3;
9352 dgst_pos2 = 2;
9353 dgst_pos3 = 1;
9354 break;
9355
9356 case 2711: hash_type = HASH_TYPE_MD5;
9357 salt_type = SALT_TYPE_INTERN;
9358 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9359 opts_type = OPTS_TYPE_PT_GENERATE_LE
9360 | OPTS_TYPE_PT_ADD80
9361 | OPTS_TYPE_PT_ADDBITS14
9362 | OPTS_TYPE_ST_ADD80;
9363 kern_type = KERN_TYPE_MD55_PWSLT2;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = vb30_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_ZERO_BYTE
9368 | OPTI_TYPE_PRECOMPUTE_INIT
9369 | OPTI_TYPE_EARLY_SKIP;
9370 dgst_pos0 = 0;
9371 dgst_pos1 = 3;
9372 dgst_pos2 = 2;
9373 dgst_pos3 = 1;
9374 break;
9375
9376 case 2811: hash_type = HASH_TYPE_MD5;
9377 salt_type = SALT_TYPE_INTERN;
9378 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9379 opts_type = OPTS_TYPE_PT_GENERATE_LE
9380 | OPTS_TYPE_PT_ADD80
9381 | OPTS_TYPE_PT_ADDBITS14;
9382 kern_type = KERN_TYPE_MD55_SLTPW;
9383 dgst_size = DGST_SIZE_4_4;
9384 parse_func = ipb2_parse_hash;
9385 sort_by_digest = sort_by_digest_4_4;
9386 opti_type = OPTI_TYPE_ZERO_BYTE
9387 | OPTI_TYPE_PRECOMPUTE_INIT
9388 | OPTI_TYPE_EARLY_SKIP;
9389 dgst_pos0 = 0;
9390 dgst_pos1 = 3;
9391 dgst_pos2 = 2;
9392 dgst_pos3 = 1;
9393 break;
9394
9395 case 3000: hash_type = HASH_TYPE_LM;
9396 salt_type = SALT_TYPE_NONE;
9397 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9398 opts_type = OPTS_TYPE_PT_GENERATE_LE
9399 | OPTS_TYPE_PT_UPPER
9400 | OPTS_TYPE_PT_BITSLICE;
9401 kern_type = KERN_TYPE_LM;
9402 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9403 parse_func = lm_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9405 opti_type = OPTI_TYPE_ZERO_BYTE
9406 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9407 dgst_pos0 = 0;
9408 dgst_pos1 = 1;
9409 dgst_pos2 = 2;
9410 dgst_pos3 = 3;
9411 break;
9412
9413 case 3100: hash_type = HASH_TYPE_ORACLEH;
9414 salt_type = SALT_TYPE_INTERN;
9415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9416 opts_type = OPTS_TYPE_PT_GENERATE_LE
9417 | OPTS_TYPE_PT_UPPER
9418 | OPTS_TYPE_ST_UPPER;
9419 kern_type = KERN_TYPE_ORACLEH;
9420 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9421 parse_func = oracleh_parse_hash;
9422 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9423 opti_type = OPTI_TYPE_ZERO_BYTE;
9424 dgst_pos0 = 0;
9425 dgst_pos1 = 1;
9426 dgst_pos2 = 2;
9427 dgst_pos3 = 3;
9428 break;
9429
9430 case 3200: hash_type = HASH_TYPE_BCRYPT;
9431 salt_type = SALT_TYPE_EMBEDDED;
9432 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9433 opts_type = OPTS_TYPE_PT_GENERATE_LE
9434 | OPTS_TYPE_ST_GENERATE_LE;
9435 kern_type = KERN_TYPE_BCRYPT;
9436 dgst_size = DGST_SIZE_4_6;
9437 parse_func = bcrypt_parse_hash;
9438 sort_by_digest = sort_by_digest_4_6;
9439 opti_type = OPTI_TYPE_ZERO_BYTE;
9440 dgst_pos0 = 0;
9441 dgst_pos1 = 1;
9442 dgst_pos2 = 2;
9443 dgst_pos3 = 3;
9444 break;
9445
9446 case 3710: hash_type = HASH_TYPE_MD5;
9447 salt_type = SALT_TYPE_INTERN;
9448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9449 opts_type = OPTS_TYPE_PT_GENERATE_LE
9450 | OPTS_TYPE_PT_ADD80
9451 | OPTS_TYPE_PT_ADDBITS14;
9452 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9453 dgst_size = DGST_SIZE_4_4;
9454 parse_func = md5s_parse_hash;
9455 sort_by_digest = sort_by_digest_4_4;
9456 opti_type = OPTI_TYPE_ZERO_BYTE
9457 | OPTI_TYPE_PRECOMPUTE_INIT
9458 | OPTI_TYPE_PRECOMPUTE_MERKLE
9459 | OPTI_TYPE_EARLY_SKIP;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 3;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 1;
9464 break;
9465
9466 case 3711: hash_type = HASH_TYPE_MD5;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_LE
9470 | OPTS_TYPE_PT_ADD80
9471 | OPTS_TYPE_PT_ADDBITS14;
9472 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
9473 dgst_size = DGST_SIZE_4_4;
9474 parse_func = mediawiki_b_parse_hash;
9475 sort_by_digest = sort_by_digest_4_4;
9476 opti_type = OPTI_TYPE_ZERO_BYTE
9477 | OPTI_TYPE_PRECOMPUTE_INIT
9478 | OPTI_TYPE_PRECOMPUTE_MERKLE
9479 | OPTI_TYPE_EARLY_SKIP;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 3;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 1;
9484 break;
9485
9486 case 3800: hash_type = HASH_TYPE_MD5;
9487 salt_type = SALT_TYPE_INTERN;
9488 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE
9490 | OPTS_TYPE_ST_ADDBITS14;
9491 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
9492 dgst_size = DGST_SIZE_4_4;
9493 parse_func = md5s_parse_hash;
9494 sort_by_digest = sort_by_digest_4_4;
9495 opti_type = OPTI_TYPE_ZERO_BYTE
9496 | OPTI_TYPE_PRECOMPUTE_INIT
9497 | OPTI_TYPE_PRECOMPUTE_MERKLE
9498 | OPTI_TYPE_EARLY_SKIP
9499 | OPTI_TYPE_NOT_ITERATED
9500 | OPTI_TYPE_RAW_HASH;
9501 dgst_pos0 = 0;
9502 dgst_pos1 = 3;
9503 dgst_pos2 = 2;
9504 dgst_pos3 = 1;
9505 break;
9506
9507 case 4300: hash_type = HASH_TYPE_MD5;
9508 salt_type = SALT_TYPE_VIRTUAL;
9509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9510 opts_type = OPTS_TYPE_PT_GENERATE_LE
9511 | OPTS_TYPE_PT_ADD80
9512 | OPTS_TYPE_PT_ADDBITS14
9513 | OPTS_TYPE_ST_ADD80;
9514 kern_type = KERN_TYPE_MD5U5_PWSLT1;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = md5md5_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE
9519 | OPTI_TYPE_PRECOMPUTE_INIT
9520 | OPTI_TYPE_PRECOMPUTE_MERKLE
9521 | OPTI_TYPE_EARLY_SKIP;
9522 dgst_pos0 = 0;
9523 dgst_pos1 = 3;
9524 dgst_pos2 = 2;
9525 dgst_pos3 = 1;
9526 break;
9527
9528
9529 case 4400: hash_type = HASH_TYPE_MD5;
9530 salt_type = SALT_TYPE_NONE;
9531 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_BE
9533 | OPTS_TYPE_PT_ADD80
9534 | OPTS_TYPE_PT_ADDBITS15;
9535 kern_type = KERN_TYPE_MD5_SHA1;
9536 dgst_size = DGST_SIZE_4_4;
9537 parse_func = md5_parse_hash;
9538 sort_by_digest = sort_by_digest_4_4;
9539 opti_type = OPTI_TYPE_ZERO_BYTE
9540 | OPTI_TYPE_PRECOMPUTE_INIT
9541 | OPTI_TYPE_PRECOMPUTE_MERKLE
9542 | OPTI_TYPE_EARLY_SKIP
9543 | OPTI_TYPE_NOT_ITERATED
9544 | OPTI_TYPE_NOT_SALTED
9545 | OPTI_TYPE_RAW_HASH;
9546 dgst_pos0 = 0;
9547 dgst_pos1 = 3;
9548 dgst_pos2 = 2;
9549 dgst_pos3 = 1;
9550 break;
9551
9552 case 4500: hash_type = HASH_TYPE_SHA1;
9553 salt_type = SALT_TYPE_NONE;
9554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9555 opts_type = OPTS_TYPE_PT_GENERATE_BE
9556 | OPTS_TYPE_PT_ADD80
9557 | OPTS_TYPE_PT_ADDBITS15;
9558 kern_type = KERN_TYPE_SHA11;
9559 dgst_size = DGST_SIZE_4_5;
9560 parse_func = sha1_parse_hash;
9561 sort_by_digest = sort_by_digest_4_5;
9562 opti_type = OPTI_TYPE_ZERO_BYTE
9563 | OPTI_TYPE_PRECOMPUTE_INIT
9564 | OPTI_TYPE_PRECOMPUTE_MERKLE
9565 | OPTI_TYPE_EARLY_SKIP
9566 | OPTI_TYPE_NOT_SALTED;
9567 dgst_pos0 = 3;
9568 dgst_pos1 = 4;
9569 dgst_pos2 = 2;
9570 dgst_pos3 = 1;
9571 break;
9572
9573 case 4700: hash_type = HASH_TYPE_SHA1;
9574 salt_type = SALT_TYPE_NONE;
9575 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9576 opts_type = OPTS_TYPE_PT_GENERATE_LE
9577 | OPTS_TYPE_PT_ADD80
9578 | OPTS_TYPE_PT_ADDBITS14;
9579 kern_type = KERN_TYPE_SHA1_MD5;
9580 dgst_size = DGST_SIZE_4_5;
9581 parse_func = sha1_parse_hash;
9582 sort_by_digest = sort_by_digest_4_5;
9583 opti_type = OPTI_TYPE_ZERO_BYTE
9584 | OPTI_TYPE_PRECOMPUTE_INIT
9585 | OPTI_TYPE_PRECOMPUTE_MERKLE
9586 | OPTI_TYPE_EARLY_SKIP
9587 | OPTI_TYPE_NOT_ITERATED
9588 | OPTI_TYPE_NOT_SALTED
9589 | OPTI_TYPE_RAW_HASH;
9590 dgst_pos0 = 3;
9591 dgst_pos1 = 4;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 1;
9594 break;
9595
9596 case 4800: hash_type = HASH_TYPE_MD5;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE
9600 | OPTS_TYPE_PT_ADDBITS14;
9601 kern_type = KERN_TYPE_MD5_CHAP;
9602 dgst_size = DGST_SIZE_4_4;
9603 parse_func = chap_parse_hash;
9604 sort_by_digest = sort_by_digest_4_4;
9605 opti_type = OPTI_TYPE_ZERO_BYTE
9606 | OPTI_TYPE_PRECOMPUTE_INIT
9607 | OPTI_TYPE_PRECOMPUTE_MERKLE
9608 | OPTI_TYPE_MEET_IN_MIDDLE
9609 | OPTI_TYPE_EARLY_SKIP
9610 | OPTI_TYPE_NOT_ITERATED
9611 | OPTI_TYPE_RAW_HASH;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 3;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 1;
9616 break;
9617
9618 case 4900: hash_type = HASH_TYPE_SHA1;
9619 salt_type = SALT_TYPE_INTERN;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9622 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9623 dgst_size = DGST_SIZE_4_5;
9624 parse_func = sha1s_parse_hash;
9625 sort_by_digest = sort_by_digest_4_5;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_PRECOMPUTE_INIT
9628 | OPTI_TYPE_PRECOMPUTE_MERKLE
9629 | OPTI_TYPE_EARLY_SKIP;
9630 dgst_pos0 = 3;
9631 dgst_pos1 = 4;
9632 dgst_pos2 = 2;
9633 dgst_pos3 = 1;
9634 break;
9635
9636 case 5000: hash_type = HASH_TYPE_KECCAK;
9637 salt_type = SALT_TYPE_EMBEDDED;
9638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9639 opts_type = OPTS_TYPE_PT_GENERATE_LE
9640 | OPTS_TYPE_PT_ADD01;
9641 kern_type = KERN_TYPE_KECCAK;
9642 dgst_size = DGST_SIZE_8_25;
9643 parse_func = keccak_parse_hash;
9644 sort_by_digest = sort_by_digest_8_25;
9645 opti_type = OPTI_TYPE_ZERO_BYTE
9646 | OPTI_TYPE_USES_BITS_64
9647 | OPTI_TYPE_RAW_HASH;
9648 dgst_pos0 = 2;
9649 dgst_pos1 = 3;
9650 dgst_pos2 = 4;
9651 dgst_pos3 = 5;
9652 break;
9653
9654 case 5100: hash_type = HASH_TYPE_MD5H;
9655 salt_type = SALT_TYPE_NONE;
9656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9657 opts_type = OPTS_TYPE_PT_GENERATE_LE
9658 | OPTS_TYPE_PT_ADD80
9659 | OPTS_TYPE_PT_ADDBITS14;
9660 kern_type = KERN_TYPE_MD5H;
9661 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9662 parse_func = md5half_parse_hash;
9663 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9664 opti_type = OPTI_TYPE_ZERO_BYTE
9665 | OPTI_TYPE_RAW_HASH;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 5200: hash_type = HASH_TYPE_SHA256;
9673 salt_type = SALT_TYPE_EMBEDDED;
9674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9676 kern_type = KERN_TYPE_PSAFE3;
9677 dgst_size = DGST_SIZE_4_8;
9678 parse_func = psafe3_parse_hash;
9679 sort_by_digest = sort_by_digest_4_8;
9680 opti_type = OPTI_TYPE_ZERO_BYTE;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 5300: hash_type = HASH_TYPE_MD5;
9688 salt_type = SALT_TYPE_EMBEDDED;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE
9691 | OPTS_TYPE_ST_ADD80;
9692 kern_type = KERN_TYPE_IKEPSK_MD5;
9693 dgst_size = DGST_SIZE_4_4;
9694 parse_func = ikepsk_md5_parse_hash;
9695 sort_by_digest = sort_by_digest_4_4;
9696 opti_type = OPTI_TYPE_ZERO_BYTE;
9697 dgst_pos0 = 0;
9698 dgst_pos1 = 3;
9699 dgst_pos2 = 2;
9700 dgst_pos3 = 1;
9701 break;
9702
9703 case 5400: hash_type = HASH_TYPE_SHA1;
9704 salt_type = SALT_TYPE_EMBEDDED;
9705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9706 opts_type = OPTS_TYPE_PT_GENERATE_BE
9707 | OPTS_TYPE_ST_ADD80;
9708 kern_type = KERN_TYPE_IKEPSK_SHA1;
9709 dgst_size = DGST_SIZE_4_5;
9710 parse_func = ikepsk_sha1_parse_hash;
9711 sort_by_digest = sort_by_digest_4_5;
9712 opti_type = OPTI_TYPE_ZERO_BYTE;
9713 dgst_pos0 = 3;
9714 dgst_pos1 = 4;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 1;
9717 break;
9718
9719 case 5500: hash_type = HASH_TYPE_NETNTLM;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE
9723 | OPTS_TYPE_PT_ADD80
9724 | OPTS_TYPE_PT_ADDBITS14
9725 | OPTS_TYPE_PT_UNICODE
9726 | OPTS_TYPE_ST_HEX;
9727 kern_type = KERN_TYPE_NETNTLMv1;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = netntlmv1_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 5600: hash_type = HASH_TYPE_MD5;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_PT_ADD80
9744 | OPTS_TYPE_PT_ADDBITS14
9745 | OPTS_TYPE_PT_UNICODE;
9746 kern_type = KERN_TYPE_NETNTLMv2;
9747 dgst_size = DGST_SIZE_4_4;
9748 parse_func = netntlmv2_parse_hash;
9749 sort_by_digest = sort_by_digest_4_4;
9750 opti_type = OPTI_TYPE_ZERO_BYTE;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 3;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 1;
9755 break;
9756
9757 case 5700: hash_type = HASH_TYPE_SHA256;
9758 salt_type = SALT_TYPE_NONE;
9759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_BE
9761 | OPTS_TYPE_PT_ADD80
9762 | OPTS_TYPE_PT_ADDBITS15;
9763 kern_type = KERN_TYPE_SHA256;
9764 dgst_size = DGST_SIZE_4_8;
9765 parse_func = cisco4_parse_hash;
9766 sort_by_digest = sort_by_digest_4_8;
9767 opti_type = OPTI_TYPE_ZERO_BYTE
9768 | OPTI_TYPE_PRECOMPUTE_INIT
9769 | OPTI_TYPE_PRECOMPUTE_MERKLE
9770 | OPTI_TYPE_EARLY_SKIP
9771 | OPTI_TYPE_NOT_ITERATED
9772 | OPTI_TYPE_NOT_SALTED
9773 | OPTI_TYPE_RAW_HASH;
9774 dgst_pos0 = 3;
9775 dgst_pos1 = 7;
9776 dgst_pos2 = 2;
9777 dgst_pos3 = 6;
9778 break;
9779
9780 case 5800: hash_type = HASH_TYPE_SHA1;
9781 salt_type = SALT_TYPE_INTERN;
9782 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9783 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9784 | OPTS_TYPE_ST_ADD80;
9785 kern_type = KERN_TYPE_ANDROIDPIN;
9786 dgst_size = DGST_SIZE_4_5;
9787 parse_func = androidpin_parse_hash;
9788 sort_by_digest = sort_by_digest_4_5;
9789 opti_type = OPTI_TYPE_ZERO_BYTE;
9790 dgst_pos0 = 0;
9791 dgst_pos1 = 1;
9792 dgst_pos2 = 2;
9793 dgst_pos3 = 3;
9794 break;
9795
9796 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9797 salt_type = SALT_TYPE_NONE;
9798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9799 opts_type = OPTS_TYPE_PT_GENERATE_LE
9800 | OPTS_TYPE_PT_ADD80;
9801 kern_type = KERN_TYPE_RIPEMD160;
9802 dgst_size = DGST_SIZE_4_5;
9803 parse_func = ripemd160_parse_hash;
9804 sort_by_digest = sort_by_digest_4_5;
9805 opti_type = OPTI_TYPE_ZERO_BYTE;
9806 dgst_pos0 = 0;
9807 dgst_pos1 = 1;
9808 dgst_pos2 = 2;
9809 dgst_pos3 = 3;
9810 break;
9811
9812 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9813 salt_type = SALT_TYPE_NONE;
9814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9815 opts_type = OPTS_TYPE_PT_GENERATE_BE
9816 | OPTS_TYPE_PT_ADD80;
9817 kern_type = KERN_TYPE_WHIRLPOOL;
9818 dgst_size = DGST_SIZE_4_16;
9819 parse_func = whirlpool_parse_hash;
9820 sort_by_digest = sort_by_digest_4_16;
9821 opti_type = OPTI_TYPE_ZERO_BYTE;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 1;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 3;
9826 break;
9827
9828 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9829 salt_type = SALT_TYPE_EMBEDDED;
9830 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9832 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9833 dgst_size = DGST_SIZE_4_5;
9834 parse_func = truecrypt_parse_hash_2k;
9835 sort_by_digest = sort_by_digest_4_5;
9836 opti_type = OPTI_TYPE_ZERO_BYTE;
9837 dgst_pos0 = 0;
9838 dgst_pos1 = 1;
9839 dgst_pos2 = 2;
9840 dgst_pos3 = 3;
9841 break;
9842
9843 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9844 salt_type = SALT_TYPE_EMBEDDED;
9845 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9846 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9847 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9848 dgst_size = DGST_SIZE_4_5;
9849 parse_func = truecrypt_parse_hash_2k;
9850 sort_by_digest = sort_by_digest_4_5;
9851 opti_type = OPTI_TYPE_ZERO_BYTE;
9852 dgst_pos0 = 0;
9853 dgst_pos1 = 1;
9854 dgst_pos2 = 2;
9855 dgst_pos3 = 3;
9856 break;
9857
9858 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9862 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9863 dgst_size = DGST_SIZE_4_5;
9864 parse_func = truecrypt_parse_hash_2k;
9865 sort_by_digest = sort_by_digest_4_5;
9866 opti_type = OPTI_TYPE_ZERO_BYTE;
9867 dgst_pos0 = 0;
9868 dgst_pos1 = 1;
9869 dgst_pos2 = 2;
9870 dgst_pos3 = 3;
9871 break;
9872
9873 case 6221: hash_type = HASH_TYPE_SHA512;
9874 salt_type = SALT_TYPE_EMBEDDED;
9875 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9876 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9877 kern_type = KERN_TYPE_TCSHA512_XTS512;
9878 dgst_size = DGST_SIZE_8_8;
9879 parse_func = truecrypt_parse_hash_1k;
9880 sort_by_digest = sort_by_digest_8_8;
9881 opti_type = OPTI_TYPE_ZERO_BYTE
9882 | OPTI_TYPE_USES_BITS_64;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 1;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 3;
9887 break;
9888
9889 case 6222: hash_type = HASH_TYPE_SHA512;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9893 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9894 dgst_size = DGST_SIZE_8_8;
9895 parse_func = truecrypt_parse_hash_1k;
9896 sort_by_digest = sort_by_digest_8_8;
9897 opti_type = OPTI_TYPE_ZERO_BYTE
9898 | OPTI_TYPE_USES_BITS_64;
9899 dgst_pos0 = 0;
9900 dgst_pos1 = 1;
9901 dgst_pos2 = 2;
9902 dgst_pos3 = 3;
9903 break;
9904
9905 case 6223: hash_type = HASH_TYPE_SHA512;
9906 salt_type = SALT_TYPE_EMBEDDED;
9907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9908 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9909 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9910 dgst_size = DGST_SIZE_8_8;
9911 parse_func = truecrypt_parse_hash_1k;
9912 sort_by_digest = sort_by_digest_8_8;
9913 opti_type = OPTI_TYPE_ZERO_BYTE
9914 | OPTI_TYPE_USES_BITS_64;
9915 dgst_pos0 = 0;
9916 dgst_pos1 = 1;
9917 dgst_pos2 = 2;
9918 dgst_pos3 = 3;
9919 break;
9920
9921 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9922 salt_type = SALT_TYPE_EMBEDDED;
9923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9925 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9926 dgst_size = DGST_SIZE_4_8;
9927 parse_func = truecrypt_parse_hash_1k;
9928 sort_by_digest = sort_by_digest_4_8;
9929 opti_type = OPTI_TYPE_ZERO_BYTE;
9930 dgst_pos0 = 0;
9931 dgst_pos1 = 1;
9932 dgst_pos2 = 2;
9933 dgst_pos3 = 3;
9934 break;
9935
9936 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9937 salt_type = SALT_TYPE_EMBEDDED;
9938 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9939 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9940 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9941 dgst_size = DGST_SIZE_4_8;
9942 parse_func = truecrypt_parse_hash_1k;
9943 sort_by_digest = sort_by_digest_4_8;
9944 opti_type = OPTI_TYPE_ZERO_BYTE;
9945 dgst_pos0 = 0;
9946 dgst_pos1 = 1;
9947 dgst_pos2 = 2;
9948 dgst_pos3 = 3;
9949 break;
9950
9951 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9952 salt_type = SALT_TYPE_EMBEDDED;
9953 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9954 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9955 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9956 dgst_size = DGST_SIZE_4_8;
9957 parse_func = truecrypt_parse_hash_1k;
9958 sort_by_digest = sort_by_digest_4_8;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 1;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 3;
9964 break;
9965
9966 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9967 salt_type = SALT_TYPE_EMBEDDED;
9968 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9970 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9971 dgst_size = DGST_SIZE_4_5;
9972 parse_func = truecrypt_parse_hash_1k;
9973 sort_by_digest = sort_by_digest_4_5;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9985 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9986 dgst_size = DGST_SIZE_4_5;
9987 parse_func = truecrypt_parse_hash_1k;
9988 sort_by_digest = sort_by_digest_4_5;
9989 opti_type = OPTI_TYPE_ZERO_BYTE;
9990 dgst_pos0 = 0;
9991 dgst_pos1 = 1;
9992 dgst_pos2 = 2;
9993 dgst_pos3 = 3;
9994 break;
9995
9996 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9997 salt_type = SALT_TYPE_EMBEDDED;
9998 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9999 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10000 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10001 dgst_size = DGST_SIZE_4_5;
10002 parse_func = truecrypt_parse_hash_1k;
10003 sort_by_digest = sort_by_digest_4_5;
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 6300: hash_type = HASH_TYPE_MD5;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10015 kern_type = KERN_TYPE_MD5AIX;
10016 dgst_size = DGST_SIZE_4_4;
10017 parse_func = md5aix_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4;
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 6400: hash_type = HASH_TYPE_SHA256;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10030 kern_type = KERN_TYPE_SHA256AIX;
10031 dgst_size = DGST_SIZE_4_8;
10032 parse_func = sha256aix_parse_hash;
10033 sort_by_digest = sort_by_digest_4_8;
10034 opti_type = OPTI_TYPE_ZERO_BYTE;
10035 dgst_pos0 = 0;
10036 dgst_pos1 = 1;
10037 dgst_pos2 = 2;
10038 dgst_pos3 = 3;
10039 break;
10040
10041 case 6500: hash_type = HASH_TYPE_SHA512;
10042 salt_type = SALT_TYPE_EMBEDDED;
10043 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10044 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10045 kern_type = KERN_TYPE_SHA512AIX;
10046 dgst_size = DGST_SIZE_8_8;
10047 parse_func = sha512aix_parse_hash;
10048 sort_by_digest = sort_by_digest_8_8;
10049 opti_type = OPTI_TYPE_ZERO_BYTE
10050 | OPTI_TYPE_USES_BITS_64;
10051 dgst_pos0 = 0;
10052 dgst_pos1 = 1;
10053 dgst_pos2 = 2;
10054 dgst_pos3 = 3;
10055 break;
10056
10057 case 6600: hash_type = HASH_TYPE_AES;
10058 salt_type = SALT_TYPE_EMBEDDED;
10059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10060 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10061 kern_type = KERN_TYPE_AGILEKEY;
10062 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10063 parse_func = agilekey_parse_hash;
10064 sort_by_digest = sort_by_digest_4_5;
10065 opti_type = OPTI_TYPE_ZERO_BYTE;
10066 dgst_pos0 = 0;
10067 dgst_pos1 = 1;
10068 dgst_pos2 = 2;
10069 dgst_pos3 = 3;
10070 break;
10071
10072 case 6700: hash_type = HASH_TYPE_SHA1;
10073 salt_type = SALT_TYPE_EMBEDDED;
10074 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10075 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10076 kern_type = KERN_TYPE_SHA1AIX;
10077 dgst_size = DGST_SIZE_4_5;
10078 parse_func = sha1aix_parse_hash;
10079 sort_by_digest = sort_by_digest_4_5;
10080 opti_type = OPTI_TYPE_ZERO_BYTE;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 6800: hash_type = HASH_TYPE_AES;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10091 kern_type = KERN_TYPE_LASTPASS;
10092 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
10093 parse_func = lastpass_parse_hash;
10094 sort_by_digest = sort_by_digest_4_8;
10095 opti_type = OPTI_TYPE_ZERO_BYTE;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 6900: hash_type = HASH_TYPE_GOST;
10103 salt_type = SALT_TYPE_NONE;
10104 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10106 kern_type = KERN_TYPE_GOST;
10107 dgst_size = DGST_SIZE_4_8;
10108 parse_func = gost_parse_hash;
10109 sort_by_digest = sort_by_digest_4_8;
10110 opti_type = OPTI_TYPE_ZERO_BYTE;
10111 dgst_pos0 = 0;
10112 dgst_pos1 = 1;
10113 dgst_pos2 = 2;
10114 dgst_pos3 = 3;
10115 break;
10116
10117 case 7100: hash_type = HASH_TYPE_SHA512;
10118 salt_type = SALT_TYPE_EMBEDDED;
10119 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10120 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10121 kern_type = KERN_TYPE_PBKDF2_SHA512;
10122 dgst_size = DGST_SIZE_8_16;
10123 parse_func = sha512osx_parse_hash;
10124 sort_by_digest = sort_by_digest_8_16;
10125 opti_type = OPTI_TYPE_ZERO_BYTE
10126 | OPTI_TYPE_USES_BITS_64
10127 | OPTI_TYPE_SLOW_HASH_SIMD;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 7200: hash_type = HASH_TYPE_SHA512;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10138 kern_type = KERN_TYPE_PBKDF2_SHA512;
10139 dgst_size = DGST_SIZE_8_16;
10140 parse_func = sha512grub_parse_hash;
10141 sort_by_digest = sort_by_digest_8_16;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_USES_BITS_64
10144 | OPTI_TYPE_SLOW_HASH_SIMD;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 1;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 3;
10149 break;
10150
10151 case 7300: hash_type = HASH_TYPE_SHA1;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_BE
10155 | OPTS_TYPE_ST_ADD80
10156 | OPTS_TYPE_ST_ADDBITS15;
10157 kern_type = KERN_TYPE_RAKP;
10158 dgst_size = DGST_SIZE_4_5;
10159 parse_func = rakp_parse_hash;
10160 sort_by_digest = sort_by_digest_4_5;
10161 opti_type = OPTI_TYPE_ZERO_BYTE
10162 | OPTI_TYPE_NOT_ITERATED;
10163 dgst_pos0 = 3;
10164 dgst_pos1 = 4;
10165 dgst_pos2 = 2;
10166 dgst_pos3 = 1;
10167 break;
10168
10169 case 7400: hash_type = HASH_TYPE_SHA256;
10170 salt_type = SALT_TYPE_EMBEDDED;
10171 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10172 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10173 kern_type = KERN_TYPE_SHA256CRYPT;
10174 dgst_size = DGST_SIZE_4_8;
10175 parse_func = sha256crypt_parse_hash;
10176 sort_by_digest = sort_by_digest_4_8;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 7500: hash_type = HASH_TYPE_KRB5PA;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10188 kern_type = KERN_TYPE_KRB5PA;
10189 dgst_size = DGST_SIZE_4_4;
10190 parse_func = krb5pa_parse_hash;
10191 sort_by_digest = sort_by_digest_4_4;
10192 opti_type = OPTI_TYPE_ZERO_BYTE
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 0;
10195 dgst_pos1 = 1;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 3;
10198 break;
10199
10200 case 7600: hash_type = HASH_TYPE_SHA1;
10201 salt_type = SALT_TYPE_INTERN;
10202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_BE
10204 | OPTS_TYPE_PT_ADD80
10205 | OPTS_TYPE_PT_ADDBITS15;
10206 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
10207 dgst_size = DGST_SIZE_4_5;
10208 parse_func = redmine_parse_hash;
10209 sort_by_digest = sort_by_digest_4_5;
10210 opti_type = OPTI_TYPE_ZERO_BYTE
10211 | OPTI_TYPE_PRECOMPUTE_INIT
10212 | OPTI_TYPE_EARLY_SKIP
10213 | OPTI_TYPE_NOT_ITERATED
10214 | OPTI_TYPE_PREPENDED_SALT;
10215 dgst_pos0 = 3;
10216 dgst_pos1 = 4;
10217 dgst_pos2 = 2;
10218 dgst_pos3 = 1;
10219 break;
10220
10221 case 7700: hash_type = HASH_TYPE_SAPB;
10222 salt_type = SALT_TYPE_EMBEDDED;
10223 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10224 opts_type = OPTS_TYPE_PT_GENERATE_LE
10225 | OPTS_TYPE_PT_UPPER
10226 | OPTS_TYPE_ST_UPPER;
10227 kern_type = KERN_TYPE_SAPB;
10228 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10229 parse_func = sapb_parse_hash;
10230 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10231 opti_type = OPTI_TYPE_ZERO_BYTE
10232 | OPTI_TYPE_PRECOMPUTE_INIT
10233 | OPTI_TYPE_NOT_ITERATED;
10234 dgst_pos0 = 0;
10235 dgst_pos1 = 1;
10236 dgst_pos2 = 2;
10237 dgst_pos3 = 3;
10238 break;
10239
10240 case 7800: hash_type = HASH_TYPE_SAPG;
10241 salt_type = SALT_TYPE_EMBEDDED;
10242 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10243 opts_type = OPTS_TYPE_PT_GENERATE_BE
10244 | OPTS_TYPE_ST_ADD80
10245 | OPTS_TYPE_ST_UPPER;
10246 kern_type = KERN_TYPE_SAPG;
10247 dgst_size = DGST_SIZE_4_5;
10248 parse_func = sapg_parse_hash;
10249 sort_by_digest = sort_by_digest_4_5;
10250 opti_type = OPTI_TYPE_ZERO_BYTE
10251 | OPTI_TYPE_PRECOMPUTE_INIT
10252 | OPTI_TYPE_NOT_ITERATED;
10253 dgst_pos0 = 3;
10254 dgst_pos1 = 4;
10255 dgst_pos2 = 2;
10256 dgst_pos3 = 1;
10257 break;
10258
10259 case 7900: hash_type = HASH_TYPE_SHA512;
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_DRUPAL7;
10264 dgst_size = DGST_SIZE_8_8;
10265 parse_func = drupal7_parse_hash;
10266 sort_by_digest = sort_by_digest_8_8;
10267 opti_type = OPTI_TYPE_ZERO_BYTE
10268 | OPTI_TYPE_USES_BITS_64;
10269 dgst_pos0 = 0;
10270 dgst_pos1 = 1;
10271 dgst_pos2 = 2;
10272 dgst_pos3 = 3;
10273 break;
10274
10275 case 8000: hash_type = HASH_TYPE_SHA256;
10276 salt_type = SALT_TYPE_EMBEDDED;
10277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10278 opts_type = OPTS_TYPE_PT_GENERATE_BE
10279 | OPTS_TYPE_PT_UNICODE
10280 | OPTS_TYPE_ST_ADD80
10281 | OPTS_TYPE_ST_HEX;
10282 kern_type = KERN_TYPE_SYBASEASE;
10283 dgst_size = DGST_SIZE_4_8;
10284 parse_func = sybasease_parse_hash;
10285 sort_by_digest = sort_by_digest_4_8;
10286 opti_type = OPTI_TYPE_ZERO_BYTE
10287 | OPTI_TYPE_PRECOMPUTE_INIT
10288 | OPTI_TYPE_EARLY_SKIP
10289 | OPTI_TYPE_NOT_ITERATED
10290 | OPTI_TYPE_RAW_HASH;
10291 dgst_pos0 = 3;
10292 dgst_pos1 = 7;
10293 dgst_pos2 = 2;
10294 dgst_pos3 = 6;
10295 break;
10296
10297 case 8100: hash_type = HASH_TYPE_SHA1;
10298 salt_type = SALT_TYPE_EMBEDDED;
10299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10300 opts_type = OPTS_TYPE_PT_GENERATE_BE;
10301 kern_type = KERN_TYPE_NETSCALER;
10302 dgst_size = DGST_SIZE_4_5;
10303 parse_func = netscaler_parse_hash;
10304 sort_by_digest = sort_by_digest_4_5;
10305 opti_type = OPTI_TYPE_ZERO_BYTE
10306 | OPTI_TYPE_PRECOMPUTE_INIT
10307 | OPTI_TYPE_PRECOMPUTE_MERKLE
10308 | OPTI_TYPE_EARLY_SKIP
10309 | OPTI_TYPE_NOT_ITERATED
10310 | OPTI_TYPE_PREPENDED_SALT
10311 | OPTI_TYPE_RAW_HASH;
10312 dgst_pos0 = 3;
10313 dgst_pos1 = 4;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 1;
10316 break;
10317
10318 case 8200: hash_type = HASH_TYPE_SHA256;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10322 kern_type = KERN_TYPE_CLOUDKEY;
10323 dgst_size = DGST_SIZE_4_8;
10324 parse_func = cloudkey_parse_hash;
10325 sort_by_digest = sort_by_digest_4_8;
10326 opti_type = OPTI_TYPE_ZERO_BYTE;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 8300: hash_type = HASH_TYPE_SHA1;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_BE
10337 | OPTS_TYPE_ST_HEX
10338 | OPTS_TYPE_ST_ADD80;
10339 kern_type = KERN_TYPE_NSEC3;
10340 dgst_size = DGST_SIZE_4_5;
10341 parse_func = nsec3_parse_hash;
10342 sort_by_digest = sort_by_digest_4_5;
10343 opti_type = OPTI_TYPE_ZERO_BYTE;
10344 dgst_pos0 = 3;
10345 dgst_pos1 = 4;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 1;
10348 break;
10349
10350 case 8400: hash_type = HASH_TYPE_SHA1;
10351 salt_type = SALT_TYPE_INTERN;
10352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_BE
10354 | OPTS_TYPE_PT_ADD80
10355 | OPTS_TYPE_PT_ADDBITS15;
10356 kern_type = KERN_TYPE_WBB3;
10357 dgst_size = DGST_SIZE_4_5;
10358 parse_func = wbb3_parse_hash;
10359 sort_by_digest = sort_by_digest_4_5;
10360 opti_type = OPTI_TYPE_ZERO_BYTE
10361 | OPTI_TYPE_PRECOMPUTE_INIT
10362 | OPTI_TYPE_NOT_ITERATED;
10363 dgst_pos0 = 3;
10364 dgst_pos1 = 4;
10365 dgst_pos2 = 2;
10366 dgst_pos3 = 1;
10367 break;
10368
10369 case 8500: hash_type = HASH_TYPE_DESRACF;
10370 salt_type = SALT_TYPE_EMBEDDED;
10371 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10372 opts_type = OPTS_TYPE_PT_GENERATE_LE
10373 | OPTS_TYPE_ST_UPPER;
10374 kern_type = KERN_TYPE_RACF;
10375 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10376 parse_func = racf_parse_hash;
10377 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10378 opti_type = OPTI_TYPE_ZERO_BYTE
10379 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10380 dgst_pos0 = 0;
10381 dgst_pos1 = 1;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 3;
10384 break;
10385
10386 case 8600: hash_type = HASH_TYPE_LOTUS5;
10387 salt_type = SALT_TYPE_NONE;
10388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10390 kern_type = KERN_TYPE_LOTUS5;
10391 dgst_size = DGST_SIZE_4_4;
10392 parse_func = lotus5_parse_hash;
10393 sort_by_digest = sort_by_digest_4_4;
10394 opti_type = OPTI_TYPE_EARLY_SKIP
10395 | OPTI_TYPE_NOT_ITERATED
10396 | OPTI_TYPE_NOT_SALTED
10397 | OPTI_TYPE_RAW_HASH;
10398 dgst_pos0 = 0;
10399 dgst_pos1 = 1;
10400 dgst_pos2 = 2;
10401 dgst_pos3 = 3;
10402 break;
10403
10404 case 8700: hash_type = HASH_TYPE_LOTUS6;
10405 salt_type = SALT_TYPE_EMBEDDED;
10406 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10407 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10408 kern_type = KERN_TYPE_LOTUS6;
10409 dgst_size = DGST_SIZE_4_4;
10410 parse_func = lotus6_parse_hash;
10411 sort_by_digest = sort_by_digest_4_4;
10412 opti_type = OPTI_TYPE_EARLY_SKIP
10413 | OPTI_TYPE_NOT_ITERATED
10414 | OPTI_TYPE_RAW_HASH;
10415 dgst_pos0 = 0;
10416 dgst_pos1 = 1;
10417 dgst_pos2 = 2;
10418 dgst_pos3 = 3;
10419 break;
10420
10421 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
10422 salt_type = SALT_TYPE_EMBEDDED;
10423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10424 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10425 kern_type = KERN_TYPE_ANDROIDFDE;
10426 dgst_size = DGST_SIZE_4_4;
10427 parse_func = androidfde_parse_hash;
10428 sort_by_digest = sort_by_digest_4_4;
10429 opti_type = OPTI_TYPE_ZERO_BYTE;
10430 dgst_pos0 = 0;
10431 dgst_pos1 = 1;
10432 dgst_pos2 = 2;
10433 dgst_pos3 = 3;
10434 break;
10435
10436 case 8900: hash_type = HASH_TYPE_SCRYPT;
10437 salt_type = SALT_TYPE_EMBEDDED;
10438 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10439 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10440 kern_type = KERN_TYPE_SCRYPT;
10441 dgst_size = DGST_SIZE_4_8;
10442 parse_func = scrypt_parse_hash;
10443 sort_by_digest = sort_by_digest_4_8;
10444 opti_type = OPTI_TYPE_ZERO_BYTE;
10445 dgst_pos0 = 0;
10446 dgst_pos1 = 1;
10447 dgst_pos2 = 2;
10448 dgst_pos3 = 3;
10449 break;
10450
10451 case 9000: hash_type = HASH_TYPE_SHA1;
10452 salt_type = SALT_TYPE_EMBEDDED;
10453 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10454 opts_type = OPTS_TYPE_PT_GENERATE_LE
10455 | OPTS_TYPE_ST_GENERATE_LE;
10456 kern_type = KERN_TYPE_PSAFE2;
10457 dgst_size = DGST_SIZE_4_5;
10458 parse_func = psafe2_parse_hash;
10459 sort_by_digest = sort_by_digest_4_5;
10460 opti_type = OPTI_TYPE_ZERO_BYTE;
10461 dgst_pos0 = 0;
10462 dgst_pos1 = 1;
10463 dgst_pos2 = 2;
10464 dgst_pos3 = 3;
10465 break;
10466
10467 case 9100: hash_type = HASH_TYPE_LOTUS8;
10468 salt_type = SALT_TYPE_EMBEDDED;
10469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10470 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10471 kern_type = KERN_TYPE_LOTUS8;
10472 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10473 parse_func = lotus8_parse_hash;
10474 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10475 opti_type = OPTI_TYPE_ZERO_BYTE;
10476 dgst_pos0 = 0;
10477 dgst_pos1 = 1;
10478 dgst_pos2 = 2;
10479 dgst_pos3 = 3;
10480 break;
10481
10482 case 9200: hash_type = HASH_TYPE_SHA256;
10483 salt_type = SALT_TYPE_EMBEDDED;
10484 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10485 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10486 kern_type = KERN_TYPE_PBKDF2_SHA256;
10487 dgst_size = DGST_SIZE_4_32;
10488 parse_func = cisco8_parse_hash;
10489 sort_by_digest = sort_by_digest_4_32;
10490 opti_type = OPTI_TYPE_ZERO_BYTE
10491 | OPTI_TYPE_SLOW_HASH_SIMD;
10492 dgst_pos0 = 0;
10493 dgst_pos1 = 1;
10494 dgst_pos2 = 2;
10495 dgst_pos3 = 3;
10496 break;
10497
10498 case 9300: hash_type = HASH_TYPE_SCRYPT;
10499 salt_type = SALT_TYPE_EMBEDDED;
10500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10502 kern_type = KERN_TYPE_SCRYPT;
10503 dgst_size = DGST_SIZE_4_8;
10504 parse_func = cisco9_parse_hash;
10505 sort_by_digest = sort_by_digest_4_8;
10506 opti_type = OPTI_TYPE_ZERO_BYTE;
10507 dgst_pos0 = 0;
10508 dgst_pos1 = 1;
10509 dgst_pos2 = 2;
10510 dgst_pos3 = 3;
10511 break;
10512
10513 case 9400: hash_type = HASH_TYPE_OFFICE2007;
10514 salt_type = SALT_TYPE_EMBEDDED;
10515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10517 kern_type = KERN_TYPE_OFFICE2007;
10518 dgst_size = DGST_SIZE_4_4;
10519 parse_func = office2007_parse_hash;
10520 sort_by_digest = sort_by_digest_4_4;
10521 opti_type = OPTI_TYPE_ZERO_BYTE;
10522 dgst_pos0 = 0;
10523 dgst_pos1 = 1;
10524 dgst_pos2 = 2;
10525 dgst_pos3 = 3;
10526 break;
10527
10528 case 9500: hash_type = HASH_TYPE_OFFICE2010;
10529 salt_type = SALT_TYPE_EMBEDDED;
10530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10532 kern_type = KERN_TYPE_OFFICE2010;
10533 dgst_size = DGST_SIZE_4_4;
10534 parse_func = office2010_parse_hash;
10535 sort_by_digest = sort_by_digest_4_4;
10536 opti_type = OPTI_TYPE_ZERO_BYTE;
10537 dgst_pos0 = 0;
10538 dgst_pos1 = 1;
10539 dgst_pos2 = 2;
10540 dgst_pos3 = 3;
10541 break;
10542
10543 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10544 salt_type = SALT_TYPE_EMBEDDED;
10545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10546 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10547 kern_type = KERN_TYPE_OFFICE2013;
10548 dgst_size = DGST_SIZE_4_4;
10549 parse_func = office2013_parse_hash;
10550 sort_by_digest = sort_by_digest_4_4;
10551 opti_type = OPTI_TYPE_ZERO_BYTE;
10552 dgst_pos0 = 0;
10553 dgst_pos1 = 1;
10554 dgst_pos2 = 2;
10555 dgst_pos3 = 3;
10556 break;
10557
10558 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10559 salt_type = SALT_TYPE_EMBEDDED;
10560 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10561 opts_type = OPTS_TYPE_PT_GENERATE_LE
10562 | OPTS_TYPE_PT_ADD80
10563 | OPTS_TYPE_PT_UNICODE;
10564 kern_type = KERN_TYPE_OLDOFFICE01;
10565 dgst_size = DGST_SIZE_4_4;
10566 parse_func = oldoffice01_parse_hash;
10567 sort_by_digest = sort_by_digest_4_4;
10568 opti_type = OPTI_TYPE_ZERO_BYTE
10569 | OPTI_TYPE_PRECOMPUTE_INIT
10570 | OPTI_TYPE_NOT_ITERATED;
10571 dgst_pos0 = 0;
10572 dgst_pos1 = 1;
10573 dgst_pos2 = 2;
10574 dgst_pos3 = 3;
10575 break;
10576
10577 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10578 salt_type = SALT_TYPE_EMBEDDED;
10579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10580 opts_type = OPTS_TYPE_PT_GENERATE_LE
10581 | OPTS_TYPE_PT_ADD80;
10582 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10583 dgst_size = DGST_SIZE_4_4;
10584 parse_func = oldoffice01cm1_parse_hash;
10585 sort_by_digest = sort_by_digest_4_4;
10586 opti_type = OPTI_TYPE_ZERO_BYTE
10587 | OPTI_TYPE_PRECOMPUTE_INIT
10588 | OPTI_TYPE_NOT_ITERATED;
10589 dgst_pos0 = 0;
10590 dgst_pos1 = 1;
10591 dgst_pos2 = 2;
10592 dgst_pos3 = 3;
10593 break;
10594
10595 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10596 salt_type = SALT_TYPE_EMBEDDED;
10597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10598 opts_type = OPTS_TYPE_PT_GENERATE_LE
10599 | OPTS_TYPE_PT_ADD80
10600 | OPTS_TYPE_PT_UNICODE
10601 | OPTS_TYPE_PT_NEVERCRACK;
10602 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10603 dgst_size = DGST_SIZE_4_4;
10604 parse_func = oldoffice01cm2_parse_hash;
10605 sort_by_digest = sort_by_digest_4_4;
10606 opti_type = OPTI_TYPE_ZERO_BYTE
10607 | OPTI_TYPE_PRECOMPUTE_INIT
10608 | OPTI_TYPE_NOT_ITERATED;
10609 dgst_pos0 = 0;
10610 dgst_pos1 = 1;
10611 dgst_pos2 = 2;
10612 dgst_pos3 = 3;
10613 break;
10614
10615 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10616 salt_type = SALT_TYPE_EMBEDDED;
10617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10618 opts_type = OPTS_TYPE_PT_GENERATE_BE
10619 | OPTS_TYPE_PT_ADD80
10620 | OPTS_TYPE_PT_UNICODE;
10621 kern_type = KERN_TYPE_OLDOFFICE34;
10622 dgst_size = DGST_SIZE_4_4;
10623 parse_func = oldoffice34_parse_hash;
10624 sort_by_digest = sort_by_digest_4_4;
10625 opti_type = OPTI_TYPE_ZERO_BYTE
10626 | OPTI_TYPE_PRECOMPUTE_INIT
10627 | OPTI_TYPE_NOT_ITERATED;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10638 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10639 dgst_size = DGST_SIZE_4_4;
10640 parse_func = oldoffice34cm1_parse_hash;
10641 sort_by_digest = sort_by_digest_4_4;
10642 opti_type = OPTI_TYPE_ZERO_BYTE
10643 | OPTI_TYPE_PRECOMPUTE_INIT
10644 | OPTI_TYPE_NOT_ITERATED;
10645 dgst_pos0 = 0;
10646 dgst_pos1 = 1;
10647 dgst_pos2 = 2;
10648 dgst_pos3 = 3;
10649 break;
10650
10651 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10652 salt_type = SALT_TYPE_EMBEDDED;
10653 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10654 opts_type = OPTS_TYPE_PT_GENERATE_BE
10655 | OPTS_TYPE_PT_ADD80
10656 | OPTS_TYPE_PT_UNICODE
10657 | OPTS_TYPE_PT_NEVERCRACK;
10658 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10659 dgst_size = DGST_SIZE_4_4;
10660 parse_func = oldoffice34cm2_parse_hash;
10661 sort_by_digest = sort_by_digest_4_4;
10662 opti_type = OPTI_TYPE_ZERO_BYTE
10663 | OPTI_TYPE_PRECOMPUTE_INIT
10664 | OPTI_TYPE_NOT_ITERATED;
10665 dgst_pos0 = 0;
10666 dgst_pos1 = 1;
10667 dgst_pos2 = 2;
10668 dgst_pos3 = 3;
10669 break;
10670
10671 case 9900: hash_type = HASH_TYPE_MD5;
10672 salt_type = SALT_TYPE_NONE;
10673 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10674 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10675 kern_type = KERN_TYPE_RADMIN2;
10676 dgst_size = DGST_SIZE_4_4;
10677 parse_func = radmin2_parse_hash;
10678 sort_by_digest = sort_by_digest_4_4;
10679 opti_type = OPTI_TYPE_ZERO_BYTE
10680 | OPTI_TYPE_PRECOMPUTE_INIT
10681 | OPTI_TYPE_EARLY_SKIP
10682 | OPTI_TYPE_NOT_ITERATED
10683 | OPTI_TYPE_NOT_SALTED;
10684 dgst_pos0 = 0;
10685 dgst_pos1 = 3;
10686 dgst_pos2 = 2;
10687 dgst_pos3 = 1;
10688 break;
10689
10690 case 10000: hash_type = HASH_TYPE_SHA256;
10691 salt_type = SALT_TYPE_EMBEDDED;
10692 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10693 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10694 kern_type = KERN_TYPE_PBKDF2_SHA256;
10695 dgst_size = DGST_SIZE_4_32;
10696 parse_func = djangopbkdf2_parse_hash;
10697 sort_by_digest = sort_by_digest_4_32;
10698 opti_type = OPTI_TYPE_ZERO_BYTE
10699 | OPTI_TYPE_SLOW_HASH_SIMD;
10700 dgst_pos0 = 0;
10701 dgst_pos1 = 1;
10702 dgst_pos2 = 2;
10703 dgst_pos3 = 3;
10704 break;
10705
10706 case 10100: hash_type = HASH_TYPE_SIPHASH;
10707 salt_type = SALT_TYPE_EMBEDDED;
10708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10709 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10710 kern_type = KERN_TYPE_SIPHASH;
10711 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10712 parse_func = siphash_parse_hash;
10713 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10714 opti_type = OPTI_TYPE_ZERO_BYTE
10715 | OPTI_TYPE_NOT_ITERATED
10716 | OPTI_TYPE_RAW_HASH;
10717 dgst_pos0 = 0;
10718 dgst_pos1 = 1;
10719 dgst_pos2 = 2;
10720 dgst_pos3 = 3;
10721 break;
10722
10723 case 10200: hash_type = HASH_TYPE_MD5;
10724 salt_type = SALT_TYPE_EMBEDDED;
10725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10726 opts_type = OPTS_TYPE_PT_GENERATE_LE
10727 | OPTS_TYPE_ST_ADD80
10728 | OPTS_TYPE_ST_ADDBITS14;
10729 kern_type = KERN_TYPE_HMACMD5_PW;
10730 dgst_size = DGST_SIZE_4_4;
10731 parse_func = crammd5_parse_hash;
10732 sort_by_digest = sort_by_digest_4_4;
10733 opti_type = OPTI_TYPE_ZERO_BYTE
10734 | OPTI_TYPE_NOT_ITERATED;
10735 dgst_pos0 = 0;
10736 dgst_pos1 = 3;
10737 dgst_pos2 = 2;
10738 dgst_pos3 = 1;
10739 break;
10740
10741 case 10300: hash_type = HASH_TYPE_SHA1;
10742 salt_type = SALT_TYPE_EMBEDDED;
10743 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10744 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10745 kern_type = KERN_TYPE_SAPH_SHA1;
10746 dgst_size = DGST_SIZE_4_5;
10747 parse_func = saph_sha1_parse_hash;
10748 sort_by_digest = sort_by_digest_4_5;
10749 opti_type = OPTI_TYPE_ZERO_BYTE;
10750 dgst_pos0 = 0;
10751 dgst_pos1 = 1;
10752 dgst_pos2 = 2;
10753 dgst_pos3 = 3;
10754 break;
10755
10756 case 10400: hash_type = HASH_TYPE_PDFU16;
10757 salt_type = SALT_TYPE_EMBEDDED;
10758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10759 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10760 kern_type = KERN_TYPE_PDF11;
10761 dgst_size = DGST_SIZE_4_4;
10762 parse_func = pdf11_parse_hash;
10763 sort_by_digest = sort_by_digest_4_4;
10764 opti_type = OPTI_TYPE_ZERO_BYTE
10765 | OPTI_TYPE_NOT_ITERATED;
10766 dgst_pos0 = 0;
10767 dgst_pos1 = 1;
10768 dgst_pos2 = 2;
10769 dgst_pos3 = 3;
10770 break;
10771
10772 case 10410: hash_type = HASH_TYPE_PDFU16;
10773 salt_type = SALT_TYPE_EMBEDDED;
10774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10776 kern_type = KERN_TYPE_PDF11CM1;
10777 dgst_size = DGST_SIZE_4_4;
10778 parse_func = pdf11cm1_parse_hash;
10779 sort_by_digest = sort_by_digest_4_4;
10780 opti_type = OPTI_TYPE_ZERO_BYTE
10781 | OPTI_TYPE_NOT_ITERATED;
10782 dgst_pos0 = 0;
10783 dgst_pos1 = 1;
10784 dgst_pos2 = 2;
10785 dgst_pos3 = 3;
10786 break;
10787
10788 case 10420: hash_type = HASH_TYPE_PDFU16;
10789 salt_type = SALT_TYPE_EMBEDDED;
10790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10792 kern_type = KERN_TYPE_PDF11CM2;
10793 dgst_size = DGST_SIZE_4_4;
10794 parse_func = pdf11cm2_parse_hash;
10795 sort_by_digest = sort_by_digest_4_4;
10796 opti_type = OPTI_TYPE_ZERO_BYTE
10797 | OPTI_TYPE_NOT_ITERATED;
10798 dgst_pos0 = 0;
10799 dgst_pos1 = 1;
10800 dgst_pos2 = 2;
10801 dgst_pos3 = 3;
10802 break;
10803
10804 case 10500: hash_type = HASH_TYPE_PDFU16;
10805 salt_type = SALT_TYPE_EMBEDDED;
10806 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10808 kern_type = KERN_TYPE_PDF14;
10809 dgst_size = DGST_SIZE_4_4;
10810 parse_func = pdf14_parse_hash;
10811 sort_by_digest = sort_by_digest_4_4;
10812 opti_type = OPTI_TYPE_ZERO_BYTE
10813 | OPTI_TYPE_NOT_ITERATED;
10814 dgst_pos0 = 0;
10815 dgst_pos1 = 1;
10816 dgst_pos2 = 2;
10817 dgst_pos3 = 3;
10818 break;
10819
10820 case 10600: hash_type = HASH_TYPE_SHA256;
10821 salt_type = SALT_TYPE_EMBEDDED;
10822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10823 opts_type = OPTS_TYPE_PT_GENERATE_BE
10824 | OPTS_TYPE_ST_ADD80
10825 | OPTS_TYPE_ST_ADDBITS15
10826 | OPTS_TYPE_HASH_COPY;
10827 kern_type = KERN_TYPE_SHA256_PWSLT;
10828 dgst_size = DGST_SIZE_4_8;
10829 parse_func = pdf17l3_parse_hash;
10830 sort_by_digest = sort_by_digest_4_8;
10831 opti_type = OPTI_TYPE_ZERO_BYTE
10832 | OPTI_TYPE_PRECOMPUTE_INIT
10833 | OPTI_TYPE_PRECOMPUTE_MERKLE
10834 | OPTI_TYPE_EARLY_SKIP
10835 | OPTI_TYPE_NOT_ITERATED
10836 | OPTI_TYPE_APPENDED_SALT
10837 | OPTI_TYPE_RAW_HASH;
10838 dgst_pos0 = 3;
10839 dgst_pos1 = 7;
10840 dgst_pos2 = 2;
10841 dgst_pos3 = 6;
10842 break;
10843
10844 case 10700: hash_type = HASH_TYPE_PDFU32;
10845 salt_type = SALT_TYPE_EMBEDDED;
10846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10847 opts_type = OPTS_TYPE_PT_GENERATE_LE
10848 | OPTS_TYPE_HASH_COPY;
10849 kern_type = KERN_TYPE_PDF17L8;
10850 dgst_size = DGST_SIZE_4_8;
10851 parse_func = pdf17l8_parse_hash;
10852 sort_by_digest = sort_by_digest_4_8;
10853 opti_type = OPTI_TYPE_ZERO_BYTE
10854 | OPTI_TYPE_NOT_ITERATED;
10855 dgst_pos0 = 0;
10856 dgst_pos1 = 1;
10857 dgst_pos2 = 2;
10858 dgst_pos3 = 3;
10859 break;
10860
10861 case 10800: hash_type = HASH_TYPE_SHA384;
10862 salt_type = SALT_TYPE_NONE;
10863 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10864 opts_type = OPTS_TYPE_PT_GENERATE_BE
10865 | OPTS_TYPE_PT_ADD80
10866 | OPTS_TYPE_PT_ADDBITS15;
10867 kern_type = KERN_TYPE_SHA384;
10868 dgst_size = DGST_SIZE_8_8;
10869 parse_func = sha384_parse_hash;
10870 sort_by_digest = sort_by_digest_8_8;
10871 opti_type = OPTI_TYPE_ZERO_BYTE
10872 | OPTI_TYPE_PRECOMPUTE_INIT
10873 | OPTI_TYPE_PRECOMPUTE_MERKLE
10874 | OPTI_TYPE_EARLY_SKIP
10875 | OPTI_TYPE_NOT_ITERATED
10876 | OPTI_TYPE_NOT_SALTED
10877 | OPTI_TYPE_USES_BITS_64
10878 | OPTI_TYPE_RAW_HASH;
10879 dgst_pos0 = 6;
10880 dgst_pos1 = 7;
10881 dgst_pos2 = 4;
10882 dgst_pos3 = 5;
10883 break;
10884
10885 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10886 salt_type = SALT_TYPE_EMBEDDED;
10887 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10888 opts_type = OPTS_TYPE_PT_GENERATE_LE
10889 | OPTS_TYPE_ST_BASE64
10890 | OPTS_TYPE_HASH_COPY;
10891 kern_type = KERN_TYPE_PBKDF2_SHA256;
10892 dgst_size = DGST_SIZE_4_32;
10893 parse_func = pbkdf2_sha256_parse_hash;
10894 sort_by_digest = sort_by_digest_4_32;
10895 opti_type = OPTI_TYPE_ZERO_BYTE
10896 | OPTI_TYPE_SLOW_HASH_SIMD;
10897 dgst_pos0 = 0;
10898 dgst_pos1 = 1;
10899 dgst_pos2 = 2;
10900 dgst_pos3 = 3;
10901 break;
10902
10903 case 11000: hash_type = HASH_TYPE_MD5;
10904 salt_type = SALT_TYPE_INTERN;
10905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10906 opts_type = OPTS_TYPE_PT_GENERATE_LE
10907 | OPTS_TYPE_PT_ADD80;
10908 kern_type = KERN_TYPE_PRESTASHOP;
10909 dgst_size = DGST_SIZE_4_4;
10910 parse_func = prestashop_parse_hash;
10911 sort_by_digest = sort_by_digest_4_4;
10912 opti_type = OPTI_TYPE_ZERO_BYTE
10913 | OPTI_TYPE_PRECOMPUTE_INIT
10914 | OPTI_TYPE_NOT_ITERATED
10915 | OPTI_TYPE_PREPENDED_SALT;
10916 dgst_pos0 = 0;
10917 dgst_pos1 = 3;
10918 dgst_pos2 = 2;
10919 dgst_pos3 = 1;
10920 break;
10921
10922 case 11100: hash_type = HASH_TYPE_MD5;
10923 salt_type = SALT_TYPE_EMBEDDED;
10924 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10925 opts_type = OPTS_TYPE_PT_GENERATE_LE
10926 | OPTS_TYPE_ST_ADD80;
10927 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10928 dgst_size = DGST_SIZE_4_4;
10929 parse_func = postgresql_auth_parse_hash;
10930 sort_by_digest = sort_by_digest_4_4;
10931 opti_type = OPTI_TYPE_ZERO_BYTE
10932 | OPTI_TYPE_PRECOMPUTE_INIT
10933 | OPTI_TYPE_PRECOMPUTE_MERKLE
10934 | OPTI_TYPE_EARLY_SKIP;
10935 dgst_pos0 = 0;
10936 dgst_pos1 = 3;
10937 dgst_pos2 = 2;
10938 dgst_pos3 = 1;
10939 break;
10940
10941 case 11200: hash_type = HASH_TYPE_SHA1;
10942 salt_type = SALT_TYPE_EMBEDDED;
10943 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10944 opts_type = OPTS_TYPE_PT_GENERATE_BE
10945 | OPTS_TYPE_PT_ADD80
10946 | OPTS_TYPE_ST_HEX;
10947 kern_type = KERN_TYPE_MYSQL_AUTH;
10948 dgst_size = DGST_SIZE_4_5;
10949 parse_func = mysql_auth_parse_hash;
10950 sort_by_digest = sort_by_digest_4_5;
10951 opti_type = OPTI_TYPE_ZERO_BYTE
10952 | OPTI_TYPE_EARLY_SKIP;
10953 dgst_pos0 = 3;
10954 dgst_pos1 = 4;
10955 dgst_pos2 = 2;
10956 dgst_pos3 = 1;
10957 break;
10958
10959 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10960 salt_type = SALT_TYPE_EMBEDDED;
10961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10962 opts_type = OPTS_TYPE_PT_GENERATE_LE
10963 | OPTS_TYPE_ST_HEX
10964 | OPTS_TYPE_ST_ADD80;
10965 kern_type = KERN_TYPE_BITCOIN_WALLET;
10966 dgst_size = DGST_SIZE_4_4;
10967 parse_func = bitcoin_wallet_parse_hash;
10968 sort_by_digest = sort_by_digest_4_4;
10969 opti_type = OPTI_TYPE_ZERO_BYTE;
10970 dgst_pos0 = 0;
10971 dgst_pos1 = 1;
10972 dgst_pos2 = 2;
10973 dgst_pos3 = 3;
10974 break;
10975
10976 case 11400: hash_type = HASH_TYPE_MD5;
10977 salt_type = SALT_TYPE_EMBEDDED;
10978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10979 opts_type = OPTS_TYPE_PT_GENERATE_LE
10980 | OPTS_TYPE_PT_ADD80
10981 | OPTS_TYPE_HASH_COPY;
10982 kern_type = KERN_TYPE_SIP_AUTH;
10983 dgst_size = DGST_SIZE_4_4;
10984 parse_func = sip_auth_parse_hash;
10985 sort_by_digest = sort_by_digest_4_4;
10986 opti_type = OPTI_TYPE_ZERO_BYTE;
10987 dgst_pos0 = 0;
10988 dgst_pos1 = 3;
10989 dgst_pos2 = 2;
10990 dgst_pos3 = 1;
10991 break;
10992
10993 case 11500: hash_type = HASH_TYPE_CRC32;
10994 salt_type = SALT_TYPE_INTERN;
10995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10996 opts_type = OPTS_TYPE_PT_GENERATE_LE
10997 | OPTS_TYPE_ST_GENERATE_LE
10998 | OPTS_TYPE_ST_HEX;
10999 kern_type = KERN_TYPE_CRC32;
11000 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
11001 parse_func = crc32_parse_hash;
11002 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
11003 opti_type = OPTI_TYPE_ZERO_BYTE;
11004 dgst_pos0 = 0;
11005 dgst_pos1 = 1;
11006 dgst_pos2 = 2;
11007 dgst_pos3 = 3;
11008 break;
11009
11010 case 11600: hash_type = HASH_TYPE_AES;
11011 salt_type = SALT_TYPE_EMBEDDED;
11012 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11013 opts_type = OPTS_TYPE_PT_GENERATE_LE
11014 | OPTS_TYPE_PT_NEVERCRACK;
11015 kern_type = KERN_TYPE_SEVEN_ZIP;
11016 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
11017 parse_func = seven_zip_parse_hash;
11018 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
11019 opti_type = OPTI_TYPE_ZERO_BYTE;
11020 dgst_pos0 = 0;
11021 dgst_pos1 = 1;
11022 dgst_pos2 = 2;
11023 dgst_pos3 = 3;
11024 break;
11025
11026 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
11027 salt_type = SALT_TYPE_NONE;
11028 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11029 opts_type = OPTS_TYPE_PT_GENERATE_LE
11030 | OPTS_TYPE_PT_ADD01;
11031 kern_type = KERN_TYPE_GOST_2012SBOG_256;
11032 dgst_size = DGST_SIZE_4_8;
11033 parse_func = gost2012sbog_256_parse_hash;
11034 sort_by_digest = sort_by_digest_4_8;
11035 opti_type = OPTI_TYPE_ZERO_BYTE;
11036 dgst_pos0 = 0;
11037 dgst_pos1 = 1;
11038 dgst_pos2 = 2;
11039 dgst_pos3 = 3;
11040 break;
11041
11042 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
11043 salt_type = SALT_TYPE_NONE;
11044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11045 opts_type = OPTS_TYPE_PT_GENERATE_LE
11046 | OPTS_TYPE_PT_ADD01;
11047 kern_type = KERN_TYPE_GOST_2012SBOG_512;
11048 dgst_size = DGST_SIZE_4_16;
11049 parse_func = gost2012sbog_512_parse_hash;
11050 sort_by_digest = sort_by_digest_4_16;
11051 opti_type = OPTI_TYPE_ZERO_BYTE;
11052 dgst_pos0 = 0;
11053 dgst_pos1 = 1;
11054 dgst_pos2 = 2;
11055 dgst_pos3 = 3;
11056 break;
11057
11058 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
11059 salt_type = SALT_TYPE_EMBEDDED;
11060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11061 opts_type = OPTS_TYPE_PT_GENERATE_LE
11062 | OPTS_TYPE_ST_BASE64
11063 | OPTS_TYPE_HASH_COPY;
11064 kern_type = KERN_TYPE_PBKDF2_MD5;
11065 dgst_size = DGST_SIZE_4_32;
11066 parse_func = pbkdf2_md5_parse_hash;
11067 sort_by_digest = sort_by_digest_4_32;
11068 opti_type = OPTI_TYPE_ZERO_BYTE
11069 | OPTI_TYPE_SLOW_HASH_SIMD;
11070 dgst_pos0 = 0;
11071 dgst_pos1 = 1;
11072 dgst_pos2 = 2;
11073 dgst_pos3 = 3;
11074 break;
11075
11076 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
11077 salt_type = SALT_TYPE_EMBEDDED;
11078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11079 opts_type = OPTS_TYPE_PT_GENERATE_LE
11080 | OPTS_TYPE_ST_BASE64
11081 | OPTS_TYPE_HASH_COPY;
11082 kern_type = KERN_TYPE_PBKDF2_SHA1;
11083 dgst_size = DGST_SIZE_4_32;
11084 parse_func = pbkdf2_sha1_parse_hash;
11085 sort_by_digest = sort_by_digest_4_32;
11086 opti_type = OPTI_TYPE_ZERO_BYTE
11087 | OPTI_TYPE_SLOW_HASH_SIMD;
11088 dgst_pos0 = 0;
11089 dgst_pos1 = 1;
11090 dgst_pos2 = 2;
11091 dgst_pos3 = 3;
11092 break;
11093
11094 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
11095 salt_type = SALT_TYPE_EMBEDDED;
11096 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11097 opts_type = OPTS_TYPE_PT_GENERATE_LE
11098 | OPTS_TYPE_ST_BASE64
11099 | OPTS_TYPE_HASH_COPY;
11100 kern_type = KERN_TYPE_PBKDF2_SHA512;
11101 dgst_size = DGST_SIZE_8_16;
11102 parse_func = pbkdf2_sha512_parse_hash;
11103 sort_by_digest = sort_by_digest_8_16;
11104 opti_type = OPTI_TYPE_ZERO_BYTE
11105 | OPTI_TYPE_USES_BITS_64
11106 | OPTI_TYPE_SLOW_HASH_SIMD;
11107 dgst_pos0 = 0;
11108 dgst_pos1 = 1;
11109 dgst_pos2 = 2;
11110 dgst_pos3 = 3;
11111 break;
11112
11113 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
11114 salt_type = SALT_TYPE_EMBEDDED;
11115 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11117 kern_type = KERN_TYPE_ECRYPTFS;
11118 dgst_size = DGST_SIZE_8_8;
11119 parse_func = ecryptfs_parse_hash;
11120 sort_by_digest = sort_by_digest_8_8;
11121 opti_type = OPTI_TYPE_ZERO_BYTE
11122 | OPTI_TYPE_USES_BITS_64;
11123 dgst_pos0 = 0;
11124 dgst_pos1 = 1;
11125 dgst_pos2 = 2;
11126 dgst_pos3 = 3;
11127 break;
11128
11129 case 12300: hash_type = HASH_TYPE_ORACLET;
11130 salt_type = SALT_TYPE_EMBEDDED;
11131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11133 kern_type = KERN_TYPE_ORACLET;
11134 dgst_size = DGST_SIZE_8_16;
11135 parse_func = oraclet_parse_hash;
11136 sort_by_digest = sort_by_digest_8_16;
11137 opti_type = OPTI_TYPE_ZERO_BYTE
11138 | OPTI_TYPE_USES_BITS_64;
11139 dgst_pos0 = 0;
11140 dgst_pos1 = 1;
11141 dgst_pos2 = 2;
11142 dgst_pos3 = 3;
11143 break;
11144
11145 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
11146 salt_type = SALT_TYPE_EMBEDDED;
11147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11149 kern_type = KERN_TYPE_BSDICRYPT;
11150 dgst_size = DGST_SIZE_4_4;
11151 parse_func = bsdicrypt_parse_hash;
11152 sort_by_digest = sort_by_digest_4_4;
11153 opti_type = OPTI_TYPE_ZERO_BYTE
11154 | OPTI_TYPE_PRECOMPUTE_PERMUT;
11155 dgst_pos0 = 0;
11156 dgst_pos1 = 1;
11157 dgst_pos2 = 2;
11158 dgst_pos3 = 3;
11159 break;
11160
11161 case 12500: hash_type = HASH_TYPE_RAR3HP;
11162 salt_type = SALT_TYPE_EMBEDDED;
11163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11165 kern_type = KERN_TYPE_RAR3;
11166 dgst_size = DGST_SIZE_4_4;
11167 parse_func = rar3hp_parse_hash;
11168 sort_by_digest = sort_by_digest_4_4;
11169 opti_type = OPTI_TYPE_ZERO_BYTE;
11170 dgst_pos0 = 0;
11171 dgst_pos1 = 1;
11172 dgst_pos2 = 2;
11173 dgst_pos3 = 3;
11174 break;
11175
11176 case 12600: hash_type = HASH_TYPE_SHA256;
11177 salt_type = SALT_TYPE_INTERN;
11178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11179 opts_type = OPTS_TYPE_PT_GENERATE_BE
11180 | OPTS_TYPE_PT_ADD80;
11181 kern_type = KERN_TYPE_CF10;
11182 dgst_size = DGST_SIZE_4_8;
11183 parse_func = cf10_parse_hash;
11184 sort_by_digest = sort_by_digest_4_8;
11185 opti_type = OPTI_TYPE_ZERO_BYTE
11186 | OPTI_TYPE_PRECOMPUTE_INIT
11187 | OPTI_TYPE_EARLY_SKIP
11188 | OPTI_TYPE_NOT_ITERATED;
11189 dgst_pos0 = 3;
11190 dgst_pos1 = 7;
11191 dgst_pos2 = 2;
11192 dgst_pos3 = 6;
11193 break;
11194
11195 case 12700: hash_type = HASH_TYPE_AES;
11196 salt_type = SALT_TYPE_EMBEDDED;
11197 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11198 opts_type = OPTS_TYPE_PT_GENERATE_LE
11199 | OPTS_TYPE_HASH_COPY;
11200 kern_type = KERN_TYPE_MYWALLET;
11201 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
11202 parse_func = mywallet_parse_hash;
11203 sort_by_digest = sort_by_digest_4_5;
11204 opti_type = OPTI_TYPE_ZERO_BYTE;
11205 dgst_pos0 = 0;
11206 dgst_pos1 = 1;
11207 dgst_pos2 = 2;
11208 dgst_pos3 = 3;
11209 break;
11210
11211 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
11212 salt_type = SALT_TYPE_EMBEDDED;
11213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11214 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11215 kern_type = KERN_TYPE_MS_DRSR;
11216 dgst_size = DGST_SIZE_4_8;
11217 parse_func = ms_drsr_parse_hash;
11218 sort_by_digest = sort_by_digest_4_8;
11219 opti_type = OPTI_TYPE_ZERO_BYTE;
11220 dgst_pos0 = 0;
11221 dgst_pos1 = 1;
11222 dgst_pos2 = 2;
11223 dgst_pos3 = 3;
11224 break;
11225
11226 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
11227 salt_type = SALT_TYPE_EMBEDDED;
11228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11229 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11230 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
11231 dgst_size = DGST_SIZE_4_8;
11232 parse_func = androidfde_samsung_parse_hash;
11233 sort_by_digest = sort_by_digest_4_8;
11234 opti_type = OPTI_TYPE_ZERO_BYTE;
11235 dgst_pos0 = 0;
11236 dgst_pos1 = 1;
11237 dgst_pos2 = 2;
11238 dgst_pos3 = 3;
11239 break;
11240
11241 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
11242 salt_type = SALT_TYPE_EMBEDDED;
11243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11244 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11245 kern_type = KERN_TYPE_RAR5;
11246 dgst_size = DGST_SIZE_4_4;
11247 parse_func = rar5_parse_hash;
11248 sort_by_digest = sort_by_digest_4_4;
11249 opti_type = OPTI_TYPE_ZERO_BYTE;
11250 dgst_pos0 = 0;
11251 dgst_pos1 = 1;
11252 dgst_pos2 = 2;
11253 dgst_pos3 = 3;
11254 break;
11255
11256 case 13100: hash_type = HASH_TYPE_KRB5TGS;
11257 salt_type = SALT_TYPE_EMBEDDED;
11258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11259 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11260 kern_type = KERN_TYPE_KRB5TGS;
11261 dgst_size = DGST_SIZE_4_4;
11262 parse_func = krb5tgs_parse_hash;
11263 sort_by_digest = sort_by_digest_4_4;
11264 opti_type = OPTI_TYPE_ZERO_BYTE
11265 | OPTI_TYPE_NOT_ITERATED;
11266 dgst_pos0 = 0;
11267 dgst_pos1 = 1;
11268 dgst_pos2 = 2;
11269 dgst_pos3 = 3;
11270 break;
11271
11272 case 13200: hash_type = HASH_TYPE_AES;
11273 salt_type = SALT_TYPE_EMBEDDED;
11274 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11276 kern_type = KERN_TYPE_AXCRYPT;
11277 dgst_size = DGST_SIZE_4_4;
11278 parse_func = axcrypt_parse_hash;
11279 sort_by_digest = sort_by_digest_4_4;
11280 opti_type = OPTI_TYPE_ZERO_BYTE;
11281 dgst_pos0 = 0;
11282 dgst_pos1 = 1;
11283 dgst_pos2 = 2;
11284 dgst_pos3 = 3;
11285 break;
11286
11287 case 13300: hash_type = HASH_TYPE_SHA1;
11288 salt_type = SALT_TYPE_NONE;
11289 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11290 opts_type = OPTS_TYPE_PT_GENERATE_BE
11291 | OPTS_TYPE_PT_ADD80
11292 | OPTS_TYPE_PT_ADDBITS15;
11293 kern_type = KERN_TYPE_SHA1_AXCRYPT;
11294 dgst_size = DGST_SIZE_4_5;
11295 parse_func = sha1axcrypt_parse_hash;
11296 sort_by_digest = sort_by_digest_4_5;
11297 opti_type = OPTI_TYPE_ZERO_BYTE
11298 | OPTI_TYPE_PRECOMPUTE_INIT
11299 | OPTI_TYPE_EARLY_SKIP
11300 | OPTI_TYPE_NOT_ITERATED
11301 | OPTI_TYPE_NOT_SALTED;
11302 dgst_pos0 = 0;
11303 dgst_pos1 = 4;
11304 dgst_pos2 = 3;
11305 dgst_pos3 = 2;
11306 break;
11307
11308 case 13400: hash_type = HASH_TYPE_AES;
11309 salt_type = SALT_TYPE_EMBEDDED;
11310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11311 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11312 kern_type = KERN_TYPE_KEEPASS;
11313 dgst_size = DGST_SIZE_4_4;
11314 parse_func = keepass_parse_hash;
11315 sort_by_digest = sort_by_digest_4_4;
11316 opti_type = OPTI_TYPE_ZERO_BYTE;
11317 dgst_pos0 = 0;
11318 dgst_pos1 = 1;
11319 dgst_pos2 = 2;
11320 dgst_pos3 = 3;
11321 break;
11322
11323 case 13500: hash_type = HASH_TYPE_SHA1;
11324 salt_type = SALT_TYPE_EMBEDDED;
11325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11326 opts_type = OPTS_TYPE_PT_GENERATE_BE
11327 | OPTS_TYPE_PT_UNICODE
11328 | OPTS_TYPE_PT_ADD80;
11329 kern_type = KERN_TYPE_PSTOKEN;
11330 dgst_size = DGST_SIZE_4_5;
11331 parse_func = pstoken_parse_hash;
11332 sort_by_digest = sort_by_digest_4_5;
11333 opti_type = OPTI_TYPE_ZERO_BYTE
11334 | OPTI_TYPE_PRECOMPUTE_INIT
11335 | OPTI_TYPE_EARLY_SKIP
11336 | OPTI_TYPE_NOT_ITERATED
11337 | OPTI_TYPE_PREPENDED_SALT
11338 | OPTI_TYPE_RAW_HASH;
11339 dgst_pos0 = 3;
11340 dgst_pos1 = 4;
11341 dgst_pos2 = 2;
11342 dgst_pos3 = 1;
11343 break;
11344
11345 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
11346 salt_type = SALT_TYPE_EMBEDDED;
11347 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11348 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11349 kern_type = KERN_TYPE_ZIP2;
11350 dgst_size = DGST_SIZE_4_4;
11351 parse_func = zip2_parse_hash;
11352 sort_by_digest = sort_by_digest_4_4;
11353 opti_type = OPTI_TYPE_ZERO_BYTE;
11354 dgst_pos0 = 0;
11355 dgst_pos1 = 1;
11356 dgst_pos2 = 2;
11357 dgst_pos3 = 3;
11358 break;
11359
11360 case 13711: hash_type = HASH_TYPE_RIPEMD160;
11361 salt_type = SALT_TYPE_EMBEDDED;
11362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11363 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11364 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11365 dgst_size = DGST_SIZE_4_5;
11366 parse_func = veracrypt_parse_hash_655331;
11367 sort_by_digest = sort_by_digest_4_5;
11368 opti_type = OPTI_TYPE_ZERO_BYTE;
11369 dgst_pos0 = 0;
11370 dgst_pos1 = 1;
11371 dgst_pos2 = 2;
11372 dgst_pos3 = 3;
11373 break;
11374
11375 case 13712: hash_type = HASH_TYPE_RIPEMD160;
11376 salt_type = SALT_TYPE_EMBEDDED;
11377 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11379 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11380 dgst_size = DGST_SIZE_4_5;
11381 parse_func = veracrypt_parse_hash_655331;
11382 sort_by_digest = sort_by_digest_4_5;
11383 opti_type = OPTI_TYPE_ZERO_BYTE;
11384 dgst_pos0 = 0;
11385 dgst_pos1 = 1;
11386 dgst_pos2 = 2;
11387 dgst_pos3 = 3;
11388 break;
11389
11390 case 13713: hash_type = HASH_TYPE_RIPEMD160;
11391 salt_type = SALT_TYPE_EMBEDDED;
11392 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11393 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11394 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11395 dgst_size = DGST_SIZE_4_5;
11396 parse_func = veracrypt_parse_hash_655331;
11397 sort_by_digest = sort_by_digest_4_5;
11398 opti_type = OPTI_TYPE_ZERO_BYTE;
11399 dgst_pos0 = 0;
11400 dgst_pos1 = 1;
11401 dgst_pos2 = 2;
11402 dgst_pos3 = 3;
11403 break;
11404
11405 case 13721: hash_type = HASH_TYPE_SHA512;
11406 salt_type = SALT_TYPE_EMBEDDED;
11407 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11408 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11409 kern_type = KERN_TYPE_TCSHA512_XTS512;
11410 dgst_size = DGST_SIZE_8_8;
11411 parse_func = veracrypt_parse_hash_500000;
11412 sort_by_digest = sort_by_digest_8_8;
11413 opti_type = OPTI_TYPE_ZERO_BYTE
11414 | OPTI_TYPE_USES_BITS_64;
11415 dgst_pos0 = 0;
11416 dgst_pos1 = 1;
11417 dgst_pos2 = 2;
11418 dgst_pos3 = 3;
11419 break;
11420
11421 case 13722: hash_type = HASH_TYPE_SHA512;
11422 salt_type = SALT_TYPE_EMBEDDED;
11423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11424 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11425 kern_type = KERN_TYPE_TCSHA512_XTS1024;
11426 dgst_size = DGST_SIZE_8_8;
11427 parse_func = veracrypt_parse_hash_500000;
11428 sort_by_digest = sort_by_digest_8_8;
11429 opti_type = OPTI_TYPE_ZERO_BYTE
11430 | OPTI_TYPE_USES_BITS_64;
11431 dgst_pos0 = 0;
11432 dgst_pos1 = 1;
11433 dgst_pos2 = 2;
11434 dgst_pos3 = 3;
11435 break;
11436
11437 case 13723: hash_type = HASH_TYPE_SHA512;
11438 salt_type = SALT_TYPE_EMBEDDED;
11439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11440 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11441 kern_type = KERN_TYPE_TCSHA512_XTS1536;
11442 dgst_size = DGST_SIZE_8_8;
11443 parse_func = veracrypt_parse_hash_500000;
11444 sort_by_digest = sort_by_digest_8_8;
11445 opti_type = OPTI_TYPE_ZERO_BYTE
11446 | OPTI_TYPE_USES_BITS_64;
11447 dgst_pos0 = 0;
11448 dgst_pos1 = 1;
11449 dgst_pos2 = 2;
11450 dgst_pos3 = 3;
11451 break;
11452
11453 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
11454 salt_type = SALT_TYPE_EMBEDDED;
11455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11456 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11457 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
11458 dgst_size = DGST_SIZE_4_8;
11459 parse_func = veracrypt_parse_hash_500000;
11460 sort_by_digest = sort_by_digest_4_8;
11461 opti_type = OPTI_TYPE_ZERO_BYTE;
11462 dgst_pos0 = 0;
11463 dgst_pos1 = 1;
11464 dgst_pos2 = 2;
11465 dgst_pos3 = 3;
11466 break;
11467
11468 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
11469 salt_type = SALT_TYPE_EMBEDDED;
11470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11472 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
11473 dgst_size = DGST_SIZE_4_8;
11474 parse_func = veracrypt_parse_hash_500000;
11475 sort_by_digest = sort_by_digest_4_8;
11476 opti_type = OPTI_TYPE_ZERO_BYTE;
11477 dgst_pos0 = 0;
11478 dgst_pos1 = 1;
11479 dgst_pos2 = 2;
11480 dgst_pos3 = 3;
11481 break;
11482
11483 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
11484 salt_type = SALT_TYPE_EMBEDDED;
11485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11487 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
11488 dgst_size = DGST_SIZE_4_8;
11489 parse_func = veracrypt_parse_hash_500000;
11490 sort_by_digest = sort_by_digest_4_8;
11491 opti_type = OPTI_TYPE_ZERO_BYTE;
11492 dgst_pos0 = 0;
11493 dgst_pos1 = 1;
11494 dgst_pos2 = 2;
11495 dgst_pos3 = 3;
11496 break;
11497
11498 case 13741: hash_type = HASH_TYPE_RIPEMD160;
11499 salt_type = SALT_TYPE_EMBEDDED;
11500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11501 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11502 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
11503 dgst_size = DGST_SIZE_4_5;
11504 parse_func = veracrypt_parse_hash_327661;
11505 sort_by_digest = sort_by_digest_4_5;
11506 opti_type = OPTI_TYPE_ZERO_BYTE;
11507 dgst_pos0 = 0;
11508 dgst_pos1 = 1;
11509 dgst_pos2 = 2;
11510 dgst_pos3 = 3;
11511 break;
11512
11513 case 13742: hash_type = HASH_TYPE_RIPEMD160;
11514 salt_type = SALT_TYPE_EMBEDDED;
11515 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11516 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11517 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
11518 dgst_size = DGST_SIZE_4_5;
11519 parse_func = veracrypt_parse_hash_327661;
11520 sort_by_digest = sort_by_digest_4_5;
11521 opti_type = OPTI_TYPE_ZERO_BYTE;
11522 dgst_pos0 = 0;
11523 dgst_pos1 = 1;
11524 dgst_pos2 = 2;
11525 dgst_pos3 = 3;
11526 break;
11527
11528 case 13743: hash_type = HASH_TYPE_RIPEMD160;
11529 salt_type = SALT_TYPE_EMBEDDED;
11530 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11531 opts_type = OPTS_TYPE_PT_GENERATE_LE;
11532 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
11533 dgst_size = DGST_SIZE_4_5;
11534 parse_func = veracrypt_parse_hash_327661;
11535 sort_by_digest = sort_by_digest_4_5;
11536 opti_type = OPTI_TYPE_ZERO_BYTE;
11537 dgst_pos0 = 0;
11538 dgst_pos1 = 1;
11539 dgst_pos2 = 2;
11540 dgst_pos3 = 3;
11541 break;
11542
11543 case 13751: hash_type = HASH_TYPE_SHA256;
11544 salt_type = SALT_TYPE_EMBEDDED;
11545 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11546 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11547 kern_type = KERN_TYPE_VCSHA256_XTS512;
11548 dgst_size = DGST_SIZE_4_8;
11549 parse_func = veracrypt_parse_hash_500000;
11550 sort_by_digest = sort_by_digest_4_8;
11551 opti_type = OPTI_TYPE_ZERO_BYTE;
11552 dgst_pos0 = 0;
11553 dgst_pos1 = 1;
11554 dgst_pos2 = 2;
11555 dgst_pos3 = 3;
11556 break;
11557
11558 case 13752: hash_type = HASH_TYPE_SHA256;
11559 salt_type = SALT_TYPE_EMBEDDED;
11560 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11561 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11562 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11563 dgst_size = DGST_SIZE_4_8;
11564 parse_func = veracrypt_parse_hash_500000;
11565 sort_by_digest = sort_by_digest_4_8;
11566 opti_type = OPTI_TYPE_ZERO_BYTE;
11567 dgst_pos0 = 0;
11568 dgst_pos1 = 1;
11569 dgst_pos2 = 2;
11570 dgst_pos3 = 3;
11571 break;
11572
11573 case 13753: hash_type = HASH_TYPE_SHA256;
11574 salt_type = SALT_TYPE_EMBEDDED;
11575 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11576 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11577 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11578 dgst_size = DGST_SIZE_4_8;
11579 parse_func = veracrypt_parse_hash_500000;
11580 sort_by_digest = sort_by_digest_4_8;
11581 opti_type = OPTI_TYPE_ZERO_BYTE;
11582 dgst_pos0 = 0;
11583 dgst_pos1 = 1;
11584 dgst_pos2 = 2;
11585 dgst_pos3 = 3;
11586 break;
11587
11588 case 13761: hash_type = HASH_TYPE_SHA256;
11589 salt_type = SALT_TYPE_EMBEDDED;
11590 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11591 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11592 kern_type = KERN_TYPE_VCSHA256_XTS512;
11593 dgst_size = DGST_SIZE_4_8;
11594 parse_func = veracrypt_parse_hash_200000;
11595 sort_by_digest = sort_by_digest_4_8;
11596 opti_type = OPTI_TYPE_ZERO_BYTE;
11597 dgst_pos0 = 0;
11598 dgst_pos1 = 1;
11599 dgst_pos2 = 2;
11600 dgst_pos3 = 3;
11601 break;
11602
11603 case 13762: hash_type = HASH_TYPE_SHA256;
11604 salt_type = SALT_TYPE_EMBEDDED;
11605 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11606 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11607 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11608 dgst_size = DGST_SIZE_4_8;
11609 parse_func = veracrypt_parse_hash_200000;
11610 sort_by_digest = sort_by_digest_4_8;
11611 opti_type = OPTI_TYPE_ZERO_BYTE;
11612 dgst_pos0 = 0;
11613 dgst_pos1 = 1;
11614 dgst_pos2 = 2;
11615 dgst_pos3 = 3;
11616 break;
11617
11618 case 13763: hash_type = HASH_TYPE_SHA256;
11619 salt_type = SALT_TYPE_EMBEDDED;
11620 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11621 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11622 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11623 dgst_size = DGST_SIZE_4_8;
11624 parse_func = veracrypt_parse_hash_200000;
11625 sort_by_digest = sort_by_digest_4_8;
11626 opti_type = OPTI_TYPE_ZERO_BYTE;
11627 dgst_pos0 = 0;
11628 dgst_pos1 = 1;
11629 dgst_pos2 = 2;
11630 dgst_pos3 = 3;
11631 break;
11632
11633 case 13800: hash_type = HASH_TYPE_SHA256;
11634 salt_type = SALT_TYPE_EMBEDDED;
11635 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11636 opts_type = OPTS_TYPE_PT_GENERATE_BE
11637 | OPTS_TYPE_PT_UNICODE;
11638 kern_type = KERN_TYPE_WIN8PHONE;
11639 dgst_size = DGST_SIZE_4_8;
11640 parse_func = win8phone_parse_hash;
11641 sort_by_digest = sort_by_digest_4_8;
11642 opti_type = OPTI_TYPE_ZERO_BYTE
11643 | OPTI_TYPE_PRECOMPUTE_INIT
11644 | OPTI_TYPE_EARLY_SKIP
11645 | OPTI_TYPE_NOT_ITERATED
11646 | OPTI_TYPE_RAW_HASH;
11647 dgst_pos0 = 3;
11648 dgst_pos1 = 7;
11649 dgst_pos2 = 2;
11650 dgst_pos3 = 6;
11651 break;
11652
11653 default: usage_mini_print (PROGNAME); return -1;
11654 }
11655
11656 /**
11657 * parser
11658 */
11659
11660 data.parse_func = parse_func;
11661
11662 /**
11663 * misc stuff
11664 */
11665
11666 if (hex_salt)
11667 {
11668 if (salt_type == SALT_TYPE_INTERN)
11669 {
11670 opts_type |= OPTS_TYPE_ST_HEX;
11671 }
11672 else
11673 {
11674 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11675
11676 return -1;
11677 }
11678 }
11679
11680 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11681 | (salt_type == SALT_TYPE_EXTERN)
11682 | (salt_type == SALT_TYPE_EMBEDDED)
11683 | (salt_type == SALT_TYPE_VIRTUAL));
11684
11685 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11686
11687 data.hash_type = hash_type;
11688 data.attack_mode = attack_mode;
11689 data.attack_kern = attack_kern;
11690 data.attack_exec = attack_exec;
11691 data.kern_type = kern_type;
11692 data.opts_type = opts_type;
11693 data.dgst_size = dgst_size;
11694 data.salt_type = salt_type;
11695 data.isSalted = isSalted;
11696 data.sort_by_digest = sort_by_digest;
11697 data.dgst_pos0 = dgst_pos0;
11698 data.dgst_pos1 = dgst_pos1;
11699 data.dgst_pos2 = dgst_pos2;
11700 data.dgst_pos3 = dgst_pos3;
11701
11702 esalt_size = 0;
11703
11704 switch (hash_mode)
11705 {
11706 case 2500: esalt_size = sizeof (wpa_t); break;
11707 case 5300: esalt_size = sizeof (ikepsk_t); break;
11708 case 5400: esalt_size = sizeof (ikepsk_t); break;
11709 case 5500: esalt_size = sizeof (netntlm_t); break;
11710 case 5600: esalt_size = sizeof (netntlm_t); break;
11711 case 6211: esalt_size = sizeof (tc_t); break;
11712 case 6212: esalt_size = sizeof (tc_t); break;
11713 case 6213: esalt_size = sizeof (tc_t); break;
11714 case 6221: esalt_size = sizeof (tc_t); break;
11715 case 6222: esalt_size = sizeof (tc_t); break;
11716 case 6223: esalt_size = sizeof (tc_t); break;
11717 case 6231: esalt_size = sizeof (tc_t); break;
11718 case 6232: esalt_size = sizeof (tc_t); break;
11719 case 6233: esalt_size = sizeof (tc_t); break;
11720 case 6241: esalt_size = sizeof (tc_t); break;
11721 case 6242: esalt_size = sizeof (tc_t); break;
11722 case 6243: esalt_size = sizeof (tc_t); break;
11723 case 6600: esalt_size = sizeof (agilekey_t); break;
11724 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11725 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11726 case 7300: esalt_size = sizeof (rakp_t); break;
11727 case 7500: esalt_size = sizeof (krb5pa_t); break;
11728 case 8200: esalt_size = sizeof (cloudkey_t); break;
11729 case 8800: esalt_size = sizeof (androidfde_t); break;
11730 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11731 case 9400: esalt_size = sizeof (office2007_t); break;
11732 case 9500: esalt_size = sizeof (office2010_t); break;
11733 case 9600: esalt_size = sizeof (office2013_t); break;
11734 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11735 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11736 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11737 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11738 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11739 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11740 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11741 case 10200: esalt_size = sizeof (cram_md5_t); break;
11742 case 10400: esalt_size = sizeof (pdf_t); break;
11743 case 10410: esalt_size = sizeof (pdf_t); break;
11744 case 10420: esalt_size = sizeof (pdf_t); break;
11745 case 10500: esalt_size = sizeof (pdf_t); break;
11746 case 10600: esalt_size = sizeof (pdf_t); break;
11747 case 10700: esalt_size = sizeof (pdf_t); break;
11748 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11749 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11750 case 11400: esalt_size = sizeof (sip_t); break;
11751 case 11600: esalt_size = sizeof (seven_zip_t); break;
11752 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11753 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11754 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11755 case 13000: esalt_size = sizeof (rar5_t); break;
11756 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11757 case 13400: esalt_size = sizeof (keepass_t); break;
11758 case 13500: esalt_size = sizeof (pstoken_t); break;
11759 case 13600: esalt_size = sizeof (zip2_t); break;
11760 case 13711: esalt_size = sizeof (tc_t); break;
11761 case 13712: esalt_size = sizeof (tc_t); break;
11762 case 13713: esalt_size = sizeof (tc_t); break;
11763 case 13721: esalt_size = sizeof (tc_t); break;
11764 case 13722: esalt_size = sizeof (tc_t); break;
11765 case 13723: esalt_size = sizeof (tc_t); break;
11766 case 13731: esalt_size = sizeof (tc_t); break;
11767 case 13732: esalt_size = sizeof (tc_t); break;
11768 case 13733: esalt_size = sizeof (tc_t); break;
11769 case 13741: esalt_size = sizeof (tc_t); break;
11770 case 13742: esalt_size = sizeof (tc_t); break;
11771 case 13743: esalt_size = sizeof (tc_t); break;
11772 case 13751: esalt_size = sizeof (tc_t); break;
11773 case 13752: esalt_size = sizeof (tc_t); break;
11774 case 13753: esalt_size = sizeof (tc_t); break;
11775 case 13761: esalt_size = sizeof (tc_t); break;
11776 case 13762: esalt_size = sizeof (tc_t); break;
11777 case 13763: esalt_size = sizeof (tc_t); break;
11778 case 13800: esalt_size = sizeof (win8phone_t); break;
11779 }
11780
11781 data.esalt_size = esalt_size;
11782
11783 /**
11784 * choose dictionary parser
11785 */
11786
11787 if (hash_type == HASH_TYPE_LM)
11788 {
11789 get_next_word_func = get_next_word_lm;
11790 }
11791 else if (opts_type & OPTS_TYPE_PT_UPPER)
11792 {
11793 get_next_word_func = get_next_word_uc;
11794 }
11795 else
11796 {
11797 get_next_word_func = get_next_word_std;
11798 }
11799
11800 /**
11801 * dictstat
11802 */
11803
11804 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11805
11806 #ifdef _POSIX
11807 size_t dictstat_nmemb = 0;
11808 #endif
11809
11810 #ifdef _WIN
11811 uint dictstat_nmemb = 0;
11812 #endif
11813
11814 char dictstat[256] = { 0 };
11815
11816 FILE *dictstat_fp = NULL;
11817
11818 if (keyspace == 0)
11819 {
11820 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11821
11822 dictstat_fp = fopen (dictstat, "rb");
11823
11824 if (dictstat_fp)
11825 {
11826 #ifdef _POSIX
11827 struct stat tmpstat;
11828
11829 fstat (fileno (dictstat_fp), &tmpstat);
11830 #endif
11831
11832 #ifdef _WIN
11833 struct stat64 tmpstat;
11834
11835 _fstat64 (fileno (dictstat_fp), &tmpstat);
11836 #endif
11837
11838 if (tmpstat.st_mtime < COMPTIME)
11839 {
11840 /* with v0.15 the format changed so we have to ensure user is using a good version
11841 since there is no version-header in the dictstat file */
11842
11843 fclose (dictstat_fp);
11844
11845 unlink (dictstat);
11846 }
11847 else
11848 {
11849 while (!feof (dictstat_fp))
11850 {
11851 dictstat_t d;
11852
11853 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11854
11855 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11856
11857 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11858 {
11859 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11860
11861 return -1;
11862 }
11863 }
11864
11865 fclose (dictstat_fp);
11866 }
11867 }
11868 }
11869
11870 /**
11871 * potfile
11872 */
11873
11874 char potfile[256] = { 0 };
11875
11876 if (potfile_path == NULL)
11877 {
11878 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11879 }
11880 else
11881 {
11882 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11883 }
11884
11885 data.pot_fp = NULL;
11886
11887 FILE *out_fp = NULL;
11888 FILE *pot_fp = NULL;
11889
11890 if (show == 1 || left == 1)
11891 {
11892 pot_fp = fopen (potfile, "rb");
11893
11894 if (pot_fp == NULL)
11895 {
11896 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11897
11898 return -1;
11899 }
11900
11901 if (outfile != NULL)
11902 {
11903 if ((out_fp = fopen (outfile, "ab")) == NULL)
11904 {
11905 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11906
11907 fclose (pot_fp);
11908
11909 return -1;
11910 }
11911 }
11912 else
11913 {
11914 out_fp = stdout;
11915 }
11916 }
11917 else
11918 {
11919 if (potfile_disable == 0)
11920 {
11921 pot_fp = fopen (potfile, "ab");
11922
11923 if (pot_fp == NULL)
11924 {
11925 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11926
11927 return -1;
11928 }
11929
11930 data.pot_fp = pot_fp;
11931 }
11932 }
11933
11934 pot_t *pot = NULL;
11935
11936 uint pot_cnt = 0;
11937 uint pot_avail = 0;
11938
11939 if (show == 1 || left == 1)
11940 {
11941 SUPPRESS_OUTPUT = 1;
11942
11943 pot_avail = count_lines (pot_fp);
11944
11945 rewind (pot_fp);
11946
11947 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11948
11949 uint pot_hashes_avail = 0;
11950
11951 uint line_num = 0;
11952
11953 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11954
11955 while (!feof (pot_fp))
11956 {
11957 line_num++;
11958
11959 int line_len = fgetl (pot_fp, line_buf);
11960
11961 if (line_len == 0) continue;
11962
11963 char *plain_buf = line_buf + line_len;
11964
11965 pot_t *pot_ptr = &pot[pot_cnt];
11966
11967 hash_t *hashes_buf = &pot_ptr->hash;
11968
11969 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11970 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11971
11972 if (pot_cnt == pot_hashes_avail)
11973 {
11974 uint pos = 0;
11975
11976 for (pos = 0; pos < INCR_POT; pos++)
11977 {
11978 if ((pot_cnt + pos) >= pot_avail) break;
11979
11980 pot_t *tmp_pot = &pot[pot_cnt + pos];
11981
11982 hash_t *tmp_hash = &tmp_pot->hash;
11983
11984 tmp_hash->digest = mymalloc (dgst_size);
11985
11986 if (isSalted)
11987 {
11988 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11989 }
11990
11991 if (esalt_size)
11992 {
11993 tmp_hash->esalt = mymalloc (esalt_size);
11994 }
11995
11996 pot_hashes_avail++;
11997 }
11998 }
11999
12000 int plain_len = 0;
12001
12002 int parser_status;
12003
12004 int iter = MAX_CUT_TRIES;
12005
12006 do
12007 {
12008 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
12009 {
12010 if (line_buf[i] == ':')
12011 {
12012 line_len--;
12013
12014 break;
12015 }
12016 }
12017
12018 if (data.hash_mode != 2500)
12019 {
12020 parser_status = parse_func (line_buf, line_len, hashes_buf);
12021 }
12022 else
12023 {
12024 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
12025
12026 if (line_len > max_salt_size)
12027 {
12028 parser_status = PARSER_GLOBAL_LENGTH;
12029 }
12030 else
12031 {
12032 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
12033
12034 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
12035
12036 hashes_buf->salt->salt_len = line_len;
12037
12038 parser_status = PARSER_OK;
12039 }
12040 }
12041
12042 // if NOT parsed without error, we add the ":" to the plain
12043
12044 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
12045 {
12046 plain_len++;
12047 plain_buf--;
12048 }
12049
12050 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
12051
12052 if (parser_status < PARSER_GLOBAL_ZERO)
12053 {
12054 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
12055
12056 continue;
12057 }
12058
12059 if (plain_len >= 255) continue;
12060
12061 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
12062
12063 pot_ptr->plain_len = plain_len;
12064
12065 pot_cnt++;
12066 }
12067
12068 myfree (line_buf);
12069
12070 fclose (pot_fp);
12071
12072 SUPPRESS_OUTPUT = 0;
12073
12074 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
12075 }
12076
12077 /**
12078 * word len
12079 */
12080
12081 uint pw_min = PW_MIN;
12082 uint pw_max = PW_MAX;
12083
12084 switch (hash_mode)
12085 {
12086 case 125: if (pw_max > 32) pw_max = 32;
12087 break;
12088 case 400: if (pw_max > 40) pw_max = 40;
12089 break;
12090 case 500: if (pw_max > 16) pw_max = 16;
12091 break;
12092 case 1500: if (pw_max > 8) pw_max = 8;
12093 break;
12094 case 1600: if (pw_max > 16) pw_max = 16;
12095 break;
12096 case 1800: if (pw_max > 16) pw_max = 16;
12097 break;
12098 case 2100: if (pw_max > 16) pw_max = 16;
12099 break;
12100 case 2500: if (pw_min < 8) pw_min = 8;
12101 break;
12102 case 3000: if (pw_max > 7) pw_max = 7;
12103 break;
12104 case 5200: if (pw_max > 24) pw_max = 24;
12105 break;
12106 case 5800: if (pw_max > 16) pw_max = 16;
12107 break;
12108 case 6300: if (pw_max > 16) pw_max = 16;
12109 break;
12110 case 7400: if (pw_max > 16) pw_max = 16;
12111 break;
12112 case 7700: if (pw_max > 8) pw_max = 8;
12113 break;
12114 case 7900: if (pw_max > 48) pw_max = 48;
12115 break;
12116 case 8500: if (pw_max > 8) pw_max = 8;
12117 break;
12118 case 8600: if (pw_max > 16) pw_max = 16;
12119 break;
12120 case 9710: pw_min = 5;
12121 pw_max = 5;
12122 break;
12123 case 9810: pw_min = 5;
12124 pw_max = 5;
12125 break;
12126 case 10410: pw_min = 5;
12127 pw_max = 5;
12128 break;
12129 case 10300: if (pw_max < 3) pw_min = 3;
12130 if (pw_max > 40) pw_max = 40;
12131 break;
12132 case 10500: if (pw_max < 3) pw_min = 3;
12133 if (pw_max > 40) pw_max = 40;
12134 break;
12135 case 10700: if (pw_max > 16) pw_max = 16;
12136 break;
12137 case 11300: if (pw_max > 40) pw_max = 40;
12138 break;
12139 case 11600: if (pw_max > 32) pw_max = 32;
12140 break;
12141 case 12500: if (pw_max > 20) pw_max = 20;
12142 break;
12143 case 12800: if (pw_max > 24) pw_max = 24;
12144 break;
12145 }
12146
12147 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12148 {
12149 switch (attack_kern)
12150 {
12151 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12152 break;
12153 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
12154 break;
12155 }
12156 }
12157
12158 /**
12159 * charsets : keep them together for more easy maintainnce
12160 */
12161
12162 cs_t mp_sys[6] = { { { 0 }, 0 } };
12163 cs_t mp_usr[4] = { { { 0 }, 0 } };
12164
12165 mp_setup_sys (mp_sys);
12166
12167 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
12168 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
12169 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
12170 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
12171
12172 /**
12173 * load hashes, part I: find input mode, count hashes
12174 */
12175
12176 uint hashlist_mode = 0;
12177 uint hashlist_format = HLFMT_HASHCAT;
12178
12179 uint hashes_avail = 0;
12180
12181 if ((benchmark == 0) && (stdout_flag == 0))
12182 {
12183 struct stat f;
12184
12185 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
12186
12187 if ((hash_mode == 2500) ||
12188 (hash_mode == 5200) ||
12189 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
12190 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
12191 (hash_mode == 9000))
12192 {
12193 hashlist_mode = HL_MODE_ARG;
12194
12195 char *hashfile = myargv[optind];
12196
12197 data.hashfile = hashfile;
12198
12199 logfile_top_var_string ("target", hashfile);
12200 }
12201
12202 if (hashlist_mode == HL_MODE_ARG)
12203 {
12204 if (hash_mode == 2500)
12205 {
12206 struct stat st;
12207
12208 if (stat (data.hashfile, &st) == -1)
12209 {
12210 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
12211
12212 return -1;
12213 }
12214
12215 hashes_avail = st.st_size / sizeof (hccap_t);
12216 }
12217 else
12218 {
12219 hashes_avail = 1;
12220 }
12221 }
12222 else if (hashlist_mode == HL_MODE_FILE)
12223 {
12224 char *hashfile = myargv[optind];
12225
12226 data.hashfile = hashfile;
12227
12228 logfile_top_var_string ("target", hashfile);
12229
12230 FILE *fp = NULL;
12231
12232 if ((fp = fopen (hashfile, "rb")) == NULL)
12233 {
12234 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12235
12236 return -1;
12237 }
12238
12239 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
12240
12241 hashes_avail = count_lines (fp);
12242
12243 rewind (fp);
12244
12245 if (hashes_avail == 0)
12246 {
12247 log_error ("ERROR: hashfile is empty or corrupt");
12248
12249 fclose (fp);
12250
12251 return -1;
12252 }
12253
12254 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
12255
12256 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
12257 {
12258 log_error ("ERROR: remove not supported in native hashfile-format mode");
12259
12260 fclose (fp);
12261
12262 return -1;
12263 }
12264
12265 fclose (fp);
12266 }
12267 }
12268 else
12269 {
12270 hashlist_mode = HL_MODE_ARG;
12271
12272 hashes_avail = 1;
12273 }
12274
12275 if (hash_mode == 3000) hashes_avail *= 2;
12276
12277 data.hashlist_mode = hashlist_mode;
12278 data.hashlist_format = hashlist_format;
12279
12280 logfile_top_uint (hashlist_mode);
12281 logfile_top_uint (hashlist_format);
12282
12283 /**
12284 * load hashes, part II: allocate required memory, set pointers
12285 */
12286
12287 hash_t *hashes_buf = NULL;
12288 void *digests_buf = NULL;
12289 salt_t *salts_buf = NULL;
12290 void *esalts_buf = NULL;
12291
12292 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
12293
12294 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
12295
12296 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12297 {
12298 u32 hash_pos;
12299
12300 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12301 {
12302 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
12303
12304 hashes_buf[hash_pos].hash_info = hash_info;
12305
12306 if (username && (remove || show || left))
12307 {
12308 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
12309 }
12310
12311 if (benchmark)
12312 {
12313 hash_info->orighash = (char *) mymalloc (256);
12314 }
12315 }
12316 }
12317
12318 if (isSalted)
12319 {
12320 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12321
12322 if (esalt_size)
12323 {
12324 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
12325 }
12326 }
12327 else
12328 {
12329 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
12330 }
12331
12332 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
12333 {
12334 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
12335
12336 if (isSalted)
12337 {
12338 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
12339
12340 if (esalt_size)
12341 {
12342 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
12343 }
12344 }
12345 else
12346 {
12347 hashes_buf[hash_pos].salt = &salts_buf[0];
12348 }
12349 }
12350
12351 /**
12352 * load hashes, part III: parse hashes or generate them if benchmark
12353 */
12354
12355 uint hashes_cnt = 0;
12356
12357 if (benchmark == 0)
12358 {
12359 if (keyspace == 1)
12360 {
12361 // useless to read hash file for keyspace, cheat a little bit w/ optind
12362 }
12363 else if (stdout_flag == 1)
12364 {
12365 // useless to read hash file for stdout, cheat a little bit w/ optind
12366 }
12367 else if (hashes_avail == 0)
12368 {
12369 }
12370 else if (hashlist_mode == HL_MODE_ARG)
12371 {
12372 char *input_buf = myargv[optind];
12373
12374 uint input_len = strlen (input_buf);
12375
12376 logfile_top_var_string ("target", input_buf);
12377
12378 char *hash_buf = NULL;
12379 int hash_len = 0;
12380
12381 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
12382
12383 bool hash_fmt_error = 0;
12384
12385 if (hash_len < 1) hash_fmt_error = 1;
12386 if (hash_buf == NULL) hash_fmt_error = 1;
12387
12388 if (hash_fmt_error)
12389 {
12390 log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12391 }
12392 else
12393 {
12394 if (opts_type & OPTS_TYPE_HASH_COPY)
12395 {
12396 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12397
12398 hash_info_tmp->orighash = mystrdup (hash_buf);
12399 }
12400
12401 if (isSalted)
12402 {
12403 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
12404 }
12405
12406 int parser_status = PARSER_OK;
12407
12408 if (hash_mode == 2500)
12409 {
12410 if (hash_len == 0)
12411 {
12412 log_error ("ERROR: hccap file not specified");
12413
12414 return -1;
12415 }
12416
12417 hashlist_mode = HL_MODE_FILE;
12418
12419 data.hashlist_mode = hashlist_mode;
12420
12421 FILE *fp = fopen (hash_buf, "rb");
12422
12423 if (fp == NULL)
12424 {
12425 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
12426
12427 return -1;
12428 }
12429
12430 if (hashes_avail < 1)
12431 {
12432 log_error ("ERROR: hccap file is empty or corrupt");
12433
12434 fclose (fp);
12435
12436 return -1;
12437 }
12438
12439 uint hccap_size = sizeof (hccap_t);
12440
12441 char *in = (char *) mymalloc (hccap_size);
12442
12443 while (!feof (fp))
12444 {
12445 int n = fread (in, hccap_size, 1, fp);
12446
12447 if (n != 1)
12448 {
12449 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
12450
12451 break;
12452 }
12453
12454 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
12455
12456 if (parser_status != PARSER_OK)
12457 {
12458 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
12459
12460 continue;
12461 }
12462
12463 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
12464
12465 if ((show == 1) || (left == 1))
12466 {
12467 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
12468
12469 char *salt_ptr = (char *) tmp_salt->salt_buf;
12470
12471 int cur_pos = tmp_salt->salt_len;
12472 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12473
12474 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
12475
12476 // do the appending task
12477
12478 snprintf (salt_ptr + cur_pos,
12479 rem_len,
12480 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
12481 wpa->orig_mac1[0],
12482 wpa->orig_mac1[1],
12483 wpa->orig_mac1[2],
12484 wpa->orig_mac1[3],
12485 wpa->orig_mac1[4],
12486 wpa->orig_mac1[5],
12487 wpa->orig_mac2[0],
12488 wpa->orig_mac2[1],
12489 wpa->orig_mac2[2],
12490 wpa->orig_mac2[3],
12491 wpa->orig_mac2[4],
12492 wpa->orig_mac2[5]);
12493
12494 // memset () the remaining part of the salt
12495
12496 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
12497 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
12498
12499 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
12500
12501 tmp_salt->salt_len += 1 + 12 + 1 + 12;
12502 }
12503
12504 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);
12505 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);
12506
12507 hashes_cnt++;
12508 }
12509
12510 fclose (fp);
12511
12512 myfree (in);
12513 }
12514 else if (hash_mode == 3000)
12515 {
12516 if (hash_len == 32)
12517 {
12518 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12519
12520 hash_t *lm_hash_left = NULL;
12521
12522 if (parser_status == PARSER_OK)
12523 {
12524 lm_hash_left = &hashes_buf[hashes_cnt];
12525
12526 hashes_cnt++;
12527 }
12528 else
12529 {
12530 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12531 }
12532
12533 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12534
12535 hash_t *lm_hash_right = NULL;
12536
12537 if (parser_status == PARSER_OK)
12538 {
12539 lm_hash_right = &hashes_buf[hashes_cnt];
12540
12541 hashes_cnt++;
12542 }
12543 else
12544 {
12545 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12546 }
12547
12548 // show / left
12549
12550 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12551 {
12552 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);
12553 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);
12554 }
12555 }
12556 else
12557 {
12558 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12559
12560 if (parser_status == PARSER_OK)
12561 {
12562 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12563 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12564 }
12565
12566 if (parser_status == PARSER_OK)
12567 {
12568 hashes_cnt++;
12569 }
12570 else
12571 {
12572 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12573 }
12574 }
12575 }
12576 else
12577 {
12578 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12579
12580 if (parser_status == PARSER_OK)
12581 {
12582 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12583 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12584 }
12585
12586 if (parser_status == PARSER_OK)
12587 {
12588 hashes_cnt++;
12589 }
12590 else
12591 {
12592 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12593 }
12594 }
12595 }
12596 }
12597 else if (hashlist_mode == HL_MODE_FILE)
12598 {
12599 char *hashfile = data.hashfile;
12600
12601 FILE *fp;
12602
12603 if ((fp = fopen (hashfile, "rb")) == NULL)
12604 {
12605 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12606
12607 return -1;
12608 }
12609
12610 uint line_num = 0;
12611
12612 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12613
12614 while (!feof (fp))
12615 {
12616 line_num++;
12617
12618 int line_len = fgetl (fp, line_buf);
12619
12620 if (line_len == 0) continue;
12621
12622 char *hash_buf = NULL;
12623 int hash_len = 0;
12624
12625 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12626
12627 bool hash_fmt_error = 0;
12628
12629 if (hash_len < 1) hash_fmt_error = 1;
12630 if (hash_buf == NULL) hash_fmt_error = 1;
12631
12632 if (hash_fmt_error)
12633 {
12634 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12635
12636 continue;
12637 }
12638
12639 if (username)
12640 {
12641 char *user_buf = NULL;
12642 int user_len = 0;
12643
12644 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12645
12646 if (remove || show)
12647 {
12648 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12649
12650 *user = (user_t *) mymalloc (sizeof (user_t));
12651
12652 user_t *user_ptr = *user;
12653
12654 if (user_buf != NULL)
12655 {
12656 user_ptr->user_name = mystrdup (user_buf);
12657 }
12658 else
12659 {
12660 user_ptr->user_name = mystrdup ("");
12661 }
12662
12663 user_ptr->user_len = user_len;
12664 }
12665 }
12666
12667 if (opts_type & OPTS_TYPE_HASH_COPY)
12668 {
12669 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12670
12671 hash_info_tmp->orighash = mystrdup (hash_buf);
12672 }
12673
12674 if (isSalted)
12675 {
12676 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12677 }
12678
12679 if (hash_mode == 3000)
12680 {
12681 if (hash_len == 32)
12682 {
12683 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12684
12685 if (parser_status < PARSER_GLOBAL_ZERO)
12686 {
12687 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12688
12689 continue;
12690 }
12691
12692 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12693
12694 hashes_cnt++;
12695
12696 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12697
12698 if (parser_status < PARSER_GLOBAL_ZERO)
12699 {
12700 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12701
12702 continue;
12703 }
12704
12705 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12706
12707 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);
12708
12709 hashes_cnt++;
12710
12711 // show / left
12712
12713 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);
12714 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);
12715 }
12716 else
12717 {
12718 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12719
12720 if (parser_status < PARSER_GLOBAL_ZERO)
12721 {
12722 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12723
12724 continue;
12725 }
12726
12727 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);
12728
12729 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12730 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12731
12732 hashes_cnt++;
12733 }
12734 }
12735 else
12736 {
12737 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12738
12739 if (parser_status < PARSER_GLOBAL_ZERO)
12740 {
12741 log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12742
12743 continue;
12744 }
12745
12746 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);
12747
12748 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12749 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12750
12751 hashes_cnt++;
12752 }
12753 }
12754
12755 myfree (line_buf);
12756
12757 fclose (fp);
12758
12759 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12760
12761 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12762 }
12763 }
12764 else
12765 {
12766 if (isSalted)
12767 {
12768 hashes_buf[0].salt->salt_len = 8;
12769
12770 // special salt handling
12771
12772 switch (hash_mode)
12773 {
12774 case 1500: hashes_buf[0].salt->salt_len = 2;
12775 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12776 break;
12777 case 1731: hashes_buf[0].salt->salt_len = 4;
12778 break;
12779 case 2410: hashes_buf[0].salt->salt_len = 4;
12780 break;
12781 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12782 break;
12783 case 3100: hashes_buf[0].salt->salt_len = 1;
12784 break;
12785 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12786 break;
12787 case 5800: hashes_buf[0].salt->salt_len = 16;
12788 break;
12789 case 6800: hashes_buf[0].salt->salt_len = 32;
12790 break;
12791 case 8400: hashes_buf[0].salt->salt_len = 40;
12792 break;
12793 case 8800: hashes_buf[0].salt->salt_len = 16;
12794 break;
12795 case 8900: hashes_buf[0].salt->salt_len = 16;
12796 hashes_buf[0].salt->scrypt_N = 1024;
12797 hashes_buf[0].salt->scrypt_r = 1;
12798 hashes_buf[0].salt->scrypt_p = 1;
12799 break;
12800 case 9100: hashes_buf[0].salt->salt_len = 16;
12801 break;
12802 case 9300: hashes_buf[0].salt->salt_len = 14;
12803 hashes_buf[0].salt->scrypt_N = 16384;
12804 hashes_buf[0].salt->scrypt_r = 1;
12805 hashes_buf[0].salt->scrypt_p = 1;
12806 break;
12807 case 9400: hashes_buf[0].salt->salt_len = 16;
12808 break;
12809 case 9500: hashes_buf[0].salt->salt_len = 16;
12810 break;
12811 case 9600: hashes_buf[0].salt->salt_len = 16;
12812 break;
12813 case 9700: hashes_buf[0].salt->salt_len = 16;
12814 break;
12815 case 9710: hashes_buf[0].salt->salt_len = 16;
12816 break;
12817 case 9720: hashes_buf[0].salt->salt_len = 16;
12818 break;
12819 case 9800: hashes_buf[0].salt->salt_len = 16;
12820 break;
12821 case 9810: hashes_buf[0].salt->salt_len = 16;
12822 break;
12823 case 9820: hashes_buf[0].salt->salt_len = 16;
12824 break;
12825 case 10300: hashes_buf[0].salt->salt_len = 12;
12826 break;
12827 case 11500: hashes_buf[0].salt->salt_len = 4;
12828 break;
12829 case 11600: hashes_buf[0].salt->salt_len = 4;
12830 break;
12831 case 12400: hashes_buf[0].salt->salt_len = 4;
12832 break;
12833 case 12500: hashes_buf[0].salt->salt_len = 8;
12834 break;
12835 case 12600: hashes_buf[0].salt->salt_len = 64;
12836 break;
12837 }
12838
12839 // special esalt handling
12840
12841 switch (hash_mode)
12842 {
12843 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12844 break;
12845 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12846 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12847 break;
12848 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12849 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12850 break;
12851 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12852 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12853 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12854 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12855 break;
12856 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12857 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12858 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12859 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12860 break;
12861 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12862 break;
12863 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12864 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12865 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12866 break;
12867 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12868 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12869 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12870 break;
12871 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12872 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12873 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12874 break;
12875 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12876 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12877 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12878 break;
12879 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12880 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12881 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12882 break;
12883 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12884 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12885 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12886 break;
12887 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12888 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12889 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12890 break;
12891 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12892 break;
12893 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12894 break;
12895 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12896 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12897 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12898 break;
12899 }
12900 }
12901
12902 // set hashfile
12903
12904 switch (hash_mode)
12905 {
12906 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12907 break;
12908 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12909 break;
12910 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12911 break;
12912 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12913 break;
12914 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12915 break;
12916 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12917 break;
12918 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12919 break;
12920 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12921 break;
12922 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12923 break;
12924 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12925 break;
12926 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12927 break;
12928 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12929 break;
12930 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12931 break;
12932 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12933 break;
12934 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12935 break;
12936 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12937 break;
12938 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12939 break;
12940 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12941 break;
12942 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12943 break;
12944 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12945 break;
12946 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12947 break;
12948 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12949 break;
12950 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12951 break;
12952 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12953 break;
12954 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12955 break;
12956 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12957 break;
12958 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12959 break;
12960 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12961 break;
12962 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12963 break;
12964 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12965 break;
12966 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12967 break;
12968 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12969 break;
12970 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12971 break;
12972 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12973 break;
12974 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12975 break;
12976 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12977 break;
12978 }
12979
12980 // set default iterations
12981
12982 switch (hash_mode)
12983 {
12984 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12985 break;
12986 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12987 break;
12988 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12989 break;
12990 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12991 break;
12992 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12993 break;
12994 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12995 break;
12996 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12997 break;
12998 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12999 break;
13000 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
13001 break;
13002 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
13003 break;
13004 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
13005 break;
13006 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
13007 break;
13008 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
13009 break;
13010 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13011 break;
13012 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13013 break;
13014 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13015 break;
13016 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13017 break;
13018 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13019 break;
13020 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13021 break;
13022 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13023 break;
13024 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13025 break;
13026 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
13027 break;
13028 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
13029 break;
13030 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
13031 break;
13032 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
13033 break;
13034 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
13035 break;
13036 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
13037 break;
13038 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
13039 break;
13040 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
13041 break;
13042 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
13043 break;
13044 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
13045 break;
13046 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
13047 break;
13048 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
13049 break;
13050 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
13051 break;
13052 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
13053 break;
13054 case 8900: hashes_buf[0].salt->salt_iter = 1;
13055 break;
13056 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
13057 break;
13058 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
13059 break;
13060 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
13061 break;
13062 case 9300: hashes_buf[0].salt->salt_iter = 1;
13063 break;
13064 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
13065 break;
13066 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
13067 break;
13068 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
13069 break;
13070 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
13071 break;
13072 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
13073 break;
13074 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
13075 break;
13076 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
13077 break;
13078 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
13079 break;
13080 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
13081 break;
13082 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
13083 break;
13084 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
13085 break;
13086 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
13087 break;
13088 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
13089 break;
13090 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
13091 break;
13092 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
13093 break;
13094 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
13095 break;
13096 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
13097 break;
13098 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
13099 break;
13100 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
13101 break;
13102 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
13103 break;
13104 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
13105 break;
13106 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
13107 break;
13108 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
13109 break;
13110 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
13111 break;
13112 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13113 break;
13114 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13115 break;
13116 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
13117 break;
13118 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13119 break;
13120 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13121 break;
13122 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13123 break;
13124 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13125 break;
13126 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13127 break;
13128 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13129 break;
13130 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13131 break;
13132 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13133 break;
13134 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
13135 break;
13136 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13137 break;
13138 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13139 break;
13140 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
13141 break;
13142 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13143 break;
13144 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13145 break;
13146 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
13147 break;
13148 }
13149
13150 hashes_cnt = 1;
13151 }
13152
13153 if (show == 1 || left == 1)
13154 {
13155 for (uint i = 0; i < pot_cnt; i++)
13156 {
13157 pot_t *pot_ptr = &pot[i];
13158
13159 hash_t *hashes_buf = &pot_ptr->hash;
13160
13161 local_free (hashes_buf->digest);
13162
13163 if (isSalted)
13164 {
13165 local_free (hashes_buf->salt);
13166 }
13167 }
13168
13169 local_free (pot);
13170
13171 if (data.quiet == 0) log_info_nn ("");
13172
13173 return 0;
13174 }
13175
13176 if ((keyspace == 0) && (stdout_flag == 0))
13177 {
13178 if (hashes_cnt == 0)
13179 {
13180 log_error ("ERROR: No hashes loaded");
13181
13182 return -1;
13183 }
13184 }
13185
13186 /**
13187 * Sanity check for hashfile vs outfile (should not point to the same physical file)
13188 */
13189
13190 if (data.outfile != NULL)
13191 {
13192 if (data.hashfile != NULL)
13193 {
13194 #ifdef _POSIX
13195 struct stat tmpstat_outfile;
13196 struct stat tmpstat_hashfile;
13197 #endif
13198
13199 #ifdef _WIN
13200 struct stat64 tmpstat_outfile;
13201 struct stat64 tmpstat_hashfile;
13202 #endif
13203
13204 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
13205
13206 if (tmp_outfile_fp)
13207 {
13208 #ifdef _POSIX
13209 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
13210 #endif
13211
13212 #ifdef _WIN
13213 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
13214 #endif
13215
13216 fclose (tmp_outfile_fp);
13217 }
13218
13219 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
13220
13221 if (tmp_hashfile_fp)
13222 {
13223 #ifdef _POSIX
13224 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13225 #endif
13226
13227 #ifdef _WIN
13228 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
13229 #endif
13230
13231 fclose (tmp_hashfile_fp);
13232 }
13233
13234 if (tmp_outfile_fp && tmp_outfile_fp)
13235 {
13236 tmpstat_outfile.st_mode = 0;
13237 tmpstat_outfile.st_nlink = 0;
13238 tmpstat_outfile.st_uid = 0;
13239 tmpstat_outfile.st_gid = 0;
13240 tmpstat_outfile.st_rdev = 0;
13241 tmpstat_outfile.st_atime = 0;
13242
13243 tmpstat_hashfile.st_mode = 0;
13244 tmpstat_hashfile.st_nlink = 0;
13245 tmpstat_hashfile.st_uid = 0;
13246 tmpstat_hashfile.st_gid = 0;
13247 tmpstat_hashfile.st_rdev = 0;
13248 tmpstat_hashfile.st_atime = 0;
13249
13250 #ifdef _POSIX
13251 tmpstat_outfile.st_blksize = 0;
13252 tmpstat_outfile.st_blocks = 0;
13253
13254 tmpstat_hashfile.st_blksize = 0;
13255 tmpstat_hashfile.st_blocks = 0;
13256 #endif
13257
13258 #ifdef _POSIX
13259 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
13260 {
13261 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13262
13263 return -1;
13264 }
13265 #endif
13266
13267 #ifdef _WIN
13268 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
13269 {
13270 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
13271
13272 return -1;
13273 }
13274 #endif
13275 }
13276 }
13277 }
13278
13279 /**
13280 * Remove duplicates
13281 */
13282
13283 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
13284
13285 if (isSalted)
13286 {
13287 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13288 }
13289 else
13290 {
13291 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13292 }
13293
13294 uint hashes_cnt_orig = hashes_cnt;
13295
13296 hashes_cnt = 1;
13297
13298 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
13299 {
13300 if (isSalted)
13301 {
13302 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
13303 {
13304 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13305 }
13306 }
13307 else
13308 {
13309 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
13310 }
13311
13312 if (hashes_pos > hashes_cnt)
13313 {
13314 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
13315 }
13316
13317 hashes_cnt++;
13318 }
13319
13320 /**
13321 * Potfile removes
13322 */
13323
13324 uint potfile_remove_cracks = 0;
13325
13326 if (potfile_disable == 0)
13327 {
13328 hash_t hash_buf;
13329
13330 hash_buf.digest = mymalloc (dgst_size);
13331 hash_buf.salt = NULL;
13332 hash_buf.esalt = NULL;
13333 hash_buf.hash_info = NULL;
13334 hash_buf.cracked = 0;
13335
13336 if (isSalted)
13337 {
13338 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
13339 }
13340
13341 if (esalt_size)
13342 {
13343 hash_buf.esalt = mymalloc (esalt_size);
13344 }
13345
13346 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
13347
13348 // no solution for these special hash types (for instane because they use hashfile in output etc)
13349 if ((hash_mode != 5200) &&
13350 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
13351 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
13352 (hash_mode != 9000))
13353 {
13354 FILE *fp = fopen (potfile, "rb");
13355
13356 if (fp != NULL)
13357 {
13358 char *line_buf = (char *) mymalloc (HCBUFSIZ);
13359
13360 // to be safe work with a copy (because of line_len loop, i etc)
13361 // moved up here because it's easier to handle continue case
13362 // it's just 64kb
13363
13364 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
13365
13366 while (!feof (fp))
13367 {
13368 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
13369
13370 if (ptr == NULL) break;
13371
13372 int line_len = strlen (line_buf);
13373
13374 if (line_len == 0) continue;
13375
13376 int iter = MAX_CUT_TRIES;
13377
13378 for (int i = line_len - 1; i && iter; i--, line_len--)
13379 {
13380 if (line_buf[i] != ':') continue;
13381
13382 if (isSalted)
13383 {
13384 memset (hash_buf.salt, 0, sizeof (salt_t));
13385 }
13386
13387 hash_t *found = NULL;
13388
13389 if (hash_mode == 6800)
13390 {
13391 if (i < 64) // 64 = 16 * uint in salt_buf[]
13392 {
13393 // manipulate salt_buf
13394 memcpy (hash_buf.salt->salt_buf, line_buf, i);
13395
13396 hash_buf.salt->salt_len = i;
13397
13398 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
13399 }
13400 }
13401 else if (hash_mode == 2500)
13402 {
13403 if (i < 64) // 64 = 16 * uint in salt_buf[]
13404 {
13405 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
13406 // manipulate salt_buf
13407
13408 memset (line_buf_cpy, 0, HCBUFSIZ);
13409 memcpy (line_buf_cpy, line_buf, i);
13410
13411 char *mac2_pos = strrchr (line_buf_cpy, ':');
13412
13413 if (mac2_pos == NULL) continue;
13414
13415 mac2_pos[0] = 0;
13416 mac2_pos++;
13417
13418 if (strlen (mac2_pos) != 12) continue;
13419
13420 char *mac1_pos = strrchr (line_buf_cpy, ':');
13421
13422 if (mac1_pos == NULL) continue;
13423
13424 mac1_pos[0] = 0;
13425 mac1_pos++;
13426
13427 if (strlen (mac1_pos) != 12) continue;
13428
13429 uint essid_length = mac1_pos - line_buf_cpy - 1;
13430
13431 // here we need the ESSID
13432 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
13433
13434 hash_buf.salt->salt_len = essid_length;
13435
13436 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
13437
13438 if (found)
13439 {
13440 wpa_t *wpa = (wpa_t *) found->esalt;
13441
13442 // compare hex string(s) vs binary MAC address(es)
13443
13444 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13445 {
13446 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
13447 {
13448 found = NULL;
13449
13450 break;
13451 }
13452 }
13453
13454 // early skip ;)
13455 if (!found) continue;
13456
13457 for (uint i = 0, j = 0; i < 6; i++, j += 2)
13458 {
13459 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
13460 {
13461 found = NULL;
13462
13463 break;
13464 }
13465 }
13466 }
13467 }
13468 }
13469 else
13470 {
13471 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
13472
13473 if (parser_status == PARSER_OK)
13474 {
13475 if (isSalted)
13476 {
13477 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
13478 }
13479 else
13480 {
13481 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
13482 }
13483 }
13484 }
13485
13486 if (found == NULL) continue;
13487
13488 if (!found->cracked) potfile_remove_cracks++;
13489
13490 found->cracked = 1;
13491
13492 if (found) break;
13493
13494 iter--;
13495 }
13496 }
13497
13498 myfree (line_buf_cpy);
13499
13500 myfree (line_buf);
13501
13502 fclose (fp);
13503 }
13504 }
13505
13506 if (esalt_size)
13507 {
13508 local_free (hash_buf.esalt);
13509 }
13510
13511 if (isSalted)
13512 {
13513 local_free (hash_buf.salt);
13514 }
13515
13516 local_free (hash_buf.digest);
13517 }
13518
13519 /**
13520 * Now generate all the buffers required for later
13521 */
13522
13523 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
13524
13525 salt_t *salts_buf_new = NULL;
13526 void *esalts_buf_new = NULL;
13527
13528 if (isSalted)
13529 {
13530 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
13531
13532 if (esalt_size)
13533 {
13534 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
13535 }
13536 }
13537 else
13538 {
13539 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13540 }
13541
13542 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13543
13544 uint digests_cnt = hashes_cnt;
13545 uint digests_done = 0;
13546
13547 size_t size_digests = digests_cnt * dgst_size;
13548 size_t size_shown = digests_cnt * sizeof (uint);
13549
13550 uint *digests_shown = (uint *) mymalloc (size_shown);
13551 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13552
13553 uint salts_cnt = 0;
13554 uint salts_done = 0;
13555
13556 hashinfo_t **hash_info = NULL;
13557
13558 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13559 {
13560 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13561
13562 if (username && (remove || show))
13563 {
13564 uint user_pos;
13565
13566 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13567 {
13568 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13569
13570 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13571 }
13572 }
13573 }
13574
13575 uint *salts_shown = (uint *) mymalloc (size_shown);
13576
13577 salt_t *salt_buf;
13578
13579 {
13580 // copied from inner loop
13581
13582 salt_buf = &salts_buf_new[salts_cnt];
13583
13584 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13585
13586 if (esalt_size)
13587 {
13588 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13589 }
13590
13591 salt_buf->digests_cnt = 0;
13592 salt_buf->digests_done = 0;
13593 salt_buf->digests_offset = 0;
13594
13595 salts_cnt++;
13596 }
13597
13598 if (hashes_buf[0].cracked == 1)
13599 {
13600 digests_shown[0] = 1;
13601
13602 digests_done++;
13603
13604 salt_buf->digests_done++;
13605 }
13606
13607 salt_buf->digests_cnt++;
13608
13609 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13610
13611 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13612 {
13613 hash_info[0] = hashes_buf[0].hash_info;
13614 }
13615
13616 // copy from inner loop
13617
13618 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13619 {
13620 if (isSalted)
13621 {
13622 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13623 {
13624 salt_buf = &salts_buf_new[salts_cnt];
13625
13626 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13627
13628 if (esalt_size)
13629 {
13630 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13631 }
13632
13633 salt_buf->digests_cnt = 0;
13634 salt_buf->digests_done = 0;
13635 salt_buf->digests_offset = hashes_pos;
13636
13637 salts_cnt++;
13638 }
13639 }
13640
13641 if (hashes_buf[hashes_pos].cracked == 1)
13642 {
13643 digests_shown[hashes_pos] = 1;
13644
13645 digests_done++;
13646
13647 salt_buf->digests_done++;
13648 }
13649
13650 salt_buf->digests_cnt++;
13651
13652 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13653
13654 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13655 {
13656 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13657 }
13658 }
13659
13660 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13661 {
13662 salt_t *salt_buf = &salts_buf_new[salt_pos];
13663
13664 if (salt_buf->digests_done == salt_buf->digests_cnt)
13665 {
13666 salts_shown[salt_pos] = 1;
13667
13668 salts_done++;
13669 }
13670
13671 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13672 }
13673
13674 local_free (digests_buf);
13675 local_free (salts_buf);
13676 local_free (esalts_buf);
13677
13678 digests_buf = digests_buf_new;
13679 salts_buf = salts_buf_new;
13680 esalts_buf = esalts_buf_new;
13681
13682 local_free (hashes_buf);
13683
13684 /**
13685 * special modification not set from parser
13686 */
13687
13688 switch (hash_mode)
13689 {
13690 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13691 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13692 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13693 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13694 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13695 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13696 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13697 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13698 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13699 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13700 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13701 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13702 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13703 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13704 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13705 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13706 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13707 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13708 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13709 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13710 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13711 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13712 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13713 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13714 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13715 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13716 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13717 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13718 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13719 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13720 }
13721
13722 if (truecrypt_keyfiles)
13723 {
13724 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13725
13726 char *keyfiles = strdup (truecrypt_keyfiles);
13727
13728 char *keyfile = strtok (keyfiles, ",");
13729
13730 do
13731 {
13732 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13733
13734 } while ((keyfile = strtok (NULL, ",")) != NULL);
13735
13736 free (keyfiles);
13737 }
13738
13739 if (veracrypt_keyfiles)
13740 {
13741 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13742
13743 char *keyfiles = strdup (veracrypt_keyfiles);
13744
13745 char *keyfile = strtok (keyfiles, ",");
13746
13747 do
13748 {
13749 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13750
13751 } while ((keyfile = strtok (NULL, ",")) != NULL);
13752
13753 free (keyfiles);
13754 }
13755
13756 data.digests_cnt = digests_cnt;
13757 data.digests_done = digests_done;
13758 data.digests_buf = digests_buf;
13759 data.digests_shown = digests_shown;
13760 data.digests_shown_tmp = digests_shown_tmp;
13761
13762 data.salts_cnt = salts_cnt;
13763 data.salts_done = salts_done;
13764 data.salts_buf = salts_buf;
13765 data.salts_shown = salts_shown;
13766
13767 data.esalts_buf = esalts_buf;
13768 data.hash_info = hash_info;
13769
13770 /**
13771 * Automatic Optimizers
13772 */
13773
13774 if (salts_cnt == 1)
13775 opti_type |= OPTI_TYPE_SINGLE_SALT;
13776
13777 if (digests_cnt == 1)
13778 opti_type |= OPTI_TYPE_SINGLE_HASH;
13779
13780 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13781 opti_type |= OPTI_TYPE_NOT_ITERATED;
13782
13783 if (attack_mode == ATTACK_MODE_BF)
13784 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13785
13786 data.opti_type = opti_type;
13787
13788 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13789 {
13790 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13791 {
13792 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13793 {
13794 if (opts_type & OPTS_TYPE_ST_ADD80)
13795 {
13796 opts_type &= ~OPTS_TYPE_ST_ADD80;
13797 opts_type |= OPTS_TYPE_PT_ADD80;
13798 }
13799
13800 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13801 {
13802 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13803 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13804 }
13805
13806 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13807 {
13808 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13809 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13810 }
13811 }
13812 }
13813 }
13814
13815 /**
13816 * Some algorithm, like descrypt, can benefit from JIT compilation
13817 */
13818
13819 int force_jit_compilation = -1;
13820
13821 if (hash_mode == 8900)
13822 {
13823 force_jit_compilation = 8900;
13824 }
13825 else if (hash_mode == 9300)
13826 {
13827 force_jit_compilation = 8900;
13828 }
13829 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13830 {
13831 force_jit_compilation = 1500;
13832 }
13833
13834 /**
13835 * generate bitmap tables
13836 */
13837
13838 const uint bitmap_shift1 = 5;
13839 const uint bitmap_shift2 = 13;
13840
13841 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13842
13843 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13844 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13845 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13846 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13847 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13848 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13849 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13850 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13851
13852 uint bitmap_bits;
13853 uint bitmap_nums;
13854 uint bitmap_mask;
13855 uint bitmap_size;
13856
13857 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13858 {
13859 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13860
13861 bitmap_nums = 1 << bitmap_bits;
13862
13863 bitmap_mask = bitmap_nums - 1;
13864
13865 bitmap_size = bitmap_nums * sizeof (uint);
13866
13867 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13868
13869 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;
13870 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;
13871
13872 break;
13873 }
13874
13875 bitmap_nums = 1 << bitmap_bits;
13876
13877 bitmap_mask = bitmap_nums - 1;
13878
13879 bitmap_size = bitmap_nums * sizeof (uint);
13880
13881 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);
13882 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);
13883
13884 /**
13885 * prepare quick rule
13886 */
13887
13888 data.rule_buf_l = rule_buf_l;
13889 data.rule_buf_r = rule_buf_r;
13890
13891 int rule_len_l = (int) strlen (rule_buf_l);
13892 int rule_len_r = (int) strlen (rule_buf_r);
13893
13894 data.rule_len_l = rule_len_l;
13895 data.rule_len_r = rule_len_r;
13896
13897 /**
13898 * load rules
13899 */
13900
13901 uint *all_kernel_rules_cnt = NULL;
13902
13903 kernel_rule_t **all_kernel_rules_buf = NULL;
13904
13905 if (rp_files_cnt)
13906 {
13907 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13908
13909 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13910 }
13911
13912 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13913
13914 int rule_len = 0;
13915
13916 for (uint i = 0; i < rp_files_cnt; i++)
13917 {
13918 uint kernel_rules_avail = 0;
13919
13920 uint kernel_rules_cnt = 0;
13921
13922 kernel_rule_t *kernel_rules_buf = NULL;
13923
13924 char *rp_file = rp_files[i];
13925
13926 char in[BLOCK_SIZE] = { 0 };
13927 char out[BLOCK_SIZE] = { 0 };
13928
13929 FILE *fp = NULL;
13930
13931 uint rule_line = 0;
13932
13933 if ((fp = fopen (rp_file, "rb")) == NULL)
13934 {
13935 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13936
13937 return -1;
13938 }
13939
13940 while (!feof (fp))
13941 {
13942 memset (rule_buf, 0, HCBUFSIZ);
13943
13944 rule_len = fgetl (fp, rule_buf);
13945
13946 rule_line++;
13947
13948 if (rule_len == 0) continue;
13949
13950 if (rule_buf[0] == '#') continue;
13951
13952 if (kernel_rules_avail == kernel_rules_cnt)
13953 {
13954 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13955
13956 kernel_rules_avail += INCR_RULES;
13957 }
13958
13959 memset (in, 0, BLOCK_SIZE);
13960 memset (out, 0, BLOCK_SIZE);
13961
13962 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13963
13964 if (result == -1)
13965 {
13966 log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13967
13968 continue;
13969 }
13970
13971 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13972 {
13973 log_info ("WARNING: Cannot convert rule for use on OpenCL device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
13974
13975 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13976
13977 continue;
13978 }
13979
13980 /* its so slow
13981 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13982 {
13983 log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13984
13985 continue;
13986 }
13987 */
13988
13989 kernel_rules_cnt++;
13990 }
13991
13992 fclose (fp);
13993
13994 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13995
13996 all_kernel_rules_buf[i] = kernel_rules_buf;
13997 }
13998
13999 /**
14000 * merge rules or automatic rule generator
14001 */
14002
14003 uint kernel_rules_cnt = 0;
14004
14005 kernel_rule_t *kernel_rules_buf = NULL;
14006
14007 if (attack_mode == ATTACK_MODE_STRAIGHT)
14008 {
14009 if (rp_files_cnt)
14010 {
14011 kernel_rules_cnt = 1;
14012
14013 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
14014
14015 repeats[0] = kernel_rules_cnt;
14016
14017 for (uint i = 0; i < rp_files_cnt; i++)
14018 {
14019 kernel_rules_cnt *= all_kernel_rules_cnt[i];
14020
14021 repeats[i + 1] = kernel_rules_cnt;
14022 }
14023
14024 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
14025
14026 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
14027
14028 for (uint i = 0; i < kernel_rules_cnt; i++)
14029 {
14030 uint out_pos = 0;
14031
14032 kernel_rule_t *out = &kernel_rules_buf[i];
14033
14034 for (uint j = 0; j < rp_files_cnt; j++)
14035 {
14036 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
14037 uint in_pos;
14038
14039 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
14040
14041 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
14042 {
14043 if (out_pos == RULES_MAX - 1)
14044 {
14045 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
14046
14047 break;
14048 }
14049
14050 out->cmds[out_pos] = in->cmds[in_pos];
14051 }
14052 }
14053 }
14054
14055 local_free (repeats);
14056 }
14057 else if (rp_gen)
14058 {
14059 uint kernel_rules_avail = 0;
14060
14061 while (kernel_rules_cnt < rp_gen)
14062 {
14063 if (kernel_rules_avail == kernel_rules_cnt)
14064 {
14065 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
14066
14067 kernel_rules_avail += INCR_RULES;
14068 }
14069
14070 memset (rule_buf, 0, HCBUFSIZ);
14071
14072 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
14073
14074 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
14075
14076 kernel_rules_cnt++;
14077 }
14078 }
14079 }
14080
14081 myfree (rule_buf);
14082
14083 /**
14084 * generate NOP rules
14085 */
14086
14087 if ((rp_files_cnt == 0) && (rp_gen == 0))
14088 {
14089 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
14090
14091 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
14092
14093 kernel_rules_cnt++;
14094 }
14095
14096 data.kernel_rules_cnt = kernel_rules_cnt;
14097 data.kernel_rules_buf = kernel_rules_buf;
14098
14099 if (kernel_rules_cnt == 0)
14100 {
14101 log_error ("ERROR: No valid rules left");
14102
14103 return -1;
14104 }
14105
14106 /**
14107 * OpenCL platforms: detect
14108 */
14109
14110 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
14111 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
14112
14113 cl_uint platforms_cnt = 0;
14114 cl_uint platform_devices_cnt = 0;
14115
14116 if (keyspace == 0)
14117 {
14118 cl_int CL_err = hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
14119
14120 if (CL_err != CL_SUCCESS)
14121 {
14122 log_error ("ERROR: clGetPlatformIDs(): %s\n", val2cstr_cl (CL_err));
14123
14124 return -1;
14125 }
14126
14127 if (platforms_cnt == 0)
14128 {
14129 log_info ("");
14130 log_info ("ATTENTION! No OpenCL compatible platform found");
14131 log_info ("");
14132 log_info ("You're probably missing the OpenCL runtime installation");
14133 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
14134 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
14135 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
14136 log_info ("");
14137
14138 return -1;
14139 }
14140
14141 if (opencl_platforms_filter != (uint) -1)
14142 {
14143 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
14144
14145 if (opencl_platforms_filter > platform_cnt_mask)
14146 {
14147 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
14148
14149 return -1;
14150 }
14151 }
14152 }
14153
14154 if (opencl_device_types == NULL)
14155 {
14156 /**
14157 * OpenCL device types:
14158 * 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.
14159 */
14160
14161 cl_device_type device_types_all = 0;
14162
14163 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14164 {
14165 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
14166
14167 cl_platform_id platform = platforms[platform_id];
14168
14169 cl_int CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14170
14171 if (CL_err != CL_SUCCESS)
14172 {
14173 //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14174
14175 //return -1;
14176
14177 // Silently ignore at this point, it will be reused later and create a note for the user at that point
14178
14179 continue;
14180 }
14181
14182 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14183 {
14184 cl_device_id device = platform_devices[platform_devices_id];
14185
14186 cl_device_type device_type;
14187
14188 cl_int CL_err = hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14189
14190 if (CL_err != CL_SUCCESS)
14191 {
14192 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14193
14194 return -1;
14195 }
14196
14197 device_types_all |= device_type;
14198 }
14199 }
14200
14201 // In such a case, automatically enable CPU device type support, since it's disabled by default.
14202
14203 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
14204 {
14205 device_types_filter |= CL_DEVICE_TYPE_CPU;
14206 }
14207
14208 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
14209 // If we have a CPU device, force it to be used
14210
14211 if (stdout_flag == 1)
14212 {
14213 if (device_types_all & CL_DEVICE_TYPE_CPU)
14214 {
14215 device_types_filter = CL_DEVICE_TYPE_CPU;
14216 }
14217 }
14218 }
14219
14220 /**
14221 * OpenCL devices: simply push all devices from all platforms into the same device array
14222 */
14223
14224 int need_adl = 0;
14225 int need_nvapi = 0;
14226 int need_nvml = 0;
14227 int need_xnvctrl = 0;
14228
14229 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
14230
14231 data.devices_param = devices_param;
14232
14233 uint devices_cnt = 0;
14234
14235 uint devices_active = 0;
14236
14237 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14238 {
14239 cl_int CL_err = CL_SUCCESS;
14240
14241 cl_platform_id platform = platforms[platform_id];
14242
14243 char platform_vendor[INFOSZ] = { 0 };
14244
14245 CL_err = hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
14246
14247 if (CL_err != CL_SUCCESS)
14248 {
14249 log_error ("ERROR: clGetPlatformInfo(): %s\n", val2cstr_cl (CL_err));
14250
14251 return -1;
14252 }
14253
14254 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
14255 // this causes trouble with vendor id based macros
14256 // we'll assign generic to those without special optimization available
14257
14258 cl_uint platform_vendor_id = 0;
14259
14260 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
14261 {
14262 platform_vendor_id = VENDOR_ID_AMD;
14263 }
14264 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14265 {
14266 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14267 }
14268 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
14269 {
14270 platform_vendor_id = VENDOR_ID_APPLE;
14271 }
14272 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14273 {
14274 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14275 }
14276 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
14277 {
14278 platform_vendor_id = VENDOR_ID_INTEL_SDK;
14279 }
14280 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
14281 {
14282 platform_vendor_id = VENDOR_ID_MESA;
14283 }
14284 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
14285 {
14286 platform_vendor_id = VENDOR_ID_NV;
14287 }
14288 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
14289 {
14290 platform_vendor_id = VENDOR_ID_POCL;
14291 }
14292 else
14293 {
14294 platform_vendor_id = VENDOR_ID_GENERIC;
14295 }
14296
14297 uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
14298
14299 CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14300
14301 if (CL_err != CL_SUCCESS)
14302 {
14303 //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14304
14305 //return -1;
14306
14307 platform_skipped = 2;
14308 }
14309
14310 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14311 {
14312 if (machine_readable == 0)
14313 {
14314 if (platform_skipped == 0)
14315 {
14316 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
14317
14318 char line[256] = { 0 };
14319
14320 for (int i = 0; i < len; i++) line[i] = '=';
14321
14322 log_info (line);
14323 }
14324 else if (platform_skipped == 1)
14325 {
14326 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
14327 log_info ("");
14328 }
14329 else if (platform_skipped == 2)
14330 {
14331 log_info ("OpenCL Platform #%u: %s, skipped! No OpenCL compatible devices found", platform_id + 1, platform_vendor);
14332 log_info ("");
14333 }
14334 }
14335 }
14336
14337 if (platform_skipped == 1) continue;
14338 if (platform_skipped == 2) continue;
14339
14340 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14341 {
14342 size_t param_value_size = 0;
14343
14344 const uint device_id = devices_cnt;
14345
14346 hc_device_param_t *device_param = &data.devices_param[device_id];
14347
14348 device_param->platform_vendor_id = platform_vendor_id;
14349
14350 device_param->device = platform_devices[platform_devices_id];
14351
14352 device_param->device_id = device_id;
14353
14354 device_param->platform_devices_id = platform_devices_id;
14355
14356 device_param->platform = platform;
14357
14358 // device_type
14359
14360 cl_device_type device_type;
14361
14362 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14363
14364 if (CL_err != CL_SUCCESS)
14365 {
14366 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14367
14368 return -1;
14369 }
14370
14371 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
14372
14373 device_param->device_type = device_type;
14374
14375 // device_name
14376
14377 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
14378
14379 if (CL_err != CL_SUCCESS)
14380 {
14381 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14382
14383 return -1;
14384 }
14385
14386 char *device_name = (char *) mymalloc (param_value_size);
14387
14388 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
14389
14390 if (CL_err != CL_SUCCESS)
14391 {
14392 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14393
14394 return -1;
14395 }
14396
14397 device_param->device_name = device_name;
14398
14399 // device_vendor
14400
14401 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
14402
14403 if (CL_err != CL_SUCCESS)
14404 {
14405 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14406
14407 return -1;
14408 }
14409
14410 char *device_vendor = (char *) mymalloc (param_value_size);
14411
14412 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
14413
14414 if (CL_err != CL_SUCCESS)
14415 {
14416 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14417
14418 return -1;
14419 }
14420
14421 device_param->device_vendor = device_vendor;
14422
14423 cl_uint device_vendor_id = 0;
14424
14425 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
14426 {
14427 device_vendor_id = VENDOR_ID_AMD;
14428 }
14429 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14430 {
14431 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14432 }
14433 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
14434 {
14435 device_vendor_id = VENDOR_ID_APPLE;
14436 }
14437 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14438 {
14439 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14440 }
14441 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
14442 {
14443 device_vendor_id = VENDOR_ID_INTEL_SDK;
14444 }
14445 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
14446 {
14447 device_vendor_id = VENDOR_ID_MESA;
14448 }
14449 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
14450 {
14451 device_vendor_id = VENDOR_ID_NV;
14452 }
14453 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
14454 {
14455 device_vendor_id = VENDOR_ID_POCL;
14456 }
14457 else
14458 {
14459 device_vendor_id = VENDOR_ID_GENERIC;
14460 }
14461
14462 device_param->device_vendor_id = device_vendor_id;
14463
14464 // tuning db
14465
14466 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14467
14468 // device_version
14469
14470 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14471
14472 if (CL_err != CL_SUCCESS)
14473 {
14474 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14475
14476 return -1;
14477 }
14478
14479 char *device_version = (char *) mymalloc (param_value_size);
14480
14481 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14482
14483 if (CL_err != CL_SUCCESS)
14484 {
14485 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14486
14487 return -1;
14488 }
14489
14490 device_param->device_version = device_version;
14491
14492 // device_opencl_version
14493
14494 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14495
14496 if (CL_err != CL_SUCCESS)
14497 {
14498 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14499
14500 return -1;
14501 }
14502
14503 char *device_opencl_version = (char *) mymalloc (param_value_size);
14504
14505 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14506
14507 if (CL_err != CL_SUCCESS)
14508 {
14509 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14510
14511 return -1;
14512 }
14513
14514 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14515
14516 myfree (device_opencl_version);
14517
14518 // vector_width
14519
14520 cl_uint vector_width;
14521
14522 if (opencl_vector_width_chgd == 0)
14523 {
14524 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14525 {
14526 if (opti_type & OPTI_TYPE_USES_BITS_64)
14527 {
14528 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14529
14530 if (CL_err != CL_SUCCESS)
14531 {
14532 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14533
14534 return -1;
14535 }
14536 }
14537 else
14538 {
14539 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14540
14541 if (CL_err != CL_SUCCESS)
14542 {
14543 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14544
14545 return -1;
14546 }
14547 }
14548 }
14549 else
14550 {
14551 vector_width = (cl_uint) tuningdb_entry->vector_width;
14552 }
14553 }
14554 else
14555 {
14556 vector_width = opencl_vector_width;
14557 }
14558
14559 if (vector_width > 16) vector_width = 16;
14560
14561 device_param->vector_width = vector_width;
14562
14563 // max_compute_units
14564
14565 cl_uint device_processors;
14566
14567 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14568
14569 if (CL_err != CL_SUCCESS)
14570 {
14571 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14572
14573 return -1;
14574 }
14575
14576 device_param->device_processors = device_processors;
14577
14578 // device_maxmem_alloc
14579 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14580
14581 cl_ulong device_maxmem_alloc;
14582
14583 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, 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 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14593
14594 // device_global_mem
14595
14596 cl_ulong device_global_mem;
14597
14598 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14599
14600 if (CL_err != CL_SUCCESS)
14601 {
14602 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14603
14604 return -1;
14605 }
14606
14607 device_param->device_global_mem = device_global_mem;
14608
14609 // max_work_group_size
14610
14611 size_t device_maxworkgroup_size;
14612
14613 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14614
14615 if (CL_err != CL_SUCCESS)
14616 {
14617 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14618
14619 return -1;
14620 }
14621
14622 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14623
14624 // max_clock_frequency
14625
14626 cl_uint device_maxclock_frequency;
14627
14628 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14629
14630 if (CL_err != CL_SUCCESS)
14631 {
14632 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14633
14634 return -1;
14635 }
14636
14637 device_param->device_maxclock_frequency = device_maxclock_frequency;
14638
14639 // device_endian_little
14640
14641 cl_bool device_endian_little;
14642
14643 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, 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_endian_little == CL_FALSE)
14653 {
14654 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14655
14656 device_param->skipped = 1;
14657 }
14658
14659 // device_available
14660
14661 cl_bool device_available;
14662
14663 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
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 if (device_available == CL_FALSE)
14673 {
14674 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14675
14676 device_param->skipped = 1;
14677 }
14678
14679 // device_compiler_available
14680
14681 cl_bool device_compiler_available;
14682
14683 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14684
14685 if (CL_err != CL_SUCCESS)
14686 {
14687 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14688
14689 return -1;
14690 }
14691
14692 if (device_compiler_available == CL_FALSE)
14693 {
14694 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14695
14696 device_param->skipped = 1;
14697 }
14698
14699 // device_execution_capabilities
14700
14701 cl_device_exec_capabilities device_execution_capabilities;
14702
14703 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, 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_execution_capabilities & CL_EXEC_KERNEL) == 0)
14713 {
14714 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14715
14716 device_param->skipped = 1;
14717 }
14718
14719 // device_extensions
14720
14721 size_t device_extensions_size;
14722
14723 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14724
14725 if (CL_err != CL_SUCCESS)
14726 {
14727 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14728
14729 return -1;
14730 }
14731
14732 char *device_extensions = mymalloc (device_extensions_size + 1);
14733
14734 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14735
14736 if (CL_err != CL_SUCCESS)
14737 {
14738 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14739
14740 return -1;
14741 }
14742
14743 if (strstr (device_extensions, "base_atomics") == 0)
14744 {
14745 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14746
14747 device_param->skipped = 1;
14748 }
14749
14750 if (strstr (device_extensions, "byte_addressable_store") == 0)
14751 {
14752 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14753
14754 device_param->skipped = 1;
14755 }
14756
14757 myfree (device_extensions);
14758
14759 // device_local_mem_size
14760
14761 cl_ulong device_local_mem_size;
14762
14763 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14764
14765 if (CL_err != CL_SUCCESS)
14766 {
14767 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14768
14769 return -1;
14770 }
14771
14772 if (device_local_mem_size < 32768)
14773 {
14774 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14775
14776 device_param->skipped = 1;
14777 }
14778
14779 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14780 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14781 // This results in both utilizing it for 50%
14782 // However, Intel has much better SIMD control over their own hardware
14783 // It makes sense to give them full control over their own hardware
14784
14785 if (device_type & CL_DEVICE_TYPE_CPU)
14786 {
14787 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14788 {
14789 if (data.force == 0)
14790 {
14791 if (algorithm_pos == 0)
14792 {
14793 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14794 log_info (" You can use --force to override this but do not post error reports if you do so");
14795 }
14796
14797 device_param->skipped = 1;
14798 }
14799 }
14800 }
14801
14802 // skipped
14803
14804 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14805 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14806
14807 // driver_version
14808
14809 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14810
14811 if (CL_err != CL_SUCCESS)
14812 {
14813 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14814
14815 return -1;
14816 }
14817
14818 char *driver_version = (char *) mymalloc (param_value_size);
14819
14820 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, 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->driver_version = driver_version;
14830
14831 // device_name_chksum
14832
14833 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14834
14835 #if __x86_64__
14836 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);
14837 #else
14838 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);
14839 #endif
14840
14841 uint device_name_digest[4] = { 0 };
14842
14843 md5_64 ((uint *) device_name_chksum, device_name_digest);
14844
14845 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14846
14847 device_param->device_name_chksum = device_name_chksum;
14848
14849 // vendor specific
14850
14851 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14852 {
14853 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14854 {
14855 need_adl = 1;
14856 }
14857
14858 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14859 {
14860 need_nvml = 1;
14861
14862 #ifdef __linux__
14863 need_xnvctrl = 1;
14864 #endif
14865
14866 #ifdef WIN
14867 need_nvapi = 1;
14868 #endif
14869 }
14870 }
14871
14872 if (device_type & CL_DEVICE_TYPE_GPU)
14873 {
14874 if (device_vendor_id == VENDOR_ID_NV)
14875 {
14876 cl_uint kernel_exec_timeout = 0;
14877
14878 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14879
14880 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14881
14882 if (CL_err != CL_SUCCESS)
14883 {
14884 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14885
14886 return -1;
14887 }
14888
14889 device_param->kernel_exec_timeout = kernel_exec_timeout;
14890
14891 cl_uint sm_minor = 0;
14892 cl_uint sm_major = 0;
14893
14894 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14895 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14896
14897 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14898
14899 if (CL_err != CL_SUCCESS)
14900 {
14901 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14902
14903 return -1;
14904 }
14905
14906 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14907
14908 if (CL_err != CL_SUCCESS)
14909 {
14910 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14911
14912 return -1;
14913 }
14914
14915 device_param->sm_minor = sm_minor;
14916 device_param->sm_major = sm_major;
14917
14918 // CPU burning loop damper
14919 // Value is given as number between 0-100
14920 // By default 100%
14921
14922 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14923
14924 if (nvidia_spin_damp_chgd == 0)
14925 {
14926 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14927 {
14928 /**
14929 * the workaround is not a friend of rule based attacks
14930 * the words from the wordlist combined with fast and slow rules cause
14931 * fluctuations which cause inaccurate wait time estimations
14932 * using a reduced damping percentage almost compensates this
14933 */
14934
14935 device_param->nvidia_spin_damp = 64;
14936 }
14937 }
14938
14939 device_param->nvidia_spin_damp /= 100;
14940 }
14941 }
14942
14943 // display results
14944
14945 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14946 {
14947 if (machine_readable == 0)
14948 {
14949 if (device_param->skipped == 0)
14950 {
14951 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14952 device_id + 1,
14953 device_name,
14954 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14955 (unsigned int) (device_global_mem / 1024 / 1024),
14956 (unsigned int) device_processors);
14957 }
14958 else
14959 {
14960 log_info ("- Device #%u: %s, skipped",
14961 device_id + 1,
14962 device_name);
14963 }
14964 }
14965 }
14966
14967 // common driver check
14968
14969 if (device_param->skipped == 0)
14970 {
14971 if (device_type & CL_DEVICE_TYPE_GPU)
14972 {
14973 if (platform_vendor_id == VENDOR_ID_AMD)
14974 {
14975 int catalyst_check = (force == 1) ? 0 : 1;
14976
14977 int catalyst_warn = 0;
14978
14979 int catalyst_broken = 0;
14980
14981 if (catalyst_check == 1)
14982 {
14983 catalyst_warn = 1;
14984
14985 // v14.9 and higher
14986 if (atoi (device_param->driver_version) >= 1573)
14987 {
14988 catalyst_warn = 0;
14989 }
14990
14991 catalyst_check = 0;
14992 }
14993
14994 if (catalyst_broken == 1)
14995 {
14996 log_info ("");
14997 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14998 log_info ("It passes over cracked hashes and will not report them as cracked");
14999 log_info ("You are STRONGLY encouraged not to use it");
15000 log_info ("You can use --force to override this but do not post error reports if you do so");
15001 log_info ("");
15002
15003 return -1;
15004 }
15005
15006 if (catalyst_warn == 1)
15007 {
15008 log_info ("");
15009 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
15010 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
15011 log_info ("See hashcat's homepage for official supported catalyst drivers");
15012 #ifdef _WIN
15013 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
15014 #endif
15015 log_info ("You can use --force to override this but do not post error reports if you do so");
15016 log_info ("");
15017
15018 return -1;
15019 }
15020 }
15021 else if (platform_vendor_id == VENDOR_ID_NV)
15022 {
15023 if (device_param->kernel_exec_timeout != 0)
15024 {
15025 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);
15026 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
15027 }
15028 }
15029 }
15030
15031 /* turns out pocl still creates segfaults (because of llvm)
15032 if (device_type & CL_DEVICE_TYPE_CPU)
15033 {
15034 if (platform_vendor_id == VENDOR_ID_AMD)
15035 {
15036 if (force == 0)
15037 {
15038 log_info ("");
15039 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
15040 log_info ("You are STRONGLY encouraged not to use it");
15041 log_info ("You can use --force to override this but do not post error reports if you do so");
15042 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
15043 log_info ("");
15044
15045 return -1;
15046 }
15047 }
15048 }
15049 */
15050
15051 /**
15052 * kernel accel and loops tuning db adjustment
15053 */
15054
15055 device_param->kernel_accel_min = 1;
15056 device_param->kernel_accel_max = 1024;
15057
15058 device_param->kernel_loops_min = 1;
15059 device_param->kernel_loops_max = 1024;
15060
15061 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
15062
15063 if (tuningdb_entry)
15064 {
15065 u32 _kernel_accel = tuningdb_entry->kernel_accel;
15066 u32 _kernel_loops = tuningdb_entry->kernel_loops;
15067
15068 if (_kernel_accel)
15069 {
15070 device_param->kernel_accel_min = _kernel_accel;
15071 device_param->kernel_accel_max = _kernel_accel;
15072 }
15073
15074 if (_kernel_loops)
15075 {
15076 if (workload_profile == 1)
15077 {
15078 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
15079 }
15080 else if (workload_profile == 2)
15081 {
15082 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
15083 }
15084
15085 device_param->kernel_loops_min = _kernel_loops;
15086 device_param->kernel_loops_max = _kernel_loops;
15087 }
15088 }
15089
15090 // commandline parameters overwrite tuningdb entries
15091
15092 if (kernel_accel)
15093 {
15094 device_param->kernel_accel_min = kernel_accel;
15095 device_param->kernel_accel_max = kernel_accel;
15096 }
15097
15098 if (kernel_loops)
15099 {
15100 device_param->kernel_loops_min = kernel_loops;
15101 device_param->kernel_loops_max = kernel_loops;
15102 }
15103
15104 /**
15105 * activate device
15106 */
15107
15108 devices_active++;
15109 }
15110
15111 // next please
15112
15113 devices_cnt++;
15114 }
15115
15116 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
15117 {
15118 if (machine_readable == 0)
15119 {
15120 log_info ("");
15121 }
15122 }
15123 }
15124
15125 if (keyspace == 0 && devices_active == 0)
15126 {
15127 log_error ("ERROR: No devices found/left");
15128
15129 return -1;
15130 }
15131
15132 // 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)
15133
15134 if (devices_filter != (uint) -1)
15135 {
15136 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
15137
15138 if (devices_filter > devices_cnt_mask)
15139 {
15140 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
15141
15142 return -1;
15143 }
15144 }
15145
15146 data.devices_cnt = devices_cnt;
15147
15148 data.devices_active = devices_active;
15149
15150 /**
15151 * HM devices: init
15152 */
15153
15154 #ifdef HAVE_HWMON
15155 hm_attrs_t hm_adapters_adl[DEVICES_MAX];
15156 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
15157 hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
15158 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
15159
15160 memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl));
15161 memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi));
15162 memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml));
15163 memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
15164
15165 if (gpu_temp_disable == 0)
15166 {
15167 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
15168 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
15169 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
15170 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
15171
15172 data.hm_adl = NULL;
15173 data.hm_nvapi = NULL;
15174 data.hm_nvml = NULL;
15175 data.hm_xnvctrl = NULL;
15176
15177 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
15178 {
15179 data.hm_nvml = nvml;
15180 }
15181
15182 if (data.hm_nvml)
15183 {
15184 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
15185 {
15186 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
15187
15188 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
15189
15190 int tmp_out = 0;
15191
15192 for (int i = 0; i < tmp_in; i++)
15193 {
15194 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
15195 }
15196
15197 for (int i = 0; i < tmp_out; i++)
15198 {
15199 unsigned int speed;
15200
15201 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
15202
15203 // doesn't seem to create any advantages
15204 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
15205 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
15206 }
15207 }
15208 }
15209
15210 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
15211 {
15212 data.hm_nvapi = nvapi;
15213 }
15214
15215 if (data.hm_nvapi)
15216 {
15217 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
15218 {
15219 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
15220
15221 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
15222
15223 int tmp_out = 0;
15224
15225 for (int i = 0; i < tmp_in; i++)
15226 {
15227 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
15228 }
15229 }
15230 }
15231
15232 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
15233 {
15234 data.hm_xnvctrl = xnvctrl;
15235 }
15236
15237 if (data.hm_xnvctrl)
15238 {
15239 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
15240 {
15241 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15242 {
15243 hc_device_param_t *device_param = &data.devices_param[device_id];
15244
15245 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15246
15247 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
15248
15249 int speed = 0;
15250
15251 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
15252 }
15253 }
15254 }
15255
15256 if ((need_adl == 1) && (adl_init (adl) == 0))
15257 {
15258 data.hm_adl = adl;
15259 }
15260
15261 if (data.hm_adl)
15262 {
15263 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
15264 {
15265 // total number of adapters
15266
15267 int hm_adapters_num;
15268
15269 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1;
15270
15271 // adapter info
15272
15273 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
15274
15275 if (lpAdapterInfo == NULL) return -1;
15276
15277 // get a list (of ids of) valid/usable adapters
15278
15279 int num_adl_adapters = 0;
15280
15281 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
15282
15283 if (num_adl_adapters > 0)
15284 {
15285 hc_thread_mutex_lock (mux_adl);
15286
15287 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
15288
15289 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15290
15291 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15292 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15293
15294 hc_thread_mutex_unlock (mux_adl);
15295 }
15296
15297 myfree (valid_adl_device_list);
15298 myfree (lpAdapterInfo);
15299 }
15300 }
15301
15302 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15303 {
15304 gpu_temp_disable = 1;
15305 }
15306 }
15307
15308 /**
15309 * OpenCL devices: allocate buffer for device specific information
15310 */
15311
15312 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
15313
15314 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
15315
15316 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
15317
15318 /**
15319 * User-defined GPU temp handling
15320 */
15321
15322 if (gpu_temp_disable == 1)
15323 {
15324 gpu_temp_abort = 0;
15325 gpu_temp_retain = 0;
15326 }
15327
15328 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
15329 {
15330 if (gpu_temp_abort < gpu_temp_retain)
15331 {
15332 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
15333
15334 return -1;
15335 }
15336 }
15337
15338 data.gpu_temp_disable = gpu_temp_disable;
15339 data.gpu_temp_abort = gpu_temp_abort;
15340 data.gpu_temp_retain = gpu_temp_retain;
15341 #endif
15342
15343 /**
15344 * enable custom signal handler(s)
15345 */
15346
15347 if (benchmark == 0)
15348 {
15349 hc_signal (sigHandler_default);
15350 }
15351 else
15352 {
15353 hc_signal (sigHandler_benchmark);
15354 }
15355
15356 /**
15357 * inform the user
15358 */
15359
15360 if (data.quiet == 0)
15361 {
15362 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
15363
15364 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);
15365
15366 if (attack_mode == ATTACK_MODE_STRAIGHT)
15367 {
15368 log_info ("Rules: %u", kernel_rules_cnt);
15369 }
15370
15371 if (opti_type)
15372 {
15373 log_info ("Applicable Optimizers:");
15374
15375 for (uint i = 0; i < 32; i++)
15376 {
15377 const uint opti_bit = 1u << i;
15378
15379 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
15380 }
15381 }
15382
15383 /**
15384 * Watchdog and Temperature balance
15385 */
15386
15387 #ifdef HAVE_HWMON
15388 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15389 {
15390 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
15391 }
15392
15393 if (gpu_temp_abort == 0)
15394 {
15395 log_info ("Watchdog: Temperature abort trigger disabled");
15396 }
15397 else
15398 {
15399 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
15400 }
15401
15402 if (gpu_temp_retain == 0)
15403 {
15404 log_info ("Watchdog: Temperature retain trigger disabled");
15405 }
15406 else
15407 {
15408 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
15409 }
15410
15411 if (data.quiet == 0) log_info ("");
15412 #endif
15413 }
15414
15415 #ifdef HAVE_HWMON
15416
15417 /**
15418 * HM devices: copy
15419 */
15420
15421 if (gpu_temp_disable == 0)
15422 {
15423 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15424 {
15425 hc_device_param_t *device_param = &data.devices_param[device_id];
15426
15427 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15428
15429 if (device_param->skipped) continue;
15430
15431 const uint platform_devices_id = device_param->platform_devices_id;
15432
15433 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15434 {
15435 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
15436 data.hm_device[device_id].nvapi = 0;
15437 data.hm_device[device_id].nvml = 0;
15438 data.hm_device[device_id].xnvctrl = 0;
15439 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
15440 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
15441 data.hm_device[device_id].fan_set_supported = 0;
15442 }
15443
15444 if (device_param->device_vendor_id == VENDOR_ID_NV)
15445 {
15446 data.hm_device[device_id].adl = 0;
15447 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
15448 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
15449 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
15450 data.hm_device[device_id].od_version = 0;
15451 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
15452 data.hm_device[device_id].fan_set_supported = 0;
15453 }
15454 }
15455 }
15456
15457 /**
15458 * powertune on user request
15459 */
15460
15461 if (powertune_enable == 1)
15462 {
15463 hc_thread_mutex_lock (mux_adl);
15464
15465 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15466 {
15467 hc_device_param_t *device_param = &data.devices_param[device_id];
15468
15469 if (device_param->skipped) continue;
15470
15471 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
15472 {
15473 /**
15474 * Temporary fix:
15475 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
15476 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
15477 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
15478 * Driver / ADL bug?
15479 */
15480
15481 if (data.hm_device[device_id].od_version == 6)
15482 {
15483 int ADL_rc;
15484
15485 // check powertune capabilities first, if not available then skip device
15486
15487 int powertune_supported = 0;
15488
15489 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
15490 {
15491 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15492
15493 return -1;
15494 }
15495
15496 // first backup current value, we will restore it later
15497
15498 if (powertune_supported != 0)
15499 {
15500 // powercontrol settings
15501
15502 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15503
15504 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
15505 {
15506 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
15507 }
15508
15509 if (ADL_rc != ADL_OK)
15510 {
15511 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15512
15513 return -1;
15514 }
15515
15516 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15517 {
15518 log_error ("ERROR: Failed to set new ADL PowerControl values");
15519
15520 return -1;
15521 }
15522
15523 // clocks
15524
15525 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15526
15527 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15528
15529 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)
15530 {
15531 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15532
15533 return -1;
15534 }
15535
15536 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15537
15538 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15539
15540 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
15541 {
15542 log_error ("ERROR: Failed to get ADL device capabilities");
15543
15544 return -1;
15545 }
15546
15547 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15548 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15549
15550 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15551 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15552
15553 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15554 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15555
15556 // warning if profile has too low max values
15557
15558 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15559 {
15560 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15561 }
15562
15563 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15564 {
15565 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15566 }
15567
15568 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15569
15570 performance_state->iNumberOfPerformanceLevels = 2;
15571
15572 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15573 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15574 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15575 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15576
15577 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)
15578 {
15579 log_info ("ERROR: Failed to set ADL performance state");
15580
15581 return -1;
15582 }
15583
15584 local_free (performance_state);
15585 }
15586
15587 // set powertune value only
15588
15589 if (powertune_supported != 0)
15590 {
15591 // powertune set
15592 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15593
15594 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
15595 {
15596 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15597
15598 return -1;
15599 }
15600
15601 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15602 {
15603 log_error ("ERROR: Failed to set new ADL PowerControl values");
15604
15605 return -1;
15606 }
15607 }
15608 }
15609 }
15610
15611 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
15612 {
15613 // first backup current value, we will restore it later
15614
15615 unsigned int limit;
15616
15617 int powertune_supported = 0;
15618
15619 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
15620 {
15621 powertune_supported = 1;
15622 }
15623
15624 // if backup worked, activate the maximum allowed
15625
15626 if (powertune_supported != 0)
15627 {
15628 unsigned int minLimit;
15629 unsigned int maxLimit;
15630
15631 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15632 {
15633 if (maxLimit > 0)
15634 {
15635 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15636 {
15637 // now we can be sure we need to reset later
15638
15639 nvml_power_limit[device_id] = limit;
15640 }
15641 }
15642 }
15643 }
15644 }
15645 }
15646
15647 hc_thread_mutex_unlock (mux_adl);
15648 }
15649
15650 #endif // HAVE_HWMON
15651
15652 #ifdef DEBUG
15653 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15654 #endif
15655
15656 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15657
15658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15659 {
15660 cl_int CL_err = CL_SUCCESS;
15661
15662 /**
15663 * host buffer
15664 */
15665
15666 hc_device_param_t *device_param = &data.devices_param[device_id];
15667
15668 if (device_param->skipped) continue;
15669
15670 /**
15671 * device properties
15672 */
15673
15674 const char *device_name_chksum = device_param->device_name_chksum;
15675 const u32 device_processors = device_param->device_processors;
15676
15677 /**
15678 * create context for each device
15679 */
15680
15681 cl_context_properties properties[3];
15682
15683 properties[0] = CL_CONTEXT_PLATFORM;
15684 properties[1] = (cl_context_properties) device_param->platform;
15685 properties[2] = 0;
15686
15687 CL_err = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL, &device_param->context);
15688
15689 if (CL_err != CL_SUCCESS)
15690 {
15691 log_error ("ERROR: clCreateContext(): %s\n", val2cstr_cl (CL_err));
15692
15693 return -1;
15694 }
15695
15696 /**
15697 * create command-queue
15698 */
15699
15700 // not supported with NV
15701 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15702
15703 CL_err = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE, &device_param->command_queue);
15704
15705 if (CL_err != CL_SUCCESS)
15706 {
15707 log_error ("ERROR: clCreateCommandQueue(): %s\n", val2cstr_cl (CL_err));
15708
15709 return -1;
15710 }
15711
15712 /**
15713 * kernel threads: some algorithms need a fixed kernel-threads count
15714 * because of shared memory usage or bitslice
15715 * there needs to be some upper limit, otherwise there's too much overhead
15716 */
15717
15718 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15719
15720 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15721 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15722
15723 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15724 {
15725 kernel_threads = KERNEL_THREADS_MAX_CPU;
15726 }
15727
15728 if (hash_mode == 1500) kernel_threads = 64; // DES
15729 if (hash_mode == 3000) kernel_threads = 64; // DES
15730 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15731 if (hash_mode == 7500) kernel_threads = 64; // RC4
15732 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15733 if (hash_mode == 9700) kernel_threads = 64; // RC4
15734 if (hash_mode == 9710) kernel_threads = 64; // RC4
15735 if (hash_mode == 9800) kernel_threads = 64; // RC4
15736 if (hash_mode == 9810) kernel_threads = 64; // RC4
15737 if (hash_mode == 10400) kernel_threads = 64; // RC4
15738 if (hash_mode == 10410) kernel_threads = 64; // RC4
15739 if (hash_mode == 10500) kernel_threads = 64; // RC4
15740 if (hash_mode == 13100) kernel_threads = 64; // RC4
15741
15742 device_param->kernel_threads = kernel_threads;
15743
15744 device_param->hardware_power = device_processors * kernel_threads;
15745
15746 /**
15747 * create input buffers on device : calculate size of fixed memory buffers
15748 */
15749
15750 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15751 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15752
15753 device_param->size_root_css = size_root_css;
15754 device_param->size_markov_css = size_markov_css;
15755
15756 size_t size_results = sizeof (uint);
15757
15758 device_param->size_results = size_results;
15759
15760 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15761 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15762
15763 size_t size_plains = digests_cnt * sizeof (plain_t);
15764 size_t size_salts = salts_cnt * sizeof (salt_t);
15765 size_t size_esalts = salts_cnt * esalt_size;
15766
15767 device_param->size_plains = size_plains;
15768 device_param->size_digests = size_digests;
15769 device_param->size_shown = size_shown;
15770 device_param->size_salts = size_salts;
15771
15772 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15773 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15774 size_t size_tm = 32 * sizeof (bs_word_t);
15775
15776 // scryptV stuff
15777
15778 size_t size_scrypt = 4;
15779
15780 if ((hash_mode == 8900) || (hash_mode == 9300))
15781 {
15782 // we need to check that all hashes have the same scrypt settings
15783
15784 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15785 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15786 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15787
15788 for (uint i = 1; i < salts_cnt; i++)
15789 {
15790 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15791 || (data.salts_buf[i].scrypt_r != scrypt_r)
15792 || (data.salts_buf[i].scrypt_p != scrypt_p))
15793 {
15794 log_error ("ERROR: Mixed scrypt settings not supported");
15795
15796 return -1;
15797 }
15798 }
15799
15800 uint tmto_start = 0;
15801 uint tmto_stop = 10;
15802
15803 if (scrypt_tmto)
15804 {
15805 tmto_start = scrypt_tmto;
15806 }
15807 else
15808 {
15809 // in case the user did not specify the tmto manually
15810 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15811
15812 if (hash_mode == 8900)
15813 {
15814 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15815 {
15816 tmto_start = 3;
15817 }
15818 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15819 {
15820 tmto_start = 2;
15821 }
15822 }
15823 else if (hash_mode == 9300)
15824 {
15825 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15826 {
15827 tmto_start = 2;
15828 }
15829 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15830 {
15831 tmto_start = 4;
15832 }
15833 }
15834 }
15835
15836 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15837
15838 device_param->kernel_accel_min = 1;
15839 device_param->kernel_accel_max = 8;
15840
15841 uint tmto;
15842
15843 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15844 {
15845 size_scrypt = (128 * scrypt_r) * scrypt_N;
15846
15847 size_scrypt /= 1 << tmto;
15848
15849 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15850
15851 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15852 {
15853 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15854
15855 continue;
15856 }
15857
15858 if (size_scrypt > device_param->device_global_mem)
15859 {
15860 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15861
15862 continue;
15863 }
15864
15865 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15866 {
15867 data.scrypt_tmto_final = tmto;
15868 }
15869
15870 break;
15871 }
15872
15873 if (tmto == tmto_stop)
15874 {
15875 log_error ("ERROR: Can't allocate enough device memory");
15876
15877 return -1;
15878 }
15879
15880 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);
15881 }
15882
15883 size_t size_scrypt4 = size_scrypt / 4;
15884
15885 /**
15886 * some algorithms need a fixed kernel-loops count
15887 */
15888
15889 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15890 {
15891 const u32 kernel_loops_fixed = 1024;
15892
15893 device_param->kernel_loops_min = kernel_loops_fixed;
15894 device_param->kernel_loops_max = kernel_loops_fixed;
15895 }
15896
15897 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15898 {
15899 const u32 kernel_loops_fixed = 1024;
15900
15901 device_param->kernel_loops_min = kernel_loops_fixed;
15902 device_param->kernel_loops_max = kernel_loops_fixed;
15903 }
15904
15905 if (hash_mode == 8900)
15906 {
15907 const u32 kernel_loops_fixed = 1;
15908
15909 device_param->kernel_loops_min = kernel_loops_fixed;
15910 device_param->kernel_loops_max = kernel_loops_fixed;
15911 }
15912
15913 if (hash_mode == 9300)
15914 {
15915 const u32 kernel_loops_fixed = 1;
15916
15917 device_param->kernel_loops_min = kernel_loops_fixed;
15918 device_param->kernel_loops_max = kernel_loops_fixed;
15919 }
15920
15921 if (hash_mode == 12500)
15922 {
15923 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15924
15925 device_param->kernel_loops_min = kernel_loops_fixed;
15926 device_param->kernel_loops_max = kernel_loops_fixed;
15927 }
15928
15929 /**
15930 * some algorithms have a maximum kernel-loops count
15931 */
15932
15933 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15934 {
15935 u32 innerloop_cnt = 0;
15936
15937 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15938 {
15939 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15940 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15941 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15942 }
15943 else
15944 {
15945 innerloop_cnt = data.salts_buf[0].salt_iter;
15946 }
15947
15948 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15949 (innerloop_cnt <= device_param->kernel_loops_max))
15950 {
15951 device_param->kernel_loops_max = innerloop_cnt;
15952 }
15953 }
15954
15955 u32 kernel_accel_min = device_param->kernel_accel_min;
15956 u32 kernel_accel_max = device_param->kernel_accel_max;
15957
15958 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15959
15960 size_t size_pws = 4;
15961 size_t size_tmps = 4;
15962 size_t size_hooks = 4;
15963
15964 while (kernel_accel_max >= kernel_accel_min)
15965 {
15966 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15967
15968 // size_pws
15969
15970 size_pws = kernel_power_max * sizeof (pw_t);
15971
15972 // size_tmps
15973
15974 switch (hash_mode)
15975 {
15976 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15977 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15978 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15979 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15980 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15981 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15982 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15983 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15984 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15985 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15986 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15987 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15988 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15989 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15990 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15991 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15992 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15993 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15994 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15995 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15996 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15997 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15998 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15999 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
16000 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
16001 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
16002 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
16003 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
16004 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
16005 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
16006 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
16007 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
16008 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
16009 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
16010 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
16011 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
16012 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
16013 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16014 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
16015 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
16016 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
16017 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
16018 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16019 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
16020 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
16021 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
16022 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
16023 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16024 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
16025 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
16026 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
16027 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
16028 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
16029 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
16030 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
16031 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
16032 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
16033 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
16034 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16035 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16036 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
16037 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
16038 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
16039 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
16040 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16041 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16042 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16043 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
16044 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
16045 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
16046 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16047 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16048 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16049 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16050 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16051 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16052 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16053 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16054 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16055 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16056 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16057 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
16058 };
16059
16060 // size_hooks
16061
16062 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
16063 {
16064 switch (hash_mode)
16065 {
16066 }
16067 }
16068
16069 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
16070 // if not, decrease amplifier and try again
16071
16072 int memory_limit_hit = 0;
16073
16074 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16075 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16076 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16077
16078 const u64 size_total
16079 = bitmap_size
16080 + bitmap_size
16081 + bitmap_size
16082 + bitmap_size
16083 + bitmap_size
16084 + bitmap_size
16085 + bitmap_size
16086 + bitmap_size
16087 + size_bfs
16088 + size_combs
16089 + size_digests
16090 + size_esalts
16091 + size_hooks
16092 + size_markov_css
16093 + size_plains
16094 + size_pws
16095 + size_pws // not a bug
16096 + size_results
16097 + size_root_css
16098 + size_rules
16099 + size_rules_c
16100 + size_salts
16101 + size_scrypt4
16102 + size_scrypt4
16103 + size_scrypt4
16104 + size_scrypt4
16105 + size_shown
16106 + size_tm
16107 + size_tmps;
16108
16109 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
16110
16111 if (memory_limit_hit == 1)
16112 {
16113 kernel_accel_max--;
16114
16115 continue;
16116 }
16117
16118 break;
16119 }
16120
16121 if (kernel_accel_max < kernel_accel_min)
16122 {
16123 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
16124
16125 return -1;
16126 }
16127
16128 device_param->kernel_accel_min = kernel_accel_min;
16129 device_param->kernel_accel_max = kernel_accel_max;
16130
16131 /*
16132 if (kernel_accel_max < kernel_accel)
16133 {
16134 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
16135
16136 device_param->kernel_accel = kernel_accel_max;
16137 }
16138 */
16139
16140 device_param->size_bfs = size_bfs;
16141 device_param->size_combs = size_combs;
16142 device_param->size_rules = size_rules;
16143 device_param->size_rules_c = size_rules_c;
16144 device_param->size_pws = size_pws;
16145 device_param->size_tmps = size_tmps;
16146 device_param->size_hooks = size_hooks;
16147
16148 /**
16149 * default building options
16150 */
16151
16152 if (chdir (cpath_real) == -1)
16153 {
16154 log_error ("ERROR: %s: %s", cpath_real, strerror (errno));
16155
16156 return -1;
16157 }
16158
16159 char build_opts[1024] = { 0 };
16160
16161 #if _WIN
16162 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
16163 #else
16164 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
16165 #endif
16166
16167 // include check
16168 // this test needs to be done manually because of osx opencl runtime
16169 // if there's a problem with permission, its not reporting back and erroring out silently
16170
16171 #define files_cnt 15
16172
16173 const char *files_names[files_cnt] =
16174 {
16175 "inc_cipher_aes256.cl",
16176 "inc_cipher_serpent256.cl",
16177 "inc_cipher_twofish256.cl",
16178 "inc_common.cl",
16179 "inc_comp_multi_bs.cl",
16180 "inc_comp_multi.cl",
16181 "inc_comp_single_bs.cl",
16182 "inc_comp_single.cl",
16183 "inc_hash_constants.h",
16184 "inc_hash_functions.cl",
16185 "inc_rp.cl",
16186 "inc_rp.h",
16187 "inc_simd.cl",
16188 "inc_types.cl",
16189 "inc_vendor.cl",
16190 };
16191
16192 for (int i = 0; i < files_cnt; i++)
16193 {
16194 FILE *fd = fopen (files_names[i], "r");
16195
16196 if (fd == NULL)
16197 {
16198 log_error ("ERROR: %s: fopen(): %s", files_names[i], strerror (errno));
16199
16200 return -1;
16201 }
16202
16203 char buf[1];
16204
16205 size_t n = fread (buf, 1, 1, fd);
16206
16207 if (n != 1)
16208 {
16209 log_error ("ERROR: %s: fread(): %s", files_names[i], strerror (errno));
16210
16211 return -1;
16212 }
16213
16214 fclose (fd);
16215 }
16216
16217 // we don't have sm_* on vendors not NV but it doesn't matter
16218
16219 char build_opts_new[1024] = { 0 };
16220
16221 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);
16222
16223 strncpy (build_opts, build_opts_new, sizeof (build_opts));
16224
16225 #ifdef DEBUG
16226 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
16227 #endif
16228
16229 /**
16230 * main kernel
16231 */
16232
16233 {
16234 /**
16235 * kernel source filename
16236 */
16237
16238 char source_file[256] = { 0 };
16239
16240 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
16241
16242 struct stat sst;
16243
16244 if (stat (source_file, &sst) == -1)
16245 {
16246 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16247
16248 return -1;
16249 }
16250
16251 /**
16252 * kernel cached filename
16253 */
16254
16255 char cached_file[256] = { 0 };
16256
16257 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
16258
16259 int cached = 1;
16260
16261 struct stat cst;
16262
16263 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
16264 {
16265 cached = 0;
16266 }
16267
16268 /**
16269 * kernel compile or load
16270 */
16271
16272 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16273
16274 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16275
16276 if (force_jit_compilation == -1)
16277 {
16278 if (cached == 0)
16279 {
16280 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));
16281
16282 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16283
16284 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16285
16286 if (CL_err != CL_SUCCESS)
16287 {
16288 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16289
16290 return -1;
16291 }
16292
16293 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16294
16295 if (CL_err != CL_SUCCESS)
16296 {
16297 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16298
16299 //return -1;
16300 }
16301
16302 #ifdef DEBUG
16303 size_t build_log_size = 0;
16304
16305 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16306
16307 if (CL_err != CL_SUCCESS)
16308 {
16309 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16310
16311 return -1;
16312 }
16313
16314 if (build_log_size > 1)
16315 {
16316 char *build_log = (char *) mymalloc (build_log_size + 1);
16317
16318 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16319
16320 if (CL_err != CL_SUCCESS)
16321 {
16322 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16323
16324 return -1;
16325 }
16326
16327 puts (build_log);
16328
16329 myfree (build_log);
16330 }
16331 #endif
16332
16333 if (CL_err != CL_SUCCESS)
16334 {
16335 device_param->skipped = true;
16336
16337 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16338
16339 continue;
16340 }
16341
16342 size_t binary_size;
16343
16344 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16345
16346 if (CL_err != CL_SUCCESS)
16347 {
16348 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16349
16350 return -1;
16351 }
16352
16353 u8 *binary = (u8 *) mymalloc (binary_size);
16354
16355 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16356
16357 if (CL_err != CL_SUCCESS)
16358 {
16359 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16360
16361 return -1;
16362 }
16363
16364 writeProgramBin (cached_file, binary, binary_size);
16365
16366 local_free (binary);
16367 }
16368 else
16369 {
16370 #ifdef DEBUG
16371 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16372 #endif
16373
16374 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16375
16376 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program);
16377
16378 if (CL_err != CL_SUCCESS)
16379 {
16380 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16381
16382 return -1;
16383 }
16384
16385 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16386
16387 if (CL_err != CL_SUCCESS)
16388 {
16389 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16390
16391 return -1;
16392 }
16393 }
16394 }
16395 else
16396 {
16397 #ifdef DEBUG
16398 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
16399 #endif
16400
16401 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16402
16403 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16404
16405 if (CL_err != CL_SUCCESS)
16406 {
16407 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16408
16409 return -1;
16410 }
16411
16412 char build_opts_update[1024] = { 0 };
16413
16414 if (force_jit_compilation == 1500)
16415 {
16416 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
16417 }
16418 else if (force_jit_compilation == 8900)
16419 {
16420 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);
16421 }
16422 else
16423 {
16424 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
16425 }
16426
16427 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
16428
16429 if (CL_err != CL_SUCCESS)
16430 {
16431 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16432
16433 //return -1;
16434 }
16435
16436 #ifdef DEBUG
16437 size_t build_log_size = 0;
16438
16439 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16440
16441 if (CL_err != CL_SUCCESS)
16442 {
16443 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16444
16445 return -1;
16446 }
16447
16448 if (build_log_size > 1)
16449 {
16450 char *build_log = (char *) mymalloc (build_log_size + 1);
16451
16452 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16453
16454 if (CL_err != CL_SUCCESS)
16455 {
16456 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16457
16458 return -1;
16459 }
16460
16461 puts (build_log);
16462
16463 myfree (build_log);
16464 }
16465 #endif
16466
16467 if (CL_err != CL_SUCCESS)
16468 {
16469 device_param->skipped = true;
16470
16471 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16472 }
16473 }
16474
16475 local_free (kernel_lengths);
16476 local_free (kernel_sources[0]);
16477 local_free (kernel_sources);
16478 }
16479
16480 /**
16481 * word generator kernel
16482 */
16483
16484 if (attack_mode != ATTACK_MODE_STRAIGHT)
16485 {
16486 /**
16487 * kernel mp source filename
16488 */
16489
16490 char source_file[256] = { 0 };
16491
16492 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
16493
16494 struct stat sst;
16495
16496 if (stat (source_file, &sst) == -1)
16497 {
16498 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16499
16500 return -1;
16501 }
16502
16503 /**
16504 * kernel mp cached filename
16505 */
16506
16507 char cached_file[256] = { 0 };
16508
16509 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
16510
16511 int cached = 1;
16512
16513 struct stat cst;
16514
16515 if (stat (cached_file, &cst) == -1)
16516 {
16517 cached = 0;
16518 }
16519
16520 /**
16521 * kernel compile or load
16522 */
16523
16524 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16525
16526 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16527
16528 if (cached == 0)
16529 {
16530 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));
16531 if (quiet == 0) log_info ("");
16532
16533 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16534
16535 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_mp);
16536
16537 if (CL_err != CL_SUCCESS)
16538 {
16539 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16540
16541 return -1;
16542 }
16543
16544 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16545
16546 if (CL_err != CL_SUCCESS)
16547 {
16548 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16549
16550 //return -1;
16551 }
16552
16553 if (CL_err != CL_SUCCESS)
16554 {
16555 device_param->skipped = true;
16556
16557 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16558
16559 continue;
16560 }
16561
16562 size_t binary_size;
16563
16564 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16565
16566 if (CL_err != CL_SUCCESS)
16567 {
16568 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16569
16570 return -1;
16571 }
16572
16573 u8 *binary = (u8 *) mymalloc (binary_size);
16574
16575 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16576
16577 if (CL_err != CL_SUCCESS)
16578 {
16579 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16580
16581 return -1;
16582 }
16583
16584 writeProgramBin (cached_file, binary, binary_size);
16585
16586 local_free (binary);
16587 }
16588 else
16589 {
16590 #ifdef DEBUG
16591 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16592 #endif
16593
16594 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16595
16596 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_mp);
16597
16598 if (CL_err != CL_SUCCESS)
16599 {
16600 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16601
16602 return -1;
16603 }
16604
16605 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16606
16607 if (CL_err != CL_SUCCESS)
16608 {
16609 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16610
16611 return -1;
16612 }
16613 }
16614
16615 local_free (kernel_lengths);
16616 local_free (kernel_sources[0]);
16617 local_free (kernel_sources);
16618 }
16619
16620 /**
16621 * amplifier kernel
16622 */
16623
16624 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16625 {
16626
16627 }
16628 else
16629 {
16630 /**
16631 * kernel amp source filename
16632 */
16633
16634 char source_file[256] = { 0 };
16635
16636 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
16637
16638 struct stat sst;
16639
16640 if (stat (source_file, &sst) == -1)
16641 {
16642 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16643
16644 return -1;
16645 }
16646
16647 /**
16648 * kernel amp cached filename
16649 */
16650
16651 char cached_file[256] = { 0 };
16652
16653 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
16654
16655 int cached = 1;
16656
16657 struct stat cst;
16658
16659 if (stat (cached_file, &cst) == -1)
16660 {
16661 cached = 0;
16662 }
16663
16664 /**
16665 * kernel compile or load
16666 */
16667
16668 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16669
16670 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16671
16672 if (cached == 0)
16673 {
16674 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));
16675 if (quiet == 0) log_info ("");
16676
16677 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16678
16679 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_amp);
16680
16681 if (CL_err != CL_SUCCESS)
16682 {
16683 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16684
16685 return -1;
16686 }
16687
16688 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16689
16690 if (CL_err != CL_SUCCESS)
16691 {
16692 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16693
16694 //return -1;
16695 }
16696
16697 if (CL_err != CL_SUCCESS)
16698 {
16699 device_param->skipped = true;
16700
16701 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
16702
16703 continue;
16704 }
16705
16706 size_t binary_size;
16707
16708 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16709
16710 if (CL_err != CL_SUCCESS)
16711 {
16712 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16713
16714 return -1;
16715 }
16716
16717 u8 *binary = (u8 *) mymalloc (binary_size);
16718
16719 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16720
16721 if (CL_err != CL_SUCCESS)
16722 {
16723 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16724
16725 return -1;
16726 }
16727
16728 writeProgramBin (cached_file, binary, binary_size);
16729
16730 local_free (binary);
16731 }
16732 else
16733 {
16734 #ifdef DEBUG
16735 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16736 #endif
16737
16738 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16739
16740 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_amp);
16741
16742 if (CL_err != CL_SUCCESS)
16743 {
16744 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16745
16746 return -1;
16747 }
16748
16749 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16750
16751 if (CL_err != CL_SUCCESS)
16752 {
16753 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16754
16755 return -1;
16756 }
16757 }
16758
16759 local_free (kernel_lengths);
16760 local_free (kernel_sources[0]);
16761 local_free (kernel_sources);
16762 }
16763
16764 // return back to the folder we came from initially (workaround)
16765
16766 if (chdir (cwd) == -1)
16767 {
16768 log_error ("ERROR: %s: %s", cwd, strerror (errno));
16769
16770 return -1;
16771 }
16772
16773 // some algorithm collide too fast, make that impossible
16774
16775 if (benchmark == 1)
16776 {
16777 ((uint *) digests_buf)[0] = -1;
16778 ((uint *) digests_buf)[1] = -1;
16779 ((uint *) digests_buf)[2] = -1;
16780 ((uint *) digests_buf)[3] = -1;
16781 }
16782
16783 /**
16784 * global buffers
16785 */
16786
16787 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_buf);
16788 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_amp_buf);
16789 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL, &device_param->d_tmps);
16790 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL, &device_param->d_hooks);
16791 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_a);
16792 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_b);
16793 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_c);
16794 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_d);
16795 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_a);
16796 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_b);
16797 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_c);
16798 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_d);
16799 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL, &device_param->d_plain_bufs);
16800 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL, &device_param->d_digests_buf);
16801 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL, &device_param->d_digests_shown);
16802 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL, &device_param->d_salt_bufs);
16803 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL, &device_param->d_result);
16804 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV0_buf);
16805 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV1_buf);
16806 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV2_buf);
16807 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV3_buf);
16808
16809 if (CL_err != CL_SUCCESS)
16810 {
16811 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16812
16813 return -1;
16814 }
16815
16816 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);
16817 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);
16818 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);
16819 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);
16820 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);
16821 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);
16822 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);
16823 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);
16824 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);
16825 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);
16826 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);
16827
16828 if (CL_err != CL_SUCCESS)
16829 {
16830 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16831
16832 return -1;
16833 }
16834
16835 /**
16836 * special buffers
16837 */
16838
16839 if (attack_kern == ATTACK_KERN_STRAIGHT)
16840 {
16841 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL, &device_param->d_rules);
16842 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL, &device_param->d_rules_c);
16843
16844 if (CL_err != CL_SUCCESS)
16845 {
16846 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16847
16848 return -1;
16849 }
16850
16851 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);
16852
16853 if (CL_err != CL_SUCCESS)
16854 {
16855 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16856
16857 return -1;
16858 }
16859 }
16860 else if (attack_kern == ATTACK_KERN_COMBI)
16861 {
16862 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs);
16863 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs_c);
16864 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16865 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16866
16867 if (CL_err != CL_SUCCESS)
16868 {
16869 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16870
16871 return -1;
16872 }
16873 }
16874 else if (attack_kern == ATTACK_KERN_BF)
16875 {
16876 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs);
16877 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs_c);
16878 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL, &device_param->d_tm_c);
16879 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16880 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16881
16882 if (CL_err != CL_SUCCESS)
16883 {
16884 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16885
16886 return -1;
16887 }
16888 }
16889
16890 if (size_esalts)
16891 {
16892 CL_err = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL, &device_param->d_esalt_bufs);
16893
16894 if (CL_err != CL_SUCCESS)
16895 {
16896 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16897
16898 return -1;
16899 }
16900
16901 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);
16902
16903 if (CL_err != CL_SUCCESS)
16904 {
16905 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16906
16907 return -1;
16908 }
16909 }
16910
16911 /**
16912 * main host data
16913 */
16914
16915 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16916
16917 device_param->pws_buf = pws_buf;
16918
16919 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16920
16921 device_param->combs_buf = combs_buf;
16922
16923 void *hooks_buf = mymalloc (size_hooks);
16924
16925 device_param->hooks_buf = hooks_buf;
16926
16927 /**
16928 * kernel args
16929 */
16930
16931 device_param->kernel_params_buf32[24] = bitmap_mask;
16932 device_param->kernel_params_buf32[25] = bitmap_shift1;
16933 device_param->kernel_params_buf32[26] = bitmap_shift2;
16934 device_param->kernel_params_buf32[27] = 0; // salt_pos
16935 device_param->kernel_params_buf32[28] = 0; // loop_pos
16936 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16937 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16938 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16939 device_param->kernel_params_buf32[32] = 0; // digests_offset
16940 device_param->kernel_params_buf32[33] = 0; // combs_mode
16941 device_param->kernel_params_buf32[34] = 0; // gid_max
16942
16943 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16944 ? &device_param->d_pws_buf
16945 : &device_param->d_pws_amp_buf;
16946 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16947 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16948 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16949 device_param->kernel_params[ 4] = &device_param->d_tmps;
16950 device_param->kernel_params[ 5] = &device_param->d_hooks;
16951 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16952 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16953 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16954 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16955 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16956 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16957 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16958 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16959 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16960 device_param->kernel_params[15] = &device_param->d_digests_buf;
16961 device_param->kernel_params[16] = &device_param->d_digests_shown;
16962 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16963 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16964 device_param->kernel_params[19] = &device_param->d_result;
16965 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16966 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16967 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16968 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16969 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16970 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16971 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16972 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16973 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16974 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16975 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16976 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16977 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16978 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16979 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16980
16981 device_param->kernel_params_mp_buf64[3] = 0;
16982 device_param->kernel_params_mp_buf32[4] = 0;
16983 device_param->kernel_params_mp_buf32[5] = 0;
16984 device_param->kernel_params_mp_buf32[6] = 0;
16985 device_param->kernel_params_mp_buf32[7] = 0;
16986 device_param->kernel_params_mp_buf32[8] = 0;
16987
16988 device_param->kernel_params_mp[0] = NULL;
16989 device_param->kernel_params_mp[1] = NULL;
16990 device_param->kernel_params_mp[2] = NULL;
16991 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16992 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16993 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16994 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16995 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16996 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16997
16998 device_param->kernel_params_mp_l_buf64[3] = 0;
16999 device_param->kernel_params_mp_l_buf32[4] = 0;
17000 device_param->kernel_params_mp_l_buf32[5] = 0;
17001 device_param->kernel_params_mp_l_buf32[6] = 0;
17002 device_param->kernel_params_mp_l_buf32[7] = 0;
17003 device_param->kernel_params_mp_l_buf32[8] = 0;
17004 device_param->kernel_params_mp_l_buf32[9] = 0;
17005
17006 device_param->kernel_params_mp_l[0] = NULL;
17007 device_param->kernel_params_mp_l[1] = NULL;
17008 device_param->kernel_params_mp_l[2] = NULL;
17009 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
17010 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
17011 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
17012 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
17013 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
17014 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
17015 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
17016
17017 device_param->kernel_params_mp_r_buf64[3] = 0;
17018 device_param->kernel_params_mp_r_buf32[4] = 0;
17019 device_param->kernel_params_mp_r_buf32[5] = 0;
17020 device_param->kernel_params_mp_r_buf32[6] = 0;
17021 device_param->kernel_params_mp_r_buf32[7] = 0;
17022 device_param->kernel_params_mp_r_buf32[8] = 0;
17023
17024 device_param->kernel_params_mp_r[0] = NULL;
17025 device_param->kernel_params_mp_r[1] = NULL;
17026 device_param->kernel_params_mp_r[2] = NULL;
17027 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
17028 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
17029 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
17030 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
17031 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
17032 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
17033
17034 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
17035 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
17036
17037 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
17038 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
17039 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
17040 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
17041 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
17042 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
17043 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
17044
17045 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
17046 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
17047
17048 device_param->kernel_params_memset_buf32[1] = 0; // value
17049 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
17050
17051 device_param->kernel_params_memset[0] = NULL;
17052 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
17053 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
17054
17055 /**
17056 * kernel name
17057 */
17058
17059 size_t kernel_wgs_tmp;
17060
17061 char kernel_name[64] = { 0 };
17062
17063 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17064 {
17065 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17066 {
17067 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
17068
17069 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17070
17071 if (CL_err != CL_SUCCESS)
17072 {
17073 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17074
17075 return -1;
17076 }
17077
17078 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
17079
17080 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
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_s%02d", kern_type, 16);
17090
17091 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
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 else
17101 {
17102 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
17103
17104 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17105
17106 if (CL_err != CL_SUCCESS)
17107 {
17108 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17109
17110 return -1;
17111 }
17112
17113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
17114
17115 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17116
17117 if (CL_err != CL_SUCCESS)
17118 {
17119 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17120
17121 return -1;
17122 }
17123
17124 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
17125
17126 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17127
17128 if (CL_err != CL_SUCCESS)
17129 {
17130 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17131
17132 return -1;
17133 }
17134 }
17135
17136 if (data.attack_mode == ATTACK_MODE_BF)
17137 {
17138 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17139 {
17140 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
17141
17142 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel_tm);
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 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);
17152
17153 if (CL_err != CL_SUCCESS)
17154 {
17155 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17156
17157 return -1;
17158 }
17159 }
17160 }
17161 }
17162 else
17163 {
17164 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
17165
17166 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17167
17168 if (CL_err != CL_SUCCESS)
17169 {
17170 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17171
17172 return -1;
17173 }
17174
17175 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
17176
17177 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
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 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
17187
17188 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17189
17190 if (CL_err != CL_SUCCESS)
17191 {
17192 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17193
17194 return -1;
17195 }
17196
17197 if (opts_type & OPTS_TYPE_HOOK12)
17198 {
17199 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
17200
17201 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel12);
17202
17203 if (CL_err != CL_SUCCESS)
17204 {
17205 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17206
17207 return -1;
17208 }
17209
17210 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);
17211
17212 if (CL_err != CL_SUCCESS)
17213 {
17214 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17215
17216 return -1;
17217 }
17218 }
17219
17220 if (opts_type & OPTS_TYPE_HOOK23)
17221 {
17222 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
17223
17224 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel23);
17225
17226 if (CL_err != CL_SUCCESS)
17227 {
17228 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17229
17230 return -1;
17231 }
17232
17233 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);
17234
17235 if (CL_err != CL_SUCCESS)
17236 {
17237 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17238
17239 return -1;
17240 }
17241 }
17242 }
17243
17244 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);
17245 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);
17246 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);
17247
17248 if (CL_err != CL_SUCCESS)
17249 {
17250 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17251
17252 return -1;
17253 }
17254
17255 for (uint i = 0; i <= 23; i++)
17256 {
17257 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
17258 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
17259 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
17260
17261 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
17262 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
17263
17264 if (CL_err != CL_SUCCESS)
17265 {
17266 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17267
17268 return -1;
17269 }
17270 }
17271
17272 for (uint i = 24; i <= 34; i++)
17273 {
17274 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
17275 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
17276 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
17277
17278 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
17279 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
17280
17281 if (CL_err != CL_SUCCESS)
17282 {
17283 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17284
17285 return -1;
17286 }
17287 }
17288
17289 // GPU memset
17290
17291 CL_err = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset", &device_param->kernel_memset);
17292
17293 if (CL_err != CL_SUCCESS)
17294 {
17295 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17296
17297 return -1;
17298 }
17299
17300 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);
17301
17302 if (CL_err != CL_SUCCESS)
17303 {
17304 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17305
17306 return -1;
17307 }
17308
17309 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
17310 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
17311 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
17312
17313 if (CL_err != CL_SUCCESS)
17314 {
17315 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17316
17317 return -1;
17318 }
17319
17320 // MP start
17321
17322 if (attack_mode == ATTACK_MODE_BF)
17323 {
17324 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov", &device_param->kernel_mp_l);
17325 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov", &device_param->kernel_mp_r);
17326
17327 if (CL_err != CL_SUCCESS)
17328 {
17329 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17330
17331 return -1;
17332 }
17333
17334 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);
17335 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);
17336
17337 if (CL_err != CL_SUCCESS)
17338 {
17339 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17340
17341 return -1;
17342 }
17343
17344 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17345 {
17346 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
17347 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
17348
17349 if (CL_err != CL_SUCCESS)
17350 {
17351 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17352
17353 return -1;
17354 }
17355 }
17356 }
17357 else if (attack_mode == ATTACK_MODE_HYBRID1)
17358 {
17359 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17360
17361 if (CL_err != CL_SUCCESS)
17362 {
17363 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17364
17365 return -1;
17366 }
17367
17368 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);
17369
17370 if (CL_err != CL_SUCCESS)
17371 {
17372 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17373
17374 return -1;
17375 }
17376 }
17377 else if (attack_mode == ATTACK_MODE_HYBRID2)
17378 {
17379 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17380
17381 if (CL_err != CL_SUCCESS)
17382 {
17383 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17384
17385 return -1;
17386 }
17387
17388 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);
17389
17390 if (CL_err != CL_SUCCESS)
17391 {
17392 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17393
17394 return -1;
17395 }
17396 }
17397
17398 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17399 {
17400 // nothing to do
17401 }
17402 else
17403 {
17404 CL_err = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp", &device_param->kernel_amp);
17405
17406 if (CL_err != CL_SUCCESS)
17407 {
17408 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17409
17410 return -1;
17411 }
17412
17413 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);
17414
17415 if (CL_err != CL_SUCCESS)
17416 {
17417 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17418
17419 return -1;
17420 }
17421 }
17422
17423 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17424 {
17425 // nothing to do
17426 }
17427 else
17428 {
17429 for (uint i = 0; i < 5; i++)
17430 {
17431 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
17432
17433 if (CL_err != CL_SUCCESS)
17434 {
17435 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17436
17437 return -1;
17438 }
17439 }
17440
17441 for (uint i = 5; i < 7; i++)
17442 {
17443 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
17444
17445 if (CL_err != CL_SUCCESS)
17446 {
17447 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17448
17449 return -1;
17450 }
17451 }
17452 }
17453
17454 // maybe this has been updated by clGetKernelWorkGroupInfo()
17455 // value can only be decreased, so we don't need to reallocate buffers
17456
17457 device_param->kernel_threads = kernel_threads;
17458
17459 // zero some data buffers
17460
17461 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
17462 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
17463 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
17464 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
17465 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
17466 run_kernel_bzero (device_param, device_param->d_result, size_results);
17467
17468 /**
17469 * special buffers
17470 */
17471
17472 if (attack_kern == ATTACK_KERN_STRAIGHT)
17473 {
17474 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
17475 }
17476 else if (attack_kern == ATTACK_KERN_COMBI)
17477 {
17478 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
17479 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
17480 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17481 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17482 }
17483 else if (attack_kern == ATTACK_KERN_BF)
17484 {
17485 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
17486 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
17487 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
17488 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17489 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17490 }
17491
17492 #if defined(HAVE_HWMON)
17493
17494 /**
17495 * Store initial fanspeed if gpu_temp_retain is enabled
17496 */
17497
17498 if (gpu_temp_disable == 0)
17499 {
17500 if (gpu_temp_retain != 0)
17501 {
17502 hc_thread_mutex_lock (mux_adl);
17503
17504 if (data.hm_device[device_id].fan_get_supported == 1)
17505 {
17506 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
17507 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
17508
17509 // we also set it to tell the OS we take control over the fan and it's automatic controller
17510 // if it was set to automatic. we do not control user-defined fanspeeds.
17511
17512 if (fanpolicy == 1)
17513 {
17514 data.hm_device[device_id].fan_set_supported = 1;
17515
17516 int rc = -1;
17517
17518 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17519 {
17520 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
17521 }
17522 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17523 {
17524 #ifdef __linux__
17525 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
17526 #endif
17527
17528 #ifdef WIN
17529 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
17530 #endif
17531 }
17532
17533 if (rc == 0)
17534 {
17535 data.hm_device[device_id].fan_set_supported = 1;
17536 }
17537 else
17538 {
17539 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
17540
17541 data.hm_device[device_id].fan_set_supported = 0;
17542 }
17543 }
17544 else
17545 {
17546 data.hm_device[device_id].fan_set_supported = 0;
17547 }
17548 }
17549
17550 hc_thread_mutex_unlock (mux_adl);
17551 }
17552 }
17553
17554 #endif // HAVE_HWMON
17555 }
17556
17557 if (data.quiet == 0) log_info_nn ("");
17558
17559 /**
17560 * In benchmark-mode, inform user which algorithm is checked
17561 */
17562
17563 if (benchmark == 1)
17564 {
17565 if (machine_readable == 0)
17566 {
17567 quiet = 0;
17568
17569 data.quiet = quiet;
17570
17571 char *hash_type = strhashtype (data.hash_mode); // not a bug
17572
17573 log_info ("Hashtype: %s", hash_type);
17574 log_info ("");
17575 }
17576 }
17577
17578 /**
17579 * keep track of the progress
17580 */
17581
17582 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17583 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17584 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17585
17586 /**
17587 * open filehandles
17588 */
17589
17590 #if _WIN
17591 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
17592 {
17593 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
17594
17595 return -1;
17596 }
17597
17598 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
17599 {
17600 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
17601
17602 return -1;
17603 }
17604
17605 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
17606 {
17607 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
17608
17609 return -1;
17610 }
17611 #endif
17612
17613 /**
17614 * dictionary pad
17615 */
17616
17617 segment_size *= (1024 * 1024);
17618
17619 data.segment_size = segment_size;
17620
17621 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
17622
17623 wl_data->buf = (char *) mymalloc (segment_size);
17624 wl_data->avail = segment_size;
17625 wl_data->incr = segment_size;
17626 wl_data->cnt = 0;
17627 wl_data->pos = 0;
17628
17629 cs_t *css_buf = NULL;
17630 uint css_cnt = 0;
17631 uint dictcnt = 0;
17632 uint maskcnt = 1;
17633 char **masks = NULL;
17634 char **dictfiles = NULL;
17635
17636 uint mask_from_file = 0;
17637
17638 if (attack_mode == ATTACK_MODE_STRAIGHT)
17639 {
17640 if (wordlist_mode == WL_MODE_FILE)
17641 {
17642 int wls_left = myargc - (optind + 1);
17643
17644 for (int i = 0; i < wls_left; i++)
17645 {
17646 char *l0_filename = myargv[optind + 1 + i];
17647
17648 struct stat l0_stat;
17649
17650 if (stat (l0_filename, &l0_stat) == -1)
17651 {
17652 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
17653
17654 return -1;
17655 }
17656
17657 uint is_dir = S_ISDIR (l0_stat.st_mode);
17658
17659 if (is_dir == 0)
17660 {
17661 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17662
17663 dictcnt++;
17664
17665 dictfiles[dictcnt - 1] = l0_filename;
17666 }
17667 else
17668 {
17669 // do not allow --keyspace w/ a directory
17670
17671 if (keyspace == 1)
17672 {
17673 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17674
17675 return -1;
17676 }
17677
17678 char **dictionary_files = NULL;
17679
17680 dictionary_files = scan_directory (l0_filename);
17681
17682 if (dictionary_files != NULL)
17683 {
17684 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17685
17686 for (int d = 0; dictionary_files[d] != NULL; d++)
17687 {
17688 char *l1_filename = dictionary_files[d];
17689
17690 struct stat l1_stat;
17691
17692 if (stat (l1_filename, &l1_stat) == -1)
17693 {
17694 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17695
17696 return -1;
17697 }
17698
17699 if (S_ISREG (l1_stat.st_mode))
17700 {
17701 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17702
17703 dictcnt++;
17704
17705 dictfiles[dictcnt - 1] = strdup (l1_filename);
17706 }
17707 }
17708 }
17709
17710 local_free (dictionary_files);
17711 }
17712 }
17713
17714 if (dictcnt < 1)
17715 {
17716 log_error ("ERROR: No usable dictionary file found.");
17717
17718 return -1;
17719 }
17720 }
17721 else if (wordlist_mode == WL_MODE_STDIN)
17722 {
17723 dictcnt = 1;
17724 }
17725 }
17726 else if (attack_mode == ATTACK_MODE_COMBI)
17727 {
17728 // display
17729
17730 char *dictfile1 = myargv[optind + 1 + 0];
17731 char *dictfile2 = myargv[optind + 1 + 1];
17732
17733 // find the bigger dictionary and use as base
17734
17735 FILE *fp1 = NULL;
17736 FILE *fp2 = NULL;
17737
17738 struct stat tmp_stat;
17739
17740 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
17741 {
17742 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17743
17744 return -1;
17745 }
17746
17747 if (stat (dictfile1, &tmp_stat) == -1)
17748 {
17749 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17750
17751 fclose (fp1);
17752
17753 return -1;
17754 }
17755
17756 if (S_ISDIR (tmp_stat.st_mode))
17757 {
17758 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
17759
17760 fclose (fp1);
17761
17762 return -1;
17763 }
17764
17765 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
17766 {
17767 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17768
17769 fclose (fp1);
17770
17771 return -1;
17772 }
17773
17774 if (stat (dictfile2, &tmp_stat) == -1)
17775 {
17776 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17777
17778 fclose (fp1);
17779 fclose (fp2);
17780
17781 return -1;
17782 }
17783
17784 if (S_ISDIR (tmp_stat.st_mode))
17785 {
17786 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
17787
17788 fclose (fp1);
17789 fclose (fp2);
17790
17791 return -1;
17792 }
17793
17794 data.combs_cnt = 1;
17795
17796 data.quiet = 1;
17797
17798 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
17799
17800 data.quiet = quiet;
17801
17802 if (words1_cnt == 0)
17803 {
17804 log_error ("ERROR: %s: empty file", dictfile1);
17805
17806 fclose (fp1);
17807 fclose (fp2);
17808
17809 return -1;
17810 }
17811
17812 data.combs_cnt = 1;
17813
17814 data.quiet = 1;
17815
17816 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
17817
17818 data.quiet = quiet;
17819
17820 if (words2_cnt == 0)
17821 {
17822 log_error ("ERROR: %s: empty file", dictfile2);
17823
17824 fclose (fp1);
17825 fclose (fp2);
17826
17827 return -1;
17828 }
17829
17830 fclose (fp1);
17831 fclose (fp2);
17832
17833 data.dictfile = dictfile1;
17834 data.dictfile2 = dictfile2;
17835
17836 if (words1_cnt >= words2_cnt)
17837 {
17838 data.combs_cnt = words2_cnt;
17839 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
17840
17841 dictfiles = &data.dictfile;
17842
17843 dictcnt = 1;
17844 }
17845 else
17846 {
17847 data.combs_cnt = words1_cnt;
17848 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17849
17850 dictfiles = &data.dictfile2;
17851
17852 dictcnt = 1;
17853
17854 // we also have to switch wordlist related rules!
17855
17856 char *tmpc = data.rule_buf_l;
17857
17858 data.rule_buf_l = data.rule_buf_r;
17859 data.rule_buf_r = tmpc;
17860
17861 int tmpi = data.rule_len_l;
17862
17863 data.rule_len_l = data.rule_len_r;
17864 data.rule_len_r = tmpi;
17865 }
17866 }
17867 else if (attack_mode == ATTACK_MODE_BF)
17868 {
17869 char *mask = NULL;
17870
17871 maskcnt = 0;
17872
17873 if (benchmark == 0)
17874 {
17875 mask = myargv[optind + 1];
17876
17877 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
17878
17879 if ((optind + 2) <= myargc)
17880 {
17881 struct stat file_stat;
17882
17883 if (stat (mask, &file_stat) == -1)
17884 {
17885 maskcnt = 1;
17886
17887 masks[maskcnt - 1] = mystrdup (mask);
17888 }
17889 else
17890 {
17891 int wls_left = myargc - (optind + 1);
17892
17893 uint masks_avail = INCR_MASKS;
17894
17895 for (int i = 0; i < wls_left; i++)
17896 {
17897 if (i != 0)
17898 {
17899 mask = myargv[optind + 1 + i];
17900
17901 if (stat (mask, &file_stat) == -1)
17902 {
17903 log_error ("ERROR: %s: %s", mask, strerror (errno));
17904
17905 return -1;
17906 }
17907 }
17908
17909 uint is_file = S_ISREG (file_stat.st_mode);
17910
17911 if (is_file == 1)
17912 {
17913 FILE *mask_fp;
17914
17915 if ((mask_fp = fopen (mask, "r")) == NULL)
17916 {
17917 log_error ("ERROR: %s: %s", mask, strerror (errno));
17918
17919 return -1;
17920 }
17921
17922 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17923
17924 while (!feof (mask_fp))
17925 {
17926 memset (line_buf, 0, HCBUFSIZ);
17927
17928 int line_len = fgetl (mask_fp, line_buf);
17929
17930 if (line_len == 0) continue;
17931
17932 if (line_buf[0] == '#') continue;
17933
17934 if (masks_avail == maskcnt)
17935 {
17936 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17937
17938 masks_avail += INCR_MASKS;
17939 }
17940
17941 masks[maskcnt] = mystrdup (line_buf);
17942
17943 maskcnt++;
17944 }
17945
17946 myfree (line_buf);
17947
17948 fclose (mask_fp);
17949 }
17950 else
17951 {
17952 log_error ("ERROR: %s: unsupported file-type", mask);
17953
17954 return -1;
17955 }
17956 }
17957
17958 mask_from_file = 1;
17959 }
17960 }
17961 else
17962 {
17963 custom_charset_1 = (char *) "?l?d?u";
17964 custom_charset_2 = (char *) "?l?d";
17965 custom_charset_3 = (char *) "?l?d*!$@_";
17966
17967 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17968 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17969 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17970
17971 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
17972
17973 wordlist_mode = WL_MODE_MASK;
17974
17975 data.wordlist_mode = wordlist_mode;
17976
17977 increment = 1;
17978
17979 maskcnt = 1;
17980 }
17981 }
17982 else
17983 {
17984 /**
17985 * generate full masks and charsets
17986 */
17987
17988 masks = (char **) mymalloc (sizeof (char *));
17989
17990 switch (hash_mode)
17991 {
17992 case 1731: pw_min = 5;
17993 pw_max = 5;
17994 mask = mystrdup ("?b?b?b?b?b");
17995 break;
17996 case 12500: pw_min = 5;
17997 pw_max = 5;
17998 mask = mystrdup ("?b?b?b?b?b");
17999 break;
18000 default: pw_min = 7;
18001 pw_max = 7;
18002 mask = mystrdup ("?b?b?b?b?b?b?b");
18003 break;
18004 }
18005
18006 maskcnt = 1;
18007
18008 masks[maskcnt - 1] = mystrdup (mask);
18009
18010 wordlist_mode = WL_MODE_MASK;
18011
18012 data.wordlist_mode = wordlist_mode;
18013
18014 increment = 1;
18015 }
18016
18017 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
18018
18019 if (increment)
18020 {
18021 if (increment_min > pw_min) pw_min = increment_min;
18022
18023 if (increment_max < pw_max) pw_max = increment_max;
18024 }
18025 }
18026 else if (attack_mode == ATTACK_MODE_HYBRID1)
18027 {
18028 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
18029
18030 // display
18031
18032 char *mask = myargv[myargc - 1];
18033
18034 maskcnt = 0;
18035
18036 masks = (char **) mymalloc (1 * sizeof (char *));
18037
18038 // mod
18039
18040 struct stat file_stat;
18041
18042 if (stat (mask, &file_stat) == -1)
18043 {
18044 maskcnt = 1;
18045
18046 masks[maskcnt - 1] = mystrdup (mask);
18047 }
18048 else
18049 {
18050 uint is_file = S_ISREG (file_stat.st_mode);
18051
18052 if (is_file == 1)
18053 {
18054 FILE *mask_fp;
18055
18056 if ((mask_fp = fopen (mask, "r")) == NULL)
18057 {
18058 log_error ("ERROR: %s: %s", mask, strerror (errno));
18059
18060 return -1;
18061 }
18062
18063 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18064
18065 uint masks_avail = 1;
18066
18067 while (!feof (mask_fp))
18068 {
18069 memset (line_buf, 0, HCBUFSIZ);
18070
18071 int line_len = fgetl (mask_fp, line_buf);
18072
18073 if (line_len == 0) continue;
18074
18075 if (line_buf[0] == '#') continue;
18076
18077 if (masks_avail == maskcnt)
18078 {
18079 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18080
18081 masks_avail += INCR_MASKS;
18082 }
18083
18084 masks[maskcnt] = mystrdup (line_buf);
18085
18086 maskcnt++;
18087 }
18088
18089 myfree (line_buf);
18090
18091 fclose (mask_fp);
18092
18093 mask_from_file = 1;
18094 }
18095 else
18096 {
18097 maskcnt = 1;
18098
18099 masks[maskcnt - 1] = mystrdup (mask);
18100 }
18101 }
18102
18103 // base
18104
18105 int wls_left = myargc - (optind + 2);
18106
18107 for (int i = 0; i < wls_left; i++)
18108 {
18109 char *filename = myargv[optind + 1 + i];
18110
18111 struct stat file_stat;
18112
18113 if (stat (filename, &file_stat) == -1)
18114 {
18115 log_error ("ERROR: %s: %s", filename, strerror (errno));
18116
18117 return -1;
18118 }
18119
18120 uint is_dir = S_ISDIR (file_stat.st_mode);
18121
18122 if (is_dir == 0)
18123 {
18124 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18125
18126 dictcnt++;
18127
18128 dictfiles[dictcnt - 1] = filename;
18129 }
18130 else
18131 {
18132 // do not allow --keyspace w/ a directory
18133
18134 if (keyspace == 1)
18135 {
18136 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18137
18138 return -1;
18139 }
18140
18141 char **dictionary_files = NULL;
18142
18143 dictionary_files = scan_directory (filename);
18144
18145 if (dictionary_files != NULL)
18146 {
18147 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18148
18149 for (int d = 0; dictionary_files[d] != NULL; d++)
18150 {
18151 char *l1_filename = dictionary_files[d];
18152
18153 struct stat l1_stat;
18154
18155 if (stat (l1_filename, &l1_stat) == -1)
18156 {
18157 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18158
18159 return -1;
18160 }
18161
18162 if (S_ISREG (l1_stat.st_mode))
18163 {
18164 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18165
18166 dictcnt++;
18167
18168 dictfiles[dictcnt - 1] = strdup (l1_filename);
18169 }
18170 }
18171 }
18172
18173 local_free (dictionary_files);
18174 }
18175 }
18176
18177 if (dictcnt < 1)
18178 {
18179 log_error ("ERROR: No usable dictionary file found.");
18180
18181 return -1;
18182 }
18183
18184 if (increment)
18185 {
18186 maskcnt = 0;
18187
18188 uint mask_min = increment_min; // we can't reject smaller masks here
18189 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18190
18191 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18192 {
18193 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18194
18195 if (cur_mask == NULL) break;
18196
18197 masks[maskcnt] = cur_mask;
18198
18199 maskcnt++;
18200
18201 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18202 }
18203 }
18204 }
18205 else if (attack_mode == ATTACK_MODE_HYBRID2)
18206 {
18207 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
18208
18209 // display
18210
18211 char *mask = myargv[optind + 1 + 0];
18212
18213 maskcnt = 0;
18214
18215 masks = (char **) mymalloc (1 * sizeof (char *));
18216
18217 // mod
18218
18219 struct stat file_stat;
18220
18221 if (stat (mask, &file_stat) == -1)
18222 {
18223 maskcnt = 1;
18224
18225 masks[maskcnt - 1] = mystrdup (mask);
18226 }
18227 else
18228 {
18229 uint is_file = S_ISREG (file_stat.st_mode);
18230
18231 if (is_file == 1)
18232 {
18233 FILE *mask_fp;
18234
18235 if ((mask_fp = fopen (mask, "r")) == NULL)
18236 {
18237 log_error ("ERROR: %s: %s", mask, strerror (errno));
18238
18239 return -1;
18240 }
18241
18242 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18243
18244 uint masks_avail = 1;
18245
18246 while (!feof (mask_fp))
18247 {
18248 memset (line_buf, 0, HCBUFSIZ);
18249
18250 int line_len = fgetl (mask_fp, line_buf);
18251
18252 if (line_len == 0) continue;
18253
18254 if (line_buf[0] == '#') continue;
18255
18256 if (masks_avail == maskcnt)
18257 {
18258 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18259
18260 masks_avail += INCR_MASKS;
18261 }
18262
18263 masks[maskcnt] = mystrdup (line_buf);
18264
18265 maskcnt++;
18266 }
18267
18268 myfree (line_buf);
18269
18270 fclose (mask_fp);
18271
18272 mask_from_file = 1;
18273 }
18274 else
18275 {
18276 maskcnt = 1;
18277
18278 masks[maskcnt - 1] = mystrdup (mask);
18279 }
18280 }
18281
18282 // base
18283
18284 int wls_left = myargc - (optind + 2);
18285
18286 for (int i = 0; i < wls_left; i++)
18287 {
18288 char *filename = myargv[optind + 2 + i];
18289
18290 struct stat file_stat;
18291
18292 if (stat (filename, &file_stat) == -1)
18293 {
18294 log_error ("ERROR: %s: %s", filename, strerror (errno));
18295
18296 return -1;
18297 }
18298
18299 uint is_dir = S_ISDIR (file_stat.st_mode);
18300
18301 if (is_dir == 0)
18302 {
18303 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18304
18305 dictcnt++;
18306
18307 dictfiles[dictcnt - 1] = filename;
18308 }
18309 else
18310 {
18311 // do not allow --keyspace w/ a directory
18312
18313 if (keyspace == 1)
18314 {
18315 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18316
18317 return -1;
18318 }
18319
18320 char **dictionary_files = NULL;
18321
18322 dictionary_files = scan_directory (filename);
18323
18324 if (dictionary_files != NULL)
18325 {
18326 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18327
18328 for (int d = 0; dictionary_files[d] != NULL; d++)
18329 {
18330 char *l1_filename = dictionary_files[d];
18331
18332 struct stat l1_stat;
18333
18334 if (stat (l1_filename, &l1_stat) == -1)
18335 {
18336 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18337
18338 return -1;
18339 }
18340
18341 if (S_ISREG (l1_stat.st_mode))
18342 {
18343 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18344
18345 dictcnt++;
18346
18347 dictfiles[dictcnt - 1] = strdup (l1_filename);
18348 }
18349 }
18350 }
18351
18352 local_free (dictionary_files);
18353 }
18354 }
18355
18356 if (dictcnt < 1)
18357 {
18358 log_error ("ERROR: No usable dictionary file found.");
18359
18360 return -1;
18361 }
18362
18363 if (increment)
18364 {
18365 maskcnt = 0;
18366
18367 uint mask_min = increment_min; // we can't reject smaller masks here
18368 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18369
18370 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18371 {
18372 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18373
18374 if (cur_mask == NULL) break;
18375
18376 masks[maskcnt] = cur_mask;
18377
18378 maskcnt++;
18379
18380 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18381 }
18382 }
18383 }
18384
18385 data.pw_min = pw_min;
18386 data.pw_max = pw_max;
18387
18388 /**
18389 * weak hash check
18390 */
18391
18392 if (weak_hash_threshold >= salts_cnt)
18393 {
18394 hc_device_param_t *device_param = NULL;
18395
18396 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18397 {
18398 device_param = &data.devices_param[device_id];
18399
18400 if (device_param->skipped) continue;
18401
18402 break;
18403 }
18404
18405 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
18406
18407 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
18408 {
18409 weak_hash_check (device_param, salt_pos);
18410 }
18411
18412 // Display hack, guarantee that there is at least one \r before real start
18413
18414 //if (data.quiet == 0) log_info ("");
18415 }
18416
18417 /**
18418 * status and monitor threads
18419 */
18420
18421 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18422 {
18423 data.devices_status = STATUS_STARTING;
18424 }
18425
18426 uint inner_threads_cnt = 0;
18427
18428 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
18429
18430 data.shutdown_inner = 0;
18431
18432 /**
18433 * Outfile remove
18434 */
18435
18436 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
18437 {
18438 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
18439
18440 inner_threads_cnt++;
18441
18442 if (outfile_check_timer != 0)
18443 {
18444 if (data.outfile_check_directory != NULL)
18445 {
18446 if ((hash_mode != 5200) &&
18447 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
18448 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
18449 (hash_mode != 9000))
18450 {
18451 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
18452
18453 inner_threads_cnt++;
18454 }
18455 else
18456 {
18457 outfile_check_timer = 0;
18458 }
18459 }
18460 else
18461 {
18462 outfile_check_timer = 0;
18463 }
18464 }
18465 }
18466
18467 /**
18468 * Inform the user if we got some hashes remove because of the pot file remove feature
18469 */
18470
18471 if (data.quiet == 0)
18472 {
18473 if (potfile_remove_cracks > 0)
18474 {
18475 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
18476 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
18477 }
18478 }
18479
18480 data.outfile_check_timer = outfile_check_timer;
18481
18482 /**
18483 * main loop
18484 */
18485
18486 char **induction_dictionaries = NULL;
18487
18488 int induction_dictionaries_cnt = 0;
18489
18490 hcstat_table_t *root_table_buf = NULL;
18491 hcstat_table_t *markov_table_buf = NULL;
18492
18493 uint initial_restore_done = 0;
18494
18495 data.maskcnt = maskcnt;
18496
18497 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
18498 {
18499 if (data.devices_status == STATUS_CRACKED) continue;
18500 if (data.devices_status == STATUS_ABORTED) continue;
18501 if (data.devices_status == STATUS_QUIT) continue;
18502
18503 if (maskpos > rd->maskpos)
18504 {
18505 rd->dictpos = 0;
18506 }
18507
18508 rd->maskpos = maskpos;
18509 data.maskpos = maskpos;
18510
18511 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
18512 {
18513 char *mask = masks[maskpos];
18514
18515 if (mask_from_file == 1)
18516 {
18517 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
18518
18519 char *str_ptr;
18520 uint str_pos;
18521
18522 uint mask_offset = 0;
18523
18524 uint separator_cnt;
18525
18526 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
18527 {
18528 str_ptr = strstr (mask + mask_offset, ",");
18529
18530 if (str_ptr == NULL) break;
18531
18532 str_pos = str_ptr - mask;
18533
18534 // escaped separator, i.e. "\,"
18535
18536 if (str_pos > 0)
18537 {
18538 if (mask[str_pos - 1] == '\\')
18539 {
18540 separator_cnt --;
18541
18542 mask_offset = str_pos + 1;
18543
18544 continue;
18545 }
18546 }
18547
18548 // reset the offset
18549
18550 mask_offset = 0;
18551
18552 mask[str_pos] = '\0';
18553
18554 switch (separator_cnt)
18555 {
18556 case 0:
18557 mp_reset_usr (mp_usr, 0);
18558
18559 custom_charset_1 = mask;
18560 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
18561 break;
18562
18563 case 1:
18564 mp_reset_usr (mp_usr, 1);
18565
18566 custom_charset_2 = mask;
18567 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
18568 break;
18569
18570 case 2:
18571 mp_reset_usr (mp_usr, 2);
18572
18573 custom_charset_3 = mask;
18574 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
18575 break;
18576
18577 case 3:
18578 mp_reset_usr (mp_usr, 3);
18579
18580 custom_charset_4 = mask;
18581 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
18582 break;
18583 }
18584
18585 mask = mask + str_pos + 1;
18586 }
18587
18588 /**
18589 * 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 "\")
18590 * it would be interpreted as a custom charset definition.
18591 *
18592 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
18593 * 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 ","
18594 */
18595
18596 uint mask_len_cur = strlen (mask);
18597
18598 uint mask_out_pos = 0;
18599 char mask_prev = 0;
18600
18601 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
18602 {
18603 if (mask[mask_iter] == ',')
18604 {
18605 if (mask_prev == '\\')
18606 {
18607 mask_out_pos -= 1; // this means: skip the previous "\"
18608 }
18609 }
18610
18611 mask_prev = mask[mask_iter];
18612
18613 mask[mask_out_pos] = mask[mask_iter];
18614 }
18615
18616 mask[mask_out_pos] = '\0';
18617 }
18618
18619 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18620 {
18621 if (maskpos > 0)
18622 {
18623 local_free (css_buf);
18624 local_free (data.root_css_buf);
18625 local_free (data.markov_css_buf);
18626
18627 local_free (masks[maskpos - 1]);
18628 }
18629
18630 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18631
18632 data.mask = mask;
18633 data.css_cnt = css_cnt;
18634 data.css_buf = css_buf;
18635
18636 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18637
18638 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18639
18640 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
18641 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18642
18643 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18644
18645 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18646
18647 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18648 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18649
18650 data.root_css_buf = root_css_buf;
18651 data.markov_css_buf = markov_css_buf;
18652
18653 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18654
18655 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18656
18657 local_free (root_table_buf);
18658 local_free (markov_table_buf);
18659
18660 // args
18661
18662 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18663 {
18664 hc_device_param_t *device_param = &data.devices_param[device_id];
18665
18666 if (device_param->skipped) continue;
18667
18668 device_param->kernel_params_mp[0] = &device_param->d_combs;
18669 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
18670 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
18671
18672 device_param->kernel_params_mp_buf64[3] = 0;
18673 device_param->kernel_params_mp_buf32[4] = css_cnt;
18674 device_param->kernel_params_mp_buf32[5] = 0;
18675 device_param->kernel_params_mp_buf32[6] = 0;
18676 device_param->kernel_params_mp_buf32[7] = 0;
18677
18678 if (attack_mode == ATTACK_MODE_HYBRID1)
18679 {
18680 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
18681 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
18682 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
18683 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
18684 }
18685 else if (attack_mode == ATTACK_MODE_HYBRID2)
18686 {
18687 device_param->kernel_params_mp_buf32[5] = 0;
18688 device_param->kernel_params_mp_buf32[6] = 0;
18689 device_param->kernel_params_mp_buf32[7] = 0;
18690 }
18691
18692 cl_int CL_err = CL_SUCCESS;
18693
18694 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]);
18695 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]);
18696 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]);
18697
18698 if (CL_err != CL_SUCCESS)
18699 {
18700 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
18701
18702 return -1;
18703 }
18704
18705 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);
18706 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);
18707
18708 if (CL_err != CL_SUCCESS)
18709 {
18710 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
18711
18712 return -1;
18713 }
18714 }
18715 }
18716 else if (attack_mode == ATTACK_MODE_BF)
18717 {
18718 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
18719
18720 if (increment)
18721 {
18722 for (uint i = 0; i < dictcnt; i++)
18723 {
18724 local_free (dictfiles[i]);
18725 }
18726
18727 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
18728 {
18729 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
18730
18731 if (l1_filename == NULL) break;
18732
18733 dictcnt++;
18734
18735 dictfiles[dictcnt - 1] = l1_filename;
18736 }
18737 }
18738 else
18739 {
18740 dictcnt++;
18741
18742 dictfiles[dictcnt - 1] = mask;
18743 }
18744
18745 if (dictcnt == 0)
18746 {
18747 log_error ("ERROR: Mask is too small");
18748
18749 return -1;
18750 }
18751 }
18752 }
18753
18754 free (induction_dictionaries);
18755
18756 // induction_dictionaries_cnt = 0; // implied
18757
18758 if (attack_mode != ATTACK_MODE_BF)
18759 {
18760 if (keyspace == 0)
18761 {
18762 induction_dictionaries = scan_directory (induction_directory);
18763
18764 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18765 }
18766 }
18767
18768 if (induction_dictionaries_cnt)
18769 {
18770 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18771 }
18772
18773 /**
18774 * prevent the user from using --keyspace together w/ maskfile and or dictfile
18775 */
18776 if (keyspace == 1)
18777 {
18778 if ((maskcnt > 1) || (dictcnt > 1))
18779 {
18780 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
18781
18782 return -1;
18783 }
18784 }
18785
18786 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
18787 {
18788 if (data.devices_status == STATUS_CRACKED) continue;
18789 if (data.devices_status == STATUS_ABORTED) continue;
18790 if (data.devices_status == STATUS_QUIT) continue;
18791
18792 rd->dictpos = dictpos;
18793
18794 char *subid = logfile_generate_subid ();
18795
18796 data.subid = subid;
18797
18798 logfile_sub_msg ("START");
18799
18800 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18801 {
18802 data.devices_status = STATUS_INIT;
18803 }
18804
18805 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
18806 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
18807 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
18808
18809 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
18810
18811 data.cpt_pos = 0;
18812
18813 data.cpt_start = time (NULL);
18814
18815 data.cpt_total = 0;
18816
18817 if (data.restore == 0)
18818 {
18819 rd->words_cur = skip;
18820
18821 skip = 0;
18822
18823 data.skip = 0;
18824 }
18825
18826 data.ms_paused = 0;
18827
18828 data.kernel_power_final = 0;
18829
18830 data.words_cur = rd->words_cur;
18831
18832 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18833 {
18834 hc_device_param_t *device_param = &data.devices_param[device_id];
18835
18836 if (device_param->skipped) continue;
18837
18838 device_param->speed_pos = 0;
18839
18840 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
18841 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
18842
18843 device_param->exec_pos = 0;
18844
18845 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
18846
18847 device_param->outerloop_pos = 0;
18848 device_param->outerloop_left = 0;
18849 device_param->innerloop_pos = 0;
18850 device_param->innerloop_left = 0;
18851
18852 // some more resets:
18853
18854 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
18855
18856 device_param->pws_cnt = 0;
18857
18858 device_param->words_off = 0;
18859 device_param->words_done = 0;
18860 }
18861
18862 // figure out some workload
18863
18864 if (attack_mode == ATTACK_MODE_STRAIGHT)
18865 {
18866 if (data.wordlist_mode == WL_MODE_FILE)
18867 {
18868 char *dictfile = NULL;
18869
18870 if (induction_dictionaries_cnt)
18871 {
18872 dictfile = induction_dictionaries[0];
18873 }
18874 else
18875 {
18876 dictfile = dictfiles[dictpos];
18877 }
18878
18879 data.dictfile = dictfile;
18880
18881 logfile_sub_string (dictfile);
18882
18883 for (uint i = 0; i < rp_files_cnt; i++)
18884 {
18885 logfile_sub_var_string ("rulefile", rp_files[i]);
18886 }
18887
18888 FILE *fd2 = fopen (dictfile, "rb");
18889
18890 if (fd2 == NULL)
18891 {
18892 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18893
18894 return -1;
18895 }
18896
18897 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18898
18899 fclose (fd2);
18900
18901 if (data.words_cnt == 0)
18902 {
18903 logfile_sub_msg ("STOP");
18904
18905 continue;
18906 }
18907 }
18908 }
18909 else if (attack_mode == ATTACK_MODE_COMBI)
18910 {
18911 char *dictfile = data.dictfile;
18912 char *dictfile2 = data.dictfile2;
18913
18914 logfile_sub_string (dictfile);
18915 logfile_sub_string (dictfile2);
18916
18917 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
18918 {
18919 FILE *fd2 = fopen (dictfile, "rb");
18920
18921 if (fd2 == NULL)
18922 {
18923 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18924
18925 return -1;
18926 }
18927
18928 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18929
18930 fclose (fd2);
18931 }
18932 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
18933 {
18934 FILE *fd2 = fopen (dictfile2, "rb");
18935
18936 if (fd2 == NULL)
18937 {
18938 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
18939
18940 return -1;
18941 }
18942
18943 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
18944
18945 fclose (fd2);
18946 }
18947
18948 if (data.words_cnt == 0)
18949 {
18950 logfile_sub_msg ("STOP");
18951
18952 continue;
18953 }
18954 }
18955 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18956 {
18957 char *dictfile = NULL;
18958
18959 if (induction_dictionaries_cnt)
18960 {
18961 dictfile = induction_dictionaries[0];
18962 }
18963 else
18964 {
18965 dictfile = dictfiles[dictpos];
18966 }
18967
18968 data.dictfile = dictfile;
18969
18970 char *mask = data.mask;
18971
18972 logfile_sub_string (dictfile);
18973 logfile_sub_string (mask);
18974
18975 FILE *fd2 = fopen (dictfile, "rb");
18976
18977 if (fd2 == NULL)
18978 {
18979 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18980
18981 return -1;
18982 }
18983
18984 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18985
18986 fclose (fd2);
18987
18988 if (data.words_cnt == 0)
18989 {
18990 logfile_sub_msg ("STOP");
18991
18992 continue;
18993 }
18994 }
18995 else if (attack_mode == ATTACK_MODE_BF)
18996 {
18997 local_free (css_buf);
18998 local_free (data.root_css_buf);
18999 local_free (data.markov_css_buf);
19000
19001 char *mask = dictfiles[dictpos];
19002
19003 logfile_sub_string (mask);
19004
19005 // base
19006
19007 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
19008
19009 if (opts_type & OPTS_TYPE_PT_UNICODE)
19010 {
19011 uint css_cnt_unicode = css_cnt * 2;
19012
19013 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
19014
19015 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
19016 {
19017 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
19018
19019 css_buf_unicode[j + 1].cs_buf[0] = 0;
19020 css_buf_unicode[j + 1].cs_len = 1;
19021 }
19022
19023 free (css_buf);
19024
19025 css_buf = css_buf_unicode;
19026 css_cnt = css_cnt_unicode;
19027 }
19028
19029 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
19030
19031 uint mask_min = pw_min;
19032 uint mask_max = pw_max;
19033
19034 if (opts_type & OPTS_TYPE_PT_UNICODE)
19035 {
19036 mask_min *= 2;
19037 mask_max *= 2;
19038 }
19039
19040 if ((css_cnt < mask_min) || (css_cnt > mask_max))
19041 {
19042 if (css_cnt < mask_min)
19043 {
19044 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
19045 }
19046
19047 if (css_cnt > mask_max)
19048 {
19049 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
19050 }
19051
19052 // skip to next mask
19053
19054 logfile_sub_msg ("STOP");
19055
19056 continue;
19057 }
19058
19059 uint save_css_cnt = css_cnt;
19060
19061 if (opti_type & OPTI_TYPE_SINGLE_HASH)
19062 {
19063 if (opti_type & OPTI_TYPE_APPENDED_SALT)
19064 {
19065 uint salt_len = (uint) data.salts_buf[0].salt_len;
19066 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
19067
19068 uint css_cnt_salt = css_cnt + salt_len;
19069
19070 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
19071
19072 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
19073
19074 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
19075 {
19076 css_buf_salt[j].cs_buf[0] = salt_buf[i];
19077 css_buf_salt[j].cs_len = 1;
19078 }
19079
19080 free (css_buf);
19081
19082 css_buf = css_buf_salt;
19083 css_cnt = css_cnt_salt;
19084 }
19085 }
19086
19087 data.mask = mask;
19088 data.css_cnt = css_cnt;
19089 data.css_buf = css_buf;
19090
19091 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
19092
19093 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
19094
19095 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
19096
19097 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
19098 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
19099
19100 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
19101
19102 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
19103
19104 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
19105 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
19106
19107 data.root_css_buf = root_css_buf;
19108 data.markov_css_buf = markov_css_buf;
19109
19110 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
19111
19112 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
19113
19114 local_free (root_table_buf);
19115 local_free (markov_table_buf);
19116
19117 // copy + args
19118
19119 uint css_cnt_l = css_cnt;
19120 uint css_cnt_r;
19121
19122 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
19123 {
19124 if (save_css_cnt < 6)
19125 {
19126 css_cnt_r = 1;
19127 }
19128 else if (save_css_cnt == 6)
19129 {
19130 css_cnt_r = 2;
19131 }
19132 else
19133 {
19134 if (opts_type & OPTS_TYPE_PT_UNICODE)
19135 {
19136 if (save_css_cnt == 8 || save_css_cnt == 10)
19137 {
19138 css_cnt_r = 2;
19139 }
19140 else
19141 {
19142 css_cnt_r = 4;
19143 }
19144 }
19145 else
19146 {
19147 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
19148 {
19149 css_cnt_r = 3;
19150 }
19151 else
19152 {
19153 css_cnt_r = 4;
19154 }
19155 }
19156 }
19157 }
19158 else
19159 {
19160 css_cnt_r = 1;
19161
19162 /* unfinished code?
19163 int sum = css_buf[css_cnt_r - 1].cs_len;
19164
19165 for (uint i = 1; i < 4 && i < css_cnt; i++)
19166 {
19167 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
19168
19169 css_cnt_r++;
19170
19171 sum *= css_buf[css_cnt_r - 1].cs_len;
19172 }
19173 */
19174 }
19175
19176 css_cnt_l -= css_cnt_r;
19177
19178 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
19179
19180 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19181 {
19182 hc_device_param_t *device_param = &data.devices_param[device_id];
19183
19184 if (device_param->skipped) continue;
19185
19186 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
19187 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
19188 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
19189
19190 device_param->kernel_params_mp_l_buf64[3] = 0;
19191 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
19192 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
19193 device_param->kernel_params_mp_l_buf32[6] = 0;
19194 device_param->kernel_params_mp_l_buf32[7] = 0;
19195 device_param->kernel_params_mp_l_buf32[8] = 0;
19196
19197 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
19198 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
19199 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
19200 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
19201
19202 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
19203 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
19204 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
19205
19206 device_param->kernel_params_mp_r_buf64[3] = 0;
19207 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
19208 device_param->kernel_params_mp_r_buf32[5] = 0;
19209 device_param->kernel_params_mp_r_buf32[6] = 0;
19210 device_param->kernel_params_mp_r_buf32[7] = 0;
19211
19212 cl_int CL_err = CL_SUCCESS;
19213
19214 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]);
19215 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]);
19216 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]);
19217
19218 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]);
19219 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]);
19220 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]);
19221
19222 if (CL_err != CL_SUCCESS)
19223 {
19224 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
19225
19226 return -1;
19227 }
19228
19229 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);
19230 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);
19231
19232 if (CL_err != CL_SUCCESS)
19233 {
19234 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
19235
19236 return -1;
19237 }
19238 }
19239 }
19240
19241 u64 words_base = data.words_cnt;
19242
19243 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19244 {
19245 if (data.kernel_rules_cnt)
19246 {
19247 words_base /= data.kernel_rules_cnt;
19248 }
19249 }
19250 else if (data.attack_kern == ATTACK_KERN_COMBI)
19251 {
19252 if (data.combs_cnt)
19253 {
19254 words_base /= data.combs_cnt;
19255 }
19256 }
19257 else if (data.attack_kern == ATTACK_KERN_BF)
19258 {
19259 if (data.bfs_cnt)
19260 {
19261 words_base /= data.bfs_cnt;
19262 }
19263 }
19264
19265 data.words_base = words_base;
19266
19267 if (keyspace == 1)
19268 {
19269 log_info ("%llu", (unsigned long long int) words_base);
19270
19271 return 0;
19272 }
19273
19274 if (data.words_cur > data.words_base)
19275 {
19276 log_error ("ERROR: Restore value greater keyspace");
19277
19278 return -1;
19279 }
19280
19281 if (data.words_cur)
19282 {
19283 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19284 {
19285 for (uint i = 0; i < data.salts_cnt; i++)
19286 {
19287 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
19288 }
19289 }
19290 else if (data.attack_kern == ATTACK_KERN_COMBI)
19291 {
19292 for (uint i = 0; i < data.salts_cnt; i++)
19293 {
19294 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
19295 }
19296 }
19297 else if (data.attack_kern == ATTACK_KERN_BF)
19298 {
19299 for (uint i = 0; i < data.salts_cnt; i++)
19300 {
19301 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
19302 }
19303 }
19304 }
19305
19306 /*
19307 * Update loopback file
19308 */
19309
19310 if (loopback == 1)
19311 {
19312 time_t now;
19313
19314 time (&now);
19315
19316 uint random_num = get_random_num (0, 9999);
19317
19318 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
19319
19320 data.loopback_file = loopback_file;
19321 }
19322
19323 /*
19324 * Update dictionary statistic
19325 */
19326
19327 if (keyspace == 0)
19328 {
19329 dictstat_fp = fopen (dictstat, "wb");
19330
19331 if (dictstat_fp)
19332 {
19333 lock_file (dictstat_fp);
19334
19335 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
19336
19337 fclose (dictstat_fp);
19338 }
19339 }
19340
19341 /**
19342 * create autotune threads
19343 */
19344
19345 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
19346
19347 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19348 {
19349 data.devices_status = STATUS_AUTOTUNE;
19350 }
19351
19352 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19353 {
19354 hc_device_param_t *device_param = &devices_param[device_id];
19355
19356 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
19357 }
19358
19359 hc_thread_wait (data.devices_cnt, c_threads);
19360
19361 /*
19362 * Inform user about possible slow speeds
19363 */
19364
19365 uint hardware_power_all = 0;
19366
19367 uint kernel_power_all = 0;
19368
19369 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19370 {
19371 hc_device_param_t *device_param = &devices_param[device_id];
19372
19373 hardware_power_all += device_param->hardware_power;
19374
19375 kernel_power_all += device_param->kernel_power;
19376 }
19377
19378 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
19379
19380 data.kernel_power_all = kernel_power_all;
19381
19382 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19383 {
19384 if (data.words_base < kernel_power_all)
19385 {
19386 if (quiet == 0)
19387 {
19388 clear_prompt ();
19389
19390 log_info ("ATTENTION!");
19391 log_info (" The wordlist or mask you are using is too small.");
19392 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
19393 log_info (" The cracking speed will drop.");
19394 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
19395 log_info ("");
19396 }
19397 }
19398 }
19399
19400 /**
19401 * create cracker threads
19402 */
19403
19404 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19405 {
19406 data.devices_status = STATUS_RUNNING;
19407 }
19408
19409 if (initial_restore_done == 0)
19410 {
19411 if (data.restore_disable == 0) cycle_restore ();
19412
19413 initial_restore_done = 1;
19414 }
19415
19416 hc_timer_set (&data.timer_running);
19417
19418 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19419 {
19420 if ((quiet == 0) && (status == 0) && (benchmark == 0))
19421 {
19422 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
19423 if (quiet == 0) fflush (stdout);
19424 }
19425 }
19426 else if (wordlist_mode == WL_MODE_STDIN)
19427 {
19428 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
19429 if (data.quiet == 0) log_info ("");
19430 }
19431
19432 time_t runtime_start;
19433
19434 time (&runtime_start);
19435
19436 data.runtime_start = runtime_start;
19437
19438 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19439 {
19440 hc_device_param_t *device_param = &devices_param[device_id];
19441
19442 if (wordlist_mode == WL_MODE_STDIN)
19443 {
19444 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
19445 }
19446 else
19447 {
19448 hc_thread_create (c_threads[device_id], thread_calc, device_param);
19449 }
19450 }
19451
19452 hc_thread_wait (data.devices_cnt, c_threads);
19453
19454 local_free (c_threads);
19455
19456 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19457 {
19458 data.devices_status = STATUS_EXHAUSTED;
19459 }
19460
19461 logfile_sub_var_uint ("status-after-work", data.devices_status);
19462
19463 data.restore = 0;
19464
19465 if (induction_dictionaries_cnt)
19466 {
19467 unlink (induction_dictionaries[0]);
19468 }
19469
19470 free (induction_dictionaries);
19471
19472 if (attack_mode != ATTACK_MODE_BF)
19473 {
19474 induction_dictionaries = scan_directory (induction_directory);
19475
19476 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
19477 }
19478
19479 if (benchmark == 1)
19480 {
19481 status_benchmark ();
19482
19483 if (machine_readable == 0)
19484 {
19485 log_info ("");
19486 }
19487 }
19488 else
19489 {
19490 if (quiet == 0)
19491 {
19492 clear_prompt ();
19493
19494 log_info ("");
19495
19496 status_display ();
19497
19498 log_info ("");
19499 }
19500 else
19501 {
19502 if (status == 1)
19503 {
19504 status_display ();
19505 }
19506 }
19507 }
19508
19509 if (induction_dictionaries_cnt)
19510 {
19511 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
19512
19513 // 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)
19514
19515 dictpos--;
19516 }
19517
19518 time_t runtime_stop;
19519
19520 time (&runtime_stop);
19521
19522 data.runtime_stop = runtime_stop;
19523
19524 logfile_sub_uint (runtime_start);
19525 logfile_sub_uint (runtime_stop);
19526
19527 logfile_sub_msg ("STOP");
19528
19529 global_free (subid);
19530
19531 // from this point we handle bypass as running
19532
19533 if (data.devices_status == STATUS_BYPASS)
19534 {
19535 data.devices_status = STATUS_RUNNING;
19536 }
19537
19538 // and overwrite benchmark aborts as well
19539
19540 if (data.benchmark == 1)
19541 {
19542 if (data.devices_status == STATUS_ABORTED)
19543 {
19544 data.devices_status = STATUS_RUNNING;
19545 }
19546 }
19547
19548 // finalize task
19549
19550 if (data.devices_status == STATUS_CRACKED) break;
19551 if (data.devices_status == STATUS_ABORTED) break;
19552 if (data.devices_status == STATUS_QUIT) break;
19553 }
19554
19555 if (data.devices_status == STATUS_CRACKED) break;
19556 if (data.devices_status == STATUS_ABORTED) break;
19557 if (data.devices_status == STATUS_QUIT) break;
19558 }
19559
19560 // 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
19561 if (attack_mode == ATTACK_MODE_STRAIGHT)
19562 {
19563 if (data.wordlist_mode == WL_MODE_FILE)
19564 {
19565 if (data.dictfile == NULL)
19566 {
19567 if (dictfiles != NULL)
19568 {
19569 data.dictfile = dictfiles[0];
19570
19571 hc_timer_set (&data.timer_running);
19572 }
19573 }
19574 }
19575 }
19576 // NOTE: combi is okay because it is already set beforehand
19577 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
19578 {
19579 if (data.dictfile == NULL)
19580 {
19581 if (dictfiles != NULL)
19582 {
19583 hc_timer_set (&data.timer_running);
19584
19585 data.dictfile = dictfiles[0];
19586 }
19587 }
19588 }
19589 else if (attack_mode == ATTACK_MODE_BF)
19590 {
19591 if (data.mask == NULL)
19592 {
19593 hc_timer_set (&data.timer_running);
19594
19595 data.mask = masks[0];
19596 }
19597 }
19598
19599 // if cracked / aborted remove last induction dictionary
19600
19601 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
19602 {
19603 struct stat induct_stat;
19604
19605 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
19606 {
19607 unlink (induction_dictionaries[file_pos]);
19608 }
19609 }
19610
19611 // wait for inner threads
19612
19613 data.shutdown_inner = 1;
19614
19615 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
19616 {
19617 hc_thread_wait (1, &inner_threads[thread_idx]);
19618 }
19619
19620 local_free (inner_threads);
19621
19622 // we dont need restore file anymore
19623 if (data.restore_disable == 0)
19624 {
19625 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
19626 {
19627 unlink (eff_restore_file);
19628 unlink (new_restore_file);
19629 }
19630 else
19631 {
19632 cycle_restore ();
19633 }
19634 }
19635
19636 // finally save left hashes
19637
19638 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
19639 {
19640 save_hash ();
19641 }
19642
19643 /**
19644 * Clean up
19645 */
19646
19647 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19648 {
19649 hc_device_param_t *device_param = &data.devices_param[device_id];
19650
19651 if (device_param->skipped) continue;
19652
19653 cl_int CL_err = CL_SUCCESS;
19654
19655 local_free (device_param->combs_buf);
19656 local_free (device_param->hooks_buf);
19657 local_free (device_param->device_name);
19658 local_free (device_param->device_name_chksum);
19659 local_free (device_param->device_version);
19660 local_free (device_param->driver_version);
19661
19662 if (device_param->pws_buf) myfree (device_param->pws_buf);
19663
19664 if (device_param->d_pws_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
19665 if (device_param->d_pws_amp_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
19666 if (device_param->d_rules) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules);
19667 if (device_param->d_rules_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
19668 if (device_param->d_combs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs);
19669 if (device_param->d_combs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
19670 if (device_param->d_bfs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
19671 if (device_param->d_bfs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
19672 if (device_param->d_bitmap_s1_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
19673 if (device_param->d_bitmap_s1_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
19674 if (device_param->d_bitmap_s1_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
19675 if (device_param->d_bitmap_s1_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
19676 if (device_param->d_bitmap_s2_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
19677 if (device_param->d_bitmap_s2_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
19678 if (device_param->d_bitmap_s2_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
19679 if (device_param->d_bitmap_s2_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
19680 if (device_param->d_plain_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
19681 if (device_param->d_digests_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
19682 if (device_param->d_digests_shown) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
19683 if (device_param->d_salt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
19684 if (device_param->d_esalt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
19685 if (device_param->d_tmps) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
19686 if (device_param->d_hooks) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
19687 if (device_param->d_result) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_result);
19688 if (device_param->d_scryptV0_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
19689 if (device_param->d_scryptV1_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
19690 if (device_param->d_scryptV2_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
19691 if (device_param->d_scryptV3_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
19692 if (device_param->d_root_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
19693 if (device_param->d_markov_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
19694 if (device_param->d_tm_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
19695
19696 if (CL_err != CL_SUCCESS)
19697 {
19698 log_error ("ERROR: clReleaseMemObject(): %s\n", val2cstr_cl (CL_err));
19699
19700 return -1;
19701 }
19702
19703 if (device_param->kernel1) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel1);
19704 if (device_param->kernel12) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel12);
19705 if (device_param->kernel2) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel2);
19706 if (device_param->kernel23) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel23);
19707 if (device_param->kernel3) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel3);
19708 if (device_param->kernel_mp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
19709 if (device_param->kernel_mp_l) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
19710 if (device_param->kernel_mp_r) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
19711 if (device_param->kernel_tm) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
19712 if (device_param->kernel_amp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
19713 if (device_param->kernel_memset) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
19714
19715 if (CL_err != CL_SUCCESS)
19716 {
19717 log_error ("ERROR: clReleaseKernel(): %s\n", val2cstr_cl (CL_err));
19718
19719 return -1;
19720 }
19721
19722 if (device_param->program) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program);
19723 if (device_param->program_mp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_mp);
19724 if (device_param->program_amp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_amp);
19725
19726 if (CL_err != CL_SUCCESS)
19727 {
19728 log_error ("ERROR: clReleaseProgram(): %s\n", val2cstr_cl (CL_err));
19729
19730 return -1;
19731 }
19732
19733 if (device_param->command_queue) CL_err |= hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
19734
19735 if (CL_err != CL_SUCCESS)
19736 {
19737 log_error ("ERROR: clReleaseCommandQueue(): %s\n", val2cstr_cl (CL_err));
19738
19739 return -1;
19740 }
19741
19742 if (device_param->context) CL_err |= hc_clReleaseContext (data.ocl, device_param->context);
19743
19744 if (CL_err != CL_SUCCESS)
19745 {
19746 log_error ("ERROR: hc_clReleaseContext(): %s\n", val2cstr_cl (CL_err));
19747
19748 return -1;
19749 }
19750 }
19751
19752 // reset default fan speed
19753
19754 #ifdef HAVE_HWMON
19755 if (gpu_temp_disable == 0)
19756 {
19757 if (gpu_temp_retain != 0)
19758 {
19759 hc_thread_mutex_lock (mux_adl);
19760
19761 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19762 {
19763 hc_device_param_t *device_param = &data.devices_param[device_id];
19764
19765 if (device_param->skipped) continue;
19766
19767 if (data.hm_device[device_id].fan_set_supported == 1)
19768 {
19769 int rc = -1;
19770
19771 if (device_param->device_vendor_id == VENDOR_ID_AMD)
19772 {
19773 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
19774 }
19775 else if (device_param->device_vendor_id == VENDOR_ID_NV)
19776 {
19777 #ifdef __linux__
19778 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
19779 #endif
19780
19781 #ifdef WIN
19782 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
19783 #endif
19784 }
19785
19786 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
19787 }
19788 }
19789
19790 hc_thread_mutex_unlock (mux_adl);
19791 }
19792 }
19793
19794 // reset power tuning
19795
19796 if (powertune_enable == 1)
19797 {
19798 hc_thread_mutex_lock (mux_adl);
19799
19800 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19801 {
19802 hc_device_param_t *device_param = &data.devices_param[device_id];
19803
19804 if (device_param->skipped) continue;
19805
19806 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
19807 {
19808 if (data.hm_device[device_id].od_version == 6)
19809 {
19810 // check powertune capabilities first, if not available then skip device
19811
19812 int powertune_supported = 0;
19813
19814 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
19815 {
19816 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
19817
19818 return -1;
19819 }
19820
19821 if (powertune_supported != 0)
19822 {
19823 // powercontrol settings
19824
19825 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
19826 {
19827 log_info ("ERROR: Failed to restore the ADL PowerControl values");
19828
19829 return -1;
19830 }
19831
19832 // clocks
19833
19834 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
19835
19836 performance_state->iNumberOfPerformanceLevels = 2;
19837
19838 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
19839 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
19840 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
19841 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
19842
19843 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
19844 {
19845 log_info ("ERROR: Failed to restore ADL performance state");
19846
19847 return -1;
19848 }
19849
19850 local_free (performance_state);
19851 }
19852 }
19853 }
19854
19855 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
19856 {
19857 unsigned int limit = nvml_power_limit[device_id];
19858
19859 if (limit > 0)
19860 {
19861 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
19862 }
19863 }
19864 }
19865
19866 hc_thread_mutex_unlock (mux_adl);
19867 }
19868
19869 if (gpu_temp_disable == 0)
19870 {
19871 if (data.hm_nvml)
19872 {
19873 hm_NVML_nvmlShutdown (data.hm_nvml);
19874
19875 nvml_close (data.hm_nvml);
19876
19877 data.hm_nvml = NULL;
19878 }
19879
19880 if (data.hm_nvapi)
19881 {
19882 hm_NvAPI_Unload (data.hm_nvapi);
19883
19884 nvapi_close (data.hm_nvapi);
19885
19886 data.hm_nvapi = NULL;
19887 }
19888
19889 if (data.hm_xnvctrl)
19890 {
19891 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
19892
19893 xnvctrl_close (data.hm_xnvctrl);
19894
19895 data.hm_xnvctrl = NULL;
19896 }
19897
19898 if (data.hm_adl)
19899 {
19900 hm_ADL_Main_Control_Destroy (data.hm_adl);
19901
19902 adl_close (data.hm_adl);
19903
19904 data.hm_adl = NULL;
19905 }
19906 }
19907 #endif // HAVE_HWMON
19908
19909 // free memory
19910
19911 local_free (masks);
19912
19913 local_free (dictstat_base);
19914
19915 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
19916 {
19917 pot_t *pot_ptr = &pot[pot_pos];
19918
19919 hash_t *hash = &pot_ptr->hash;
19920
19921 local_free (hash->digest);
19922
19923 if (isSalted)
19924 {
19925 local_free (hash->salt);
19926 }
19927 }
19928
19929 local_free (pot);
19930
19931 local_free (all_kernel_rules_cnt);
19932 local_free (all_kernel_rules_buf);
19933
19934 local_free (wl_data->buf);
19935 local_free (wl_data);
19936
19937 local_free (bitmap_s1_a);
19938 local_free (bitmap_s1_b);
19939 local_free (bitmap_s1_c);
19940 local_free (bitmap_s1_d);
19941 local_free (bitmap_s2_a);
19942 local_free (bitmap_s2_b);
19943 local_free (bitmap_s2_c);
19944 local_free (bitmap_s2_d);
19945
19946 #ifdef HAVE_HWMON
19947 local_free (od_clock_mem_status);
19948 local_free (od_power_control_status);
19949 local_free (nvml_power_limit);
19950 #endif
19951
19952 global_free (devices_param);
19953
19954 global_free (kernel_rules_buf);
19955
19956 global_free (root_css_buf);
19957 global_free (markov_css_buf);
19958
19959 global_free (digests_buf);
19960 global_free (digests_shown);
19961 global_free (digests_shown_tmp);
19962
19963 global_free (salts_buf);
19964 global_free (salts_shown);
19965
19966 global_free (esalts_buf);
19967
19968 global_free (words_progress_done);
19969 global_free (words_progress_rejected);
19970 global_free (words_progress_restored);
19971
19972 if (pot_fp) fclose (pot_fp);
19973
19974 if (data.devices_status == STATUS_QUIT) break;
19975 }
19976
19977 // wait for outer threads
19978
19979 data.shutdown_outer = 1;
19980
19981 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
19982 {
19983 hc_thread_wait (1, &outer_threads[thread_idx]);
19984 }
19985
19986 local_free (outer_threads);
19987
19988 // destroy others mutex
19989
19990 hc_thread_mutex_delete (mux_dispatcher);
19991 hc_thread_mutex_delete (mux_counter);
19992 hc_thread_mutex_delete (mux_display);
19993 hc_thread_mutex_delete (mux_adl);
19994
19995 // free memory
19996
19997 local_free (eff_restore_file);
19998 local_free (new_restore_file);
19999
20000 local_free (rd);
20001
20002 // tuning db
20003
20004 tuning_db_destroy (tuning_db);
20005
20006 // loopback
20007
20008 local_free (loopback_file);
20009
20010 if (loopback == 1) unlink (loopback_file);
20011
20012 // induction directory
20013
20014 if (induction_dir == NULL)
20015 {
20016 if (attack_mode != ATTACK_MODE_BF)
20017 {
20018 if (rmdir (induction_directory) == -1)
20019 {
20020 if (errno == ENOENT)
20021 {
20022 // good, we can ignore
20023 }
20024 else if (errno == ENOTEMPTY)
20025 {
20026 // good, we can ignore
20027 }
20028 else
20029 {
20030 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
20031
20032 return -1;
20033 }
20034 }
20035
20036 local_free (induction_directory);
20037 }
20038 }
20039
20040 // outfile-check directory
20041
20042 if (outfile_check_dir == NULL)
20043 {
20044 if (rmdir (outfile_check_directory) == -1)
20045 {
20046 if (errno == ENOENT)
20047 {
20048 // good, we can ignore
20049 }
20050 else if (errno == ENOTEMPTY)
20051 {
20052 // good, we can ignore
20053 }
20054 else
20055 {
20056 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
20057
20058 return -1;
20059 }
20060 }
20061
20062 local_free (outfile_check_directory);
20063 }
20064
20065 time_t proc_stop;
20066
20067 time (&proc_stop);
20068
20069 logfile_top_uint (proc_start);
20070 logfile_top_uint (proc_stop);
20071
20072 logfile_top_msg ("STOP");
20073
20074 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
20075 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
20076
20077 if (data.ocl) ocl_close (data.ocl);
20078
20079 if (data.devices_status == STATUS_ABORTED) return 2;
20080 if (data.devices_status == STATUS_QUIT) return 2;
20081 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
20082 if (data.devices_status == STATUS_EXHAUSTED) return 1;
20083 if (data.devices_status == STATUS_CRACKED) return 0;
20084
20085 return -1;
20086 }
Hashcat additions to support pwdhash