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