projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add missing continue
[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 // Silently ignore at this point, it will be reused later and create a note for the user at that point
14103
14104 continue;
14105 }
14106
14107 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14108 {
14109 cl_device_id device = platform_devices[platform_devices_id];
14110
14111 cl_device_type device_type;
14112
14113 cl_int CL_err = hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14114
14115 if (CL_err != CL_SUCCESS)
14116 {
14117 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14118
14119 return -1;
14120 }
14121
14122 device_types_all |= device_type;
14123 }
14124 }
14125
14126 // In such a case, automatically enable CPU device type support, since it's disabled by default.
14127
14128 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
14129 {
14130 device_types_filter |= CL_DEVICE_TYPE_CPU;
14131 }
14132
14133 // In another case, when the user uses --stdout, using CPU devices is much faster to setup
14134 // If we have a CPU device, force it to be used
14135
14136 if (stdout_flag == 1)
14137 {
14138 if (device_types_all & CL_DEVICE_TYPE_CPU)
14139 {
14140 device_types_filter = CL_DEVICE_TYPE_CPU;
14141 }
14142 }
14143 }
14144
14145 /**
14146 * OpenCL devices: simply push all devices from all platforms into the same device array
14147 */
14148
14149 int need_adl = 0;
14150 int need_nvapi = 0;
14151 int need_nvml = 0;
14152 int need_xnvctrl = 0;
14153
14154 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
14155
14156 data.devices_param = devices_param;
14157
14158 uint devices_cnt = 0;
14159
14160 uint devices_active = 0;
14161
14162 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
14163 {
14164 cl_int CL_err = CL_SUCCESS;
14165
14166 cl_platform_id platform = platforms[platform_id];
14167
14168 char platform_vendor[INFOSZ] = { 0 };
14169
14170 CL_err = hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
14171
14172 if (CL_err != CL_SUCCESS)
14173 {
14174 log_error ("ERROR: clGetPlatformInfo(): %s\n", val2cstr_cl (CL_err));
14175
14176 return -1;
14177 }
14178
14179 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
14180 // this causes trouble with vendor id based macros
14181 // we'll assign generic to those without special optimization available
14182
14183 cl_uint platform_vendor_id = 0;
14184
14185 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
14186 {
14187 platform_vendor_id = VENDOR_ID_AMD;
14188 }
14189 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14190 {
14191 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14192 }
14193 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
14194 {
14195 platform_vendor_id = VENDOR_ID_APPLE;
14196 }
14197 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14198 {
14199 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14200 }
14201 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
14202 {
14203 platform_vendor_id = VENDOR_ID_INTEL_SDK;
14204 }
14205 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
14206 {
14207 platform_vendor_id = VENDOR_ID_MESA;
14208 }
14209 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
14210 {
14211 platform_vendor_id = VENDOR_ID_NV;
14212 }
14213 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
14214 {
14215 platform_vendor_id = VENDOR_ID_POCL;
14216 }
14217 else
14218 {
14219 platform_vendor_id = VENDOR_ID_GENERIC;
14220 }
14221
14222 uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
14223
14224 CL_err = hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
14225
14226 if (CL_err != CL_SUCCESS)
14227 {
14228 //log_error ("ERROR: clGetDeviceIDs(): %s\n", val2cstr_cl (CL_err));
14229
14230 //return -1;
14231
14232 platform_skipped = 2;
14233 }
14234
14235 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14236 {
14237 if (machine_readable == 0)
14238 {
14239 if (platform_skipped == 0)
14240 {
14241 const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
14242
14243 char line[256] = { 0 };
14244
14245 for (int i = 0; i < len; i++) line[i] = '=';
14246
14247 log_info (line);
14248 }
14249 else if (platform_skipped == 1)
14250 {
14251 log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
14252 log_info ("");
14253 }
14254 else if (platform_skipped == 2)
14255 {
14256 log_info ("OpenCL Platform #%u: %s, skipped! No OpenCL compatible devices found", platform_id + 1, platform_vendor);
14257 log_info ("");
14258 }
14259 }
14260 }
14261
14262 if (platform_skipped == 1) continue;
14263 if (platform_skipped == 2) continue;
14264
14265 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
14266 {
14267 size_t param_value_size = 0;
14268
14269 const uint device_id = devices_cnt;
14270
14271 hc_device_param_t *device_param = &data.devices_param[device_id];
14272
14273 device_param->platform_vendor_id = platform_vendor_id;
14274
14275 device_param->device = platform_devices[platform_devices_id];
14276
14277 device_param->device_id = device_id;
14278
14279 device_param->platform_devices_id = platform_devices_id;
14280
14281 device_param->platform = platform;
14282
14283 // device_type
14284
14285 cl_device_type device_type;
14286
14287 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
14288
14289 if (CL_err != CL_SUCCESS)
14290 {
14291 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14292
14293 return -1;
14294 }
14295
14296 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
14297
14298 device_param->device_type = device_type;
14299
14300 // device_name
14301
14302 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
14303
14304 if (CL_err != CL_SUCCESS)
14305 {
14306 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14307
14308 return -1;
14309 }
14310
14311 char *device_name = (char *) mymalloc (param_value_size);
14312
14313 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
14314
14315 if (CL_err != CL_SUCCESS)
14316 {
14317 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14318
14319 return -1;
14320 }
14321
14322 device_param->device_name = device_name;
14323
14324 // device_vendor
14325
14326 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
14327
14328 if (CL_err != CL_SUCCESS)
14329 {
14330 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14331
14332 return -1;
14333 }
14334
14335 char *device_vendor = (char *) mymalloc (param_value_size);
14336
14337 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
14338
14339 if (CL_err != CL_SUCCESS)
14340 {
14341 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14342
14343 return -1;
14344 }
14345
14346 device_param->device_vendor = device_vendor;
14347
14348 cl_uint device_vendor_id = 0;
14349
14350 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
14351 {
14352 device_vendor_id = VENDOR_ID_AMD;
14353 }
14354 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
14355 {
14356 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
14357 }
14358 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
14359 {
14360 device_vendor_id = VENDOR_ID_APPLE;
14361 }
14362 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
14363 {
14364 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
14365 }
14366 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
14367 {
14368 device_vendor_id = VENDOR_ID_INTEL_SDK;
14369 }
14370 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
14371 {
14372 device_vendor_id = VENDOR_ID_MESA;
14373 }
14374 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
14375 {
14376 device_vendor_id = VENDOR_ID_NV;
14377 }
14378 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
14379 {
14380 device_vendor_id = VENDOR_ID_POCL;
14381 }
14382 else
14383 {
14384 device_vendor_id = VENDOR_ID_GENERIC;
14385 }
14386
14387 device_param->device_vendor_id = device_vendor_id;
14388
14389 // tuning db
14390
14391 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14392
14393 // device_version
14394
14395 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
14396
14397 if (CL_err != CL_SUCCESS)
14398 {
14399 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14400
14401 return -1;
14402 }
14403
14404 char *device_version = (char *) mymalloc (param_value_size);
14405
14406 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
14407
14408 if (CL_err != CL_SUCCESS)
14409 {
14410 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14411
14412 return -1;
14413 }
14414
14415 device_param->device_version = device_version;
14416
14417 // device_opencl_version
14418
14419 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
14420
14421 if (CL_err != CL_SUCCESS)
14422 {
14423 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14424
14425 return -1;
14426 }
14427
14428 char *device_opencl_version = (char *) mymalloc (param_value_size);
14429
14430 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
14431
14432 if (CL_err != CL_SUCCESS)
14433 {
14434 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14435
14436 return -1;
14437 }
14438
14439 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
14440
14441 myfree (device_opencl_version);
14442
14443 // vector_width
14444
14445 cl_uint vector_width;
14446
14447 if (opencl_vector_width_chgd == 0)
14448 {
14449 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
14450 {
14451 if (opti_type & OPTI_TYPE_USES_BITS_64)
14452 {
14453 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
14454
14455 if (CL_err != CL_SUCCESS)
14456 {
14457 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14458
14459 return -1;
14460 }
14461 }
14462 else
14463 {
14464 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
14465
14466 if (CL_err != CL_SUCCESS)
14467 {
14468 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14469
14470 return -1;
14471 }
14472 }
14473 }
14474 else
14475 {
14476 vector_width = (cl_uint) tuningdb_entry->vector_width;
14477 }
14478 }
14479 else
14480 {
14481 vector_width = opencl_vector_width;
14482 }
14483
14484 if (vector_width > 16) vector_width = 16;
14485
14486 device_param->vector_width = vector_width;
14487
14488 // max_compute_units
14489
14490 cl_uint device_processors;
14491
14492 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
14493
14494 if (CL_err != CL_SUCCESS)
14495 {
14496 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14497
14498 return -1;
14499 }
14500
14501 device_param->device_processors = device_processors;
14502
14503 // device_maxmem_alloc
14504 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
14505
14506 cl_ulong device_maxmem_alloc;
14507
14508 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
14509
14510 if (CL_err != CL_SUCCESS)
14511 {
14512 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14513
14514 return -1;
14515 }
14516
14517 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
14518
14519 // device_global_mem
14520
14521 cl_ulong device_global_mem;
14522
14523 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
14524
14525 if (CL_err != CL_SUCCESS)
14526 {
14527 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14528
14529 return -1;
14530 }
14531
14532 device_param->device_global_mem = device_global_mem;
14533
14534 // max_work_group_size
14535
14536 size_t device_maxworkgroup_size;
14537
14538 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
14539
14540 if (CL_err != CL_SUCCESS)
14541 {
14542 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14543
14544 return -1;
14545 }
14546
14547 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
14548
14549 // max_clock_frequency
14550
14551 cl_uint device_maxclock_frequency;
14552
14553 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
14554
14555 if (CL_err != CL_SUCCESS)
14556 {
14557 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14558
14559 return -1;
14560 }
14561
14562 device_param->device_maxclock_frequency = device_maxclock_frequency;
14563
14564 // device_endian_little
14565
14566 cl_bool device_endian_little;
14567
14568 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
14569
14570 if (CL_err != CL_SUCCESS)
14571 {
14572 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14573
14574 return -1;
14575 }
14576
14577 if (device_endian_little == CL_FALSE)
14578 {
14579 log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
14580
14581 device_param->skipped = 1;
14582 }
14583
14584 // device_available
14585
14586 cl_bool device_available;
14587
14588 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
14589
14590 if (CL_err != CL_SUCCESS)
14591 {
14592 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14593
14594 return -1;
14595 }
14596
14597 if (device_available == CL_FALSE)
14598 {
14599 log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
14600
14601 device_param->skipped = 1;
14602 }
14603
14604 // device_compiler_available
14605
14606 cl_bool device_compiler_available;
14607
14608 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
14609
14610 if (CL_err != CL_SUCCESS)
14611 {
14612 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14613
14614 return -1;
14615 }
14616
14617 if (device_compiler_available == CL_FALSE)
14618 {
14619 log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
14620
14621 device_param->skipped = 1;
14622 }
14623
14624 // device_execution_capabilities
14625
14626 cl_device_exec_capabilities device_execution_capabilities;
14627
14628 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
14629
14630 if (CL_err != CL_SUCCESS)
14631 {
14632 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14633
14634 return -1;
14635 }
14636
14637 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
14638 {
14639 log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
14640
14641 device_param->skipped = 1;
14642 }
14643
14644 // device_extensions
14645
14646 size_t device_extensions_size;
14647
14648 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
14649
14650 if (CL_err != CL_SUCCESS)
14651 {
14652 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14653
14654 return -1;
14655 }
14656
14657 char *device_extensions = mymalloc (device_extensions_size + 1);
14658
14659 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
14660
14661 if (CL_err != CL_SUCCESS)
14662 {
14663 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14664
14665 return -1;
14666 }
14667
14668 if (strstr (device_extensions, "base_atomics") == 0)
14669 {
14670 log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
14671
14672 device_param->skipped = 1;
14673 }
14674
14675 if (strstr (device_extensions, "byte_addressable_store") == 0)
14676 {
14677 log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
14678
14679 device_param->skipped = 1;
14680 }
14681
14682 myfree (device_extensions);
14683
14684 // device_local_mem_size
14685
14686 cl_ulong device_local_mem_size;
14687
14688 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
14689
14690 if (CL_err != CL_SUCCESS)
14691 {
14692 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14693
14694 return -1;
14695 }
14696
14697 if (device_local_mem_size < 32768)
14698 {
14699 log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
14700
14701 device_param->skipped = 1;
14702 }
14703
14704 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
14705 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
14706 // This results in both utilizing it for 50%
14707 // However, Intel has much better SIMD control over their own hardware
14708 // It makes sense to give them full control over their own hardware
14709
14710 if (device_type & CL_DEVICE_TYPE_CPU)
14711 {
14712 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
14713 {
14714 if (data.force == 0)
14715 {
14716 if (algorithm_pos == 0)
14717 {
14718 log_info ("- Device #%u: WARNING: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
14719 log_info (" You can use --force to override this but do not post error reports if you do so");
14720 }
14721
14722 device_param->skipped = 1;
14723 }
14724 }
14725 }
14726
14727 // skipped
14728
14729 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14730 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14731
14732 // driver_version
14733
14734 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14735
14736 if (CL_err != CL_SUCCESS)
14737 {
14738 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14739
14740 return -1;
14741 }
14742
14743 char *driver_version = (char *) mymalloc (param_value_size);
14744
14745 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14746
14747 if (CL_err != CL_SUCCESS)
14748 {
14749 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14750
14751 return -1;
14752 }
14753
14754 device_param->driver_version = driver_version;
14755
14756 // device_name_chksum
14757
14758 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14759
14760 #if __x86_64__
14761 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);
14762 #else
14763 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);
14764 #endif
14765
14766 uint device_name_digest[4] = { 0 };
14767
14768 md5_64 ((uint *) device_name_chksum, device_name_digest);
14769
14770 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14771
14772 device_param->device_name_chksum = device_name_chksum;
14773
14774 // vendor specific
14775
14776 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14777 {
14778 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14779 {
14780 need_adl = 1;
14781 }
14782
14783 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14784 {
14785 need_nvml = 1;
14786
14787 #ifdef __linux__
14788 need_xnvctrl = 1;
14789 #endif
14790
14791 #ifdef WIN
14792 need_nvapi = 1;
14793 #endif
14794 }
14795 }
14796
14797 if (device_type & CL_DEVICE_TYPE_GPU)
14798 {
14799 if (device_vendor_id == VENDOR_ID_NV)
14800 {
14801 cl_uint kernel_exec_timeout = 0;
14802
14803 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14804
14805 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14806
14807 if (CL_err != CL_SUCCESS)
14808 {
14809 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14810
14811 return -1;
14812 }
14813
14814 device_param->kernel_exec_timeout = kernel_exec_timeout;
14815
14816 cl_uint sm_minor = 0;
14817 cl_uint sm_major = 0;
14818
14819 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14820 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14821
14822 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14823
14824 if (CL_err != CL_SUCCESS)
14825 {
14826 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14827
14828 return -1;
14829 }
14830
14831 CL_err = hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14832
14833 if (CL_err != CL_SUCCESS)
14834 {
14835 log_error ("ERROR: clGetDeviceInfo(): %s\n", val2cstr_cl (CL_err));
14836
14837 return -1;
14838 }
14839
14840 device_param->sm_minor = sm_minor;
14841 device_param->sm_major = sm_major;
14842
14843 // CPU burning loop damper
14844 // Value is given as number between 0-100
14845 // By default 100%
14846
14847 device_param->nvidia_spin_damp = (double) nvidia_spin_damp;
14848
14849 if (nvidia_spin_damp_chgd == 0)
14850 {
14851 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
14852 {
14853 /**
14854 * the workaround is not a friend of rule based attacks
14855 * the words from the wordlist combined with fast and slow rules cause
14856 * fluctuations which cause inaccurate wait time estimations
14857 * using a reduced damping percentage almost compensates this
14858 */
14859
14860 device_param->nvidia_spin_damp = 64;
14861 }
14862 }
14863
14864 device_param->nvidia_spin_damp /= 100;
14865 }
14866 }
14867
14868 // display results
14869
14870 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14871 {
14872 if (machine_readable == 0)
14873 {
14874 if (device_param->skipped == 0)
14875 {
14876 log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14877 device_id + 1,
14878 device_name,
14879 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14880 (unsigned int) (device_global_mem / 1024 / 1024),
14881 (unsigned int) device_processors);
14882 }
14883 else
14884 {
14885 log_info ("- Device #%u: %s, skipped",
14886 device_id + 1,
14887 device_name);
14888 }
14889 }
14890 }
14891
14892 // common driver check
14893
14894 if (device_param->skipped == 0)
14895 {
14896 if (device_type & CL_DEVICE_TYPE_GPU)
14897 {
14898 if (platform_vendor_id == VENDOR_ID_AMD)
14899 {
14900 int catalyst_check = (force == 1) ? 0 : 1;
14901
14902 int catalyst_warn = 0;
14903
14904 int catalyst_broken = 0;
14905
14906 if (catalyst_check == 1)
14907 {
14908 catalyst_warn = 1;
14909
14910 // v14.9 and higher
14911 if (atoi (device_param->driver_version) >= 1573)
14912 {
14913 catalyst_warn = 0;
14914 }
14915
14916 catalyst_check = 0;
14917 }
14918
14919 if (catalyst_broken == 1)
14920 {
14921 log_info ("");
14922 log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
14923 log_info ("It passes over cracked hashes and will not report them as cracked");
14924 log_info ("You are STRONGLY encouraged not to use it");
14925 log_info ("You can use --force to override this but do not post error reports if you do so");
14926 log_info ("");
14927
14928 return -1;
14929 }
14930
14931 if (catalyst_warn == 1)
14932 {
14933 log_info ("");
14934 log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
14935 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
14936 log_info ("See hashcat's homepage for official supported catalyst drivers");
14937 #ifdef _WIN
14938 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14939 #endif
14940 log_info ("You can use --force to override this but do not post error reports if you do so");
14941 log_info ("");
14942
14943 return -1;
14944 }
14945 }
14946 else if (platform_vendor_id == VENDOR_ID_NV)
14947 {
14948 if (device_param->kernel_exec_timeout != 0)
14949 {
14950 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);
14951 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14952 }
14953 }
14954 }
14955
14956 /* turns out pocl still creates segfaults (because of llvm)
14957 if (device_type & CL_DEVICE_TYPE_CPU)
14958 {
14959 if (platform_vendor_id == VENDOR_ID_AMD)
14960 {
14961 if (force == 0)
14962 {
14963 log_info ("");
14964 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14965 log_info ("You are STRONGLY encouraged not to use it");
14966 log_info ("You can use --force to override this but do not post error reports if you do so");
14967 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14968 log_info ("");
14969
14970 return -1;
14971 }
14972 }
14973 }
14974 */
14975
14976 /**
14977 * kernel accel and loops tuning db adjustment
14978 */
14979
14980 device_param->kernel_accel_min = 1;
14981 device_param->kernel_accel_max = 1024;
14982
14983 device_param->kernel_loops_min = 1;
14984 device_param->kernel_loops_max = 1024;
14985
14986 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14987
14988 if (tuningdb_entry)
14989 {
14990 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14991 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14992
14993 if (_kernel_accel)
14994 {
14995 device_param->kernel_accel_min = _kernel_accel;
14996 device_param->kernel_accel_max = _kernel_accel;
14997 }
14998
14999 if (_kernel_loops)
15000 {
15001 if (workload_profile == 1)
15002 {
15003 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
15004 }
15005 else if (workload_profile == 2)
15006 {
15007 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
15008 }
15009
15010 device_param->kernel_loops_min = _kernel_loops;
15011 device_param->kernel_loops_max = _kernel_loops;
15012 }
15013 }
15014
15015 // commandline parameters overwrite tuningdb entries
15016
15017 if (kernel_accel)
15018 {
15019 device_param->kernel_accel_min = kernel_accel;
15020 device_param->kernel_accel_max = kernel_accel;
15021 }
15022
15023 if (kernel_loops)
15024 {
15025 device_param->kernel_loops_min = kernel_loops;
15026 device_param->kernel_loops_max = kernel_loops;
15027 }
15028
15029 /**
15030 * activate device
15031 */
15032
15033 devices_active++;
15034 }
15035
15036 // next please
15037
15038 devices_cnt++;
15039 }
15040
15041 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
15042 {
15043 if (machine_readable == 0)
15044 {
15045 log_info ("");
15046 }
15047 }
15048 }
15049
15050 if (keyspace == 0 && devices_active == 0)
15051 {
15052 log_error ("ERROR: No devices found/left");
15053
15054 return -1;
15055 }
15056
15057 // 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)
15058
15059 if (devices_filter != (uint) -1)
15060 {
15061 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
15062
15063 if (devices_filter > devices_cnt_mask)
15064 {
15065 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
15066
15067 return -1;
15068 }
15069 }
15070
15071 data.devices_cnt = devices_cnt;
15072
15073 data.devices_active = devices_active;
15074
15075 /**
15076 * HM devices: init
15077 */
15078
15079 #ifdef HAVE_HWMON
15080 hm_attrs_t hm_adapters_adl[DEVICES_MAX];
15081 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX];
15082 hm_attrs_t hm_adapters_nvml[DEVICES_MAX];
15083 hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX];
15084
15085 memset (hm_adapters_adl, 0, sizeof (hm_adapters_adl));
15086 memset (hm_adapters_nvapi, 0, sizeof (hm_adapters_nvapi));
15087 memset (hm_adapters_nvml, 0, sizeof (hm_adapters_nvml));
15088 memset (hm_adapters_xnvctrl, 0, sizeof (hm_adapters_xnvctrl));
15089
15090 if (gpu_temp_disable == 0)
15091 {
15092 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
15093 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
15094 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
15095 XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR));
15096
15097 data.hm_adl = NULL;
15098 data.hm_nvapi = NULL;
15099 data.hm_nvml = NULL;
15100 data.hm_xnvctrl = NULL;
15101
15102 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
15103 {
15104 data.hm_nvml = nvml;
15105 }
15106
15107 if (data.hm_nvml)
15108 {
15109 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
15110 {
15111 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
15112
15113 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
15114
15115 int tmp_out = 0;
15116
15117 for (int i = 0; i < tmp_in; i++)
15118 {
15119 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
15120 }
15121
15122 for (int i = 0; i < tmp_out; i++)
15123 {
15124 unsigned int speed;
15125
15126 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
15127
15128 // doesn't seem to create any advantages
15129 //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
15130 //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
15131 }
15132 }
15133 }
15134
15135 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
15136 {
15137 data.hm_nvapi = nvapi;
15138 }
15139
15140 if (data.hm_nvapi)
15141 {
15142 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
15143 {
15144 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
15145
15146 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
15147
15148 int tmp_out = 0;
15149
15150 for (int i = 0; i < tmp_in; i++)
15151 {
15152 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
15153 }
15154 }
15155 }
15156
15157 if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0))
15158 {
15159 data.hm_xnvctrl = xnvctrl;
15160 }
15161
15162 if (data.hm_xnvctrl)
15163 {
15164 if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0)
15165 {
15166 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15167 {
15168 hc_device_param_t *device_param = &data.devices_param[device_id];
15169
15170 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15171
15172 hm_adapters_xnvctrl[device_id].xnvctrl = device_id;
15173
15174 int speed = 0;
15175
15176 if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1;
15177 }
15178 }
15179 }
15180
15181 if ((need_adl == 1) && (adl_init (adl) == 0))
15182 {
15183 data.hm_adl = adl;
15184 }
15185
15186 if (data.hm_adl)
15187 {
15188 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
15189 {
15190 // total number of adapters
15191
15192 int hm_adapters_num;
15193
15194 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return -1;
15195
15196 // adapter info
15197
15198 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
15199
15200 if (lpAdapterInfo == NULL) return -1;
15201
15202 // get a list (of ids of) valid/usable adapters
15203
15204 int num_adl_adapters = 0;
15205
15206 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
15207
15208 if (num_adl_adapters > 0)
15209 {
15210 hc_thread_mutex_lock (mux_adl);
15211
15212 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
15213
15214 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15215
15216 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15217 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
15218
15219 hc_thread_mutex_unlock (mux_adl);
15220 }
15221
15222 myfree (valid_adl_device_list);
15223 myfree (lpAdapterInfo);
15224 }
15225 }
15226
15227 if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15228 {
15229 gpu_temp_disable = 1;
15230 }
15231 }
15232
15233 /**
15234 * OpenCL devices: allocate buffer for device specific information
15235 */
15236
15237 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
15238
15239 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
15240
15241 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
15242
15243 /**
15244 * User-defined GPU temp handling
15245 */
15246
15247 if (gpu_temp_disable == 1)
15248 {
15249 gpu_temp_abort = 0;
15250 gpu_temp_retain = 0;
15251 }
15252
15253 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
15254 {
15255 if (gpu_temp_abort < gpu_temp_retain)
15256 {
15257 log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
15258
15259 return -1;
15260 }
15261 }
15262
15263 data.gpu_temp_disable = gpu_temp_disable;
15264 data.gpu_temp_abort = gpu_temp_abort;
15265 data.gpu_temp_retain = gpu_temp_retain;
15266 #endif
15267
15268 /**
15269 * enable custom signal handler(s)
15270 */
15271
15272 if (benchmark == 0)
15273 {
15274 hc_signal (sigHandler_default);
15275 }
15276 else
15277 {
15278 hc_signal (sigHandler_benchmark);
15279 }
15280
15281 /**
15282 * inform the user
15283 */
15284
15285 if (data.quiet == 0)
15286 {
15287 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
15288
15289 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);
15290
15291 if (attack_mode == ATTACK_MODE_STRAIGHT)
15292 {
15293 log_info ("Rules: %u", kernel_rules_cnt);
15294 }
15295
15296 if (opti_type)
15297 {
15298 log_info ("Applicable Optimizers:");
15299
15300 for (uint i = 0; i < 32; i++)
15301 {
15302 const uint opti_bit = 1u << i;
15303
15304 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
15305 }
15306 }
15307
15308 /**
15309 * Watchdog and Temperature balance
15310 */
15311
15312 #ifdef HAVE_HWMON
15313 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL)
15314 {
15315 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
15316 }
15317
15318 if (gpu_temp_abort == 0)
15319 {
15320 log_info ("Watchdog: Temperature abort trigger disabled");
15321 }
15322 else
15323 {
15324 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
15325 }
15326
15327 if (gpu_temp_retain == 0)
15328 {
15329 log_info ("Watchdog: Temperature retain trigger disabled");
15330 }
15331 else
15332 {
15333 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
15334 }
15335
15336 if (data.quiet == 0) log_info ("");
15337 #endif
15338 }
15339
15340 #ifdef HAVE_HWMON
15341
15342 /**
15343 * HM devices: copy
15344 */
15345
15346 if (gpu_temp_disable == 0)
15347 {
15348 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15349 {
15350 hc_device_param_t *device_param = &data.devices_param[device_id];
15351
15352 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
15353
15354 if (device_param->skipped) continue;
15355
15356 const uint platform_devices_id = device_param->platform_devices_id;
15357
15358 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15359 {
15360 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
15361 data.hm_device[device_id].nvapi = 0;
15362 data.hm_device[device_id].nvml = 0;
15363 data.hm_device[device_id].xnvctrl = 0;
15364 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
15365 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
15366 data.hm_device[device_id].fan_set_supported = 0;
15367 }
15368
15369 if (device_param->device_vendor_id == VENDOR_ID_NV)
15370 {
15371 data.hm_device[device_id].adl = 0;
15372 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
15373 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
15374 data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl;
15375 data.hm_device[device_id].od_version = 0;
15376 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
15377 data.hm_device[device_id].fan_set_supported = 0;
15378 }
15379 }
15380 }
15381
15382 /**
15383 * powertune on user request
15384 */
15385
15386 if (powertune_enable == 1)
15387 {
15388 hc_thread_mutex_lock (mux_adl);
15389
15390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15391 {
15392 hc_device_param_t *device_param = &data.devices_param[device_id];
15393
15394 if (device_param->skipped) continue;
15395
15396 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
15397 {
15398 /**
15399 * Temporary fix:
15400 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
15401 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
15402 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
15403 * Driver / ADL bug?
15404 */
15405
15406 if (data.hm_device[device_id].od_version == 6)
15407 {
15408 int ADL_rc;
15409
15410 // check powertune capabilities first, if not available then skip device
15411
15412 int powertune_supported = 0;
15413
15414 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
15415 {
15416 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15417
15418 return -1;
15419 }
15420
15421 // first backup current value, we will restore it later
15422
15423 if (powertune_supported != 0)
15424 {
15425 // powercontrol settings
15426
15427 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15428
15429 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
15430 {
15431 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
15432 }
15433
15434 if (ADL_rc != ADL_OK)
15435 {
15436 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15437
15438 return -1;
15439 }
15440
15441 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15442 {
15443 log_error ("ERROR: Failed to set new ADL PowerControl values");
15444
15445 return -1;
15446 }
15447
15448 // clocks
15449
15450 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15451
15452 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15453
15454 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)
15455 {
15456 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15457
15458 return -1;
15459 }
15460
15461 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15462
15463 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15464
15465 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
15466 {
15467 log_error ("ERROR: Failed to get ADL device capabilities");
15468
15469 return -1;
15470 }
15471
15472 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15473 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15474
15475 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15476 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15477
15478 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15479 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15480
15481 // warning if profile has too low max values
15482
15483 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15484 {
15485 log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15486 }
15487
15488 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15489 {
15490 log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15491 }
15492
15493 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15494
15495 performance_state->iNumberOfPerformanceLevels = 2;
15496
15497 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15498 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15499 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15500 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15501
15502 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)
15503 {
15504 log_info ("ERROR: Failed to set ADL performance state");
15505
15506 return -1;
15507 }
15508
15509 local_free (performance_state);
15510 }
15511
15512 // set powertune value only
15513
15514 if (powertune_supported != 0)
15515 {
15516 // powertune set
15517 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15518
15519 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
15520 {
15521 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15522
15523 return -1;
15524 }
15525
15526 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
15527 {
15528 log_error ("ERROR: Failed to set new ADL PowerControl values");
15529
15530 return -1;
15531 }
15532 }
15533 }
15534 }
15535
15536 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
15537 {
15538 // first backup current value, we will restore it later
15539
15540 unsigned int limit;
15541
15542 int powertune_supported = 0;
15543
15544 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
15545 {
15546 powertune_supported = 1;
15547 }
15548
15549 // if backup worked, activate the maximum allowed
15550
15551 if (powertune_supported != 0)
15552 {
15553 unsigned int minLimit;
15554 unsigned int maxLimit;
15555
15556 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
15557 {
15558 if (maxLimit > 0)
15559 {
15560 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
15561 {
15562 // now we can be sure we need to reset later
15563
15564 nvml_power_limit[device_id] = limit;
15565 }
15566 }
15567 }
15568 }
15569 }
15570 }
15571
15572 hc_thread_mutex_unlock (mux_adl);
15573 }
15574
15575 #endif // HAVE_HWMON
15576
15577 #ifdef DEBUG
15578 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
15579 #endif
15580
15581 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
15582
15583 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
15584 {
15585 cl_int CL_err = CL_SUCCESS;
15586
15587 /**
15588 * host buffer
15589 */
15590
15591 hc_device_param_t *device_param = &data.devices_param[device_id];
15592
15593 if (device_param->skipped) continue;
15594
15595 /**
15596 * device properties
15597 */
15598
15599 const char *device_name_chksum = device_param->device_name_chksum;
15600 const u32 device_processors = device_param->device_processors;
15601
15602 /**
15603 * create context for each device
15604 */
15605
15606 cl_context_properties properties[3];
15607
15608 properties[0] = CL_CONTEXT_PLATFORM;
15609 properties[1] = (cl_context_properties) device_param->platform;
15610 properties[2] = 0;
15611
15612 CL_err = hc_clCreateContext (data.ocl, properties, 1, &device_param->device, NULL, NULL, &device_param->context);
15613
15614 if (CL_err != CL_SUCCESS)
15615 {
15616 log_error ("ERROR: clCreateContext(): %s\n", val2cstr_cl (CL_err));
15617
15618 return -1;
15619 }
15620
15621 /**
15622 * create command-queue
15623 */
15624
15625 // not supported with NV
15626 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
15627
15628 CL_err = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE, &device_param->command_queue);
15629
15630 if (CL_err != CL_SUCCESS)
15631 {
15632 log_error ("ERROR: clCreateCommandQueue(): %s\n", val2cstr_cl (CL_err));
15633
15634 return -1;
15635 }
15636
15637 /**
15638 * kernel threads: some algorithms need a fixed kernel-threads count
15639 * because of shared memory usage or bitslice
15640 * there needs to be some upper limit, otherwise there's too much overhead
15641 */
15642
15643 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
15644
15645 if (hash_mode == 8900) kernel_threads = 64; // Scrypt
15646 if (hash_mode == 9300) kernel_threads = 64; // Scrypt
15647
15648 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
15649 {
15650 kernel_threads = KERNEL_THREADS_MAX_CPU;
15651 }
15652
15653 if (hash_mode == 1500) kernel_threads = 64; // DES
15654 if (hash_mode == 3000) kernel_threads = 64; // DES
15655 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
15656 if (hash_mode == 7500) kernel_threads = 64; // RC4
15657 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
15658 if (hash_mode == 9700) kernel_threads = 64; // RC4
15659 if (hash_mode == 9710) kernel_threads = 64; // RC4
15660 if (hash_mode == 9800) kernel_threads = 64; // RC4
15661 if (hash_mode == 9810) kernel_threads = 64; // RC4
15662 if (hash_mode == 10400) kernel_threads = 64; // RC4
15663 if (hash_mode == 10410) kernel_threads = 64; // RC4
15664 if (hash_mode == 10500) kernel_threads = 64; // RC4
15665 if (hash_mode == 13100) kernel_threads = 64; // RC4
15666
15667 device_param->kernel_threads = kernel_threads;
15668
15669 device_param->hardware_power = device_processors * kernel_threads;
15670
15671 /**
15672 * create input buffers on device : calculate size of fixed memory buffers
15673 */
15674
15675 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
15676 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
15677
15678 device_param->size_root_css = size_root_css;
15679 device_param->size_markov_css = size_markov_css;
15680
15681 size_t size_results = sizeof (uint);
15682
15683 device_param->size_results = size_results;
15684
15685 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
15686 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
15687
15688 size_t size_plains = digests_cnt * sizeof (plain_t);
15689 size_t size_salts = salts_cnt * sizeof (salt_t);
15690 size_t size_esalts = salts_cnt * esalt_size;
15691
15692 device_param->size_plains = size_plains;
15693 device_param->size_digests = size_digests;
15694 device_param->size_shown = size_shown;
15695 device_param->size_salts = size_salts;
15696
15697 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
15698 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
15699 size_t size_tm = 32 * sizeof (bs_word_t);
15700
15701 // scryptV stuff
15702
15703 size_t size_scrypt = 4;
15704
15705 if ((hash_mode == 8900) || (hash_mode == 9300))
15706 {
15707 // we need to check that all hashes have the same scrypt settings
15708
15709 const u32 scrypt_N = data.salts_buf[0].scrypt_N;
15710 const u32 scrypt_r = data.salts_buf[0].scrypt_r;
15711 const u32 scrypt_p = data.salts_buf[0].scrypt_p;
15712
15713 for (uint i = 1; i < salts_cnt; i++)
15714 {
15715 if ((data.salts_buf[i].scrypt_N != scrypt_N)
15716 || (data.salts_buf[i].scrypt_r != scrypt_r)
15717 || (data.salts_buf[i].scrypt_p != scrypt_p))
15718 {
15719 log_error ("ERROR: Mixed scrypt settings not supported");
15720
15721 return -1;
15722 }
15723 }
15724
15725 uint tmto_start = 0;
15726 uint tmto_stop = 10;
15727
15728 if (scrypt_tmto)
15729 {
15730 tmto_start = scrypt_tmto;
15731 }
15732 else
15733 {
15734 // in case the user did not specify the tmto manually
15735 // use some values known to run best (tested on 290x for AMD and GTX1080 for NV)
15736
15737 if (hash_mode == 8900)
15738 {
15739 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15740 {
15741 tmto_start = 3;
15742 }
15743 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15744 {
15745 tmto_start = 2;
15746 }
15747 }
15748 else if (hash_mode == 9300)
15749 {
15750 if (device_param->device_vendor_id == VENDOR_ID_AMD)
15751 {
15752 tmto_start = 2;
15753 }
15754 else if (device_param->device_vendor_id == VENDOR_ID_NV)
15755 {
15756 tmto_start = 4;
15757 }
15758 }
15759 }
15760
15761 data.scrypt_tmp_size = (128 * scrypt_r * scrypt_p);
15762
15763 device_param->kernel_accel_min = 1;
15764 device_param->kernel_accel_max = 8;
15765
15766 uint tmto;
15767
15768 for (tmto = tmto_start; tmto < tmto_stop; tmto++)
15769 {
15770 size_scrypt = (128 * scrypt_r) * scrypt_N;
15771
15772 size_scrypt /= 1 << tmto;
15773
15774 size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max;
15775
15776 if ((size_scrypt / 4) > device_param->device_maxmem_alloc)
15777 {
15778 if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15779
15780 continue;
15781 }
15782
15783 if (size_scrypt > device_param->device_global_mem)
15784 {
15785 if (quiet == 0) log_info ("WARNING: Not enough total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
15786
15787 continue;
15788 }
15789
15790 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
15791 {
15792 data.scrypt_tmto_final = tmto;
15793 }
15794
15795 break;
15796 }
15797
15798 if (tmto == tmto_stop)
15799 {
15800 log_error ("ERROR: Can't allocate enough device memory");
15801
15802 return -1;
15803 }
15804
15805 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);
15806 }
15807
15808 size_t size_scrypt4 = size_scrypt / 4;
15809
15810 /**
15811 * some algorithms need a fixed kernel-loops count
15812 */
15813
15814 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
15815 {
15816 const u32 kernel_loops_fixed = 1024;
15817
15818 device_param->kernel_loops_min = kernel_loops_fixed;
15819 device_param->kernel_loops_max = kernel_loops_fixed;
15820 }
15821
15822 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
15823 {
15824 const u32 kernel_loops_fixed = 1024;
15825
15826 device_param->kernel_loops_min = kernel_loops_fixed;
15827 device_param->kernel_loops_max = kernel_loops_fixed;
15828 }
15829
15830 if (hash_mode == 8900)
15831 {
15832 const u32 kernel_loops_fixed = 1;
15833
15834 device_param->kernel_loops_min = kernel_loops_fixed;
15835 device_param->kernel_loops_max = kernel_loops_fixed;
15836 }
15837
15838 if (hash_mode == 9300)
15839 {
15840 const u32 kernel_loops_fixed = 1;
15841
15842 device_param->kernel_loops_min = kernel_loops_fixed;
15843 device_param->kernel_loops_max = kernel_loops_fixed;
15844 }
15845
15846 if (hash_mode == 12500)
15847 {
15848 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15849
15850 device_param->kernel_loops_min = kernel_loops_fixed;
15851 device_param->kernel_loops_max = kernel_loops_fixed;
15852 }
15853
15854 /**
15855 * some algorithms have a maximum kernel-loops count
15856 */
15857
15858 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15859 {
15860 u32 innerloop_cnt = 0;
15861
15862 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15863 {
15864 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15865 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15866 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15867 }
15868 else
15869 {
15870 innerloop_cnt = data.salts_buf[0].salt_iter;
15871 }
15872
15873 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15874 (innerloop_cnt <= device_param->kernel_loops_max))
15875 {
15876 device_param->kernel_loops_max = innerloop_cnt;
15877 }
15878 }
15879
15880 u32 kernel_accel_min = device_param->kernel_accel_min;
15881 u32 kernel_accel_max = device_param->kernel_accel_max;
15882
15883 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15884
15885 size_t size_pws = 4;
15886 size_t size_tmps = 4;
15887 size_t size_hooks = 4;
15888
15889 while (kernel_accel_max >= kernel_accel_min)
15890 {
15891 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15892
15893 // size_pws
15894
15895 size_pws = kernel_power_max * sizeof (pw_t);
15896
15897 // size_tmps
15898
15899 switch (hash_mode)
15900 {
15901 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15902 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15903 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15904 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15905 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15906 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15907 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15908 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15909 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15910 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15911 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15912 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15913 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15914 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15915 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15916 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15917 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15918 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15919 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15920 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15921 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15922 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15923 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15924 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15925 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15926 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15927 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15928 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15929 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15930 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15931 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15932 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15933 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15934 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15935 case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15936 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15937 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15938 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15939 case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break;
15940 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15941 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15942 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15943 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15944 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15945 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15946 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15947 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15948 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15949 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15950 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15951 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15952 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15953 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15954 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15955 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15956 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15957 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15958 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15959 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15960 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15961 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15962 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15963 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15964 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15965 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15966 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15967 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15968 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15969 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15970 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15971 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15972 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15973 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15974 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15975 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15976 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15977 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15978 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15979 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15980 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15981 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15982 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15983 };
15984
15985 // size_hooks
15986
15987 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15988 {
15989 switch (hash_mode)
15990 {
15991 }
15992 }
15993
15994 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15995 // if not, decrease amplifier and try again
15996
15997 int memory_limit_hit = 0;
15998
15999 if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16000 if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16001 if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1;
16002
16003 const u64 size_total
16004 = bitmap_size
16005 + bitmap_size
16006 + bitmap_size
16007 + bitmap_size
16008 + bitmap_size
16009 + bitmap_size
16010 + bitmap_size
16011 + bitmap_size
16012 + size_bfs
16013 + size_combs
16014 + size_digests
16015 + size_esalts
16016 + size_hooks
16017 + size_markov_css
16018 + size_plains
16019 + size_pws
16020 + size_pws // not a bug
16021 + size_results
16022 + size_root_css
16023 + size_rules
16024 + size_rules_c
16025 + size_salts
16026 + size_scrypt4
16027 + size_scrypt4
16028 + size_scrypt4
16029 + size_scrypt4
16030 + size_shown
16031 + size_tm
16032 + size_tmps;
16033
16034 if (size_total > device_param->device_global_mem) memory_limit_hit = 1;
16035
16036 if (memory_limit_hit == 1)
16037 {
16038 kernel_accel_max--;
16039
16040 continue;
16041 }
16042
16043 break;
16044 }
16045
16046 if (kernel_accel_max < kernel_accel_min)
16047 {
16048 log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle this attack", device_id + 1);
16049
16050 return -1;
16051 }
16052
16053 device_param->kernel_accel_min = kernel_accel_min;
16054 device_param->kernel_accel_max = kernel_accel_max;
16055
16056 /*
16057 if (kernel_accel_max < kernel_accel)
16058 {
16059 if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
16060
16061 device_param->kernel_accel = kernel_accel_max;
16062 }
16063 */
16064
16065 device_param->size_bfs = size_bfs;
16066 device_param->size_combs = size_combs;
16067 device_param->size_rules = size_rules;
16068 device_param->size_rules_c = size_rules_c;
16069 device_param->size_pws = size_pws;
16070 device_param->size_tmps = size_tmps;
16071 device_param->size_hooks = size_hooks;
16072
16073 /**
16074 * default building options
16075 */
16076
16077 char cpath[1024] = { 0 };
16078
16079 char build_opts[1024] = { 0 };
16080
16081 #if _WIN
16082
16083 snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir);
16084
16085 char *cpath_real = mymalloc (MAX_PATH);
16086
16087 if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0)
16088 {
16089 log_error ("ERROR: %s: %s", cpath, "GetFullPathName()");
16090
16091 return -1;
16092 }
16093
16094 naive_replace (cpath_real, '\\', '/');
16095
16096 // not escaping here, windows has quotes
16097
16098 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real);
16099
16100 #else
16101
16102 snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir);
16103
16104 char *cpath_real = mymalloc (PATH_MAX);
16105
16106 if (realpath (cpath, cpath_real) == NULL)
16107 {
16108 log_error ("ERROR: %s: %s", cpath, strerror (errno));
16109
16110 return -1;
16111 }
16112
16113 naive_escape (cpath_real, PATH_MAX, ' ', '\\');
16114
16115 snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real);
16116
16117 #endif
16118
16119 // include check
16120 // this test needs to be done manually because of osx opencl runtime
16121 // if there's a problem with permission, its not reporting back and erroring out silently
16122
16123 #define files_cnt 15
16124
16125 const char *files_names[files_cnt] =
16126 {
16127 "inc_cipher_aes256.cl",
16128 "inc_cipher_serpent256.cl",
16129 "inc_cipher_twofish256.cl",
16130 "inc_common.cl",
16131 "inc_comp_multi_bs.cl",
16132 "inc_comp_multi.cl",
16133 "inc_comp_single_bs.cl",
16134 "inc_comp_single.cl",
16135 "inc_hash_constants.h",
16136 "inc_hash_functions.cl",
16137 "inc_rp.cl",
16138 "inc_rp.h",
16139 "inc_simd.cl",
16140 "inc_types.cl",
16141 "inc_vendor.cl",
16142 };
16143
16144 for (int i = 0; i < files_cnt; i++)
16145 {
16146 char path[1024] = { 0 };
16147
16148 snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]);
16149
16150 FILE *fd = fopen (path, "r");
16151
16152 if (fd == NULL)
16153 {
16154 log_error ("ERROR: %s: fopen(): %s", path, strerror (errno));
16155
16156 return -1;
16157 }
16158
16159 char buf[1];
16160
16161 size_t n = fread (buf, 1, 1, fd);
16162
16163 if (n != 1)
16164 {
16165 log_error ("ERROR: %s: fread(): %s", path, strerror (errno));
16166
16167 return -1;
16168 }
16169
16170 fclose (fd);
16171 }
16172
16173 myfree (cpath_real);
16174
16175 // we don't have sm_* on vendors not NV but it doesn't matter
16176
16177 char build_opts_new[1024] = { 0 };
16178
16179 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);
16180
16181 strncpy (build_opts, build_opts_new, sizeof (build_opts));
16182
16183 #ifdef DEBUG
16184 log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
16185 #endif
16186
16187 /**
16188 * main kernel
16189 */
16190
16191 {
16192 /**
16193 * kernel source filename
16194 */
16195
16196 char source_file[256] = { 0 };
16197
16198 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
16199
16200 struct stat sst;
16201
16202 if (stat (source_file, &sst) == -1)
16203 {
16204 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16205
16206 return -1;
16207 }
16208
16209 /**
16210 * kernel cached filename
16211 */
16212
16213 char cached_file[256] = { 0 };
16214
16215 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
16216
16217 int cached = 1;
16218
16219 struct stat cst;
16220
16221 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
16222 {
16223 cached = 0;
16224 }
16225
16226 /**
16227 * kernel compile or load
16228 */
16229
16230 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16231
16232 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16233
16234 if (force_jit_compilation == -1)
16235 {
16236 if (cached == 0)
16237 {
16238 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));
16239
16240 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16241
16242 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16243
16244 if (CL_err != CL_SUCCESS)
16245 {
16246 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16247
16248 return -1;
16249 }
16250
16251 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16252
16253 if (CL_err != CL_SUCCESS)
16254 {
16255 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16256
16257 //return -1;
16258 }
16259
16260 #ifdef DEBUG
16261 size_t build_log_size = 0;
16262
16263 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16264
16265 if (CL_err != CL_SUCCESS)
16266 {
16267 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16268
16269 return -1;
16270 }
16271
16272 if (build_log_size > 1)
16273 {
16274 char *build_log = (char *) mymalloc (build_log_size + 1);
16275
16276 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16277
16278 if (CL_err != CL_SUCCESS)
16279 {
16280 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16281
16282 return -1;
16283 }
16284
16285 puts (build_log);
16286
16287 myfree (build_log);
16288 }
16289 #endif
16290
16291 if (CL_err != CL_SUCCESS)
16292 {
16293 device_param->skipped = true;
16294
16295 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16296
16297 continue;
16298 }
16299
16300 size_t binary_size;
16301
16302 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16303
16304 if (CL_err != CL_SUCCESS)
16305 {
16306 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16307
16308 return -1;
16309 }
16310
16311 u8 *binary = (u8 *) mymalloc (binary_size);
16312
16313 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16314
16315 if (CL_err != CL_SUCCESS)
16316 {
16317 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16318
16319 return -1;
16320 }
16321
16322 writeProgramBin (cached_file, binary, binary_size);
16323
16324 local_free (binary);
16325 }
16326 else
16327 {
16328 #ifdef DEBUG
16329 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16330 #endif
16331
16332 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16333
16334 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program);
16335
16336 if (CL_err != CL_SUCCESS)
16337 {
16338 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16339
16340 return -1;
16341 }
16342
16343 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL);
16344
16345 if (CL_err != CL_SUCCESS)
16346 {
16347 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16348
16349 return -1;
16350 }
16351 }
16352 }
16353 else
16354 {
16355 #ifdef DEBUG
16356 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
16357 #endif
16358
16359 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16360
16361 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program);
16362
16363 if (CL_err != CL_SUCCESS)
16364 {
16365 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16366
16367 return -1;
16368 }
16369
16370 char build_opts_update[1024] = { 0 };
16371
16372 if (force_jit_compilation == 1500)
16373 {
16374 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]);
16375 }
16376 else if (force_jit_compilation == 8900)
16377 {
16378 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);
16379 }
16380 else
16381 {
16382 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
16383 }
16384
16385 CL_err = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL);
16386
16387 if (CL_err != CL_SUCCESS)
16388 {
16389 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16390
16391 //return -1;
16392 }
16393
16394 #ifdef DEBUG
16395 size_t build_log_size = 0;
16396
16397 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
16398
16399 if (CL_err != CL_SUCCESS)
16400 {
16401 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16402
16403 return -1;
16404 }
16405
16406 if (build_log_size > 1)
16407 {
16408 char *build_log = (char *) mymalloc (build_log_size + 1);
16409
16410 CL_err = hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
16411
16412 if (CL_err != CL_SUCCESS)
16413 {
16414 log_error ("ERROR: clGetProgramBuildInfo(): %s\n", val2cstr_cl (CL_err));
16415
16416 return -1;
16417 }
16418
16419 puts (build_log);
16420
16421 myfree (build_log);
16422 }
16423 #endif
16424
16425 if (CL_err != CL_SUCCESS)
16426 {
16427 device_param->skipped = true;
16428
16429 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16430 }
16431 }
16432
16433 local_free (kernel_lengths);
16434 local_free (kernel_sources[0]);
16435 local_free (kernel_sources);
16436 }
16437
16438 /**
16439 * word generator kernel
16440 */
16441
16442 if (attack_mode != ATTACK_MODE_STRAIGHT)
16443 {
16444 /**
16445 * kernel mp source filename
16446 */
16447
16448 char source_file[256] = { 0 };
16449
16450 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
16451
16452 struct stat sst;
16453
16454 if (stat (source_file, &sst) == -1)
16455 {
16456 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16457
16458 return -1;
16459 }
16460
16461 /**
16462 * kernel mp cached filename
16463 */
16464
16465 char cached_file[256] = { 0 };
16466
16467 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
16468
16469 int cached = 1;
16470
16471 struct stat cst;
16472
16473 if (stat (cached_file, &cst) == -1)
16474 {
16475 cached = 0;
16476 }
16477
16478 /**
16479 * kernel compile or load
16480 */
16481
16482 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16483
16484 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16485
16486 if (cached == 0)
16487 {
16488 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));
16489 if (quiet == 0) log_info ("");
16490
16491 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16492
16493 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_mp);
16494
16495 if (CL_err != CL_SUCCESS)
16496 {
16497 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16498
16499 return -1;
16500 }
16501
16502 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16503
16504 if (CL_err != CL_SUCCESS)
16505 {
16506 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16507
16508 //return -1;
16509 }
16510
16511 if (CL_err != CL_SUCCESS)
16512 {
16513 device_param->skipped = true;
16514
16515 log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
16516
16517 continue;
16518 }
16519
16520 size_t binary_size;
16521
16522 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16523
16524 if (CL_err != CL_SUCCESS)
16525 {
16526 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16527
16528 return -1;
16529 }
16530
16531 u8 *binary = (u8 *) mymalloc (binary_size);
16532
16533 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16534
16535 if (CL_err != CL_SUCCESS)
16536 {
16537 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16538
16539 return -1;
16540 }
16541
16542 writeProgramBin (cached_file, binary, binary_size);
16543
16544 local_free (binary);
16545 }
16546 else
16547 {
16548 #ifdef DEBUG
16549 log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16550 #endif
16551
16552 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16553
16554 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_mp);
16555
16556 if (CL_err != CL_SUCCESS)
16557 {
16558 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16559
16560 return -1;
16561 }
16562
16563 CL_err = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL);
16564
16565 if (CL_err != CL_SUCCESS)
16566 {
16567 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16568
16569 return -1;
16570 }
16571 }
16572
16573 local_free (kernel_lengths);
16574 local_free (kernel_sources[0]);
16575 local_free (kernel_sources);
16576 }
16577
16578 /**
16579 * amplifier kernel
16580 */
16581
16582 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16583 {
16584
16585 }
16586 else
16587 {
16588 /**
16589 * kernel amp source filename
16590 */
16591
16592 char source_file[256] = { 0 };
16593
16594 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
16595
16596 struct stat sst;
16597
16598 if (stat (source_file, &sst) == -1)
16599 {
16600 log_error ("ERROR: %s: %s", source_file, strerror (errno));
16601
16602 return -1;
16603 }
16604
16605 /**
16606 * kernel amp cached filename
16607 */
16608
16609 char cached_file[256] = { 0 };
16610
16611 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
16612
16613 int cached = 1;
16614
16615 struct stat cst;
16616
16617 if (stat (cached_file, &cst) == -1)
16618 {
16619 cached = 0;
16620 }
16621
16622 /**
16623 * kernel compile or load
16624 */
16625
16626 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
16627
16628 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
16629
16630 if (cached == 0)
16631 {
16632 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));
16633 if (quiet == 0) log_info ("");
16634
16635 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
16636
16637 CL_err = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_amp);
16638
16639 if (CL_err != CL_SUCCESS)
16640 {
16641 log_error ("ERROR: clCreateProgramWithSource(): %s\n", val2cstr_cl (CL_err));
16642
16643 return -1;
16644 }
16645
16646 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16647
16648 if (CL_err != CL_SUCCESS)
16649 {
16650 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16651
16652 //return -1;
16653 }
16654
16655 if (CL_err != CL_SUCCESS)
16656 {
16657 device_param->skipped = true;
16658
16659 log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
16660
16661 continue;
16662 }
16663
16664 size_t binary_size;
16665
16666 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
16667
16668 if (CL_err != CL_SUCCESS)
16669 {
16670 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16671
16672 return -1;
16673 }
16674
16675 u8 *binary = (u8 *) mymalloc (binary_size);
16676
16677 CL_err = hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
16678
16679 if (CL_err != CL_SUCCESS)
16680 {
16681 log_error ("ERROR: clGetProgramInfo(): %s\n", val2cstr_cl (CL_err));
16682
16683 return -1;
16684 }
16685
16686 writeProgramBin (cached_file, binary, binary_size);
16687
16688 local_free (binary);
16689 }
16690 else
16691 {
16692 #ifdef DEBUG
16693 if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
16694 #endif
16695
16696 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
16697
16698 CL_err = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL, &device_param->program_amp);
16699
16700 if (CL_err != CL_SUCCESS)
16701 {
16702 log_error ("ERROR: clCreateProgramWithBinary(): %s\n", val2cstr_cl (CL_err));
16703
16704 return -1;
16705 }
16706
16707 CL_err = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL);
16708
16709 if (CL_err != CL_SUCCESS)
16710 {
16711 log_error ("ERROR: clBuildProgram(): %s\n", val2cstr_cl (CL_err));
16712
16713 return -1;
16714 }
16715 }
16716
16717 local_free (kernel_lengths);
16718 local_free (kernel_sources[0]);
16719 local_free (kernel_sources);
16720 }
16721
16722 // some algorithm collide too fast, make that impossible
16723
16724 if (benchmark == 1)
16725 {
16726 ((uint *) digests_buf)[0] = -1;
16727 ((uint *) digests_buf)[1] = -1;
16728 ((uint *) digests_buf)[2] = -1;
16729 ((uint *) digests_buf)[3] = -1;
16730 }
16731
16732 /**
16733 * global buffers
16734 */
16735
16736 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_buf);
16737 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL, &device_param->d_pws_amp_buf);
16738 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL, &device_param->d_tmps);
16739 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL, &device_param->d_hooks);
16740 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_a);
16741 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_b);
16742 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_c);
16743 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s1_d);
16744 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_a);
16745 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_b);
16746 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_c);
16747 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL, &device_param->d_bitmap_s2_d);
16748 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL, &device_param->d_plain_bufs);
16749 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL, &device_param->d_digests_buf);
16750 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL, &device_param->d_digests_shown);
16751 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL, &device_param->d_salt_bufs);
16752 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL, &device_param->d_result);
16753 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV0_buf);
16754 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV1_buf);
16755 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV2_buf);
16756 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL, &device_param->d_scryptV3_buf);
16757
16758 if (CL_err != CL_SUCCESS)
16759 {
16760 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16761
16762 return -1;
16763 }
16764
16765 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);
16766 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);
16767 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);
16768 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);
16769 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);
16770 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);
16771 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);
16772 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);
16773 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);
16774 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);
16775 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);
16776
16777 if (CL_err != CL_SUCCESS)
16778 {
16779 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16780
16781 return -1;
16782 }
16783
16784 /**
16785 * special buffers
16786 */
16787
16788 if (attack_kern == ATTACK_KERN_STRAIGHT)
16789 {
16790 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL, &device_param->d_rules);
16791 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL, &device_param->d_rules_c);
16792
16793 if (CL_err != CL_SUCCESS)
16794 {
16795 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16796
16797 return -1;
16798 }
16799
16800 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);
16801
16802 if (CL_err != CL_SUCCESS)
16803 {
16804 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16805
16806 return -1;
16807 }
16808 }
16809 else if (attack_kern == ATTACK_KERN_COMBI)
16810 {
16811 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs);
16812 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL, &device_param->d_combs_c);
16813 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16814 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
16815
16816 if (CL_err != CL_SUCCESS)
16817 {
16818 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16819
16820 return -1;
16821 }
16822 }
16823 else if (attack_kern == ATTACK_KERN_BF)
16824 {
16825 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs);
16826 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL, &device_param->d_bfs_c);
16827 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL, &device_param->d_tm_c);
16828 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL, &device_param->d_root_css_buf);
16829 CL_err |= hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL, &device_param->d_markov_css_buf);
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
16839 if (size_esalts)
16840 {
16841 CL_err = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL, &device_param->d_esalt_bufs);
16842
16843 if (CL_err != CL_SUCCESS)
16844 {
16845 log_error ("ERROR: clCreateBuffer(): %s\n", val2cstr_cl (CL_err));
16846
16847 return -1;
16848 }
16849
16850 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);
16851
16852 if (CL_err != CL_SUCCESS)
16853 {
16854 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
16855
16856 return -1;
16857 }
16858 }
16859
16860 /**
16861 * main host data
16862 */
16863
16864 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
16865
16866 device_param->pws_buf = pws_buf;
16867
16868 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
16869
16870 device_param->combs_buf = combs_buf;
16871
16872 void *hooks_buf = mymalloc (size_hooks);
16873
16874 device_param->hooks_buf = hooks_buf;
16875
16876 /**
16877 * kernel args
16878 */
16879
16880 device_param->kernel_params_buf32[24] = bitmap_mask;
16881 device_param->kernel_params_buf32[25] = bitmap_shift1;
16882 device_param->kernel_params_buf32[26] = bitmap_shift2;
16883 device_param->kernel_params_buf32[27] = 0; // salt_pos
16884 device_param->kernel_params_buf32[28] = 0; // loop_pos
16885 device_param->kernel_params_buf32[29] = 0; // loop_cnt
16886 device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt
16887 device_param->kernel_params_buf32[31] = 0; // digests_cnt
16888 device_param->kernel_params_buf32[32] = 0; // digests_offset
16889 device_param->kernel_params_buf32[33] = 0; // combs_mode
16890 device_param->kernel_params_buf32[34] = 0; // gid_max
16891
16892 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16893 ? &device_param->d_pws_buf
16894 : &device_param->d_pws_amp_buf;
16895 device_param->kernel_params[ 1] = &device_param->d_rules_c;
16896 device_param->kernel_params[ 2] = &device_param->d_combs_c;
16897 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
16898 device_param->kernel_params[ 4] = &device_param->d_tmps;
16899 device_param->kernel_params[ 5] = &device_param->d_hooks;
16900 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
16901 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
16902 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
16903 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
16904 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
16905 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
16906 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
16907 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
16908 device_param->kernel_params[14] = &device_param->d_plain_bufs;
16909 device_param->kernel_params[15] = &device_param->d_digests_buf;
16910 device_param->kernel_params[16] = &device_param->d_digests_shown;
16911 device_param->kernel_params[17] = &device_param->d_salt_bufs;
16912 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
16913 device_param->kernel_params[19] = &device_param->d_result;
16914 device_param->kernel_params[20] = &device_param->d_scryptV0_buf;
16915 device_param->kernel_params[21] = &device_param->d_scryptV1_buf;
16916 device_param->kernel_params[22] = &device_param->d_scryptV2_buf;
16917 device_param->kernel_params[23] = &device_param->d_scryptV3_buf;
16918 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
16919 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
16920 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
16921 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
16922 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
16923 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
16924 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
16925 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
16926 device_param->kernel_params[32] = &device_param->kernel_params_buf32[32];
16927 device_param->kernel_params[33] = &device_param->kernel_params_buf32[33];
16928 device_param->kernel_params[34] = &device_param->kernel_params_buf32[34];
16929
16930 device_param->kernel_params_mp_buf64[3] = 0;
16931 device_param->kernel_params_mp_buf32[4] = 0;
16932 device_param->kernel_params_mp_buf32[5] = 0;
16933 device_param->kernel_params_mp_buf32[6] = 0;
16934 device_param->kernel_params_mp_buf32[7] = 0;
16935 device_param->kernel_params_mp_buf32[8] = 0;
16936
16937 device_param->kernel_params_mp[0] = NULL;
16938 device_param->kernel_params_mp[1] = NULL;
16939 device_param->kernel_params_mp[2] = NULL;
16940 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
16941 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
16942 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
16943 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
16944 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
16945 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
16946
16947 device_param->kernel_params_mp_l_buf64[3] = 0;
16948 device_param->kernel_params_mp_l_buf32[4] = 0;
16949 device_param->kernel_params_mp_l_buf32[5] = 0;
16950 device_param->kernel_params_mp_l_buf32[6] = 0;
16951 device_param->kernel_params_mp_l_buf32[7] = 0;
16952 device_param->kernel_params_mp_l_buf32[8] = 0;
16953 device_param->kernel_params_mp_l_buf32[9] = 0;
16954
16955 device_param->kernel_params_mp_l[0] = NULL;
16956 device_param->kernel_params_mp_l[1] = NULL;
16957 device_param->kernel_params_mp_l[2] = NULL;
16958 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
16959 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
16960 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
16961 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
16962 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
16963 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
16964 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
16965
16966 device_param->kernel_params_mp_r_buf64[3] = 0;
16967 device_param->kernel_params_mp_r_buf32[4] = 0;
16968 device_param->kernel_params_mp_r_buf32[5] = 0;
16969 device_param->kernel_params_mp_r_buf32[6] = 0;
16970 device_param->kernel_params_mp_r_buf32[7] = 0;
16971 device_param->kernel_params_mp_r_buf32[8] = 0;
16972
16973 device_param->kernel_params_mp_r[0] = NULL;
16974 device_param->kernel_params_mp_r[1] = NULL;
16975 device_param->kernel_params_mp_r[2] = NULL;
16976 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
16977 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
16978 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
16979 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
16980 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
16981 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
16982
16983 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
16984 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
16985
16986 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
16987 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
16988 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
16989 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
16990 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
16991 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
16992 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
16993
16994 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
16995 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
16996
16997 device_param->kernel_params_memset_buf32[1] = 0; // value
16998 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
16999
17000 device_param->kernel_params_memset[0] = NULL;
17001 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
17002 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
17003
17004 /**
17005 * kernel name
17006 */
17007
17008 size_t kernel_wgs_tmp;
17009
17010 char kernel_name[64] = { 0 };
17011
17012 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17013 {
17014 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17015 {
17016 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
17017
17018 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17019
17020 if (CL_err != CL_SUCCESS)
17021 {
17022 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17023
17024 return -1;
17025 }
17026
17027 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
17028
17029 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17030
17031 if (CL_err != CL_SUCCESS)
17032 {
17033 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17034
17035 return -1;
17036 }
17037
17038 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
17039
17040 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17041
17042 if (CL_err != CL_SUCCESS)
17043 {
17044 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17045
17046 return -1;
17047 }
17048 }
17049 else
17050 {
17051 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
17052
17053 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17054
17055 if (CL_err != CL_SUCCESS)
17056 {
17057 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17058
17059 return -1;
17060 }
17061
17062 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
17063
17064 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17065
17066 if (CL_err != CL_SUCCESS)
17067 {
17068 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17069
17070 return -1;
17071 }
17072
17073 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
17074
17075 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17076
17077 if (CL_err != CL_SUCCESS)
17078 {
17079 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17080
17081 return -1;
17082 }
17083 }
17084
17085 if (data.attack_mode == ATTACK_MODE_BF)
17086 {
17087 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17088 {
17089 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
17090
17091 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel_tm);
17092
17093 if (CL_err != CL_SUCCESS)
17094 {
17095 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17096
17097 return -1;
17098 }
17099
17100 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);
17101
17102 if (CL_err != CL_SUCCESS)
17103 {
17104 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17105
17106 return -1;
17107 }
17108 }
17109 }
17110 }
17111 else
17112 {
17113 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
17114
17115 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel1);
17116
17117 if (CL_err != CL_SUCCESS)
17118 {
17119 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17120
17121 return -1;
17122 }
17123
17124 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
17125
17126 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel2);
17127
17128 if (CL_err != CL_SUCCESS)
17129 {
17130 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17131
17132 return -1;
17133 }
17134
17135 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
17136
17137 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel3);
17138
17139 if (CL_err != CL_SUCCESS)
17140 {
17141 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17142
17143 return -1;
17144 }
17145
17146 if (opts_type & OPTS_TYPE_HOOK12)
17147 {
17148 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
17149
17150 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel12);
17151
17152 if (CL_err != CL_SUCCESS)
17153 {
17154 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17155
17156 return -1;
17157 }
17158
17159 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);
17160
17161 if (CL_err != CL_SUCCESS)
17162 {
17163 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17164
17165 return -1;
17166 }
17167 }
17168
17169 if (opts_type & OPTS_TYPE_HOOK23)
17170 {
17171 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
17172
17173 CL_err = hc_clCreateKernel (data.ocl, device_param->program, kernel_name, &device_param->kernel23);
17174
17175 if (CL_err != CL_SUCCESS)
17176 {
17177 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17178
17179 return -1;
17180 }
17181
17182 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);
17183
17184 if (CL_err != CL_SUCCESS)
17185 {
17186 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17187
17188 return -1;
17189 }
17190 }
17191 }
17192
17193 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);
17194 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);
17195 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);
17196
17197 if (CL_err != CL_SUCCESS)
17198 {
17199 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17200
17201 return -1;
17202 }
17203
17204 for (uint i = 0; i <= 23; i++)
17205 {
17206 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
17207 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
17208 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
17209
17210 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
17211 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
17212
17213 if (CL_err != CL_SUCCESS)
17214 {
17215 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17216
17217 return -1;
17218 }
17219 }
17220
17221 for (uint i = 24; i <= 34; i++)
17222 {
17223 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
17224 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
17225 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
17226
17227 if (opts_type & OPTS_TYPE_HOOK12) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
17228 if (opts_type & OPTS_TYPE_HOOK23) CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
17229
17230 if (CL_err != CL_SUCCESS)
17231 {
17232 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17233
17234 return -1;
17235 }
17236 }
17237
17238 // GPU memset
17239
17240 CL_err = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset", &device_param->kernel_memset);
17241
17242 if (CL_err != CL_SUCCESS)
17243 {
17244 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17245
17246 return -1;
17247 }
17248
17249 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);
17250
17251 if (CL_err != CL_SUCCESS)
17252 {
17253 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17254
17255 return -1;
17256 }
17257
17258 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
17259 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
17260 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
17261
17262 if (CL_err != CL_SUCCESS)
17263 {
17264 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17265
17266 return -1;
17267 }
17268
17269 // MP start
17270
17271 if (attack_mode == ATTACK_MODE_BF)
17272 {
17273 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov", &device_param->kernel_mp_l);
17274 CL_err |= hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov", &device_param->kernel_mp_r);
17275
17276 if (CL_err != CL_SUCCESS)
17277 {
17278 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17279
17280 return -1;
17281 }
17282
17283 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);
17284 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);
17285
17286 if (CL_err != CL_SUCCESS)
17287 {
17288 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17289
17290 return -1;
17291 }
17292
17293 if (opts_type & OPTS_TYPE_PT_BITSLICE)
17294 {
17295 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
17296 CL_err |= hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
17297
17298 if (CL_err != CL_SUCCESS)
17299 {
17300 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17301
17302 return -1;
17303 }
17304 }
17305 }
17306 else if (attack_mode == ATTACK_MODE_HYBRID1)
17307 {
17308 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17309
17310 if (CL_err != CL_SUCCESS)
17311 {
17312 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17313
17314 return -1;
17315 }
17316
17317 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);
17318
17319 if (CL_err != CL_SUCCESS)
17320 {
17321 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17322
17323 return -1;
17324 }
17325 }
17326 else if (attack_mode == ATTACK_MODE_HYBRID2)
17327 {
17328 CL_err = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov", &device_param->kernel_mp);
17329
17330 if (CL_err != CL_SUCCESS)
17331 {
17332 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17333
17334 return -1;
17335 }
17336
17337 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);
17338
17339 if (CL_err != CL_SUCCESS)
17340 {
17341 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17342
17343 return -1;
17344 }
17345 }
17346
17347 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17348 {
17349 // nothing to do
17350 }
17351 else
17352 {
17353 CL_err = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp", &device_param->kernel_amp);
17354
17355 if (CL_err != CL_SUCCESS)
17356 {
17357 log_error ("ERROR: clCreateKernel(): %s\n", val2cstr_cl (CL_err));
17358
17359 return -1;
17360 }
17361
17362 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);
17363
17364 if (CL_err != CL_SUCCESS)
17365 {
17366 log_error ("ERROR: clGetKernelWorkGroupInfo(): %s\n", val2cstr_cl (CL_err));
17367
17368 return -1;
17369 }
17370 }
17371
17372 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17373 {
17374 // nothing to do
17375 }
17376 else
17377 {
17378 for (uint i = 0; i < 5; i++)
17379 {
17380 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), 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 for (uint i = 5; i < 7; i++)
17391 {
17392 CL_err = hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
17393
17394 if (CL_err != CL_SUCCESS)
17395 {
17396 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
17397
17398 return -1;
17399 }
17400 }
17401 }
17402
17403 // maybe this has been updated by clGetKernelWorkGroupInfo()
17404 // value can only be decreased, so we don't need to reallocate buffers
17405
17406 device_param->kernel_threads = kernel_threads;
17407
17408 // zero some data buffers
17409
17410 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
17411 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
17412 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
17413 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
17414 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
17415 run_kernel_bzero (device_param, device_param->d_result, size_results);
17416
17417 /**
17418 * special buffers
17419 */
17420
17421 if (attack_kern == ATTACK_KERN_STRAIGHT)
17422 {
17423 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
17424 }
17425 else if (attack_kern == ATTACK_KERN_COMBI)
17426 {
17427 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
17428 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
17429 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17430 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17431 }
17432 else if (attack_kern == ATTACK_KERN_BF)
17433 {
17434 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
17435 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
17436 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
17437 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
17438 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
17439 }
17440
17441 #if defined(HAVE_HWMON)
17442
17443 /**
17444 * Store initial fanspeed if gpu_temp_retain is enabled
17445 */
17446
17447 if (gpu_temp_disable == 0)
17448 {
17449 if (gpu_temp_retain != 0)
17450 {
17451 hc_thread_mutex_lock (mux_adl);
17452
17453 if (data.hm_device[device_id].fan_get_supported == 1)
17454 {
17455 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
17456 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
17457
17458 // we also set it to tell the OS we take control over the fan and it's automatic controller
17459 // if it was set to automatic. we do not control user-defined fanspeeds.
17460
17461 if (fanpolicy == 1)
17462 {
17463 data.hm_device[device_id].fan_set_supported = 1;
17464
17465 int rc = -1;
17466
17467 if (device_param->device_vendor_id == VENDOR_ID_AMD)
17468 {
17469 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
17470 }
17471 else if (device_param->device_vendor_id == VENDOR_ID_NV)
17472 {
17473 #ifdef __linux__
17474 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE);
17475 #endif
17476
17477 #ifdef WIN
17478 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1);
17479 #endif
17480 }
17481
17482 if (rc == 0)
17483 {
17484 data.hm_device[device_id].fan_set_supported = 1;
17485 }
17486 else
17487 {
17488 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
17489
17490 data.hm_device[device_id].fan_set_supported = 0;
17491 }
17492 }
17493 else
17494 {
17495 data.hm_device[device_id].fan_set_supported = 0;
17496 }
17497 }
17498
17499 hc_thread_mutex_unlock (mux_adl);
17500 }
17501 }
17502
17503 #endif // HAVE_HWMON
17504 }
17505
17506 if (data.quiet == 0) log_info_nn ("");
17507
17508 /**
17509 * In benchmark-mode, inform user which algorithm is checked
17510 */
17511
17512 if (benchmark == 1)
17513 {
17514 if (machine_readable == 0)
17515 {
17516 quiet = 0;
17517
17518 data.quiet = quiet;
17519
17520 char *hash_type = strhashtype (data.hash_mode); // not a bug
17521
17522 log_info ("Hashtype: %s", hash_type);
17523 log_info ("");
17524 }
17525 }
17526
17527 /**
17528 * keep track of the progress
17529 */
17530
17531 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17532 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17533 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
17534
17535 /**
17536 * open filehandles
17537 */
17538
17539 #if _WIN
17540 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
17541 {
17542 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
17543
17544 return -1;
17545 }
17546
17547 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
17548 {
17549 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
17550
17551 return -1;
17552 }
17553
17554 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
17555 {
17556 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
17557
17558 return -1;
17559 }
17560 #endif
17561
17562 /**
17563 * dictionary pad
17564 */
17565
17566 segment_size *= (1024 * 1024);
17567
17568 data.segment_size = segment_size;
17569
17570 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
17571
17572 wl_data->buf = (char *) mymalloc (segment_size);
17573 wl_data->avail = segment_size;
17574 wl_data->incr = segment_size;
17575 wl_data->cnt = 0;
17576 wl_data->pos = 0;
17577
17578 cs_t *css_buf = NULL;
17579 uint css_cnt = 0;
17580 uint dictcnt = 0;
17581 uint maskcnt = 1;
17582 char **masks = NULL;
17583 char **dictfiles = NULL;
17584
17585 uint mask_from_file = 0;
17586
17587 if (attack_mode == ATTACK_MODE_STRAIGHT)
17588 {
17589 if (wordlist_mode == WL_MODE_FILE)
17590 {
17591 int wls_left = myargc - (optind + 1);
17592
17593 for (int i = 0; i < wls_left; i++)
17594 {
17595 char *l0_filename = myargv[optind + 1 + i];
17596
17597 struct stat l0_stat;
17598
17599 if (stat (l0_filename, &l0_stat) == -1)
17600 {
17601 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
17602
17603 return -1;
17604 }
17605
17606 uint is_dir = S_ISDIR (l0_stat.st_mode);
17607
17608 if (is_dir == 0)
17609 {
17610 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17611
17612 dictcnt++;
17613
17614 dictfiles[dictcnt - 1] = l0_filename;
17615 }
17616 else
17617 {
17618 // do not allow --keyspace w/ a directory
17619
17620 if (keyspace == 1)
17621 {
17622 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
17623
17624 return -1;
17625 }
17626
17627 char **dictionary_files = NULL;
17628
17629 dictionary_files = scan_directory (l0_filename);
17630
17631 if (dictionary_files != NULL)
17632 {
17633 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
17634
17635 for (int d = 0; dictionary_files[d] != NULL; d++)
17636 {
17637 char *l1_filename = dictionary_files[d];
17638
17639 struct stat l1_stat;
17640
17641 if (stat (l1_filename, &l1_stat) == -1)
17642 {
17643 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
17644
17645 return -1;
17646 }
17647
17648 if (S_ISREG (l1_stat.st_mode))
17649 {
17650 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
17651
17652 dictcnt++;
17653
17654 dictfiles[dictcnt - 1] = strdup (l1_filename);
17655 }
17656 }
17657 }
17658
17659 local_free (dictionary_files);
17660 }
17661 }
17662
17663 if (dictcnt < 1)
17664 {
17665 log_error ("ERROR: No usable dictionary file found.");
17666
17667 return -1;
17668 }
17669 }
17670 else if (wordlist_mode == WL_MODE_STDIN)
17671 {
17672 dictcnt = 1;
17673 }
17674 }
17675 else if (attack_mode == ATTACK_MODE_COMBI)
17676 {
17677 // display
17678
17679 char *dictfile1 = myargv[optind + 1 + 0];
17680 char *dictfile2 = myargv[optind + 1 + 1];
17681
17682 // find the bigger dictionary and use as base
17683
17684 FILE *fp1 = NULL;
17685 FILE *fp2 = NULL;
17686
17687 struct stat tmp_stat;
17688
17689 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
17690 {
17691 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17692
17693 return -1;
17694 }
17695
17696 if (stat (dictfile1, &tmp_stat) == -1)
17697 {
17698 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
17699
17700 fclose (fp1);
17701
17702 return -1;
17703 }
17704
17705 if (S_ISDIR (tmp_stat.st_mode))
17706 {
17707 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
17708
17709 fclose (fp1);
17710
17711 return -1;
17712 }
17713
17714 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
17715 {
17716 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17717
17718 fclose (fp1);
17719
17720 return -1;
17721 }
17722
17723 if (stat (dictfile2, &tmp_stat) == -1)
17724 {
17725 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17726
17727 fclose (fp1);
17728 fclose (fp2);
17729
17730 return -1;
17731 }
17732
17733 if (S_ISDIR (tmp_stat.st_mode))
17734 {
17735 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
17736
17737 fclose (fp1);
17738 fclose (fp2);
17739
17740 return -1;
17741 }
17742
17743 data.combs_cnt = 1;
17744
17745 data.quiet = 1;
17746
17747 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
17748
17749 data.quiet = quiet;
17750
17751 if (words1_cnt == 0)
17752 {
17753 log_error ("ERROR: %s: empty file", dictfile1);
17754
17755 fclose (fp1);
17756 fclose (fp2);
17757
17758 return -1;
17759 }
17760
17761 data.combs_cnt = 1;
17762
17763 data.quiet = 1;
17764
17765 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
17766
17767 data.quiet = quiet;
17768
17769 if (words2_cnt == 0)
17770 {
17771 log_error ("ERROR: %s: empty file", dictfile2);
17772
17773 fclose (fp1);
17774 fclose (fp2);
17775
17776 return -1;
17777 }
17778
17779 fclose (fp1);
17780 fclose (fp2);
17781
17782 data.dictfile = dictfile1;
17783 data.dictfile2 = dictfile2;
17784
17785 if (words1_cnt >= words2_cnt)
17786 {
17787 data.combs_cnt = words2_cnt;
17788 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
17789
17790 dictfiles = &data.dictfile;
17791
17792 dictcnt = 1;
17793 }
17794 else
17795 {
17796 data.combs_cnt = words1_cnt;
17797 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
17798
17799 dictfiles = &data.dictfile2;
17800
17801 dictcnt = 1;
17802
17803 // we also have to switch wordlist related rules!
17804
17805 char *tmpc = data.rule_buf_l;
17806
17807 data.rule_buf_l = data.rule_buf_r;
17808 data.rule_buf_r = tmpc;
17809
17810 int tmpi = data.rule_len_l;
17811
17812 data.rule_len_l = data.rule_len_r;
17813 data.rule_len_r = tmpi;
17814 }
17815 }
17816 else if (attack_mode == ATTACK_MODE_BF)
17817 {
17818 char *mask = NULL;
17819
17820 maskcnt = 0;
17821
17822 if (benchmark == 0)
17823 {
17824 mask = myargv[optind + 1];
17825
17826 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
17827
17828 if ((optind + 2) <= myargc)
17829 {
17830 struct stat file_stat;
17831
17832 if (stat (mask, &file_stat) == -1)
17833 {
17834 maskcnt = 1;
17835
17836 masks[maskcnt - 1] = mystrdup (mask);
17837 }
17838 else
17839 {
17840 int wls_left = myargc - (optind + 1);
17841
17842 uint masks_avail = INCR_MASKS;
17843
17844 for (int i = 0; i < wls_left; i++)
17845 {
17846 if (i != 0)
17847 {
17848 mask = myargv[optind + 1 + i];
17849
17850 if (stat (mask, &file_stat) == -1)
17851 {
17852 log_error ("ERROR: %s: %s", mask, strerror (errno));
17853
17854 return -1;
17855 }
17856 }
17857
17858 uint is_file = S_ISREG (file_stat.st_mode);
17859
17860 if (is_file == 1)
17861 {
17862 FILE *mask_fp;
17863
17864 if ((mask_fp = fopen (mask, "r")) == NULL)
17865 {
17866 log_error ("ERROR: %s: %s", mask, strerror (errno));
17867
17868 return -1;
17869 }
17870
17871 char *line_buf = (char *) mymalloc (HCBUFSIZ);
17872
17873 while (!feof (mask_fp))
17874 {
17875 memset (line_buf, 0, HCBUFSIZ);
17876
17877 int line_len = fgetl (mask_fp, line_buf);
17878
17879 if (line_len == 0) continue;
17880
17881 if (line_buf[0] == '#') continue;
17882
17883 if (masks_avail == maskcnt)
17884 {
17885 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
17886
17887 masks_avail += INCR_MASKS;
17888 }
17889
17890 masks[maskcnt] = mystrdup (line_buf);
17891
17892 maskcnt++;
17893 }
17894
17895 myfree (line_buf);
17896
17897 fclose (mask_fp);
17898 }
17899 else
17900 {
17901 log_error ("ERROR: %s: unsupported file-type", mask);
17902
17903 return -1;
17904 }
17905 }
17906
17907 mask_from_file = 1;
17908 }
17909 }
17910 else
17911 {
17912 custom_charset_1 = (char *) "?l?d?u";
17913 custom_charset_2 = (char *) "?l?d";
17914 custom_charset_3 = (char *) "?l?d*!$@_";
17915
17916 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17917 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17918 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17919
17920 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
17921
17922 wordlist_mode = WL_MODE_MASK;
17923
17924 data.wordlist_mode = wordlist_mode;
17925
17926 increment = 1;
17927
17928 maskcnt = 1;
17929 }
17930 }
17931 else
17932 {
17933 /**
17934 * generate full masks and charsets
17935 */
17936
17937 masks = (char **) mymalloc (sizeof (char *));
17938
17939 switch (hash_mode)
17940 {
17941 case 1731: pw_min = 5;
17942 pw_max = 5;
17943 mask = mystrdup ("?b?b?b?b?b");
17944 break;
17945 case 12500: pw_min = 5;
17946 pw_max = 5;
17947 mask = mystrdup ("?b?b?b?b?b");
17948 break;
17949 default: pw_min = 7;
17950 pw_max = 7;
17951 mask = mystrdup ("?b?b?b?b?b?b?b");
17952 break;
17953 }
17954
17955 maskcnt = 1;
17956
17957 masks[maskcnt - 1] = mystrdup (mask);
17958
17959 wordlist_mode = WL_MODE_MASK;
17960
17961 data.wordlist_mode = wordlist_mode;
17962
17963 increment = 1;
17964 }
17965
17966 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
17967
17968 if (increment)
17969 {
17970 if (increment_min > pw_min) pw_min = increment_min;
17971
17972 if (increment_max < pw_max) pw_max = increment_max;
17973 }
17974 }
17975 else if (attack_mode == ATTACK_MODE_HYBRID1)
17976 {
17977 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
17978
17979 // display
17980
17981 char *mask = myargv[myargc - 1];
17982
17983 maskcnt = 0;
17984
17985 masks = (char **) mymalloc (1 * sizeof (char *));
17986
17987 // mod
17988
17989 struct stat file_stat;
17990
17991 if (stat (mask, &file_stat) == -1)
17992 {
17993 maskcnt = 1;
17994
17995 masks[maskcnt - 1] = mystrdup (mask);
17996 }
17997 else
17998 {
17999 uint is_file = S_ISREG (file_stat.st_mode);
18000
18001 if (is_file == 1)
18002 {
18003 FILE *mask_fp;
18004
18005 if ((mask_fp = fopen (mask, "r")) == NULL)
18006 {
18007 log_error ("ERROR: %s: %s", mask, strerror (errno));
18008
18009 return -1;
18010 }
18011
18012 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18013
18014 uint masks_avail = 1;
18015
18016 while (!feof (mask_fp))
18017 {
18018 memset (line_buf, 0, HCBUFSIZ);
18019
18020 int line_len = fgetl (mask_fp, line_buf);
18021
18022 if (line_len == 0) continue;
18023
18024 if (line_buf[0] == '#') continue;
18025
18026 if (masks_avail == maskcnt)
18027 {
18028 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18029
18030 masks_avail += INCR_MASKS;
18031 }
18032
18033 masks[maskcnt] = mystrdup (line_buf);
18034
18035 maskcnt++;
18036 }
18037
18038 myfree (line_buf);
18039
18040 fclose (mask_fp);
18041
18042 mask_from_file = 1;
18043 }
18044 else
18045 {
18046 maskcnt = 1;
18047
18048 masks[maskcnt - 1] = mystrdup (mask);
18049 }
18050 }
18051
18052 // base
18053
18054 int wls_left = myargc - (optind + 2);
18055
18056 for (int i = 0; i < wls_left; i++)
18057 {
18058 char *filename = myargv[optind + 1 + i];
18059
18060 struct stat file_stat;
18061
18062 if (stat (filename, &file_stat) == -1)
18063 {
18064 log_error ("ERROR: %s: %s", filename, strerror (errno));
18065
18066 return -1;
18067 }
18068
18069 uint is_dir = S_ISDIR (file_stat.st_mode);
18070
18071 if (is_dir == 0)
18072 {
18073 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18074
18075 dictcnt++;
18076
18077 dictfiles[dictcnt - 1] = filename;
18078 }
18079 else
18080 {
18081 // do not allow --keyspace w/ a directory
18082
18083 if (keyspace == 1)
18084 {
18085 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18086
18087 return -1;
18088 }
18089
18090 char **dictionary_files = NULL;
18091
18092 dictionary_files = scan_directory (filename);
18093
18094 if (dictionary_files != NULL)
18095 {
18096 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18097
18098 for (int d = 0; dictionary_files[d] != NULL; d++)
18099 {
18100 char *l1_filename = dictionary_files[d];
18101
18102 struct stat l1_stat;
18103
18104 if (stat (l1_filename, &l1_stat) == -1)
18105 {
18106 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18107
18108 return -1;
18109 }
18110
18111 if (S_ISREG (l1_stat.st_mode))
18112 {
18113 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18114
18115 dictcnt++;
18116
18117 dictfiles[dictcnt - 1] = strdup (l1_filename);
18118 }
18119 }
18120 }
18121
18122 local_free (dictionary_files);
18123 }
18124 }
18125
18126 if (dictcnt < 1)
18127 {
18128 log_error ("ERROR: No usable dictionary file found.");
18129
18130 return -1;
18131 }
18132
18133 if (increment)
18134 {
18135 maskcnt = 0;
18136
18137 uint mask_min = increment_min; // we can't reject smaller masks here
18138 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18139
18140 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18141 {
18142 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18143
18144 if (cur_mask == NULL) break;
18145
18146 masks[maskcnt] = cur_mask;
18147
18148 maskcnt++;
18149
18150 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18151 }
18152 }
18153 }
18154 else if (attack_mode == ATTACK_MODE_HYBRID2)
18155 {
18156 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
18157
18158 // display
18159
18160 char *mask = myargv[optind + 1 + 0];
18161
18162 maskcnt = 0;
18163
18164 masks = (char **) mymalloc (1 * sizeof (char *));
18165
18166 // mod
18167
18168 struct stat file_stat;
18169
18170 if (stat (mask, &file_stat) == -1)
18171 {
18172 maskcnt = 1;
18173
18174 masks[maskcnt - 1] = mystrdup (mask);
18175 }
18176 else
18177 {
18178 uint is_file = S_ISREG (file_stat.st_mode);
18179
18180 if (is_file == 1)
18181 {
18182 FILE *mask_fp;
18183
18184 if ((mask_fp = fopen (mask, "r")) == NULL)
18185 {
18186 log_error ("ERROR: %s: %s", mask, strerror (errno));
18187
18188 return -1;
18189 }
18190
18191 char *line_buf = (char *) mymalloc (HCBUFSIZ);
18192
18193 uint masks_avail = 1;
18194
18195 while (!feof (mask_fp))
18196 {
18197 memset (line_buf, 0, HCBUFSIZ);
18198
18199 int line_len = fgetl (mask_fp, line_buf);
18200
18201 if (line_len == 0) continue;
18202
18203 if (line_buf[0] == '#') continue;
18204
18205 if (masks_avail == maskcnt)
18206 {
18207 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
18208
18209 masks_avail += INCR_MASKS;
18210 }
18211
18212 masks[maskcnt] = mystrdup (line_buf);
18213
18214 maskcnt++;
18215 }
18216
18217 myfree (line_buf);
18218
18219 fclose (mask_fp);
18220
18221 mask_from_file = 1;
18222 }
18223 else
18224 {
18225 maskcnt = 1;
18226
18227 masks[maskcnt - 1] = mystrdup (mask);
18228 }
18229 }
18230
18231 // base
18232
18233 int wls_left = myargc - (optind + 2);
18234
18235 for (int i = 0; i < wls_left; i++)
18236 {
18237 char *filename = myargv[optind + 2 + i];
18238
18239 struct stat file_stat;
18240
18241 if (stat (filename, &file_stat) == -1)
18242 {
18243 log_error ("ERROR: %s: %s", filename, strerror (errno));
18244
18245 return -1;
18246 }
18247
18248 uint is_dir = S_ISDIR (file_stat.st_mode);
18249
18250 if (is_dir == 0)
18251 {
18252 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18253
18254 dictcnt++;
18255
18256 dictfiles[dictcnt - 1] = filename;
18257 }
18258 else
18259 {
18260 // do not allow --keyspace w/ a directory
18261
18262 if (keyspace == 1)
18263 {
18264 log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
18265
18266 return -1;
18267 }
18268
18269 char **dictionary_files = NULL;
18270
18271 dictionary_files = scan_directory (filename);
18272
18273 if (dictionary_files != NULL)
18274 {
18275 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
18276
18277 for (int d = 0; dictionary_files[d] != NULL; d++)
18278 {
18279 char *l1_filename = dictionary_files[d];
18280
18281 struct stat l1_stat;
18282
18283 if (stat (l1_filename, &l1_stat) == -1)
18284 {
18285 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
18286
18287 return -1;
18288 }
18289
18290 if (S_ISREG (l1_stat.st_mode))
18291 {
18292 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
18293
18294 dictcnt++;
18295
18296 dictfiles[dictcnt - 1] = strdup (l1_filename);
18297 }
18298 }
18299 }
18300
18301 local_free (dictionary_files);
18302 }
18303 }
18304
18305 if (dictcnt < 1)
18306 {
18307 log_error ("ERROR: No usable dictionary file found.");
18308
18309 return -1;
18310 }
18311
18312 if (increment)
18313 {
18314 maskcnt = 0;
18315
18316 uint mask_min = increment_min; // we can't reject smaller masks here
18317 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
18318
18319 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
18320 {
18321 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
18322
18323 if (cur_mask == NULL) break;
18324
18325 masks[maskcnt] = cur_mask;
18326
18327 maskcnt++;
18328
18329 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
18330 }
18331 }
18332 }
18333
18334 data.pw_min = pw_min;
18335 data.pw_max = pw_max;
18336
18337 /**
18338 * weak hash check
18339 */
18340
18341 if (weak_hash_threshold >= salts_cnt)
18342 {
18343 hc_device_param_t *device_param = NULL;
18344
18345 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18346 {
18347 device_param = &data.devices_param[device_id];
18348
18349 if (device_param->skipped) continue;
18350
18351 break;
18352 }
18353
18354 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
18355
18356 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
18357 {
18358 weak_hash_check (device_param, salt_pos);
18359 }
18360
18361 // Display hack, guarantee that there is at least one \r before real start
18362
18363 //if (data.quiet == 0) log_info ("");
18364 }
18365
18366 /**
18367 * status and monitor threads
18368 */
18369
18370 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18371 {
18372 data.devices_status = STATUS_STARTING;
18373 }
18374
18375 uint inner_threads_cnt = 0;
18376
18377 hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
18378
18379 data.shutdown_inner = 0;
18380
18381 /**
18382 * Outfile remove
18383 */
18384
18385 if (keyspace == 0 && benchmark == 0 && stdout_flag == 0)
18386 {
18387 hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL);
18388
18389 inner_threads_cnt++;
18390
18391 if (outfile_check_timer != 0)
18392 {
18393 if (data.outfile_check_directory != NULL)
18394 {
18395 if ((hash_mode != 5200) &&
18396 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
18397 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
18398 (hash_mode != 9000))
18399 {
18400 hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL);
18401
18402 inner_threads_cnt++;
18403 }
18404 else
18405 {
18406 outfile_check_timer = 0;
18407 }
18408 }
18409 else
18410 {
18411 outfile_check_timer = 0;
18412 }
18413 }
18414 }
18415
18416 /**
18417 * Inform the user if we got some hashes remove because of the pot file remove feature
18418 */
18419
18420 if (data.quiet == 0)
18421 {
18422 if (potfile_remove_cracks > 0)
18423 {
18424 if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
18425 else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
18426 }
18427 }
18428
18429 data.outfile_check_timer = outfile_check_timer;
18430
18431 /**
18432 * main loop
18433 */
18434
18435 char **induction_dictionaries = NULL;
18436
18437 int induction_dictionaries_cnt = 0;
18438
18439 hcstat_table_t *root_table_buf = NULL;
18440 hcstat_table_t *markov_table_buf = NULL;
18441
18442 uint initial_restore_done = 0;
18443
18444 data.maskcnt = maskcnt;
18445
18446 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
18447 {
18448 if (data.devices_status == STATUS_CRACKED) continue;
18449 if (data.devices_status == STATUS_ABORTED) continue;
18450 if (data.devices_status == STATUS_QUIT) continue;
18451
18452 if (maskpos > rd->maskpos)
18453 {
18454 rd->dictpos = 0;
18455 }
18456
18457 rd->maskpos = maskpos;
18458 data.maskpos = maskpos;
18459
18460 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
18461 {
18462 char *mask = masks[maskpos];
18463
18464 if (mask_from_file == 1)
18465 {
18466 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
18467
18468 char *str_ptr;
18469 uint str_pos;
18470
18471 uint mask_offset = 0;
18472
18473 uint separator_cnt;
18474
18475 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
18476 {
18477 str_ptr = strstr (mask + mask_offset, ",");
18478
18479 if (str_ptr == NULL) break;
18480
18481 str_pos = str_ptr - mask;
18482
18483 // escaped separator, i.e. "\,"
18484
18485 if (str_pos > 0)
18486 {
18487 if (mask[str_pos - 1] == '\\')
18488 {
18489 separator_cnt --;
18490
18491 mask_offset = str_pos + 1;
18492
18493 continue;
18494 }
18495 }
18496
18497 // reset the offset
18498
18499 mask_offset = 0;
18500
18501 mask[str_pos] = '\0';
18502
18503 switch (separator_cnt)
18504 {
18505 case 0:
18506 mp_reset_usr (mp_usr, 0);
18507
18508 custom_charset_1 = mask;
18509 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
18510 break;
18511
18512 case 1:
18513 mp_reset_usr (mp_usr, 1);
18514
18515 custom_charset_2 = mask;
18516 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
18517 break;
18518
18519 case 2:
18520 mp_reset_usr (mp_usr, 2);
18521
18522 custom_charset_3 = mask;
18523 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
18524 break;
18525
18526 case 3:
18527 mp_reset_usr (mp_usr, 3);
18528
18529 custom_charset_4 = mask;
18530 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
18531 break;
18532 }
18533
18534 mask = mask + str_pos + 1;
18535 }
18536
18537 /**
18538 * 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 "\")
18539 * it would be interpreted as a custom charset definition.
18540 *
18541 * We need to replace all "\," with just "," within the mask (but allow the special case "\\," which means "\" followed by ",")
18542 * 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 ","
18543 */
18544
18545 uint mask_len_cur = strlen (mask);
18546
18547 uint mask_out_pos = 0;
18548 char mask_prev = 0;
18549
18550 for (uint mask_iter = 0; mask_iter < mask_len_cur; mask_iter++, mask_out_pos++)
18551 {
18552 if (mask[mask_iter] == ',')
18553 {
18554 if (mask_prev == '\\')
18555 {
18556 mask_out_pos -= 1; // this means: skip the previous "\"
18557 }
18558 }
18559
18560 mask_prev = mask[mask_iter];
18561
18562 mask[mask_out_pos] = mask[mask_iter];
18563 }
18564
18565 mask[mask_out_pos] = '\0';
18566 }
18567
18568 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18569 {
18570 if (maskpos > 0)
18571 {
18572 local_free (css_buf);
18573 local_free (data.root_css_buf);
18574 local_free (data.markov_css_buf);
18575
18576 local_free (masks[maskpos - 1]);
18577 }
18578
18579 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18580
18581 data.mask = mask;
18582 data.css_cnt = css_cnt;
18583 data.css_buf = css_buf;
18584
18585 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
18586
18587 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
18588
18589 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
18590 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
18591
18592 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
18593
18594 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
18595
18596 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
18597 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
18598
18599 data.root_css_buf = root_css_buf;
18600 data.markov_css_buf = markov_css_buf;
18601
18602 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
18603
18604 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
18605
18606 local_free (root_table_buf);
18607 local_free (markov_table_buf);
18608
18609 // args
18610
18611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18612 {
18613 hc_device_param_t *device_param = &data.devices_param[device_id];
18614
18615 if (device_param->skipped) continue;
18616
18617 device_param->kernel_params_mp[0] = &device_param->d_combs;
18618 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
18619 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
18620
18621 device_param->kernel_params_mp_buf64[3] = 0;
18622 device_param->kernel_params_mp_buf32[4] = css_cnt;
18623 device_param->kernel_params_mp_buf32[5] = 0;
18624 device_param->kernel_params_mp_buf32[6] = 0;
18625 device_param->kernel_params_mp_buf32[7] = 0;
18626
18627 if (attack_mode == ATTACK_MODE_HYBRID1)
18628 {
18629 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
18630 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
18631 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
18632 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
18633 }
18634 else if (attack_mode == ATTACK_MODE_HYBRID2)
18635 {
18636 device_param->kernel_params_mp_buf32[5] = 0;
18637 device_param->kernel_params_mp_buf32[6] = 0;
18638 device_param->kernel_params_mp_buf32[7] = 0;
18639 }
18640
18641 cl_int CL_err = CL_SUCCESS;
18642
18643 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]);
18644 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]);
18645 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]);
18646
18647 if (CL_err != CL_SUCCESS)
18648 {
18649 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
18650
18651 return -1;
18652 }
18653
18654 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);
18655 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);
18656
18657 if (CL_err != CL_SUCCESS)
18658 {
18659 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
18660
18661 return -1;
18662 }
18663 }
18664 }
18665 else if (attack_mode == ATTACK_MODE_BF)
18666 {
18667 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
18668
18669 if (increment)
18670 {
18671 for (uint i = 0; i < dictcnt; i++)
18672 {
18673 local_free (dictfiles[i]);
18674 }
18675
18676 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
18677 {
18678 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
18679
18680 if (l1_filename == NULL) break;
18681
18682 dictcnt++;
18683
18684 dictfiles[dictcnt - 1] = l1_filename;
18685 }
18686 }
18687 else
18688 {
18689 dictcnt++;
18690
18691 dictfiles[dictcnt - 1] = mask;
18692 }
18693
18694 if (dictcnt == 0)
18695 {
18696 log_error ("ERROR: Mask is too small");
18697
18698 return -1;
18699 }
18700 }
18701 }
18702
18703 free (induction_dictionaries);
18704
18705 // induction_dictionaries_cnt = 0; // implied
18706
18707 if (attack_mode != ATTACK_MODE_BF)
18708 {
18709 if (keyspace == 0)
18710 {
18711 induction_dictionaries = scan_directory (induction_directory);
18712
18713 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18714 }
18715 }
18716
18717 if (induction_dictionaries_cnt)
18718 {
18719 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18720 }
18721
18722 /**
18723 * prevent the user from using --keyspace together w/ maskfile and or dictfile
18724 */
18725 if (keyspace == 1)
18726 {
18727 if ((maskcnt > 1) || (dictcnt > 1))
18728 {
18729 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
18730
18731 return -1;
18732 }
18733 }
18734
18735 for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++)
18736 {
18737 if (data.devices_status == STATUS_CRACKED) continue;
18738 if (data.devices_status == STATUS_ABORTED) continue;
18739 if (data.devices_status == STATUS_QUIT) continue;
18740
18741 rd->dictpos = dictpos;
18742
18743 char *subid = logfile_generate_subid ();
18744
18745 data.subid = subid;
18746
18747 logfile_sub_msg ("START");
18748
18749 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18750 {
18751 data.devices_status = STATUS_INIT;
18752 }
18753
18754 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
18755 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
18756 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
18757
18758 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
18759
18760 data.cpt_pos = 0;
18761
18762 data.cpt_start = time (NULL);
18763
18764 data.cpt_total = 0;
18765
18766 if (data.restore == 0)
18767 {
18768 rd->words_cur = skip;
18769
18770 skip = 0;
18771
18772 data.skip = 0;
18773 }
18774
18775 data.ms_paused = 0;
18776
18777 data.kernel_power_final = 0;
18778
18779 data.words_cur = rd->words_cur;
18780
18781 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18782 {
18783 hc_device_param_t *device_param = &data.devices_param[device_id];
18784
18785 if (device_param->skipped) continue;
18786
18787 device_param->speed_pos = 0;
18788
18789 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
18790 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
18791
18792 device_param->exec_pos = 0;
18793
18794 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
18795
18796 device_param->outerloop_pos = 0;
18797 device_param->outerloop_left = 0;
18798 device_param->innerloop_pos = 0;
18799 device_param->innerloop_left = 0;
18800
18801 // some more resets:
18802
18803 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
18804
18805 device_param->pws_cnt = 0;
18806
18807 device_param->words_off = 0;
18808 device_param->words_done = 0;
18809 }
18810
18811 // figure out some workload
18812
18813 if (attack_mode == ATTACK_MODE_STRAIGHT)
18814 {
18815 if (data.wordlist_mode == WL_MODE_FILE)
18816 {
18817 char *dictfile = NULL;
18818
18819 if (induction_dictionaries_cnt)
18820 {
18821 dictfile = induction_dictionaries[0];
18822 }
18823 else
18824 {
18825 dictfile = dictfiles[dictpos];
18826 }
18827
18828 data.dictfile = dictfile;
18829
18830 logfile_sub_string (dictfile);
18831
18832 for (uint i = 0; i < rp_files_cnt; i++)
18833 {
18834 logfile_sub_var_string ("rulefile", rp_files[i]);
18835 }
18836
18837 FILE *fd2 = fopen (dictfile, "rb");
18838
18839 if (fd2 == NULL)
18840 {
18841 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18842
18843 return -1;
18844 }
18845
18846 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18847
18848 fclose (fd2);
18849
18850 if (data.words_cnt == 0)
18851 {
18852 logfile_sub_msg ("STOP");
18853
18854 continue;
18855 }
18856 }
18857 }
18858 else if (attack_mode == ATTACK_MODE_COMBI)
18859 {
18860 char *dictfile = data.dictfile;
18861 char *dictfile2 = data.dictfile2;
18862
18863 logfile_sub_string (dictfile);
18864 logfile_sub_string (dictfile2);
18865
18866 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
18867 {
18868 FILE *fd2 = fopen (dictfile, "rb");
18869
18870 if (fd2 == NULL)
18871 {
18872 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18873
18874 return -1;
18875 }
18876
18877 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18878
18879 fclose (fd2);
18880 }
18881 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
18882 {
18883 FILE *fd2 = fopen (dictfile2, "rb");
18884
18885 if (fd2 == NULL)
18886 {
18887 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
18888
18889 return -1;
18890 }
18891
18892 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
18893
18894 fclose (fd2);
18895 }
18896
18897 if (data.words_cnt == 0)
18898 {
18899 logfile_sub_msg ("STOP");
18900
18901 continue;
18902 }
18903 }
18904 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
18905 {
18906 char *dictfile = NULL;
18907
18908 if (induction_dictionaries_cnt)
18909 {
18910 dictfile = induction_dictionaries[0];
18911 }
18912 else
18913 {
18914 dictfile = dictfiles[dictpos];
18915 }
18916
18917 data.dictfile = dictfile;
18918
18919 char *mask = data.mask;
18920
18921 logfile_sub_string (dictfile);
18922 logfile_sub_string (mask);
18923
18924 FILE *fd2 = fopen (dictfile, "rb");
18925
18926 if (fd2 == NULL)
18927 {
18928 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
18929
18930 return -1;
18931 }
18932
18933 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
18934
18935 fclose (fd2);
18936
18937 if (data.words_cnt == 0)
18938 {
18939 logfile_sub_msg ("STOP");
18940
18941 continue;
18942 }
18943 }
18944 else if (attack_mode == ATTACK_MODE_BF)
18945 {
18946 local_free (css_buf);
18947 local_free (data.root_css_buf);
18948 local_free (data.markov_css_buf);
18949
18950 char *mask = dictfiles[dictpos];
18951
18952 logfile_sub_string (mask);
18953
18954 // base
18955
18956 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
18957
18958 if (opts_type & OPTS_TYPE_PT_UNICODE)
18959 {
18960 uint css_cnt_unicode = css_cnt * 2;
18961
18962 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
18963
18964 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
18965 {
18966 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
18967
18968 css_buf_unicode[j + 1].cs_buf[0] = 0;
18969 css_buf_unicode[j + 1].cs_len = 1;
18970 }
18971
18972 free (css_buf);
18973
18974 css_buf = css_buf_unicode;
18975 css_cnt = css_cnt_unicode;
18976 }
18977
18978 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
18979
18980 uint mask_min = pw_min;
18981 uint mask_max = pw_max;
18982
18983 if (opts_type & OPTS_TYPE_PT_UNICODE)
18984 {
18985 mask_min *= 2;
18986 mask_max *= 2;
18987 }
18988
18989 if ((css_cnt < mask_min) || (css_cnt > mask_max))
18990 {
18991 if (css_cnt < mask_min)
18992 {
18993 log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
18994 }
18995
18996 if (css_cnt > mask_max)
18997 {
18998 log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
18999 }
19000
19001 // skip to next mask
19002
19003 logfile_sub_msg ("STOP");
19004
19005 continue;
19006 }
19007
19008 uint save_css_cnt = css_cnt;
19009
19010 if (opti_type & OPTI_TYPE_SINGLE_HASH)
19011 {
19012 if (opti_type & OPTI_TYPE_APPENDED_SALT)
19013 {
19014 uint salt_len = (uint) data.salts_buf[0].salt_len;
19015 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
19016
19017 uint css_cnt_salt = css_cnt + salt_len;
19018
19019 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
19020
19021 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
19022
19023 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
19024 {
19025 css_buf_salt[j].cs_buf[0] = salt_buf[i];
19026 css_buf_salt[j].cs_len = 1;
19027 }
19028
19029 free (css_buf);
19030
19031 css_buf = css_buf_salt;
19032 css_cnt = css_cnt_salt;
19033 }
19034 }
19035
19036 data.mask = mask;
19037 data.css_cnt = css_cnt;
19038 data.css_buf = css_buf;
19039
19040 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
19041
19042 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
19043
19044 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
19045
19046 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
19047 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
19048
19049 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
19050
19051 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
19052
19053 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
19054 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
19055
19056 data.root_css_buf = root_css_buf;
19057 data.markov_css_buf = markov_css_buf;
19058
19059 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
19060
19061 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
19062
19063 local_free (root_table_buf);
19064 local_free (markov_table_buf);
19065
19066 // copy + args
19067
19068 uint css_cnt_l = css_cnt;
19069 uint css_cnt_r;
19070
19071 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
19072 {
19073 if (save_css_cnt < 6)
19074 {
19075 css_cnt_r = 1;
19076 }
19077 else if (save_css_cnt == 6)
19078 {
19079 css_cnt_r = 2;
19080 }
19081 else
19082 {
19083 if (opts_type & OPTS_TYPE_PT_UNICODE)
19084 {
19085 if (save_css_cnt == 8 || save_css_cnt == 10)
19086 {
19087 css_cnt_r = 2;
19088 }
19089 else
19090 {
19091 css_cnt_r = 4;
19092 }
19093 }
19094 else
19095 {
19096 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
19097 {
19098 css_cnt_r = 3;
19099 }
19100 else
19101 {
19102 css_cnt_r = 4;
19103 }
19104 }
19105 }
19106 }
19107 else
19108 {
19109 css_cnt_r = 1;
19110
19111 /* unfinished code?
19112 int sum = css_buf[css_cnt_r - 1].cs_len;
19113
19114 for (uint i = 1; i < 4 && i < css_cnt; i++)
19115 {
19116 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
19117
19118 css_cnt_r++;
19119
19120 sum *= css_buf[css_cnt_r - 1].cs_len;
19121 }
19122 */
19123 }
19124
19125 css_cnt_l -= css_cnt_r;
19126
19127 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
19128
19129 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19130 {
19131 hc_device_param_t *device_param = &data.devices_param[device_id];
19132
19133 if (device_param->skipped) continue;
19134
19135 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
19136 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
19137 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
19138
19139 device_param->kernel_params_mp_l_buf64[3] = 0;
19140 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
19141 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
19142 device_param->kernel_params_mp_l_buf32[6] = 0;
19143 device_param->kernel_params_mp_l_buf32[7] = 0;
19144 device_param->kernel_params_mp_l_buf32[8] = 0;
19145
19146 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
19147 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
19148 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
19149 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
19150
19151 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
19152 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
19153 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
19154
19155 device_param->kernel_params_mp_r_buf64[3] = 0;
19156 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
19157 device_param->kernel_params_mp_r_buf32[5] = 0;
19158 device_param->kernel_params_mp_r_buf32[6] = 0;
19159 device_param->kernel_params_mp_r_buf32[7] = 0;
19160
19161 cl_int CL_err = CL_SUCCESS;
19162
19163 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]);
19164 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]);
19165 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]);
19166
19167 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]);
19168 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]);
19169 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]);
19170
19171 if (CL_err != CL_SUCCESS)
19172 {
19173 log_error ("ERROR: clSetKernelArg(): %s\n", val2cstr_cl (CL_err));
19174
19175 return -1;
19176 }
19177
19178 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);
19179 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);
19180
19181 if (CL_err != CL_SUCCESS)
19182 {
19183 log_error ("ERROR: clEnqueueWriteBuffer(): %s\n", val2cstr_cl (CL_err));
19184
19185 return -1;
19186 }
19187 }
19188 }
19189
19190 u64 words_base = data.words_cnt;
19191
19192 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19193 {
19194 if (data.kernel_rules_cnt)
19195 {
19196 words_base /= data.kernel_rules_cnt;
19197 }
19198 }
19199 else if (data.attack_kern == ATTACK_KERN_COMBI)
19200 {
19201 if (data.combs_cnt)
19202 {
19203 words_base /= data.combs_cnt;
19204 }
19205 }
19206 else if (data.attack_kern == ATTACK_KERN_BF)
19207 {
19208 if (data.bfs_cnt)
19209 {
19210 words_base /= data.bfs_cnt;
19211 }
19212 }
19213
19214 data.words_base = words_base;
19215
19216 if (keyspace == 1)
19217 {
19218 log_info ("%llu", (unsigned long long int) words_base);
19219
19220 return 0;
19221 }
19222
19223 if (data.words_cur > data.words_base)
19224 {
19225 log_error ("ERROR: Restore value greater keyspace");
19226
19227 return -1;
19228 }
19229
19230 if (data.words_cur)
19231 {
19232 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
19233 {
19234 for (uint i = 0; i < data.salts_cnt; i++)
19235 {
19236 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
19237 }
19238 }
19239 else if (data.attack_kern == ATTACK_KERN_COMBI)
19240 {
19241 for (uint i = 0; i < data.salts_cnt; i++)
19242 {
19243 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
19244 }
19245 }
19246 else if (data.attack_kern == ATTACK_KERN_BF)
19247 {
19248 for (uint i = 0; i < data.salts_cnt; i++)
19249 {
19250 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
19251 }
19252 }
19253 }
19254
19255 /*
19256 * Update loopback file
19257 */
19258
19259 if (loopback == 1)
19260 {
19261 time_t now;
19262
19263 time (&now);
19264
19265 uint random_num = get_random_num (0, 9999);
19266
19267 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
19268
19269 data.loopback_file = loopback_file;
19270 }
19271
19272 /*
19273 * Update dictionary statistic
19274 */
19275
19276 if (keyspace == 0)
19277 {
19278 dictstat_fp = fopen (dictstat, "wb");
19279
19280 if (dictstat_fp)
19281 {
19282 lock_file (dictstat_fp);
19283
19284 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
19285
19286 fclose (dictstat_fp);
19287 }
19288 }
19289
19290 /**
19291 * create autotune threads
19292 */
19293
19294 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
19295
19296 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19297 {
19298 data.devices_status = STATUS_AUTOTUNE;
19299 }
19300
19301 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19302 {
19303 hc_device_param_t *device_param = &devices_param[device_id];
19304
19305 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
19306 }
19307
19308 hc_thread_wait (data.devices_cnt, c_threads);
19309
19310 /*
19311 * Inform user about possible slow speeds
19312 */
19313
19314 uint hardware_power_all = 0;
19315
19316 uint kernel_power_all = 0;
19317
19318 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19319 {
19320 hc_device_param_t *device_param = &devices_param[device_id];
19321
19322 hardware_power_all += device_param->hardware_power;
19323
19324 kernel_power_all += device_param->kernel_power;
19325 }
19326
19327 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
19328
19329 data.kernel_power_all = kernel_power_all;
19330
19331 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19332 {
19333 if (data.words_base < kernel_power_all)
19334 {
19335 if (quiet == 0)
19336 {
19337 clear_prompt ();
19338
19339 log_info ("ATTENTION!");
19340 log_info (" The wordlist or mask you are using is too small.");
19341 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
19342 log_info (" The cracking speed will drop.");
19343 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
19344 log_info ("");
19345 }
19346 }
19347 }
19348
19349 /**
19350 * create cracker threads
19351 */
19352
19353 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19354 {
19355 data.devices_status = STATUS_RUNNING;
19356 }
19357
19358 if (initial_restore_done == 0)
19359 {
19360 if (data.restore_disable == 0) cycle_restore ();
19361
19362 initial_restore_done = 1;
19363 }
19364
19365 hc_timer_set (&data.timer_running);
19366
19367 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
19368 {
19369 if ((quiet == 0) && (status == 0) && (benchmark == 0))
19370 {
19371 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
19372 if (quiet == 0) fflush (stdout);
19373 }
19374 }
19375 else if (wordlist_mode == WL_MODE_STDIN)
19376 {
19377 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
19378 if (data.quiet == 0) log_info ("");
19379 }
19380
19381 time_t runtime_start;
19382
19383 time (&runtime_start);
19384
19385 data.runtime_start = runtime_start;
19386
19387 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19388 {
19389 hc_device_param_t *device_param = &devices_param[device_id];
19390
19391 if (wordlist_mode == WL_MODE_STDIN)
19392 {
19393 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
19394 }
19395 else
19396 {
19397 hc_thread_create (c_threads[device_id], thread_calc, device_param);
19398 }
19399 }
19400
19401 hc_thread_wait (data.devices_cnt, c_threads);
19402
19403 local_free (c_threads);
19404
19405 if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
19406 {
19407 data.devices_status = STATUS_EXHAUSTED;
19408 }
19409
19410 logfile_sub_var_uint ("status-after-work", data.devices_status);
19411
19412 data.restore = 0;
19413
19414 if (induction_dictionaries_cnt)
19415 {
19416 unlink (induction_dictionaries[0]);
19417 }
19418
19419 free (induction_dictionaries);
19420
19421 if (attack_mode != ATTACK_MODE_BF)
19422 {
19423 induction_dictionaries = scan_directory (induction_directory);
19424
19425 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
19426 }
19427
19428 if (benchmark == 1)
19429 {
19430 status_benchmark ();
19431
19432 if (machine_readable == 0)
19433 {
19434 log_info ("");
19435 }
19436 }
19437 else
19438 {
19439 if (quiet == 0)
19440 {
19441 clear_prompt ();
19442
19443 log_info ("");
19444
19445 status_display ();
19446
19447 log_info ("");
19448 }
19449 else
19450 {
19451 if (status == 1)
19452 {
19453 status_display ();
19454 }
19455 }
19456 }
19457
19458 if (induction_dictionaries_cnt)
19459 {
19460 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
19461
19462 // 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)
19463
19464 dictpos--;
19465 }
19466
19467 time_t runtime_stop;
19468
19469 time (&runtime_stop);
19470
19471 data.runtime_stop = runtime_stop;
19472
19473 logfile_sub_uint (runtime_start);
19474 logfile_sub_uint (runtime_stop);
19475
19476 logfile_sub_msg ("STOP");
19477
19478 global_free (subid);
19479
19480 // from this point we handle bypass as running
19481
19482 if (data.devices_status == STATUS_BYPASS)
19483 {
19484 data.devices_status = STATUS_RUNNING;
19485 }
19486
19487 // and overwrite benchmark aborts as well
19488
19489 if (data.benchmark == 1)
19490 {
19491 if (data.devices_status == STATUS_ABORTED)
19492 {
19493 data.devices_status = STATUS_RUNNING;
19494 }
19495 }
19496
19497 // finalize task
19498
19499 if (data.devices_status == STATUS_CRACKED) break;
19500 if (data.devices_status == STATUS_ABORTED) break;
19501 if (data.devices_status == STATUS_QUIT) break;
19502 }
19503
19504 if (data.devices_status == STATUS_CRACKED) break;
19505 if (data.devices_status == STATUS_ABORTED) break;
19506 if (data.devices_status == STATUS_QUIT) break;
19507 }
19508
19509 // 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
19510 if (attack_mode == ATTACK_MODE_STRAIGHT)
19511 {
19512 if (data.wordlist_mode == WL_MODE_FILE)
19513 {
19514 if (data.dictfile == NULL)
19515 {
19516 if (dictfiles != NULL)
19517 {
19518 data.dictfile = dictfiles[0];
19519
19520 hc_timer_set (&data.timer_running);
19521 }
19522 }
19523 }
19524 }
19525 // NOTE: combi is okay because it is already set beforehand
19526 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
19527 {
19528 if (data.dictfile == NULL)
19529 {
19530 if (dictfiles != NULL)
19531 {
19532 hc_timer_set (&data.timer_running);
19533
19534 data.dictfile = dictfiles[0];
19535 }
19536 }
19537 }
19538 else if (attack_mode == ATTACK_MODE_BF)
19539 {
19540 if (data.mask == NULL)
19541 {
19542 hc_timer_set (&data.timer_running);
19543
19544 data.mask = masks[0];
19545 }
19546 }
19547
19548 // if cracked / aborted remove last induction dictionary
19549
19550 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
19551 {
19552 struct stat induct_stat;
19553
19554 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
19555 {
19556 unlink (induction_dictionaries[file_pos]);
19557 }
19558 }
19559
19560 // wait for inner threads
19561
19562 data.shutdown_inner = 1;
19563
19564 for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++)
19565 {
19566 hc_thread_wait (1, &inner_threads[thread_idx]);
19567 }
19568
19569 local_free (inner_threads);
19570
19571 // we dont need restore file anymore
19572 if (data.restore_disable == 0)
19573 {
19574 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
19575 {
19576 unlink (eff_restore_file);
19577 unlink (new_restore_file);
19578 }
19579 else
19580 {
19581 cycle_restore ();
19582 }
19583 }
19584
19585 // finally save left hashes
19586
19587 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
19588 {
19589 save_hash ();
19590 }
19591
19592 /**
19593 * Clean up
19594 */
19595
19596 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19597 {
19598 hc_device_param_t *device_param = &data.devices_param[device_id];
19599
19600 if (device_param->skipped) continue;
19601
19602 cl_int CL_err = CL_SUCCESS;
19603
19604 local_free (device_param->combs_buf);
19605 local_free (device_param->hooks_buf);
19606 local_free (device_param->device_name);
19607 local_free (device_param->device_name_chksum);
19608 local_free (device_param->device_version);
19609 local_free (device_param->driver_version);
19610
19611 if (device_param->pws_buf) myfree (device_param->pws_buf);
19612
19613 if (device_param->d_pws_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
19614 if (device_param->d_pws_amp_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
19615 if (device_param->d_rules) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules);
19616 if (device_param->d_rules_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
19617 if (device_param->d_combs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs);
19618 if (device_param->d_combs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
19619 if (device_param->d_bfs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
19620 if (device_param->d_bfs_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
19621 if (device_param->d_bitmap_s1_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
19622 if (device_param->d_bitmap_s1_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
19623 if (device_param->d_bitmap_s1_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
19624 if (device_param->d_bitmap_s1_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
19625 if (device_param->d_bitmap_s2_a) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
19626 if (device_param->d_bitmap_s2_b) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
19627 if (device_param->d_bitmap_s2_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
19628 if (device_param->d_bitmap_s2_d) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
19629 if (device_param->d_plain_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
19630 if (device_param->d_digests_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
19631 if (device_param->d_digests_shown) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
19632 if (device_param->d_salt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
19633 if (device_param->d_esalt_bufs) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
19634 if (device_param->d_tmps) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
19635 if (device_param->d_hooks) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
19636 if (device_param->d_result) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_result);
19637 if (device_param->d_scryptV0_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf);
19638 if (device_param->d_scryptV1_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf);
19639 if (device_param->d_scryptV2_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf);
19640 if (device_param->d_scryptV3_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf);
19641 if (device_param->d_root_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
19642 if (device_param->d_markov_css_buf) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
19643 if (device_param->d_tm_c) CL_err |= hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
19644
19645 if (CL_err != CL_SUCCESS)
19646 {
19647 log_error ("ERROR: clReleaseMemObject(): %s\n", val2cstr_cl (CL_err));
19648
19649 return -1;
19650 }
19651
19652 if (device_param->kernel1) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel1);
19653 if (device_param->kernel12) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel12);
19654 if (device_param->kernel2) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel2);
19655 if (device_param->kernel23) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel23);
19656 if (device_param->kernel3) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel3);
19657 if (device_param->kernel_mp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
19658 if (device_param->kernel_mp_l) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
19659 if (device_param->kernel_mp_r) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
19660 if (device_param->kernel_tm) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
19661 if (device_param->kernel_amp) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
19662 if (device_param->kernel_memset) CL_err |= hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
19663
19664 if (CL_err != CL_SUCCESS)
19665 {
19666 log_error ("ERROR: clReleaseKernel(): %s\n", val2cstr_cl (CL_err));
19667
19668 return -1;
19669 }
19670
19671 if (device_param->program) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program);
19672 if (device_param->program_mp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_mp);
19673 if (device_param->program_amp) CL_err |= hc_clReleaseProgram (data.ocl, device_param->program_amp);
19674
19675 if (CL_err != CL_SUCCESS)
19676 {
19677 log_error ("ERROR: clReleaseProgram(): %s\n", val2cstr_cl (CL_err));
19678
19679 return -1;
19680 }
19681
19682 if (device_param->command_queue) CL_err |= hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
19683
19684 if (CL_err != CL_SUCCESS)
19685 {
19686 log_error ("ERROR: clReleaseCommandQueue(): %s\n", val2cstr_cl (CL_err));
19687
19688 return -1;
19689 }
19690
19691 if (device_param->context) CL_err |= hc_clReleaseContext (data.ocl, device_param->context);
19692
19693 if (CL_err != CL_SUCCESS)
19694 {
19695 log_error ("ERROR: hc_clReleaseContext(): %s\n", val2cstr_cl (CL_err));
19696
19697 return -1;
19698 }
19699 }
19700
19701 // reset default fan speed
19702
19703 #ifdef HAVE_HWMON
19704 if (gpu_temp_disable == 0)
19705 {
19706 if (gpu_temp_retain != 0)
19707 {
19708 hc_thread_mutex_lock (mux_adl);
19709
19710 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19711 {
19712 hc_device_param_t *device_param = &data.devices_param[device_id];
19713
19714 if (device_param->skipped) continue;
19715
19716 if (data.hm_device[device_id].fan_set_supported == 1)
19717 {
19718 int rc = -1;
19719
19720 if (device_param->device_vendor_id == VENDOR_ID_AMD)
19721 {
19722 rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0);
19723 }
19724 else if (device_param->device_vendor_id == VENDOR_ID_NV)
19725 {
19726 #ifdef __linux__
19727 rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE);
19728 #endif
19729
19730 #ifdef WIN
19731 rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0);
19732 #endif
19733 }
19734
19735 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
19736 }
19737 }
19738
19739 hc_thread_mutex_unlock (mux_adl);
19740 }
19741 }
19742
19743 // reset power tuning
19744
19745 if (powertune_enable == 1)
19746 {
19747 hc_thread_mutex_lock (mux_adl);
19748
19749 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
19750 {
19751 hc_device_param_t *device_param = &data.devices_param[device_id];
19752
19753 if (device_param->skipped) continue;
19754
19755 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
19756 {
19757 if (data.hm_device[device_id].od_version == 6)
19758 {
19759 // check powertune capabilities first, if not available then skip device
19760
19761 int powertune_supported = 0;
19762
19763 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
19764 {
19765 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
19766
19767 return -1;
19768 }
19769
19770 if (powertune_supported != 0)
19771 {
19772 // powercontrol settings
19773
19774 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
19775 {
19776 log_info ("ERROR: Failed to restore the ADL PowerControl values");
19777
19778 return -1;
19779 }
19780
19781 // clocks
19782
19783 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
19784
19785 performance_state->iNumberOfPerformanceLevels = 2;
19786
19787 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
19788 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
19789 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
19790 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
19791
19792 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
19793 {
19794 log_info ("ERROR: Failed to restore ADL performance state");
19795
19796 return -1;
19797 }
19798
19799 local_free (performance_state);
19800 }
19801 }
19802 }
19803
19804 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
19805 {
19806 unsigned int limit = nvml_power_limit[device_id];
19807
19808 if (limit > 0)
19809 {
19810 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
19811 }
19812 }
19813 }
19814
19815 hc_thread_mutex_unlock (mux_adl);
19816 }
19817
19818 if (gpu_temp_disable == 0)
19819 {
19820 if (data.hm_nvml)
19821 {
19822 hm_NVML_nvmlShutdown (data.hm_nvml);
19823
19824 nvml_close (data.hm_nvml);
19825
19826 data.hm_nvml = NULL;
19827 }
19828
19829 if (data.hm_nvapi)
19830 {
19831 hm_NvAPI_Unload (data.hm_nvapi);
19832
19833 nvapi_close (data.hm_nvapi);
19834
19835 data.hm_nvapi = NULL;
19836 }
19837
19838 if (data.hm_xnvctrl)
19839 {
19840 hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl);
19841
19842 xnvctrl_close (data.hm_xnvctrl);
19843
19844 data.hm_xnvctrl = NULL;
19845 }
19846
19847 if (data.hm_adl)
19848 {
19849 hm_ADL_Main_Control_Destroy (data.hm_adl);
19850
19851 adl_close (data.hm_adl);
19852
19853 data.hm_adl = NULL;
19854 }
19855 }
19856 #endif // HAVE_HWMON
19857
19858 // free memory
19859
19860 local_free (masks);
19861
19862 local_free (dictstat_base);
19863
19864 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
19865 {
19866 pot_t *pot_ptr = &pot[pot_pos];
19867
19868 hash_t *hash = &pot_ptr->hash;
19869
19870 local_free (hash->digest);
19871
19872 if (isSalted)
19873 {
19874 local_free (hash->salt);
19875 }
19876 }
19877
19878 local_free (pot);
19879
19880 local_free (all_kernel_rules_cnt);
19881 local_free (all_kernel_rules_buf);
19882
19883 local_free (wl_data->buf);
19884 local_free (wl_data);
19885
19886 local_free (bitmap_s1_a);
19887 local_free (bitmap_s1_b);
19888 local_free (bitmap_s1_c);
19889 local_free (bitmap_s1_d);
19890 local_free (bitmap_s2_a);
19891 local_free (bitmap_s2_b);
19892 local_free (bitmap_s2_c);
19893 local_free (bitmap_s2_d);
19894
19895 #ifdef HAVE_HWMON
19896 local_free (od_clock_mem_status);
19897 local_free (od_power_control_status);
19898 local_free (nvml_power_limit);
19899 #endif
19900
19901 global_free (devices_param);
19902
19903 global_free (kernel_rules_buf);
19904
19905 global_free (root_css_buf);
19906 global_free (markov_css_buf);
19907
19908 global_free (digests_buf);
19909 global_free (digests_shown);
19910 global_free (digests_shown_tmp);
19911
19912 global_free (salts_buf);
19913 global_free (salts_shown);
19914
19915 global_free (esalts_buf);
19916
19917 global_free (words_progress_done);
19918 global_free (words_progress_rejected);
19919 global_free (words_progress_restored);
19920
19921 if (pot_fp) fclose (pot_fp);
19922
19923 if (data.devices_status == STATUS_QUIT) break;
19924 }
19925
19926 // wait for outer threads
19927
19928 data.shutdown_outer = 1;
19929
19930 for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++)
19931 {
19932 hc_thread_wait (1, &outer_threads[thread_idx]);
19933 }
19934
19935 local_free (outer_threads);
19936
19937 // destroy others mutex
19938
19939 hc_thread_mutex_delete (mux_dispatcher);
19940 hc_thread_mutex_delete (mux_counter);
19941 hc_thread_mutex_delete (mux_display);
19942 hc_thread_mutex_delete (mux_adl);
19943
19944 // free memory
19945
19946 local_free (eff_restore_file);
19947 local_free (new_restore_file);
19948
19949 local_free (rd);
19950
19951 // tuning db
19952
19953 tuning_db_destroy (tuning_db);
19954
19955 // loopback
19956
19957 local_free (loopback_file);
19958
19959 if (loopback == 1) unlink (loopback_file);
19960
19961 // induction directory
19962
19963 if (induction_dir == NULL)
19964 {
19965 if (attack_mode != ATTACK_MODE_BF)
19966 {
19967 if (rmdir (induction_directory) == -1)
19968 {
19969 if (errno == ENOENT)
19970 {
19971 // good, we can ignore
19972 }
19973 else if (errno == ENOTEMPTY)
19974 {
19975 // good, we can ignore
19976 }
19977 else
19978 {
19979 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
19980
19981 return -1;
19982 }
19983 }
19984
19985 local_free (induction_directory);
19986 }
19987 }
19988
19989 // outfile-check directory
19990
19991 if (outfile_check_dir == NULL)
19992 {
19993 if (rmdir (outfile_check_directory) == -1)
19994 {
19995 if (errno == ENOENT)
19996 {
19997 // good, we can ignore
19998 }
19999 else if (errno == ENOTEMPTY)
20000 {
20001 // good, we can ignore
20002 }
20003 else
20004 {
20005 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
20006
20007 return -1;
20008 }
20009 }
20010
20011 local_free (outfile_check_directory);
20012 }
20013
20014 time_t proc_stop;
20015
20016 time (&proc_stop);
20017
20018 logfile_top_uint (proc_start);
20019 logfile_top_uint (proc_stop);
20020
20021 logfile_top_msg ("STOP");
20022
20023 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
20024 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
20025
20026 if (data.ocl) ocl_close (data.ocl);
20027
20028 if (data.devices_status == STATUS_ABORTED) return 2;
20029 if (data.devices_status == STATUS_QUIT) return 2;
20030 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
20031 if (data.devices_status == STATUS_EXHAUSTED) return 1;
20032 if (data.devices_status == STATUS_CRACKED) return 0;
20033
20034 return -1;
20035 }
Hashcat additions to support pwdhash