projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch 'master' of https://github.com/hashcat/oclHashcat
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define STDOUT_FLAG 0
37 #define RESTORE 0
38 #define RESTORE_TIMER 60
39 #define RESTORE_DISABLE 0
40 #define STATUS 0
41 #define STATUS_TIMER 10
42 #define MACHINE_READABLE 0
43 #define LOOPBACK 0
44 #define WEAK_HASH_THRESHOLD 100
45 #define SHOW 0
46 #define LEFT 0
47 #define USERNAME 0
48 #define REMOVE 0
49 #define REMOVE_TIMER 60
50 #define SKIP 0
51 #define LIMIT 0
52 #define KEYSPACE 0
53 #define POTFILE_DISABLE 0
54 #define DEBUG_MODE 0
55 #define RP_GEN 0
56 #define RP_GEN_FUNC_MIN 1
57 #define RP_GEN_FUNC_MAX 4
58 #define RP_GEN_SEED 0
59 #define RULE_BUF_L ":"
60 #define RULE_BUF_R ":"
61 #define FORCE 0
62 #define RUNTIME 0
63 #define HEX_CHARSET 0
64 #define HEX_SALT 0
65 #define HEX_WORDLIST 0
66 #define OUTFILE_FORMAT 3
67 #define OUTFILE_AUTOHEX 1
68 #define OUTFILE_CHECK_TIMER 5
69 #define ATTACK_MODE 0
70 #define HASH_MODE 0
71 #define SEGMENT_SIZE 32
72 #define INCREMENT 0
73 #define INCREMENT_MIN 1
74 #define INCREMENT_MAX PW_MAX
75 #define SEPARATOR ':'
76 #define BITMAP_MIN 16
77 #define BITMAP_MAX 24
78 #define GPU_TEMP_DISABLE 0
79 #define GPU_TEMP_ABORT 90
80 #define GPU_TEMP_RETAIN 0
81 #define WORKLOAD_PROFILE 2
82 #define KERNEL_ACCEL 0
83 #define KERNEL_LOOPS 0
84 #define KERNEL_RULES 1024
85 #define KERNEL_COMBS 1024
86 #define KERNEL_BFS 1024
87 #define KERNEL_THREADS_MAX 256
88 #define KERNEL_THREADS_MAX_CPU 16
89 #define POWERTUNE_ENABLE 0
90 #define LOGFILE_DISABLE 0
91 #define SCRYPT_TMTO 0
92 #define OPENCL_VECTOR_WIDTH 0
93
94 #define WL_MODE_STDIN 1
95 #define WL_MODE_FILE 2
96 #define WL_MODE_MASK 3
97
98 #define HL_MODE_FILE 4
99 #define HL_MODE_ARG 5
100
101 #define HLFMTS_CNT 11
102 #define HLFMT_HASHCAT 0
103 #define HLFMT_PWDUMP 1
104 #define HLFMT_PASSWD 2
105 #define HLFMT_SHADOW 3
106 #define HLFMT_DCC 4
107 #define HLFMT_DCC2 5
108 #define HLFMT_NETNTLM1 7
109 #define HLFMT_NETNTLM2 8
110 #define HLFMT_NSLDAP 9
111 #define HLFMT_NSLDAPS 10
112
113 #define HLFMT_TEXT_HASHCAT "native hashcat"
114 #define HLFMT_TEXT_PWDUMP "pwdump"
115 #define HLFMT_TEXT_PASSWD "passwd"
116 #define HLFMT_TEXT_SHADOW "shadow"
117 #define HLFMT_TEXT_DCC "DCC"
118 #define HLFMT_TEXT_DCC2 "DCC 2"
119 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
120 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
121 #define HLFMT_TEXT_NSLDAP "nsldap"
122 #define HLFMT_TEXT_NSLDAPS "nsldaps"
123
124 #define ATTACK_MODE_STRAIGHT 0
125 #define ATTACK_MODE_COMBI 1
126 #define ATTACK_MODE_TOGGLE 2
127 #define ATTACK_MODE_BF 3
128 #define ATTACK_MODE_PERM 4
129 #define ATTACK_MODE_TABLE 5
130 #define ATTACK_MODE_HYBRID1 6
131 #define ATTACK_MODE_HYBRID2 7
132 #define ATTACK_MODE_NONE 100
133
134 #define ATTACK_KERN_STRAIGHT 0
135 #define ATTACK_KERN_COMBI 1
136 #define ATTACK_KERN_BF 3
137 #define ATTACK_KERN_NONE 100
138
139 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
140 #define ATTACK_EXEC_INSIDE_KERNEL 11
141
142 #define COMBINATOR_MODE_BASE_LEFT 10001
143 #define COMBINATOR_MODE_BASE_RIGHT 10002
144
145 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
146 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
147
148 #define MAX_CUT_TRIES 4
149
150 #define MAX_DICTSTAT 10000
151
152 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
153
154 #define NVIDIA_100PERCENTCPU_WORKAROUND 100
155
156 #define global_free(attr) \
157 { \
158 myfree ((void *) data.attr); \
159 \
160 data.attr = NULL; \
161 }
162
163 #define local_free(attr) \
164 { \
165 myfree ((void *) attr); \
166 \
167 attr = NULL; \
168 }
169
170 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
171 #define HC_API_CALL __stdcall
172 #else
173 #define HC_API_CALL
174 #endif
175
176 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
177 {
178 900,
179 0,
180 5100,
181 100,
182 1400,
183 10800,
184 1700,
185 5000,
186 10100,
187 6000,
188 6100,
189 6900,
190 11700,
191 11800,
192 400,
193 8900,
194 11900,
195 12000,
196 10900,
197 12100,
198 23,
199 2500,
200 5300,
201 5400,
202 5500,
203 5600,
204 7300,
205 7500,
206 13100,
207 8300,
208 11100,
209 11200,
210 11400,
211 121,
212 2611,
213 2711,
214 2811,
215 8400,
216 11,
217 2612,
218 7900,
219 21,
220 11000,
221 124,
222 10000,
223 3711,
224 7600,
225 12,
226 131,
227 132,
228 1731,
229 200,
230 300,
231 3100,
232 112,
233 12300,
234 8000,
235 141,
236 1441,
237 1600,
238 12600,
239 1421,
240 101,
241 111,
242 1711,
243 3000,
244 1000,
245 1100,
246 2100,
247 12800,
248 1500,
249 12400,
250 500,
251 3200,
252 7400,
253 1800,
254 122,
255 1722,
256 7100,
257 6300,
258 6700,
259 6400,
260 6500,
261 2400,
262 2410,
263 5700,
264 9200,
265 9300,
266 22,
267 501,
268 5800,
269 8100,
270 8500,
271 7200,
272 9900,
273 7700,
274 7800,
275 10300,
276 8600,
277 8700,
278 9100,
279 133,
280 13500,
281 11600,
282 13600,
283 12500,
284 13000,
285 13200,
286 13300,
287 6211,
288 6221,
289 6231,
290 6241,
291 13711,
292 13721,
293 13731,
294 13741,
295 13751,
296 13761,
297 8800,
298 12900,
299 12200,
300 9700,
301 9710,
302 9800,
303 9810,
304 9400,
305 9500,
306 9600,
307 10400,
308 10410,
309 10500,
310 10600,
311 10700,
312 9000,
313 5200,
314 6800,
315 6600,
316 8200,
317 11300,
318 12700,
319 13400,
320 125
321 };
322
323 /**
324 * types
325 */
326
327 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
328
329 /**
330 * globals
331 */
332
333 static unsigned int full01 = 0x01010101;
334 static unsigned int full80 = 0x80808080;
335
336 int SUPPRESS_OUTPUT = 0;
337
338 hc_thread_mutex_t mux_adl;
339 hc_thread_mutex_t mux_counter;
340 hc_thread_mutex_t mux_dispatcher;
341 hc_thread_mutex_t mux_display;
342
343 hc_global_data_t data;
344
345 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
346
347 const char *USAGE_MINI[] =
348 {
349 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
350 "",
351 "Try --help for more help.",
352 NULL
353 };
354
355 const char *USAGE_BIG[] =
356 {
357 "%s, advanced password recovery",
358 "",
359 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
360 "",
361 "- [ Options ] -",
362 "",
363 " Options Short / Long | Type | Description | Example",
364 "===============================|======|======================================================|=======================",
365 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
366 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
367 " -V, --version | | Print version |",
368 " -h, --help | | Print help |",
369 " --quiet | | Suppress output |",
370 " --hex-charset | | Assume charset is given in hex |",
371 " --hex-salt | | Assume salt is given in hex |",
372 " --hex-wordlist | | Assume words in wordlist is given in hex |",
373 " --force | | Ignore warnings |",
374 " --status | | Enable automatic update of the status-screen |",
375 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
376 " --machine-readable | | Display the status view in a machine readable format |",
377 " --loopback | | Add new plains to induct directory |",
378 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
379 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
380 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
381 " --markov-classic | | Enables classic markov-chains, no per-position |",
382 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
383 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
384 " --session | Str | Define specific session name | --session=mysession",
385 " --restore | | Restore session from --session |",
386 " --restore-disable | | Do not write restore file |",
387 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
388 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
389 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
390 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
391 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
392 " --stdout | | Do not crack a hash, instead print candidates only |",
393 " --show | | Show cracked passwords only |",
394 " --left | | Show un-cracked passwords only |",
395 " --username | | Enable ignoring of usernames in hashfile |",
396 " --remove | | Enable remove of hash once it is cracked |",
397 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
398 " --potfile-disable | | Do not write potfile |",
399 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
400 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
401 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
402 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
403 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
404 " --logfile-disable | | Disable the logfile |",
405 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
406 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
407 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
408 " -b, --benchmark | | Run benchmark |",
409 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
410 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
411 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
412 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
413 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
414 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
415 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
416 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
417 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
418 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
419 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
420 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
421 #ifdef HAVE_HWMON
422 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
423 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
424 " --powertune-enable | | Enable power tuning, restores settings when finished |",
425 #endif
426 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
427 " -s, --skip | Num | Skip X words from the start | -s 1000000",
428 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
429 " --keyspace | | Show keyspace base:mod values and quit |",
430 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
431 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
432 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
433 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
434 " --generate-rules-func-min | Num | Force min X funcs per rule |",
435 " --generate-rules-func-max | Num | Force max X funcs per rule |",
436 " --generate-rules-seed | Num | Force RNG seed set to X |",
437 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
438 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
439 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
440 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
441 " -i, --increment | | Enable mask increment mode |",
442 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
443 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
444 "",
445 "- [ Hash modes ] -",
446 "",
447 " # | Name | Category",
448 " ======+==================================================+======================================",
449 " 900 | MD4 | Raw Hash",
450 " 0 | MD5 | Raw Hash",
451 " 5100 | Half MD5 | Raw Hash",
452 " 100 | SHA1 | Raw Hash",
453 " 10800 | SHA-384 | Raw Hash",
454 " 1400 | SHA-256 | Raw Hash",
455 " 1700 | SHA-512 | Raw Hash",
456 " 5000 | SHA-3(Keccak) | Raw Hash",
457 " 10100 | SipHash | Raw Hash",
458 " 6000 | RipeMD160 | Raw Hash",
459 " 6100 | Whirlpool | Raw Hash",
460 " 6900 | GOST R 34.11-94 | Raw Hash",
461 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
462 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
463 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
465 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
466 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
467 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
468 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
469 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
470 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
471 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
472 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
473 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
474 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
475 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
476 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
477 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
478 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
479 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
484 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
485 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
486 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
487 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
488 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
489 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
490 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
491 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
492 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
493 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
494 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
495 " 400 | phpass | Generic KDF",
496 " 8900 | scrypt | Generic KDF",
497 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
498 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
499 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
500 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
501 " 23 | Skype | Network protocols",
502 " 2500 | WPA/WPA2 | Network protocols",
503 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
504 " 5300 | IKE-PSK MD5 | Network protocols",
505 " 5400 | IKE-PSK SHA1 | Network protocols",
506 " 5500 | NetNTLMv1 | Network protocols",
507 " 5500 | NetNTLMv1 + ESS | Network protocols",
508 " 5600 | NetNTLMv2 | Network protocols",
509 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
510 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
511 " 8300 | DNSSEC (NSEC3) | Network protocols",
512 " 10200 | Cram MD5 | Network protocols",
513 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
514 " 11200 | MySQL CRAM (SHA1) | Network protocols",
515 " 11400 | SIP digest authentication (MD5) | Network protocols",
516 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
517 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
519 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
520 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
521 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
522 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
523 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
524 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
525 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
526 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
527 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
528 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
529 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
530 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
531 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
532 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
533 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
534 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
535 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
536 " 12 | PostgreSQL | Database Server",
537 " 131 | MSSQL(2000) | Database Server",
538 " 132 | MSSQL(2005) | Database Server",
539 " 1731 | MSSQL(2012) | Database Server",
540 " 1731 | MSSQL(2014) | Database Server",
541 " 200 | MySQL323 | Database Server",
542 " 300 | MySQL4.1/MySQL5 | Database Server",
543 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
544 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
545 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
546 " 8000 | Sybase ASE | Database Server",
547 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
548 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
549 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
550 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
551 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
552 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
553 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
554 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
555 " 11500 | CRC32 | Checksums",
556 " 3000 | LM | Operating-Systems",
557 " 1000 | NTLM | Operating-Systems",
558 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
559 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
560 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
561 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
562 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
563 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
564 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
565 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
566 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
567 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
568 " 1722 | OSX v10.7 | Operating-Systems",
569 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
570 " 6300 | AIX {smd5} | Operating-Systems",
571 " 6700 | AIX {ssha1} | Operating-Systems",
572 " 6400 | AIX {ssha256} | Operating-Systems",
573 " 6500 | AIX {ssha512} | Operating-Systems",
574 " 2400 | Cisco-PIX | Operating-Systems",
575 " 2410 | Cisco-ASA | Operating-Systems",
576 " 500 | Cisco-IOS $1$ | Operating-Systems",
577 " 5700 | Cisco-IOS $4$ | Operating-Systems",
578 " 9200 | Cisco-IOS $8$ | Operating-Systems",
579 " 9300 | Cisco-IOS $9$ | Operating-Systems",
580 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
581 " 501 | Juniper IVE | Operating-Systems",
582 " 5800 | Android PIN | Operating-Systems",
583 " 13800 | Windows 8+ phone PIN/Password | Operating-Systems",
584 " 8100 | Citrix Netscaler | Operating-Systems",
585 " 8500 | RACF | Operating-Systems",
586 " 7200 | GRUB 2 | Operating-Systems",
587 " 9900 | Radmin2 | Operating-Systems",
588 " 125 | ArubaOS | Operating-Systems",
589 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
590 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
591 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
592 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
593 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
594 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
595 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
596 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
597 " 11600 | 7-Zip | Archives",
598 " 12500 | RAR3-hp | Archives",
599 " 13000 | RAR5 | Archives",
600 " 13200 | AxCrypt | Archives",
601 " 13300 | AxCrypt in memory SHA1 | Archives",
602 " 13600 | WinZip | Archives",
603 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
604 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
605 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
606 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
607 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
608 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
609 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
610 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
613 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
614 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
615 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
616 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
617 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
618 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
619 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
620 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
621 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
622 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
623 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
624 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
625 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
626 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
627 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
628 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
629 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
630 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
633 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
634 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
635 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
636 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
637 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
638 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
639 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
640 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
641 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
642 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
643 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
644 " 9400 | MS Office 2007 | Documents",
645 " 9500 | MS Office 2010 | Documents",
646 " 9600 | MS Office 2013 | Documents",
647 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
648 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
649 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
650 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
651 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
652 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
653 " 9000 | Password Safe v2 | Password Managers",
654 " 5200 | Password Safe v3 | Password Managers",
655 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
656 " 6600 | 1Password, agilekeychain | Password Managers",
657 " 8200 | 1Password, cloudkeychain | Password Managers",
658 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
659 " 12700 | Blockchain, My Wallet | Password Managers",
660 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
661 "",
662 "- [ Outfile Formats ] -",
663 "",
664 " # | Format",
665 " ===+========",
666 " 1 | hash[:salt]",
667 " 2 | plain",
668 " 3 | hash[:salt]:plain",
669 " 4 | hex_plain",
670 " 5 | hash[:salt]:hex_plain",
671 " 6 | plain:hex_plain",
672 " 7 | hash[:salt]:plain:hex_plain",
673 " 8 | crackpos",
674 " 9 | hash[:salt]:crack_pos",
675 " 10 | plain:crack_pos",
676 " 11 | hash[:salt]:plain:crack_pos",
677 " 12 | hex_plain:crack_pos",
678 " 13 | hash[:salt]:hex_plain:crack_pos",
679 " 14 | plain:hex_plain:crack_pos",
680 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
681 "",
682 "- [ Rule Debugging Modes ] -",
683 "",
684 " # | Format",
685 " ===+========",
686 " 1 | Finding-Rule",
687 " 2 | Original-Word",
688 " 3 | Original-Word:Finding-Rule",
689 " 4 | Original-Word:Finding-Rule:Processed-Word",
690 "",
691 "- [ Attack Modes ] -",
692 "",
693 " # | Mode",
694 " ===+======",
695 " 0 | Straight",
696 " 1 | Combination",
697 " 3 | Brute-force",
698 " 6 | Hybrid Wordlist + Mask",
699 " 7 | Hybrid Mask + Wordlist",
700 "",
701 "- [ Built-in Charsets ] -",
702 "",
703 " ? | Charset",
704 " ===+=========",
705 " l | abcdefghijklmnopqrstuvwxyz",
706 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
707 " d | 0123456789",
708 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
709 " a | ?l?u?d?s",
710 " b | 0x00 - 0xff",
711 "",
712 "- [ OpenCL Device Types ] -",
713 "",
714 " # | Device Type",
715 " ===+=============",
716 " 1 | CPU",
717 " 2 | GPU",
718 " 3 | FPGA, DSP, Co-Processor",
719 "",
720 "- [ Workload Profiles ] -",
721 "",
722 " # | Performance | Runtime | Power Consumption | Desktop Impact",
723 " ===+=============+=========+===================+=================",
724 " 1 | Low | 2 ms | Low | Minimal",
725 " 2 | Default | 12 ms | Economic | Noticeable",
726 " 3 | High | 96 ms | High | Unresponsive",
727 " 4 | Nightmare | 480 ms | Insane | Headless",
728 "",
729 "If you have no idea what just happened then visit the following pages:",
730 "",
731 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
732 "* https://hashcat.net/wiki/#frequently_asked_questions",
733 "",
734 NULL
735 };
736
737 /**
738 * hashcat specific functions
739 */
740
741 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
742 {
743 int exec_pos = (int) device_param->exec_pos - last_num_entries;
744
745 if (exec_pos < 0) exec_pos += EXEC_CACHE;
746
747 double exec_ms_sum = 0;
748
749 int exec_ms_cnt = 0;
750
751 for (int i = 0; i < last_num_entries; i++)
752 {
753 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
754
755 if (exec_ms)
756 {
757 exec_ms_sum += exec_ms;
758
759 exec_ms_cnt++;
760 }
761 }
762
763 if (exec_ms_cnt == 0) return 0;
764
765 return exec_ms_sum / exec_ms_cnt;
766 }
767
768 void status_display_machine_readable ()
769 {
770 FILE *out = stdout;
771
772 fprintf (out, "STATUS\t%u\t", data.devices_status);
773
774 /**
775 * speed new
776 */
777
778 fprintf (out, "SPEED\t");
779
780 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
781 {
782 hc_device_param_t *device_param = &data.devices_param[device_id];
783
784 if (device_param->skipped) continue;
785
786 u64 speed_cnt = 0;
787 double speed_ms = 0;
788
789 for (int i = 0; i < SPEED_CACHE; i++)
790 {
791 speed_cnt += device_param->speed_cnt[i];
792 speed_ms += device_param->speed_ms[i];
793 }
794
795 speed_cnt /= SPEED_CACHE;
796 speed_ms /= SPEED_CACHE;
797
798 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
799 }
800
801 /**
802 * exec time
803 */
804
805 fprintf (out, "EXEC_RUNTIME\t");
806
807 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
808 {
809 hc_device_param_t *device_param = &data.devices_param[device_id];
810
811 if (device_param->skipped) continue;
812
813 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
814
815 fprintf (out, "%f\t", exec_ms_avg);
816 }
817
818 /**
819 * words_cur
820 */
821
822 u64 words_cur = get_lowest_words_done ();
823
824 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
825
826 /**
827 * counter
828 */
829
830 u64 progress_total = data.words_cnt * data.salts_cnt;
831
832 u64 all_done = 0;
833 u64 all_rejected = 0;
834 u64 all_restored = 0;
835
836 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
837 {
838 all_done += data.words_progress_done[salt_pos];
839 all_rejected += data.words_progress_rejected[salt_pos];
840 all_restored += data.words_progress_restored[salt_pos];
841 }
842
843 u64 progress_cur = all_restored + all_done + all_rejected;
844 u64 progress_end = progress_total;
845
846 u64 progress_skip = 0;
847
848 if (data.skip)
849 {
850 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
855 }
856
857 if (data.limit)
858 {
859 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
860
861 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
862 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
863 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
864 }
865
866 u64 progress_cur_relative_skip = progress_cur - progress_skip;
867 u64 progress_end_relative_skip = progress_end - progress_skip;
868
869 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
870
871 /**
872 * cracks
873 */
874
875 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
876 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
877
878 /**
879 * temperature
880 */
881
882 #ifdef HAVE_HWMON
883 if (data.gpu_temp_disable == 0)
884 {
885 fprintf (out, "TEMP\t");
886
887 hc_thread_mutex_lock (mux_adl);
888
889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
890 {
891 hc_device_param_t *device_param = &data.devices_param[device_id];
892
893 if (device_param->skipped) continue;
894
895 int temp = hm_get_temperature_with_device_id (device_id);
896
897 fprintf (out, "%d\t", temp);
898 }
899
900 hc_thread_mutex_unlock (mux_adl);
901 }
902 #endif // HAVE_HWMON
903
904 /**
905 * flush
906 */
907
908 #ifdef _WIN
909 fputc ('\r', out);
910 fputc ('\n', out);
911 #endif
912
913 #ifdef _POSIX
914 fputc ('\n', out);
915 #endif
916
917 fflush (out);
918 }
919
920 void status_display ()
921 {
922 if (data.devices_status == STATUS_INIT) return;
923 if (data.devices_status == STATUS_STARTING) return;
924 if (data.devices_status == STATUS_BYPASS) return;
925
926 if (data.machine_readable == 1)
927 {
928 status_display_machine_readable ();
929
930 return;
931 }
932
933 char tmp_buf[1000] = { 0 };
934
935 uint tmp_len = 0;
936
937 log_info ("Session.Name...: %s", data.session);
938
939 char *status_type = strstatus (data.devices_status);
940
941 uint hash_mode = data.hash_mode;
942
943 char *hash_type = strhashtype (hash_mode); // not a bug
944
945 log_info ("Status.........: %s", status_type);
946
947 /**
948 * show rules
949 */
950
951 if (data.rp_files_cnt)
952 {
953 uint i;
954
955 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
956 {
957 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
958 }
959
960 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
961
962 log_info ("Rules.Type.....: %s", tmp_buf);
963
964 tmp_len = 0;
965 }
966
967 if (data.rp_gen)
968 {
969 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
970
971 if (data.rp_gen_seed)
972 {
973 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
974 }
975 }
976
977 /**
978 * show input
979 */
980
981 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
982 {
983 if (data.wordlist_mode == WL_MODE_FILE)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
986 }
987 else if (data.wordlist_mode == WL_MODE_STDIN)
988 {
989 log_info ("Input.Mode.....: Pipe");
990 }
991 }
992 else if (data.attack_mode == ATTACK_MODE_COMBI)
993 {
994 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
995 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
996 }
997 else if (data.attack_mode == ATTACK_MODE_BF)
998 {
999 char *mask = data.mask;
1000
1001 if (mask != NULL)
1002 {
1003 uint mask_len = data.css_cnt;
1004
1005 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1006
1007 if (mask_len > 0)
1008 {
1009 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1010 {
1011 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1012 {
1013 mask_len -= data.salts_buf[0].salt_len;
1014 }
1015 }
1016
1017 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1018
1019 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1020 }
1021
1022 if (data.maskcnt > 1)
1023 {
1024 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1027 }
1028
1029 log_info ("Input.Mode.....: %s", tmp_buf);
1030 }
1031
1032 tmp_len = 0;
1033 }
1034 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1035 {
1036 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1037 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1038 }
1039 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1040 {
1041 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1042 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1043 }
1044
1045 if (data.digests_cnt == 1)
1046 {
1047 if (data.hash_mode == 2500)
1048 {
1049 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1050
1051 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1052 (char *) data.salts_buf[0].salt_buf,
1053 wpa->orig_mac1[0],
1054 wpa->orig_mac1[1],
1055 wpa->orig_mac1[2],
1056 wpa->orig_mac1[3],
1057 wpa->orig_mac1[4],
1058 wpa->orig_mac1[5],
1059 wpa->orig_mac2[0],
1060 wpa->orig_mac2[1],
1061 wpa->orig_mac2[2],
1062 wpa->orig_mac2[3],
1063 wpa->orig_mac2[4],
1064 wpa->orig_mac2[5]);
1065 }
1066 else if (data.hash_mode == 5200)
1067 {
1068 log_info ("Hash.Target....: File (%s)", data.hashfile);
1069 }
1070 else if (data.hash_mode == 9000)
1071 {
1072 log_info ("Hash.Target....: File (%s)", data.hashfile);
1073 }
1074 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1075 {
1076 log_info ("Hash.Target....: File (%s)", data.hashfile);
1077 }
1078 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1079 {
1080 log_info ("Hash.Target....: File (%s)", data.hashfile);
1081 }
1082 else
1083 {
1084 char out_buf[HCBUFSIZ] = { 0 };
1085
1086 ascii_digest (out_buf, 0, 0);
1087
1088 // limit length
1089 if (strlen (out_buf) > 40)
1090 {
1091 out_buf[41] = '.';
1092 out_buf[42] = '.';
1093 out_buf[43] = '.';
1094 out_buf[44] = 0;
1095 }
1096
1097 log_info ("Hash.Target....: %s", out_buf);
1098 }
1099 }
1100 else
1101 {
1102 if (data.hash_mode == 3000)
1103 {
1104 char out_buf1[32] = { 0 };
1105 char out_buf2[32] = { 0 };
1106
1107 ascii_digest (out_buf1, 0, 0);
1108 ascii_digest (out_buf2, 0, 1);
1109
1110 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1111 }
1112 else
1113 {
1114 log_info ("Hash.Target....: File (%s)", data.hashfile);
1115 }
1116 }
1117
1118 log_info ("Hash.Type......: %s", hash_type);
1119
1120 /**
1121 * speed new
1122 */
1123
1124 u64 speed_cnt[DEVICES_MAX] = { 0 };
1125 double speed_ms[DEVICES_MAX] = { 0 };
1126
1127 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1128 {
1129 hc_device_param_t *device_param = &data.devices_param[device_id];
1130
1131 if (device_param->skipped) continue;
1132
1133 speed_cnt[device_id] = 0;
1134 speed_ms[device_id] = 0;
1135
1136 for (int i = 0; i < SPEED_CACHE; i++)
1137 {
1138 speed_cnt[device_id] += device_param->speed_cnt[i];
1139 speed_ms[device_id] += device_param->speed_ms[i];
1140 }
1141
1142 speed_cnt[device_id] /= SPEED_CACHE;
1143 speed_ms[device_id] /= SPEED_CACHE;
1144 }
1145
1146 double hashes_all_ms = 0;
1147
1148 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1149
1150 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1151 {
1152 hc_device_param_t *device_param = &data.devices_param[device_id];
1153
1154 if (device_param->skipped) continue;
1155
1156 hashes_dev_ms[device_id] = 0;
1157
1158 if (speed_ms[device_id])
1159 {
1160 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1161
1162 hashes_all_ms += hashes_dev_ms[device_id];
1163 }
1164 }
1165
1166 /**
1167 * exec time
1168 */
1169
1170 double exec_all_ms[DEVICES_MAX] = { 0 };
1171
1172 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1173 {
1174 hc_device_param_t *device_param = &data.devices_param[device_id];
1175
1176 if (device_param->skipped) continue;
1177
1178 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1179
1180 exec_all_ms[device_id] = exec_ms_avg;
1181 }
1182
1183 /**
1184 * timers
1185 */
1186
1187 double ms_running = 0;
1188
1189 hc_timer_get (data.timer_running, ms_running);
1190
1191 double ms_paused = data.ms_paused;
1192
1193 if (data.devices_status == STATUS_PAUSED)
1194 {
1195 double ms_paused_tmp = 0;
1196
1197 hc_timer_get (data.timer_paused, ms_paused_tmp);
1198
1199 ms_paused += ms_paused_tmp;
1200 }
1201
1202 #ifdef WIN
1203
1204 __time64_t sec_run = ms_running / 1000;
1205
1206 #else
1207
1208 time_t sec_run = ms_running / 1000;
1209
1210 #endif
1211
1212 if (sec_run)
1213 {
1214 char display_run[32] = { 0 };
1215
1216 struct tm tm_run;
1217
1218 struct tm *tmp = NULL;
1219
1220 #ifdef WIN
1221
1222 tmp = _gmtime64 (&sec_run);
1223
1224 #else
1225
1226 tmp = gmtime (&sec_run);
1227
1228 #endif
1229
1230 if (tmp != NULL)
1231 {
1232 memset (&tm_run, 0, sizeof (tm_run));
1233
1234 memcpy (&tm_run, tmp, sizeof (tm_run));
1235
1236 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1237
1238 char *start = ctime (&data.proc_start);
1239
1240 size_t start_len = strlen (start);
1241
1242 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1243 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1244
1245 log_info ("Time.Started...: %s (%s)", start, display_run);
1246 }
1247 }
1248 else
1249 {
1250 log_info ("Time.Started...: 0 secs");
1251 }
1252
1253 /**
1254 * counters
1255 */
1256
1257 u64 progress_total = data.words_cnt * data.salts_cnt;
1258
1259 u64 all_done = 0;
1260 u64 all_rejected = 0;
1261 u64 all_restored = 0;
1262
1263 u64 progress_noneed = 0;
1264
1265 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1266 {
1267 all_done += data.words_progress_done[salt_pos];
1268 all_rejected += data.words_progress_rejected[salt_pos];
1269 all_restored += data.words_progress_restored[salt_pos];
1270
1271 // Important for ETA only
1272
1273 if (data.salts_shown[salt_pos] == 1)
1274 {
1275 const u64 all = data.words_progress_done[salt_pos]
1276 + data.words_progress_rejected[salt_pos]
1277 + data.words_progress_restored[salt_pos];
1278
1279 const u64 left = data.words_cnt - all;
1280
1281 progress_noneed += left;
1282 }
1283 }
1284
1285 u64 progress_cur = all_restored + all_done + all_rejected;
1286 u64 progress_end = progress_total;
1287
1288 u64 progress_skip = 0;
1289
1290 if (data.skip)
1291 {
1292 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1297 }
1298
1299 if (data.limit)
1300 {
1301 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1302
1303 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1305 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1306 }
1307
1308 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1309 u64 progress_end_relative_skip = progress_end - progress_skip;
1310
1311 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1312 {
1313 if (data.devices_status != STATUS_CRACKED)
1314 {
1315 #ifdef WIN
1316 __time64_t sec_etc = 0;
1317 #else
1318 time_t sec_etc = 0;
1319 #endif
1320
1321 if (hashes_all_ms)
1322 {
1323 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1324
1325 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1326
1327 sec_etc = ms_left / 1000;
1328 }
1329
1330 if (sec_etc == 0)
1331 {
1332 //log_info ("Time.Estimated.: 0 secs");
1333 }
1334 else if ((u64) sec_etc > ETC_MAX)
1335 {
1336 log_info ("Time.Estimated.: > 10 Years");
1337 }
1338 else
1339 {
1340 char display_etc[32] = { 0 };
1341
1342 struct tm tm_etc;
1343
1344 struct tm *tmp = NULL;
1345
1346 #ifdef WIN
1347
1348 tmp = _gmtime64 (&sec_etc);
1349
1350 #else
1351
1352 tmp = gmtime (&sec_etc);
1353
1354 #endif
1355
1356 if (tmp != NULL)
1357 {
1358 memset (&tm_etc, 0, sizeof (tm_etc));
1359
1360 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1361
1362 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1363
1364 time_t now;
1365
1366 time (&now);
1367
1368 now += sec_etc;
1369
1370 char *etc = ctime (&now);
1371
1372 size_t etc_len = strlen (etc);
1373
1374 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1375 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1376
1377 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1378 }
1379 }
1380 }
1381 }
1382
1383 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1384 {
1385 hc_device_param_t *device_param = &data.devices_param[device_id];
1386
1387 if (device_param->skipped) continue;
1388
1389 char display_dev_cur[16] = { 0 };
1390
1391 strncpy (display_dev_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1394
1395 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1396 }
1397
1398 char display_all_cur[16] = { 0 };
1399
1400 strncpy (display_all_cur, "0.00", 4);
1401
1402 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1403
1404 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1405
1406 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1407 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1408
1409 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1410
1411 // crack-per-time
1412
1413 if (data.digests_cnt > 100)
1414 {
1415 time_t now = time (NULL);
1416
1417 int cpt_cur_min = 0;
1418 int cpt_cur_hour = 0;
1419 int cpt_cur_day = 0;
1420
1421 for (int i = 0; i < CPT_BUF; i++)
1422 {
1423 const uint cracked = data.cpt_buf[i].cracked;
1424 const time_t timestamp = data.cpt_buf[i].timestamp;
1425
1426 if ((timestamp + 60) > now)
1427 {
1428 cpt_cur_min += cracked;
1429 }
1430
1431 if ((timestamp + 3600) > now)
1432 {
1433 cpt_cur_hour += cracked;
1434 }
1435
1436 if ((timestamp + 86400) > now)
1437 {
1438 cpt_cur_day += cracked;
1439 }
1440 }
1441
1442 double ms_real = ms_running - ms_paused;
1443
1444 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1445 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1446 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1447
1448 if ((data.cpt_start + 86400) < now)
1449 {
1450 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1451 cpt_cur_min,
1452 cpt_cur_hour,
1453 cpt_cur_day,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 3600) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_cur_hour,
1463 cpt_avg_min,
1464 cpt_avg_hour,
1465 cpt_avg_day);
1466 }
1467 else if ((data.cpt_start + 60) < now)
1468 {
1469 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1470 cpt_cur_min,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else
1476 {
1477 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 }
1483
1484 // Restore point
1485
1486 u64 restore_point = get_lowest_words_done ();
1487
1488 u64 restore_total = data.words_base;
1489
1490 float percent_restore = 0;
1491
1492 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1493
1494 if (progress_end_relative_skip)
1495 {
1496 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1497 {
1498 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1499 float percent_rejected = 0.0;
1500
1501 if (progress_cur)
1502 {
1503 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1504 }
1505
1506 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1507 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1508
1509 if (data.restore_disable == 0)
1510 {
1511 if (percent_finished != 1)
1512 {
1513 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1514 }
1515 }
1516 }
1517 }
1518 else
1519 {
1520 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1521 {
1522 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1523 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1524
1525 if (data.restore_disable == 0)
1526 {
1527 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1528 }
1529 }
1530 else
1531 {
1532 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1533 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1534
1535 // --restore not allowed if stdin is used -- really? why?
1536
1537 //if (data.restore_disable == 0)
1538 //{
1539 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1540 //}
1541 }
1542 }
1543
1544 #ifdef HAVE_HWMON
1545
1546 if (data.devices_status == STATUS_EXHAUSTED) return;
1547 if (data.devices_status == STATUS_CRACKED) return;
1548 if (data.devices_status == STATUS_ABORTED) return;
1549 if (data.devices_status == STATUS_QUIT) return;
1550
1551 if (data.gpu_temp_disable == 0)
1552 {
1553 hc_thread_mutex_lock (mux_adl);
1554
1555 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1556 {
1557 hc_device_param_t *device_param = &data.devices_param[device_id];
1558
1559 if (device_param->skipped) continue;
1560
1561 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1562 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1563 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1564 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1565 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1566 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1567 const int num_throttle = hm_get_throttle_with_device_id (device_id);
1568
1569 char output_buf[256] = { 0 };
1570
1571 int output_len = 0;
1572
1573 if (num_temperature >= 0)
1574 {
1575 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1576
1577 output_len = strlen (output_buf);
1578 }
1579
1580 if (num_fanspeed >= 0)
1581 {
1582 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1583
1584 output_len = strlen (output_buf);
1585 }
1586
1587 if (num_utilization >= 0)
1588 {
1589 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1590
1591 output_len = strlen (output_buf);
1592 }
1593
1594 if (num_corespeed >= 0)
1595 {
1596 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1597
1598 output_len = strlen (output_buf);
1599 }
1600
1601 if (num_memoryspeed >= 0)
1602 {
1603 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1604
1605 output_len = strlen (output_buf);
1606 }
1607
1608 if (num_buslanes >= 0)
1609 {
1610 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1611
1612 output_len = strlen (output_buf);
1613 }
1614
1615 if (num_throttle == 1)
1616 {
1617 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*");
1618
1619 output_len = strlen (output_buf);
1620 }
1621
1622 if (output_len == 0)
1623 {
1624 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1625
1626 output_len = strlen (output_buf);
1627 }
1628
1629 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1630 }
1631
1632 hc_thread_mutex_unlock (mux_adl);
1633 }
1634
1635 #endif // HAVE_HWMON
1636 }
1637
1638 static void status_benchmark_automate ()
1639 {
1640 u64 speed_cnt[DEVICES_MAX] = { 0 };
1641 double speed_ms[DEVICES_MAX] = { 0 };
1642
1643 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1644 {
1645 hc_device_param_t *device_param = &data.devices_param[device_id];
1646
1647 if (device_param->skipped) continue;
1648
1649 speed_cnt[device_id] = device_param->speed_cnt[0];
1650 speed_ms[device_id] = device_param->speed_ms[0];
1651 }
1652
1653 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1654
1655 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1656 {
1657 hc_device_param_t *device_param = &data.devices_param[device_id];
1658
1659 if (device_param->skipped) continue;
1660
1661 hashes_dev_ms[device_id] = 0;
1662
1663 if (speed_ms[device_id])
1664 {
1665 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1666 }
1667 }
1668
1669 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1670 {
1671 hc_device_param_t *device_param = &data.devices_param[device_id];
1672
1673 if (device_param->skipped) continue;
1674
1675 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1676 }
1677 }
1678
1679 static void status_benchmark ()
1680 {
1681 if (data.devices_status == STATUS_INIT) return;
1682 if (data.devices_status == STATUS_STARTING) return;
1683 if (data.devices_status == STATUS_BYPASS) return;
1684
1685 if (data.machine_readable == 1)
1686 {
1687 status_benchmark_automate ();
1688
1689 return;
1690 }
1691
1692 u64 speed_cnt[DEVICES_MAX] = { 0 };
1693 double speed_ms[DEVICES_MAX] = { 0 };
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 speed_cnt[device_id] = device_param->speed_cnt[0];
1702 speed_ms[device_id] = device_param->speed_ms[0];
1703 }
1704
1705 double hashes_all_ms = 0;
1706
1707 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1708
1709 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1710 {
1711 hc_device_param_t *device_param = &data.devices_param[device_id];
1712
1713 if (device_param->skipped) continue;
1714
1715 hashes_dev_ms[device_id] = 0;
1716
1717 if (speed_ms[device_id])
1718 {
1719 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1720
1721 hashes_all_ms += hashes_dev_ms[device_id];
1722 }
1723 }
1724
1725 /**
1726 * exec time
1727 */
1728
1729 double exec_all_ms[DEVICES_MAX] = { 0 };
1730
1731 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1732 {
1733 hc_device_param_t *device_param = &data.devices_param[device_id];
1734
1735 if (device_param->skipped) continue;
1736
1737 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1738
1739 exec_all_ms[device_id] = exec_ms_avg;
1740 }
1741
1742 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1743 {
1744 hc_device_param_t *device_param = &data.devices_param[device_id];
1745
1746 if (device_param->skipped) continue;
1747
1748 char display_dev_cur[16] = { 0 };
1749
1750 strncpy (display_dev_cur, "0.00", 4);
1751
1752 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1753
1754 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1755 }
1756
1757 char display_all_cur[16] = { 0 };
1758
1759 strncpy (display_all_cur, "0.00", 4);
1760
1761 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1762
1763 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1764 }
1765
1766 /**
1767 * hashcat -only- functions
1768 */
1769
1770 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1771 {
1772 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1773 {
1774 if (attack_kern == ATTACK_KERN_STRAIGHT)
1775 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1776 else if (attack_kern == ATTACK_KERN_COMBI)
1777 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1778 else if (attack_kern == ATTACK_KERN_BF)
1779 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1780 }
1781 else
1782 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1783 }
1784
1785 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1786 {
1787 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1788 {
1789 if (attack_kern == ATTACK_KERN_STRAIGHT)
1790 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1791 else if (attack_kern == ATTACK_KERN_COMBI)
1792 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1793 else if (attack_kern == ATTACK_KERN_BF)
1794 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1795 }
1796 else
1797 {
1798 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1799 }
1800 }
1801
1802 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1803 {
1804 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1805 {
1806 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1807 }
1808 else
1809 {
1810 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1811 }
1812 }
1813
1814 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1815 {
1816 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1817 {
1818 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1819 }
1820 else
1821 {
1822 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1823 }
1824 }
1825
1826 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1827 {
1828 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1829 }
1830
1831 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1832 {
1833 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1834 }
1835
1836 static uint convert_from_hex (char *line_buf, const uint line_len)
1837 {
1838 if (line_len & 1) return (line_len); // not in hex
1839
1840 if (data.hex_wordlist == 1)
1841 {
1842 uint i;
1843 uint j;
1844
1845 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1846 {
1847 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1848 }
1849
1850 memset (line_buf + i, 0, line_len - i);
1851
1852 return (i);
1853 }
1854 else if (line_len >= 6) // $HEX[] = 6
1855 {
1856 if (line_buf[0] != '$') return (line_len);
1857 if (line_buf[1] != 'H') return (line_len);
1858 if (line_buf[2] != 'E') return (line_len);
1859 if (line_buf[3] != 'X') return (line_len);
1860 if (line_buf[4] != '[') return (line_len);
1861 if (line_buf[line_len - 1] != ']') return (line_len);
1862
1863 uint i;
1864 uint j;
1865
1866 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1867 {
1868 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1869 }
1870
1871 memset (line_buf + i, 0, line_len - i);
1872
1873 return (i);
1874 }
1875
1876 return (line_len);
1877 }
1878
1879 static void clear_prompt ()
1880 {
1881 fputc ('\r', stdout);
1882
1883 for (size_t i = 0; i < strlen (PROMPT); i++)
1884 {
1885 fputc (' ', stdout);
1886 }
1887
1888 fputc ('\r', stdout);
1889
1890 fflush (stdout);
1891 }
1892
1893 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1894 {
1895 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1896 }
1897
1898 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1899 {
1900 char *outfile = data.outfile;
1901 uint quiet = data.quiet;
1902 FILE *pot_fp = data.pot_fp;
1903 uint loopback = data.loopback;
1904 uint debug_mode = data.debug_mode;
1905 char *debug_file = data.debug_file;
1906
1907 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1908 int debug_rule_len = 0; // -1 error
1909 uint debug_plain_len = 0;
1910
1911 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1912
1913 // hash
1914
1915 char out_buf[HCBUFSIZ] = { 0 };
1916
1917 const u32 salt_pos = plain->salt_pos;
1918 const u32 digest_pos = plain->digest_pos; // relative
1919 const u32 gidvid = plain->gidvid;
1920 const u32 il_pos = plain->il_pos;
1921
1922 ascii_digest (out_buf, salt_pos, digest_pos);
1923
1924 // plain
1925
1926 u64 crackpos = device_param->words_off;
1927
1928 uint plain_buf[16] = { 0 };
1929
1930 u8 *plain_ptr = (u8 *) plain_buf;
1931
1932 unsigned int plain_len = 0;
1933
1934 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1935 {
1936 pw_t pw;
1937
1938 gidd_to_pw_t (device_param, gidvid, &pw);
1939
1940 for (int i = 0; i < 16; i++)
1941 {
1942 plain_buf[i] = pw.i[i];
1943 }
1944
1945 plain_len = pw.pw_len;
1946
1947 const uint off = device_param->innerloop_pos + il_pos;
1948
1949 if (debug_mode > 0)
1950 {
1951 debug_rule_len = 0;
1952
1953 // save rule
1954 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1955 {
1956 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1957
1958 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1959 }
1960
1961 // save plain
1962 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1963 {
1964 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1965
1966 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1967
1968 debug_plain_len = plain_len;
1969 }
1970 }
1971
1972 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1973
1974 crackpos += gidvid;
1975 crackpos *= data.kernel_rules_cnt;
1976 crackpos += device_param->innerloop_pos + il_pos;
1977
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 else if (data.attack_mode == ATTACK_MODE_COMBI)
1981 {
1982 pw_t pw;
1983
1984 gidd_to_pw_t (device_param, gidvid, &pw);
1985
1986 for (int i = 0; i < 16; i++)
1987 {
1988 plain_buf[i] = pw.i[i];
1989 }
1990
1991 plain_len = pw.pw_len;
1992
1993 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1994 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1995
1996 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1997 {
1998 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1999 }
2000 else
2001 {
2002 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2003
2004 memcpy (plain_ptr, comb_buf, comb_len);
2005 }
2006
2007 plain_len += comb_len;
2008
2009 crackpos += gidvid;
2010 crackpos *= data.combs_cnt;
2011 crackpos += device_param->innerloop_pos + il_pos;
2012
2013 if (data.pw_max != PW_DICTMAX1)
2014 {
2015 if (plain_len > data.pw_max) plain_len = data.pw_max;
2016 }
2017 }
2018 else if (data.attack_mode == ATTACK_MODE_BF)
2019 {
2020 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2021 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2022
2023 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2024 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2025
2026 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2027 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2028
2029 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2030 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2031
2032 plain_len = data.css_cnt;
2033
2034 crackpos += gidvid;
2035 crackpos *= data.bfs_cnt;
2036 crackpos += device_param->innerloop_pos + il_pos;
2037 }
2038 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2039 {
2040 pw_t pw;
2041
2042 gidd_to_pw_t (device_param, gidvid, &pw);
2043
2044 for (int i = 0; i < 16; i++)
2045 {
2046 plain_buf[i] = pw.i[i];
2047 }
2048
2049 plain_len = pw.pw_len;
2050
2051 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2052
2053 uint start = 0;
2054 uint stop = device_param->kernel_params_mp_buf32[4];
2055
2056 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2057
2058 plain_len += start + stop;
2059
2060 crackpos += gidvid;
2061 crackpos *= data.combs_cnt;
2062 crackpos += device_param->innerloop_pos + il_pos;
2063
2064 if (data.pw_max != PW_DICTMAX1)
2065 {
2066 if (plain_len > data.pw_max) plain_len = data.pw_max;
2067 }
2068 }
2069 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2070 {
2071 pw_t pw;
2072
2073 gidd_to_pw_t (device_param, gidvid, &pw);
2074
2075 for (int i = 0; i < 16; i++)
2076 {
2077 plain_buf[i] = pw.i[i];
2078 }
2079
2080 plain_len = pw.pw_len;
2081
2082 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2083
2084 uint start = 0;
2085 uint stop = device_param->kernel_params_mp_buf32[4];
2086
2087 memmove (plain_ptr + stop, plain_ptr, plain_len);
2088
2089 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2090
2091 plain_len += start + stop;
2092
2093 crackpos += gidvid;
2094 crackpos *= data.combs_cnt;
2095 crackpos += device_param->innerloop_pos + il_pos;
2096
2097 if (data.pw_max != PW_DICTMAX1)
2098 {
2099 if (plain_len > data.pw_max) plain_len = data.pw_max;
2100 }
2101 }
2102
2103 if (data.attack_mode == ATTACK_MODE_BF)
2104 {
2105 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2106 {
2107 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2108 {
2109 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2110 {
2111 plain_len = plain_len - data.salts_buf[0].salt_len;
2112 }
2113 }
2114
2115 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2116 {
2117 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2118 {
2119 plain_ptr[j] = plain_ptr[i];
2120 }
2121
2122 plain_len = plain_len / 2;
2123 }
2124 }
2125 }
2126
2127 // if enabled, update also the potfile
2128
2129 if (pot_fp)
2130 {
2131 lock_file (pot_fp);
2132
2133 fprintf (pot_fp, "%s:", out_buf);
2134
2135 format_plain (pot_fp, plain_ptr, plain_len, 1);
2136
2137 fputc ('\n', pot_fp);
2138
2139 fflush (pot_fp);
2140
2141 unlock_file (pot_fp);
2142 }
2143
2144 // outfile
2145
2146 FILE *out_fp = NULL;
2147
2148 if (outfile != NULL)
2149 {
2150 if ((out_fp = fopen (outfile, "ab")) == NULL)
2151 {
2152 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2153
2154 out_fp = stdout;
2155 }
2156
2157 lock_file (out_fp);
2158 }
2159 else
2160 {
2161 out_fp = stdout;
2162
2163 if (quiet == 0) clear_prompt ();
2164 }
2165
2166 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2167
2168 if (outfile != NULL)
2169 {
2170 if (out_fp != stdout)
2171 {
2172 fclose (out_fp);
2173 }
2174 }
2175 else
2176 {
2177 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2178 {
2179 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2180 {
2181 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2182 if (quiet == 0) fflush (stdout);
2183 }
2184 }
2185 }
2186
2187 // loopback
2188
2189 if (loopback)
2190 {
2191 char *loopback_file = data.loopback_file;
2192
2193 FILE *fb_fp = NULL;
2194
2195 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2196 {
2197 lock_file (fb_fp);
2198
2199 format_plain (fb_fp, plain_ptr, plain_len, 1);
2200
2201 fputc ('\n', fb_fp);
2202
2203 fclose (fb_fp);
2204 }
2205 }
2206
2207 // (rule) debug mode
2208
2209 // the next check implies that:
2210 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2211 // - debug_mode > 0
2212
2213 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2214 {
2215 if (debug_rule_len < 0) debug_rule_len = 0;
2216
2217 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2218
2219 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2220
2221 if ((quiet == 0) && (debug_file == NULL))
2222 {
2223 fprintf (stdout, "%s", PROMPT);
2224
2225 fflush (stdout);
2226 }
2227 }
2228 }
2229
2230 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2231 {
2232 salt_t *salt_buf = &data.salts_buf[salt_pos];
2233
2234 u32 num_cracked;
2235
2236 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2237
2238 if (num_cracked)
2239 {
2240 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2241
2242 log_info_nn ("");
2243
2244 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2245
2246 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2247
2248 uint cpt_cracked = 0;
2249
2250 for (uint i = 0; i < num_cracked; i++)
2251 {
2252 const uint hash_pos = cracked[i].hash_pos;
2253
2254 if (data.digests_shown[hash_pos] == 1) continue;
2255
2256 hc_thread_mutex_lock (mux_display);
2257
2258 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2259 {
2260 data.digests_shown[hash_pos] = 1;
2261
2262 data.digests_done++;
2263
2264 cpt_cracked++;
2265
2266 salt_buf->digests_done++;
2267
2268 if (salt_buf->digests_done == salt_buf->digests_cnt)
2269 {
2270 data.salts_shown[salt_pos] = 1;
2271
2272 data.salts_done++;
2273 }
2274 }
2275
2276 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2277
2278 hc_thread_mutex_unlock (mux_display);
2279
2280 check_hash (device_param, &cracked[i]);
2281 }
2282
2283 myfree (cracked);
2284
2285 if (cpt_cracked > 0)
2286 {
2287 hc_thread_mutex_lock (mux_display);
2288
2289 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2290 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2291
2292 data.cpt_pos++;
2293
2294 data.cpt_total += cpt_cracked;
2295
2296 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2297
2298 hc_thread_mutex_unlock (mux_display);
2299 }
2300
2301 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2302 {
2303 // we need to reset cracked state on the device
2304 // otherwise host thinks again and again the hash was cracked
2305 // and returns invalid password each time
2306
2307 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2308
2309 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2310 }
2311
2312 num_cracked = 0;
2313
2314 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2315 }
2316 }
2317
2318 static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
2319 {
2320 char out_buf[HCBUFSIZ] = { 0 };
2321
2322 uint plain_buf[16] = { 0 };
2323
2324 u8 *plain_ptr = (u8 *) plain_buf;
2325
2326 uint plain_len = 0;
2327
2328 const uint il_cnt = device_param->kernel_params_buf32[27]; // ugly, i know
2329
2330 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
2331 {
2332 pw_t pw;
2333
2334 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2335 {
2336 gidd_to_pw_t (device_param, gidvid, &pw);
2337
2338 const uint pos = device_param->innerloop_pos;
2339
2340 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2341 {
2342 for (int i = 0; i < 8; i++)
2343 {
2344 plain_buf[i] = pw.i[i];
2345 }
2346
2347 plain_len = pw.pw_len;
2348
2349 plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len);
2350
2351 if (plain_len > data.pw_max) plain_len = data.pw_max;
2352
2353 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2354 }
2355 }
2356 }
2357 else if (data.attack_mode == ATTACK_MODE_COMBI)
2358 {
2359 pw_t pw;
2360
2361 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2362 {
2363 gidd_to_pw_t (device_param, gidvid, &pw);
2364
2365 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2366 {
2367 for (int i = 0; i < 8; i++)
2368 {
2369 plain_buf[i] = pw.i[i];
2370 }
2371
2372 plain_len = pw.pw_len;
2373
2374 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
2375 uint comb_len = device_param->combs_buf[il_pos].pw_len;
2376
2377 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
2378 {
2379 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
2380 }
2381 else
2382 {
2383 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
2384
2385 memcpy (plain_ptr, comb_buf, comb_len);
2386 }
2387
2388 plain_len += comb_len;
2389
2390 if (data.pw_max != PW_DICTMAX1)
2391 {
2392 if (plain_len > data.pw_max) plain_len = data.pw_max;
2393 }
2394
2395 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2396 }
2397 }
2398 }
2399 else if (data.attack_mode == ATTACK_MODE_BF)
2400 {
2401 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2402 {
2403 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2404 {
2405 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2406 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2407
2408 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2409 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2410
2411 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2412 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2413
2414 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2415 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2416
2417 plain_len = data.css_cnt;
2418
2419 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2420 }
2421 }
2422 }
2423 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2424 {
2425 pw_t pw;
2426
2427 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2428 {
2429 gidd_to_pw_t (device_param, gidvid, &pw);
2430
2431 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2432 {
2433 for (int i = 0; i < 8; i++)
2434 {
2435 plain_buf[i] = pw.i[i];
2436 }
2437
2438 plain_len = pw.pw_len;
2439
2440 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2441
2442 uint start = 0;
2443 uint stop = device_param->kernel_params_mp_buf32[4];
2444
2445 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2446
2447 plain_len += start + stop;
2448
2449 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2450 }
2451 }
2452 }
2453 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2454 {
2455 pw_t pw;
2456
2457 for (uint gidvid = 0; gidvid < pws_cnt; gidvid++)
2458 {
2459 gidd_to_pw_t (device_param, gidvid, &pw);
2460
2461 for (uint il_pos = 0; il_pos < il_cnt; il_pos++)
2462 {
2463 for (int i = 0; i < 8; i++)
2464 {
2465 plain_buf[i] = pw.i[i];
2466 }
2467
2468 plain_len = pw.pw_len;
2469
2470 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2471
2472 uint start = 0;
2473 uint stop = device_param->kernel_params_mp_buf32[4];
2474
2475 memmove (plain_ptr + stop, plain_ptr, plain_len);
2476
2477 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2478
2479 plain_len += start + stop;
2480
2481 format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
2482 }
2483 }
2484 }
2485 }
2486
2487 static void save_hash ()
2488 {
2489 char *hashfile = data.hashfile;
2490
2491 char new_hashfile[256] = { 0 };
2492 char old_hashfile[256] = { 0 };
2493
2494 snprintf (new_hashfile, 255, "%s.new", hashfile);
2495 snprintf (old_hashfile, 255, "%s.old", hashfile);
2496
2497 unlink (new_hashfile);
2498
2499 char separator = data.separator;
2500
2501 FILE *fp = fopen (new_hashfile, "wb");
2502
2503 if (fp == NULL)
2504 {
2505 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2506
2507 exit (-1);
2508 }
2509
2510 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2511 {
2512 if (data.salts_shown[salt_pos] == 1) continue;
2513
2514 salt_t *salt_buf = &data.salts_buf[salt_pos];
2515
2516 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2517 {
2518 uint idx = salt_buf->digests_offset + digest_pos;
2519
2520 if (data.digests_shown[idx] == 1) continue;
2521
2522 if (data.hash_mode != 2500)
2523 {
2524 if (data.username == 1)
2525 {
2526 user_t *user = data.hash_info[idx]->user;
2527
2528 uint i;
2529
2530 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2531
2532 fputc (separator, fp);
2533 }
2534
2535 char out_buf[HCBUFSIZ]; // scratch buffer
2536
2537 out_buf[0] = 0;
2538
2539 ascii_digest (out_buf, salt_pos, digest_pos);
2540
2541 fputs (out_buf, fp);
2542
2543 if (fp == stdout)
2544 {
2545 log_out (fp, "");
2546 }
2547 else
2548 {
2549 fputc ('\n', fp);
2550 }
2551 }
2552 else
2553 {
2554 hccap_t hccap;
2555
2556 to_hccap_t (&hccap, salt_pos, digest_pos);
2557
2558 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2559 }
2560 }
2561 }
2562
2563 fflush (fp);
2564
2565 fclose (fp);
2566
2567 unlink (old_hashfile);
2568
2569 if (rename (hashfile, old_hashfile) != 0)
2570 {
2571 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2572
2573 exit (-1);
2574 }
2575
2576 unlink (hashfile);
2577
2578 if (rename (new_hashfile, hashfile) != 0)
2579 {
2580 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2581
2582 exit (-1);
2583 }
2584
2585 unlink (old_hashfile);
2586 }
2587
2588 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration)
2589 {
2590 uint num_elements = num;
2591
2592 device_param->kernel_params_buf32[30] = data.combs_mode;
2593 device_param->kernel_params_buf32[31] = num;
2594
2595 uint kernel_threads = device_param->kernel_threads;
2596
2597 while (num_elements % kernel_threads) num_elements++;
2598
2599 cl_kernel kernel = NULL;
2600
2601 switch (kern_run)
2602 {
2603 case KERN_RUN_1: kernel = device_param->kernel1; break;
2604 case KERN_RUN_12: kernel = device_param->kernel12; break;
2605 case KERN_RUN_2: kernel = device_param->kernel2; break;
2606 case KERN_RUN_23: kernel = device_param->kernel23; break;
2607 case KERN_RUN_3: kernel = device_param->kernel3; break;
2608 }
2609
2610 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2611 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2612 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2613 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2614 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2615 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2616 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2617 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2618 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2619 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2620 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2621
2622 cl_event event;
2623
2624 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2625 {
2626 const size_t global_work_size[3] = { num_elements, 32, 1 };
2627 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2628
2629 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2630 }
2631 else
2632 {
2633 if (kern_run == KERN_RUN_2)
2634 {
2635 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2636 {
2637 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2638 }
2639 }
2640
2641 while (num_elements % kernel_threads) num_elements++;
2642
2643 const size_t global_work_size[3] = { num_elements, 1, 1 };
2644 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2645
2646 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2647 }
2648
2649 hc_clFlush (data.ocl, device_param->command_queue);
2650
2651 if (data.devices_status == STATUS_RUNNING)
2652 {
2653 if (iteration < EXPECTED_ITERATIONS)
2654 {
2655 switch (kern_run)
2656 {
2657 case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration]); break;
2658 case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration]); break;
2659 case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration]); break;
2660 }
2661 }
2662 }
2663
2664 hc_clWaitForEvents (data.ocl, 1, &event);
2665
2666 cl_ulong time_start;
2667 cl_ulong time_end;
2668
2669 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2670 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2671
2672 const double exec_us = (double) (time_end - time_start) / 1000;
2673
2674 if (data.devices_status == STATUS_RUNNING)
2675 {
2676 if (iteration < EXPECTED_ITERATIONS)
2677 {
2678 switch (kern_run)
2679 {
2680 case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break;
2681 case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break;
2682 case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break;
2683 }
2684 }
2685 }
2686
2687 if (event_update)
2688 {
2689 uint exec_pos = device_param->exec_pos;
2690
2691 device_param->exec_ms[exec_pos] = exec_us / 1000;
2692
2693 exec_pos++;
2694
2695 if (exec_pos == EXEC_CACHE)
2696 {
2697 exec_pos = 0;
2698 }
2699
2700 device_param->exec_pos = exec_pos;
2701 }
2702
2703 hc_clReleaseEvent (data.ocl, event);
2704
2705 hc_clFinish (data.ocl, device_param->command_queue);
2706 }
2707
2708 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2709 {
2710 uint num_elements = num;
2711
2712 switch (kern_run)
2713 {
2714 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2715 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2716 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2717 }
2718
2719 // causes problems with special threads like in bcrypt
2720 // const uint kernel_threads = device_param->kernel_threads;
2721
2722 uint kernel_threads = device_param->kernel_threads;
2723
2724 while (num_elements % kernel_threads) num_elements++;
2725
2726 cl_kernel kernel = NULL;
2727
2728 switch (kern_run)
2729 {
2730 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2731 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2732 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2733 }
2734
2735 switch (kern_run)
2736 {
2737 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2738 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2739 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2740 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2741 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2742 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2743 break;
2744 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2745 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2746 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2747 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2748 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2749 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2750 break;
2751 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2752 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2753 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2754 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2755 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2756 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2757 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2758 break;
2759 }
2760
2761 const size_t global_work_size[3] = { num_elements, 1, 1 };
2762 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2763
2764 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2765
2766 hc_clFlush (data.ocl, device_param->command_queue);
2767
2768 hc_clFinish (data.ocl, device_param->command_queue);
2769 }
2770
2771 static void run_kernel_tm (hc_device_param_t *device_param)
2772 {
2773 const uint num_elements = 1024; // fixed
2774
2775 uint kernel_threads = 32;
2776
2777 cl_kernel kernel = device_param->kernel_tm;
2778
2779 const size_t global_work_size[3] = { num_elements, 1, 1 };
2780 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2781
2782 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2783
2784 hc_clFlush (data.ocl, device_param->command_queue);
2785
2786 hc_clFinish (data.ocl, device_param->command_queue);
2787 }
2788
2789 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2790 {
2791 uint num_elements = num;
2792
2793 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2794 device_param->kernel_params_amp_buf32[6] = num_elements;
2795
2796 // causes problems with special threads like in bcrypt
2797 // const uint kernel_threads = device_param->kernel_threads;
2798
2799 uint kernel_threads = device_param->kernel_threads;
2800
2801 while (num_elements % kernel_threads) num_elements++;
2802
2803 cl_kernel kernel = device_param->kernel_amp;
2804
2805 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2806 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2807
2808 const size_t global_work_size[3] = { num_elements, 1, 1 };
2809 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2810
2811 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2812
2813 hc_clFlush (data.ocl, device_param->command_queue);
2814
2815 hc_clFinish (data.ocl, device_param->command_queue);
2816 }
2817
2818 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2819 {
2820 const u32 num16d = num / 16;
2821 const u32 num16m = num % 16;
2822
2823 if (num16d)
2824 {
2825 device_param->kernel_params_memset_buf32[1] = value;
2826 device_param->kernel_params_memset_buf32[2] = num16d;
2827
2828 uint kernel_threads = device_param->kernel_threads;
2829
2830 uint num_elements = num16d;
2831
2832 while (num_elements % kernel_threads) num_elements++;
2833
2834 cl_kernel kernel = device_param->kernel_memset;
2835
2836 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2837 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2838 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2839
2840 const size_t global_work_size[3] = { num_elements, 1, 1 };
2841 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2842
2843 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2844
2845 hc_clFlush (data.ocl, device_param->command_queue);
2846
2847 hc_clFinish (data.ocl, device_param->command_queue);
2848 }
2849
2850 if (num16m)
2851 {
2852 u32 tmp[4];
2853
2854 tmp[0] = value;
2855 tmp[1] = value;
2856 tmp[2] = value;
2857 tmp[3] = value;
2858
2859 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2860 }
2861 }
2862
2863 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2864 {
2865 run_kernel_memset (device_param, buf, 0, size);
2866
2867 /*
2868 int rc = -1;
2869
2870 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2871 {
2872 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2873
2874 const cl_uchar zero = 0;
2875
2876 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2877 }
2878
2879 if (rc != 0)
2880 {
2881 // NOTE: clEnqueueFillBuffer () always fails with -59
2882 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2883 // How's that possible, OpenCL 1.2 support is advertised??
2884 // We need to workaround...
2885
2886 #define FILLSZ 0x100000
2887
2888 char *tmp = (char *) mymalloc (FILLSZ);
2889
2890 for (size_t i = 0; i < size; i += FILLSZ)
2891 {
2892 const size_t left = size - i;
2893
2894 const size_t fillsz = MIN (FILLSZ, left);
2895
2896 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2897 }
2898
2899 myfree (tmp);
2900 }
2901 */
2902 }
2903
2904 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration)
2905 {
2906 if (data.hash_mode == 2000)
2907 {
2908 process_stdout (device_param, pws_cnt);
2909
2910 return;
2911 }
2912
2913 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2914 {
2915 if (attack_mode == ATTACK_MODE_BF)
2916 {
2917 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2918 {
2919 const uint size_tm = 32 * sizeof (bs_word_t);
2920
2921 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2922
2923 run_kernel_tm (device_param);
2924
2925 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);
2926 }
2927 }
2928
2929 if (highest_pw_len < 16)
2930 {
2931 run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration);
2932 }
2933 else if (highest_pw_len < 32)
2934 {
2935 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration);
2936 }
2937 else
2938 {
2939 run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration);
2940 }
2941 }
2942 else
2943 {
2944 run_kernel_amp (device_param, pws_cnt);
2945
2946 run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0);
2947
2948 if (opts_type & OPTS_TYPE_HOOK12)
2949 {
2950 run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0);
2951
2952 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);
2953
2954 // do something with data
2955
2956 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);
2957 }
2958
2959 uint iter = salt_buf->salt_iter;
2960
2961 uint loop_step = device_param->kernel_loops;
2962
2963 for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++)
2964 {
2965 uint loop_left = iter - loop_pos;
2966
2967 loop_left = MIN (loop_left, loop_step);
2968
2969 device_param->kernel_params_buf32[25] = loop_pos;
2970 device_param->kernel_params_buf32[26] = loop_left;
2971
2972 run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration);
2973
2974 if (data.devices_status == STATUS_CRACKED) break;
2975 if (data.devices_status == STATUS_ABORTED) break;
2976 if (data.devices_status == STATUS_QUIT) break;
2977
2978 /**
2979 * speed
2980 */
2981
2982 const float iter_part = (float) (loop_pos + loop_left) / iter;
2983
2984 const u64 perf_sum_all = pws_cnt * iter_part;
2985
2986 double speed_ms;
2987
2988 hc_timer_get (device_param->timer_speed, speed_ms);
2989
2990 const u32 speed_pos = device_param->speed_pos;
2991
2992 device_param->speed_cnt[speed_pos] = perf_sum_all;
2993
2994 device_param->speed_ms[speed_pos] = speed_ms;
2995
2996 if (data.benchmark == 1)
2997 {
2998 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2999 }
3000 }
3001
3002 if (opts_type & OPTS_TYPE_HOOK23)
3003 {
3004 run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0);
3005
3006 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);
3007
3008 // do something with data
3009
3010 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);
3011 }
3012
3013 run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0);
3014 }
3015 }
3016
3017 static int run_rule_engine (const int rule_len, const char *rule_buf)
3018 {
3019 if (rule_len == 0)
3020 {
3021 return 0;
3022 }
3023 else if (rule_len == 1)
3024 {
3025 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
3026 }
3027
3028 return 1;
3029 }
3030
3031 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
3032 {
3033 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3034 {
3035 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);
3036 }
3037 else if (data.attack_kern == ATTACK_KERN_COMBI)
3038 {
3039 if (data.attack_mode == ATTACK_MODE_COMBI)
3040 {
3041 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
3042 {
3043 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3044 {
3045 for (u32 i = 0; i < pws_cnt; i++)
3046 {
3047 const u32 pw_len = device_param->pws_buf[i].pw_len;
3048
3049 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3050
3051 ptr[pw_len] = 0x01;
3052 }
3053 }
3054 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3055 {
3056 for (u32 i = 0; i < pws_cnt; i++)
3057 {
3058 const u32 pw_len = device_param->pws_buf[i].pw_len;
3059
3060 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3061
3062 ptr[pw_len] = 0x80;
3063 }
3064 }
3065 }
3066 }
3067 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3068 {
3069 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3070 {
3071 for (u32 i = 0; i < pws_cnt; i++)
3072 {
3073 const u32 pw_len = device_param->pws_buf[i].pw_len;
3074
3075 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3076
3077 ptr[pw_len] = 0x01;
3078 }
3079 }
3080 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
3081 {
3082 for (u32 i = 0; i < pws_cnt; i++)
3083 {
3084 const u32 pw_len = device_param->pws_buf[i].pw_len;
3085
3086 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
3087
3088 ptr[pw_len] = 0x80;
3089 }
3090 }
3091 }
3092
3093 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);
3094 }
3095 else if (data.attack_kern == ATTACK_KERN_BF)
3096 {
3097 const u64 off = device_param->words_off;
3098
3099 device_param->kernel_params_mp_l_buf64[3] = off;
3100
3101 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
3102 }
3103 }
3104
3105 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
3106 {
3107 const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel;
3108
3109 device_param->kernel_params_buf32[25] = 0;
3110 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
3111 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
3112
3113 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3114 {
3115 run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0);
3116 }
3117 else
3118 {
3119 run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0);
3120 }
3121
3122 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
3123
3124 return exec_ms_prev;
3125 }
3126
3127 static void autotune (hc_device_param_t *device_param)
3128 {
3129 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
3130
3131 const u32 kernel_accel_min = device_param->kernel_accel_min;
3132 const u32 kernel_accel_max = device_param->kernel_accel_max;
3133
3134 const u32 kernel_loops_min = device_param->kernel_loops_min;
3135 const u32 kernel_loops_max = device_param->kernel_loops_max;
3136
3137 u32 kernel_accel = kernel_accel_min;
3138 u32 kernel_loops = kernel_loops_min;
3139
3140 // in this case the user specified a fixed -u and -n on the commandline
3141 // no way to tune anything
3142 // but we need to run a few caching rounds
3143
3144 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
3145 {
3146 if (data.hash_mode != 2000)
3147 {
3148 try_run (device_param, kernel_accel, kernel_loops);
3149 try_run (device_param, kernel_accel, kernel_loops);
3150 try_run (device_param, kernel_accel, kernel_loops);
3151 try_run (device_param, kernel_accel, kernel_loops);
3152 }
3153
3154 device_param->kernel_accel = kernel_accel;
3155 device_param->kernel_loops = kernel_loops;
3156
3157 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3158
3159 device_param->kernel_power = kernel_power;
3160
3161 return;
3162 }
3163
3164 // from here it's clear we are allowed to autotune
3165 // so let's init some fake words
3166
3167 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
3168
3169 if (data.attack_kern == ATTACK_KERN_BF)
3170 {
3171 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
3172 }
3173 else
3174 {
3175 for (u32 i = 0; i < kernel_power_max; i++)
3176 {
3177 device_param->pws_buf[i].i[0] = i;
3178 device_param->pws_buf[i].i[1] = 0x01234567;
3179 device_param->pws_buf[i].pw_len = 7 + (i & 7);
3180 }
3181
3182 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);
3183 }
3184
3185 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
3186 {
3187 if (data.kernel_rules_cnt > 1)
3188 {
3189 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);
3190 }
3191 }
3192 else
3193 {
3194 run_kernel_amp (device_param, kernel_power_max);
3195 }
3196
3197 #define VERIFIER_CNT 1
3198
3199 // first find out highest kernel-loops that stays below target_ms
3200
3201 if (kernel_loops_min < kernel_loops_max)
3202 {
3203 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3204 {
3205 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3206
3207 for (int i = 0; i < VERIFIER_CNT; i++)
3208 {
3209 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3210
3211 exec_ms = MIN (exec_ms, exec_ms_v);
3212 }
3213
3214 if (exec_ms < target_ms) break;
3215 }
3216 }
3217
3218 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3219
3220 #define STEPS_CNT 10
3221
3222 if (kernel_accel_min < kernel_accel_max)
3223 {
3224 for (int i = 0; i < STEPS_CNT; i++)
3225 {
3226 const u32 kernel_accel_try = 1 << i;
3227
3228 if (kernel_accel_try < kernel_accel_min) continue;
3229 if (kernel_accel_try > kernel_accel_max) break;
3230
3231 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3232
3233 for (int i = 0; i < VERIFIER_CNT; i++)
3234 {
3235 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3236
3237 exec_ms = MIN (exec_ms, exec_ms_v);
3238 }
3239
3240 if (exec_ms > target_ms) break;
3241
3242 kernel_accel = kernel_accel_try;
3243 }
3244 }
3245
3246 // at this point we want to know the actual runtime for the following reason:
3247 // we need a reference for the balancing loop following up, and this
3248 // the balancing loop can have an effect that the creates a new opportunity, for example:
3249 // if the target is 95 ms and the current runtime is 48ms the above loop
3250 // stopped the execution because the previous exec_ms was > 95ms
3251 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3252 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3253
3254 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3255
3256 for (int i = 0; i < VERIFIER_CNT; i++)
3257 {
3258 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3259
3260 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3261 }
3262
3263 u32 diff = kernel_loops - kernel_accel;
3264
3265 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3266 {
3267 u32 kernel_accel_orig = kernel_accel;
3268 u32 kernel_loops_orig = kernel_loops;
3269
3270 for (u32 f = 1; f < 1024; f++)
3271 {
3272 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3273 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3274
3275 if (kernel_accel_try > kernel_accel_max) break;
3276 if (kernel_loops_try < kernel_loops_min) break;
3277
3278 u32 diff_new = kernel_loops_try - kernel_accel_try;
3279
3280 if (diff_new > diff) break;
3281
3282 diff_new = diff;
3283
3284 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3285
3286 for (int i = 0; i < VERIFIER_CNT; i++)
3287 {
3288 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3289
3290 exec_ms = MIN (exec_ms, exec_ms_v);
3291 }
3292
3293 if (exec_ms < exec_ms_pre_final)
3294 {
3295 exec_ms_pre_final = exec_ms;
3296
3297 kernel_accel = kernel_accel_try;
3298 kernel_loops = kernel_loops_try;
3299 }
3300 }
3301 }
3302
3303 const double exec_left = target_ms / exec_ms_pre_final;
3304
3305 const double accel_left = kernel_accel_max / kernel_accel;
3306
3307 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3308
3309 if (exec_accel_min >= 1.0)
3310 {
3311 // this is safe to not overflow kernel_accel_max because of accel_left
3312
3313 kernel_accel = (double) kernel_accel * exec_accel_min;
3314 }
3315
3316 // reset them fake words
3317
3318 /*
3319 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3320
3321 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);
3322 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);
3323 */
3324
3325 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3326
3327 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3328 {
3329 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3330 }
3331
3332 // reset timer
3333
3334 device_param->exec_pos = 0;
3335
3336 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3337
3338 memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double));
3339 memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double));
3340 memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double));
3341
3342 // store
3343
3344 device_param->kernel_accel = kernel_accel;
3345 device_param->kernel_loops = kernel_loops;
3346
3347 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3348
3349 device_param->kernel_power = kernel_power;
3350
3351 #ifdef DEBUG
3352
3353 if (data.quiet == 0)
3354 {
3355 clear_prompt ();
3356
3357 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3358 "Device #%u: autotuned kernel-loops to %u\n",
3359 device_param->device_id + 1, kernel_accel,
3360 device_param->device_id + 1, kernel_loops);
3361
3362 fprintf (stdout, "%s", PROMPT);
3363
3364 fflush (stdout);
3365 }
3366
3367 #endif
3368 }
3369
3370 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3371 {
3372 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3373
3374 // init speed timer
3375
3376 uint speed_pos = device_param->speed_pos;
3377
3378 #ifdef _POSIX
3379 if (device_param->timer_speed.tv_sec == 0)
3380 {
3381 hc_timer_set (&device_param->timer_speed);
3382 }
3383 #endif
3384
3385 #ifdef _WIN
3386 if (device_param->timer_speed.QuadPart == 0)
3387 {
3388 hc_timer_set (&device_param->timer_speed);
3389 }
3390 #endif
3391
3392 // find higest password length, this is for optimization stuff
3393
3394 uint highest_pw_len = 0;
3395
3396 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3397 {
3398 }
3399 else if (data.attack_kern == ATTACK_KERN_COMBI)
3400 {
3401 }
3402 else if (data.attack_kern == ATTACK_KERN_BF)
3403 {
3404 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3405 + device_param->kernel_params_mp_l_buf32[5];
3406 }
3407
3408 // iteration type
3409
3410 uint innerloop_step = 0;
3411 uint innerloop_cnt = 0;
3412
3413 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3414 else innerloop_step = 1;
3415
3416 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3417 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3418 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3419
3420 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3421
3422 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3423 {
3424 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3425
3426 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3427
3428 if (data.devices_status == STATUS_CRACKED) break;
3429 if (data.devices_status == STATUS_ABORTED) break;
3430 if (data.devices_status == STATUS_QUIT) break;
3431 if (data.devices_status == STATUS_BYPASS) break;
3432
3433 salt_t *salt_buf = &data.salts_buf[salt_pos];
3434
3435 device_param->kernel_params_buf32[24] = salt_pos;
3436 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3437 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3438
3439 FILE *combs_fp = device_param->combs_fp;
3440
3441 if (data.attack_mode == ATTACK_MODE_COMBI)
3442 {
3443 rewind (combs_fp);
3444 }
3445
3446 // innerloops
3447
3448 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3449 {
3450 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3451
3452 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3453
3454 if (data.devices_status == STATUS_CRACKED) break;
3455 if (data.devices_status == STATUS_ABORTED) break;
3456 if (data.devices_status == STATUS_QUIT) break;
3457 if (data.devices_status == STATUS_BYPASS) break;
3458
3459 uint fast_iteration = 0;
3460
3461 uint innerloop_left = innerloop_cnt - innerloop_pos;
3462
3463 if (innerloop_left > innerloop_step)
3464 {
3465 innerloop_left = innerloop_step;
3466
3467 fast_iteration = 1;
3468 }
3469
3470 device_param->innerloop_pos = innerloop_pos;
3471 device_param->innerloop_left = innerloop_left;
3472
3473 device_param->kernel_params_buf32[27] = innerloop_left;
3474
3475 // i think we can get rid of this
3476 if (innerloop_left == 0)
3477 {
3478 puts ("bug, how should this happen????\n");
3479
3480 continue;
3481 }
3482
3483 if (data.salts_shown[salt_pos] == 1)
3484 {
3485 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3486
3487 continue;
3488 }
3489
3490 // initialize amplifiers
3491
3492 if (data.attack_mode == ATTACK_MODE_COMBI)
3493 {
3494 uint i = 0;
3495
3496 while (i < innerloop_left)
3497 {
3498 if (feof (combs_fp)) break;
3499
3500 int line_len = fgetl (combs_fp, line_buf);
3501
3502 if (line_len >= PW_MAX1) continue;
3503
3504 line_len = convert_from_hex (line_buf, line_len);
3505
3506 char *line_buf_new = line_buf;
3507
3508 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3509 {
3510 char rule_buf_out[BLOCK_SIZE] = { 0 };
3511
3512 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3513
3514 if (rule_len_out < 0)
3515 {
3516 data.words_progress_rejected[salt_pos] += pws_cnt;
3517
3518 continue;
3519 }
3520
3521 line_len = rule_len_out;
3522
3523 line_buf_new = rule_buf_out;
3524 }
3525
3526 line_len = MIN (line_len, PW_DICTMAX);
3527
3528 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3529
3530 memcpy (ptr, line_buf_new, line_len);
3531
3532 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3533
3534 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3535 {
3536 uppercase (ptr, line_len);
3537 }
3538
3539 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3540 {
3541 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3542 {
3543 ptr[line_len] = 0x80;
3544 }
3545
3546 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3547 {
3548 ptr[line_len] = 0x01;
3549 }
3550 }
3551
3552 device_param->combs_buf[i].pw_len = line_len;
3553
3554 i++;
3555 }
3556
3557 for (uint j = i; j < innerloop_left; j++)
3558 {
3559 device_param->combs_buf[j].i[0] = 0;
3560 device_param->combs_buf[j].i[1] = 0;
3561 device_param->combs_buf[j].i[2] = 0;
3562 device_param->combs_buf[j].i[3] = 0;
3563 device_param->combs_buf[j].i[4] = 0;
3564 device_param->combs_buf[j].i[5] = 0;
3565 device_param->combs_buf[j].i[6] = 0;
3566 device_param->combs_buf[j].i[7] = 0;
3567
3568 device_param->combs_buf[j].pw_len = 0;
3569 }
3570
3571 innerloop_left = i;
3572 }
3573 else if (data.attack_mode == ATTACK_MODE_BF)
3574 {
3575 u64 off = innerloop_pos;
3576
3577 device_param->kernel_params_mp_r_buf64[3] = off;
3578
3579 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3580 }
3581 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3582 {
3583 u64 off = innerloop_pos;
3584
3585 device_param->kernel_params_mp_buf64[3] = off;
3586
3587 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3588 }
3589 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3590 {
3591 u64 off = innerloop_pos;
3592
3593 device_param->kernel_params_mp_buf64[3] = off;
3594
3595 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3596 }
3597
3598 // copy amplifiers
3599
3600 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3601 {
3602 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);
3603 }
3604 else if (data.attack_mode == ATTACK_MODE_COMBI)
3605 {
3606 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);
3607 }
3608 else if (data.attack_mode == ATTACK_MODE_BF)
3609 {
3610 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);
3611 }
3612 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3613 {
3614 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);
3615 }
3616 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3617 {
3618 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);
3619 }
3620
3621 if (data.benchmark == 1)
3622 {
3623 hc_timer_set (&device_param->timer_speed);
3624 }
3625
3626 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration);
3627
3628 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3629
3630 if (data.devices_status == STATUS_CRACKED) break;
3631 if (data.devices_status == STATUS_ABORTED) break;
3632 if (data.devices_status == STATUS_QUIT) break;
3633
3634 /**
3635 * result
3636 */
3637
3638 if (data.benchmark == 0)
3639 {
3640 check_cracked (device_param, salt_pos);
3641 }
3642
3643 /**
3644 * progress
3645 */
3646
3647 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3648
3649 hc_thread_mutex_lock (mux_counter);
3650
3651 data.words_progress_done[salt_pos] += perf_sum_all;
3652
3653 hc_thread_mutex_unlock (mux_counter);
3654
3655 /**
3656 * speed
3657 */
3658
3659 double speed_ms;
3660
3661 hc_timer_get (device_param->timer_speed, speed_ms);
3662
3663 hc_timer_set (&device_param->timer_speed);
3664
3665 // current speed
3666
3667 //hc_thread_mutex_lock (mux_display);
3668
3669 device_param->speed_cnt[speed_pos] = perf_sum_all;
3670
3671 device_param->speed_ms[speed_pos] = speed_ms;
3672
3673 //hc_thread_mutex_unlock (mux_display);
3674
3675 speed_pos++;
3676
3677 if (speed_pos == SPEED_CACHE)
3678 {
3679 speed_pos = 0;
3680 }
3681
3682 /**
3683 * benchmark
3684 */
3685
3686 if (data.benchmark == 1) break;
3687 }
3688 }
3689
3690 device_param->speed_pos = speed_pos;
3691
3692 myfree (line_buf);
3693 }
3694
3695 static void load_segment (wl_data_t *wl_data, FILE *fd)
3696 {
3697 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3698
3699 wl_data->pos = 0;
3700
3701 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3702
3703 wl_data->buf[wl_data->cnt] = 0;
3704
3705 if (wl_data->cnt == 0) return;
3706
3707 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3708
3709 while (!feof (fd))
3710 {
3711 if (wl_data->cnt == wl_data->avail)
3712 {
3713 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3714
3715 wl_data->avail += wl_data->incr;
3716 }
3717
3718 const int c = fgetc (fd);
3719
3720 if (c == EOF) break;
3721
3722 wl_data->buf[wl_data->cnt] = (char) c;
3723
3724 wl_data->cnt++;
3725
3726 if (c == '\n') break;
3727 }
3728
3729 // ensure stream ends with a newline
3730
3731 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3732 {
3733 wl_data->cnt++;
3734
3735 wl_data->buf[wl_data->cnt - 1] = '\n';
3736 }
3737
3738 return;
3739 }
3740
3741 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3742 {
3743 char *ptr = buf;
3744
3745 for (u32 i = 0; i < sz; i++, ptr++)
3746 {
3747 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3748
3749 if (i == 7)
3750 {
3751 *off = i;
3752 *len = i;
3753
3754 return;
3755 }
3756
3757 if (*ptr != '\n') continue;
3758
3759 *off = i + 1;
3760
3761 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3762
3763 *len = i;
3764
3765 return;
3766 }
3767
3768 *off = sz;
3769 *len = sz;
3770 }
3771
3772 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3773 {
3774 char *ptr = buf;
3775
3776 for (u32 i = 0; i < sz; i++, ptr++)
3777 {
3778 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3779
3780 if (*ptr != '\n') continue;
3781
3782 *off = i + 1;
3783
3784 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3785
3786 *len = i;
3787
3788 return;
3789 }
3790
3791 *off = sz;
3792 *len = sz;
3793 }
3794
3795 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3796 {
3797 char *ptr = buf;
3798
3799 for (u32 i = 0; i < sz; i++, ptr++)
3800 {
3801 if (*ptr != '\n') continue;
3802
3803 *off = i + 1;
3804
3805 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3806
3807 *len = i;
3808
3809 return;
3810 }
3811
3812 *off = sz;
3813 *len = sz;
3814 }
3815
3816 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3817 {
3818 while (wl_data->pos < wl_data->cnt)
3819 {
3820 uint off;
3821 uint len;
3822
3823 char *ptr = wl_data->buf + wl_data->pos;
3824
3825 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3826
3827 wl_data->pos += off;
3828
3829 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3830 {
3831 char rule_buf_out[BLOCK_SIZE] = { 0 };
3832
3833 int rule_len_out = -1;
3834
3835 if (len < BLOCK_SIZE)
3836 {
3837 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3838 }
3839
3840 if (rule_len_out < 0)
3841 {
3842 continue;
3843 }
3844
3845 if (rule_len_out > PW_MAX)
3846 {
3847 continue;
3848 }
3849 }
3850 else
3851 {
3852 if (len > PW_MAX)
3853 {
3854 continue;
3855 }
3856 }
3857
3858 *out_buf = ptr;
3859 *out_len = len;
3860
3861 return;
3862 }
3863
3864 if (feof (fd))
3865 {
3866 fprintf (stderr, "BUG feof()!!\n");
3867
3868 return;
3869 }
3870
3871 load_segment (wl_data, fd);
3872
3873 get_next_word (wl_data, fd, out_buf, out_len);
3874 }
3875
3876 #ifdef _POSIX
3877 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3878 #endif
3879
3880 #ifdef _WIN
3881 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3882 #endif
3883 {
3884 hc_signal (NULL);
3885
3886 dictstat_t d;
3887
3888 d.cnt = 0;
3889
3890 #ifdef _POSIX
3891 fstat (fileno (fd), &d.stat);
3892 #endif
3893
3894 #ifdef _WIN
3895 _fstat64 (fileno (fd), &d.stat);
3896 #endif
3897
3898 d.stat.st_mode = 0;
3899 d.stat.st_nlink = 0;
3900 d.stat.st_uid = 0;
3901 d.stat.st_gid = 0;
3902 d.stat.st_rdev = 0;
3903 d.stat.st_atime = 0;
3904
3905 #ifdef _POSIX
3906 d.stat.st_blksize = 0;
3907 d.stat.st_blocks = 0;
3908 #endif
3909
3910 if (d.stat.st_size == 0) return 0;
3911
3912 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3913
3914 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3915 {
3916 if (d_cache)
3917 {
3918 u64 cnt = d_cache->cnt;
3919
3920 u64 keyspace = cnt;
3921
3922 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3923 {
3924 keyspace *= data.kernel_rules_cnt;
3925 }
3926 else if (data.attack_kern == ATTACK_KERN_COMBI)
3927 {
3928 keyspace *= data.combs_cnt;
3929 }
3930
3931 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);
3932 if (data.quiet == 0) log_info ("");
3933
3934 hc_signal (sigHandler_default);
3935
3936 return (keyspace);
3937 }
3938 }
3939
3940 time_t now = 0;
3941 time_t prev = 0;
3942
3943 u64 comp = 0;
3944 u64 cnt = 0;
3945 u64 cnt2 = 0;
3946
3947 while (!feof (fd))
3948 {
3949 load_segment (wl_data, fd);
3950
3951 comp += wl_data->cnt;
3952
3953 u32 i = 0;
3954
3955 while (i < wl_data->cnt)
3956 {
3957 u32 len;
3958 u32 off;
3959
3960 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3961
3962 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3963 {
3964 char rule_buf_out[BLOCK_SIZE] = { 0 };
3965
3966 int rule_len_out = -1;
3967
3968 if (len < BLOCK_SIZE)
3969 {
3970 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3971 }
3972
3973 if (rule_len_out < 0)
3974 {
3975 len = PW_MAX1;
3976 }
3977 else
3978 {
3979 len = rule_len_out;
3980 }
3981 }
3982
3983 if (len < PW_MAX1)
3984 {
3985 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3986 {
3987 cnt += data.kernel_rules_cnt;
3988 }
3989 else if (data.attack_kern == ATTACK_KERN_COMBI)
3990 {
3991 cnt += data.combs_cnt;
3992 }
3993
3994 d.cnt++;
3995 }
3996
3997 i += off;
3998
3999 cnt2++;
4000 }
4001
4002 time (&now);
4003
4004 if ((now - prev) == 0) continue;
4005
4006 float percent = (float) comp / (float) d.stat.st_size;
4007
4008 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);
4009
4010 time (&prev);
4011 }
4012
4013 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);
4014 if (data.quiet == 0) log_info ("");
4015
4016 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
4017
4018 hc_signal (sigHandler_default);
4019
4020 return (cnt);
4021 }
4022
4023 static void *thread_monitor (void *p)
4024 {
4025 uint runtime_check = 0;
4026 uint remove_check = 0;
4027 uint status_check = 0;
4028 uint restore_check = 0;
4029
4030 uint restore_left = data.restore_timer;
4031 uint remove_left = data.remove_timer;
4032 uint status_left = data.status_timer;
4033
4034 #ifdef HAVE_HWMON
4035 uint hwmon_check = 0;
4036
4037 int slowdown_warnings = 0;
4038
4039 // these variables are mainly used for fan control
4040
4041 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
4042
4043 // temperature controller "loopback" values
4044
4045 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
4046 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
4047
4048 int temp_threshold = 1; // degrees celcius
4049
4050 int fan_speed_min = 15; // in percentage
4051 int fan_speed_max = 100;
4052
4053 time_t last_temp_check_time;
4054 #endif // HAVE_HWMON
4055
4056 uint sleep_time = 1;
4057
4058 if (data.runtime)
4059 {
4060 runtime_check = 1;
4061 }
4062
4063 if (data.restore_timer)
4064 {
4065 restore_check = 1;
4066 }
4067
4068 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
4069 {
4070 remove_check = 1;
4071 }
4072
4073 if (data.status == 1)
4074 {
4075 status_check = 1;
4076 }
4077
4078 #ifdef HAVE_HWMON
4079 if (data.gpu_temp_disable == 0)
4080 {
4081 time (&last_temp_check_time);
4082
4083 hwmon_check = 1;
4084 }
4085 #endif
4086
4087 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
4088 {
4089 #ifdef HAVE_HWMON
4090 if (hwmon_check == 0)
4091 #endif
4092 return (p);
4093 }
4094
4095 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4096 {
4097 hc_sleep (sleep_time);
4098
4099 if (data.devices_status != STATUS_RUNNING) continue;
4100
4101 #ifdef HAVE_HWMON
4102
4103 if (hwmon_check == 1)
4104 {
4105 hc_thread_mutex_lock (mux_adl);
4106
4107 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4108 {
4109 hc_device_param_t *device_param = &data.devices_param[device_id];
4110
4111 if (device_param->skipped) continue;
4112
4113 if (device_param->device_vendor_id == VENDOR_ID_NV)
4114 {
4115 if (data.hm_nvapi)
4116 {
4117 NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 };
4118 NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 };
4119
4120 perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1);
4121 perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1);
4122
4123 hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info);
4124
4125 perfPolicies_status.info_value = perfPolicies_info.info_value;
4126
4127 hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status);
4128
4129 if (perfPolicies_status.throttle & 2)
4130 {
4131 if (slowdown_warnings < 3)
4132 {
4133 if (data.quiet == 0) clear_prompt ();
4134
4135 log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1);
4136
4137 if (slowdown_warnings == 2)
4138 {
4139 log_info ("");
4140 }
4141
4142 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
4143 if (data.quiet == 0) fflush (stdout);
4144
4145 slowdown_warnings++;
4146 }
4147 }
4148 else
4149 {
4150 slowdown_warnings = 0;
4151 }
4152 }
4153 }
4154 }
4155
4156 hc_thread_mutex_unlock (mux_adl);
4157 }
4158
4159 if (hwmon_check == 1)
4160 {
4161 hc_thread_mutex_lock (mux_adl);
4162
4163 time_t temp_check_time;
4164
4165 time (&temp_check_time);
4166
4167 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
4168
4169 if (Ta == 0) Ta = 1;
4170
4171 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
4172 {
4173 hc_device_param_t *device_param = &data.devices_param[device_id];
4174
4175 if (device_param->skipped) continue;
4176
4177 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
4178
4179 const int temperature = hm_get_temperature_with_device_id (device_id);
4180
4181 if (temperature > (int) data.gpu_temp_abort)
4182 {
4183 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
4184
4185 if (data.devices_status != STATUS_QUIT) myabort ();
4186
4187 break;
4188 }
4189
4190 const int gpu_temp_retain = data.gpu_temp_retain;
4191
4192 if (gpu_temp_retain)
4193 {
4194 if (data.hm_device[device_id].fan_set_supported == 1)
4195 {
4196 int temp_cur = temperature;
4197
4198 int temp_diff_new = gpu_temp_retain - temp_cur;
4199
4200 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
4201
4202 // calculate Ta value (time difference in seconds between the last check and this check)
4203
4204 last_temp_check_time = temp_check_time;
4205
4206 float Kp = 1.8;
4207 float Ki = 0.005;
4208 float Kd = 6;
4209
4210 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
4211
4212 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);
4213
4214 if (abs (fan_diff_required) >= temp_threshold)
4215 {
4216 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
4217
4218 int fan_speed_level = fan_speed_cur;
4219
4220 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
4221
4222 int fan_speed_new = fan_speed_level - fan_diff_required;
4223
4224 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4225 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4226
4227 if (fan_speed_new != fan_speed_cur)
4228 {
4229 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4230 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4231
4232 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4233 {
4234 if (device_param->device_vendor_id == VENDOR_ID_AMD)
4235 {
4236 hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1);
4237 }
4238 else if (device_param->device_vendor_id == VENDOR_ID_NV)
4239 {
4240
4241 }
4242
4243 fan_speed_chgd[device_id] = 1;
4244 }
4245
4246 temp_diff_old[device_id] = temp_diff_new;
4247 }
4248 }
4249 }
4250 }
4251 }
4252
4253 hc_thread_mutex_unlock (mux_adl);
4254 }
4255 #endif // HAVE_HWMON
4256
4257 if (restore_check == 1)
4258 {
4259 restore_left--;
4260
4261 if (restore_left == 0)
4262 {
4263 if (data.restore_disable == 0) cycle_restore ();
4264
4265 restore_left = data.restore_timer;
4266 }
4267 }
4268
4269 if ((runtime_check == 1) && (data.runtime_start > 0))
4270 {
4271 time_t runtime_cur;
4272
4273 time (&runtime_cur);
4274
4275 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4276
4277 if (runtime_left <= 0)
4278 {
4279 if (data.benchmark == 0)
4280 {
4281 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4282 }
4283
4284 if (data.devices_status != STATUS_QUIT) myabort ();
4285 }
4286 }
4287
4288 if (remove_check == 1)
4289 {
4290 remove_left--;
4291
4292 if (remove_left == 0)
4293 {
4294 if (data.digests_saved != data.digests_done)
4295 {
4296 data.digests_saved = data.digests_done;
4297
4298 save_hash ();
4299 }
4300
4301 remove_left = data.remove_timer;
4302 }
4303 }
4304
4305 if (status_check == 1)
4306 {
4307 status_left--;
4308
4309 if (status_left == 0)
4310 {
4311 //hc_thread_mutex_lock (mux_display);
4312
4313 if (data.quiet == 0) clear_prompt ();
4314
4315 if (data.quiet == 0) log_info ("");
4316
4317 status_display ();
4318
4319 if (data.quiet == 0) log_info ("");
4320
4321 //hc_thread_mutex_unlock (mux_display);
4322
4323 status_left = data.status_timer;
4324 }
4325 }
4326 }
4327
4328 #ifdef HAVE_HWMON
4329 myfree (fan_speed_chgd);
4330
4331 myfree (temp_diff_old);
4332 myfree (temp_diff_sum);
4333 #endif
4334
4335 p = NULL;
4336
4337 return (p);
4338 }
4339
4340 static void *thread_outfile_remove (void *p)
4341 {
4342 // some hash-dependent constants
4343 char *outfile_dir = data.outfile_check_directory;
4344 uint dgst_size = data.dgst_size;
4345 uint isSalted = data.isSalted;
4346 uint esalt_size = data.esalt_size;
4347 uint hash_mode = data.hash_mode;
4348
4349 uint outfile_check_timer = data.outfile_check_timer;
4350
4351 char separator = data.separator;
4352
4353 // some hash-dependent functions
4354 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4355 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4356
4357 // buffers
4358 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4359
4360 hash_buf.digest = mymalloc (dgst_size);
4361
4362 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4363
4364 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4365
4366 uint digest_buf[64] = { 0 };
4367
4368 outfile_data_t *out_info = NULL;
4369
4370 char **out_files = NULL;
4371
4372 time_t folder_mtime = 0;
4373
4374 int out_cnt = 0;
4375
4376 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4377
4378 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4379 {
4380 hc_sleep (1);
4381
4382 if (data.devices_status != STATUS_RUNNING) continue;
4383
4384 check_left--;
4385
4386 if (check_left == 0)
4387 {
4388 struct stat outfile_check_stat;
4389
4390 if (stat (outfile_dir, &outfile_check_stat) == 0)
4391 {
4392 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4393
4394 if (is_dir == 1)
4395 {
4396 if (outfile_check_stat.st_mtime > folder_mtime)
4397 {
4398 char **out_files_new = scan_directory (outfile_dir);
4399
4400 int out_cnt_new = count_dictionaries (out_files_new);
4401
4402 outfile_data_t *out_info_new = NULL;
4403
4404 if (out_cnt_new > 0)
4405 {
4406 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4407
4408 for (int i = 0; i < out_cnt_new; i++)
4409 {
4410 out_info_new[i].file_name = out_files_new[i];
4411
4412 // check if there are files that we have seen/checked before (and not changed)
4413
4414 for (int j = 0; j < out_cnt; j++)
4415 {
4416 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4417 {
4418 struct stat outfile_stat;
4419
4420 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4421 {
4422 if (outfile_stat.st_ctime == out_info[j].ctime)
4423 {
4424 out_info_new[i].ctime = out_info[j].ctime;
4425 out_info_new[i].seek = out_info[j].seek;
4426 }
4427 }
4428 }
4429 }
4430 }
4431 }
4432
4433 local_free (out_info);
4434 local_free (out_files);
4435
4436 out_files = out_files_new;
4437 out_cnt = out_cnt_new;
4438 out_info = out_info_new;
4439
4440 folder_mtime = outfile_check_stat.st_mtime;
4441 }
4442
4443 for (int j = 0; j < out_cnt; j++)
4444 {
4445 FILE *fp = fopen (out_info[j].file_name, "rb");
4446
4447 if (fp != NULL)
4448 {
4449 //hc_thread_mutex_lock (mux_display);
4450
4451 #ifdef _POSIX
4452 struct stat outfile_stat;
4453
4454 fstat (fileno (fp), &outfile_stat);
4455 #endif
4456
4457 #ifdef _WIN
4458 struct stat64 outfile_stat;
4459
4460 _fstat64 (fileno (fp), &outfile_stat);
4461 #endif
4462
4463 if (outfile_stat.st_ctime > out_info[j].ctime)
4464 {
4465 out_info[j].ctime = outfile_stat.st_ctime;
4466 out_info[j].seek = 0;
4467 }
4468
4469 fseek (fp, out_info[j].seek, SEEK_SET);
4470
4471 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4472
4473 while (!feof (fp))
4474 {
4475 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4476
4477 if (ptr == NULL) break;
4478
4479 int line_len = strlen (line_buf);
4480
4481 if (line_len <= 0) continue;
4482
4483 int iter = MAX_CUT_TRIES;
4484
4485 for (uint i = line_len - 1; i && iter; i--, line_len--)
4486 {
4487 if (line_buf[i] != separator) continue;
4488
4489 int parser_status = PARSER_OK;
4490
4491 if ((hash_mode != 2500) && (hash_mode != 6800))
4492 {
4493 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4494 }
4495
4496 uint found = 0;
4497
4498 if (parser_status == PARSER_OK)
4499 {
4500 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4501 {
4502 if (data.salts_shown[salt_pos] == 1) continue;
4503
4504 salt_t *salt_buf = &data.salts_buf[salt_pos];
4505
4506 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4507 {
4508 uint idx = salt_buf->digests_offset + digest_pos;
4509
4510 if (data.digests_shown[idx] == 1) continue;
4511
4512 uint cracked = 0;
4513
4514 if (hash_mode == 6800)
4515 {
4516 if (i == salt_buf->salt_len)
4517 {
4518 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4519 }
4520 }
4521 else if (hash_mode == 2500)
4522 {
4523 // BSSID : MAC1 : MAC2 (:plain)
4524 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4525 {
4526 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4527
4528 if (!cracked) continue;
4529
4530 // now compare MAC1 and MAC2 too, since we have this additional info
4531 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4532 char *mac2_pos = mac1_pos + 12 + 1;
4533
4534 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4535 wpa_t *wpa = &wpas[salt_pos];
4536
4537 // compare hex string(s) vs binary MAC address(es)
4538
4539 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4540 {
4541 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4542 {
4543 cracked = 0;
4544
4545 break;
4546 }
4547 }
4548
4549 // early skip ;)
4550 if (!cracked) continue;
4551
4552 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4553 {
4554 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4555 {
4556 cracked = 0;
4557
4558 break;
4559 }
4560 }
4561 }
4562 }
4563 else
4564 {
4565 char *digests_buf_ptr = (char *) data.digests_buf;
4566
4567 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4568
4569 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4570 }
4571
4572 if (cracked == 1)
4573 {
4574 found = 1;
4575
4576 data.digests_shown[idx] = 1;
4577
4578 data.digests_done++;
4579
4580 salt_buf->digests_done++;
4581
4582 if (salt_buf->digests_done == salt_buf->digests_cnt)
4583 {
4584 data.salts_shown[salt_pos] = 1;
4585
4586 data.salts_done++;
4587
4588 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4589 }
4590 }
4591 }
4592
4593 if (data.devices_status == STATUS_CRACKED) break;
4594 }
4595 }
4596
4597 if (found) break;
4598
4599 if (data.devices_status == STATUS_CRACKED) break;
4600
4601 iter--;
4602 }
4603
4604 if (data.devices_status == STATUS_CRACKED) break;
4605 }
4606
4607 myfree (line_buf);
4608
4609 out_info[j].seek = ftell (fp);
4610
4611 //hc_thread_mutex_unlock (mux_display);
4612
4613 fclose (fp);
4614 }
4615 }
4616 }
4617 }
4618
4619 check_left = outfile_check_timer;
4620 }
4621 }
4622
4623 if (esalt_size) local_free (hash_buf.esalt);
4624
4625 if (isSalted) local_free (hash_buf.salt);
4626
4627 local_free (hash_buf.digest);
4628
4629 local_free (out_info);
4630
4631 local_free (out_files);
4632
4633 p = NULL;
4634
4635 return (p);
4636 }
4637
4638 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4639 {
4640 //if (device_param->pws_cnt < device_param->kernel_power)
4641 //{
4642 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4643
4644 u8 *ptr = (u8 *) pw->i;
4645
4646 memcpy (ptr, pw_buf, pw_len);
4647
4648 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4649
4650 pw->pw_len = pw_len;
4651
4652 device_param->pws_cnt++;
4653 //}
4654 //else
4655 //{
4656 // fprintf (stderr, "BUG pw_add()!!\n");
4657 //
4658 // return;
4659 //}
4660 }
4661
4662 static void set_kernel_power_final (const u64 kernel_power_final)
4663 {
4664 if (data.quiet == 0)
4665 {
4666 clear_prompt ();
4667
4668 //log_info ("");
4669
4670 log_info ("INFO: approaching final keyspace, workload adjusted");
4671 log_info ("");
4672
4673 fprintf (stdout, "%s", PROMPT);
4674
4675 fflush (stdout);
4676 }
4677
4678 data.kernel_power_final = kernel_power_final;
4679 }
4680
4681 static u32 get_power (hc_device_param_t *device_param)
4682 {
4683 const u64 kernel_power_final = data.kernel_power_final;
4684
4685 if (kernel_power_final)
4686 {
4687 const double device_factor = (double) device_param->hardware_power / data.hardware_power_all;
4688
4689 const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor);
4690
4691 // work should be at least the hardware power available without any accelerator
4692
4693 const u64 work = MAX (words_left_device, device_param->hardware_power);
4694
4695 return work;
4696 }
4697
4698 return device_param->kernel_power;
4699 }
4700
4701 static uint get_work (hc_device_param_t *device_param, const u64 max)
4702 {
4703 hc_thread_mutex_lock (mux_dispatcher);
4704
4705 const u64 words_cur = data.words_cur;
4706 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4707
4708 device_param->words_off = words_cur;
4709
4710 const u64 kernel_power_all = data.kernel_power_all;
4711
4712 const u64 words_left = words_base - words_cur;
4713
4714 if (words_left < kernel_power_all)
4715 {
4716 if (data.kernel_power_final == 0)
4717 {
4718 set_kernel_power_final (words_left);
4719 }
4720 }
4721
4722 const u32 kernel_power = get_power (device_param);
4723
4724 uint work = MIN (words_left, kernel_power);
4725
4726 work = MIN (work, max);
4727
4728 data.words_cur += work;
4729
4730 hc_thread_mutex_unlock (mux_dispatcher);
4731
4732 return work;
4733 }
4734
4735 static void *thread_autotune (void *p)
4736 {
4737 hc_device_param_t *device_param = (hc_device_param_t *) p;
4738
4739 if (device_param->skipped) return NULL;
4740
4741 autotune (device_param);
4742
4743 return NULL;
4744 }
4745
4746 static void *thread_calc_stdin (void *p)
4747 {
4748 hc_device_param_t *device_param = (hc_device_param_t *) p;
4749
4750 if (device_param->skipped) return NULL;
4751
4752 char *buf = (char *) mymalloc (HCBUFSIZ);
4753
4754 const uint attack_kern = data.attack_kern;
4755
4756 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4757 {
4758 hc_thread_mutex_lock (mux_dispatcher);
4759
4760 if (feof (stdin) != 0)
4761 {
4762 hc_thread_mutex_unlock (mux_dispatcher);
4763
4764 break;
4765 }
4766
4767 uint words_cur = 0;
4768
4769 while (words_cur < device_param->kernel_power)
4770 {
4771 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4772
4773 if (line_buf == NULL) break;
4774
4775 uint line_len = in_superchop (line_buf);
4776
4777 line_len = convert_from_hex (line_buf, line_len);
4778
4779 // post-process rule engine
4780
4781 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4782 {
4783 char rule_buf_out[BLOCK_SIZE] = { 0 };
4784
4785 int rule_len_out = -1;
4786
4787 if (line_len < BLOCK_SIZE)
4788 {
4789 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4790 }
4791
4792 if (rule_len_out < 0) continue;
4793
4794 line_buf = rule_buf_out;
4795 line_len = rule_len_out;
4796 }
4797
4798 if (line_len > PW_MAX)
4799 {
4800 continue;
4801 }
4802
4803 // hmm that's always the case, or?
4804
4805 if (attack_kern == ATTACK_KERN_STRAIGHT)
4806 {
4807 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4808 {
4809 hc_thread_mutex_lock (mux_counter);
4810
4811 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4812 {
4813 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4814 }
4815
4816 hc_thread_mutex_unlock (mux_counter);
4817
4818 continue;
4819 }
4820 }
4821
4822 pw_add (device_param, (u8 *) line_buf, line_len);
4823
4824 words_cur++;
4825
4826 if (data.devices_status == STATUS_CRACKED) break;
4827 if (data.devices_status == STATUS_ABORTED) break;
4828 if (data.devices_status == STATUS_QUIT) break;
4829 if (data.devices_status == STATUS_BYPASS) break;
4830 }
4831
4832 hc_thread_mutex_unlock (mux_dispatcher);
4833
4834 if (data.devices_status == STATUS_CRACKED) break;
4835 if (data.devices_status == STATUS_ABORTED) break;
4836 if (data.devices_status == STATUS_QUIT) break;
4837 if (data.devices_status == STATUS_BYPASS) break;
4838
4839 // flush
4840
4841 const uint pws_cnt = device_param->pws_cnt;
4842
4843 if (pws_cnt)
4844 {
4845 run_copy (device_param, pws_cnt);
4846
4847 run_cracker (device_param, pws_cnt);
4848
4849 device_param->pws_cnt = 0;
4850
4851 /*
4852 still required?
4853 if (attack_kern == ATTACK_KERN_STRAIGHT)
4854 {
4855 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4856 }
4857 else if (attack_kern == ATTACK_KERN_COMBI)
4858 {
4859 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4860 }
4861 */
4862 }
4863 }
4864
4865 device_param->kernel_accel = 0;
4866 device_param->kernel_loops = 0;
4867
4868 myfree (buf);
4869
4870 return NULL;
4871 }
4872
4873 static void *thread_calc (void *p)
4874 {
4875 hc_device_param_t *device_param = (hc_device_param_t *) p;
4876
4877 if (device_param->skipped) return NULL;
4878
4879 const uint attack_mode = data.attack_mode;
4880 const uint attack_kern = data.attack_kern;
4881
4882 if (attack_mode == ATTACK_MODE_BF)
4883 {
4884 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4885 {
4886 const uint work = get_work (device_param, -1);
4887
4888 if (work == 0) break;
4889
4890 const u64 words_off = device_param->words_off;
4891 const u64 words_fin = words_off + work;
4892
4893 const uint pws_cnt = work;
4894
4895 device_param->pws_cnt = pws_cnt;
4896
4897 if (pws_cnt)
4898 {
4899 run_copy (device_param, pws_cnt);
4900
4901 run_cracker (device_param, pws_cnt);
4902
4903 device_param->pws_cnt = 0;
4904
4905 /*
4906 still required?
4907 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4908 */
4909 }
4910
4911 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4912
4913 if (data.devices_status == STATUS_CRACKED) break;
4914 if (data.devices_status == STATUS_ABORTED) break;
4915 if (data.devices_status == STATUS_QUIT) break;
4916 if (data.devices_status == STATUS_BYPASS) break;
4917
4918 if (data.benchmark == 1) break;
4919
4920 device_param->words_done = words_fin;
4921 }
4922 }
4923 else
4924 {
4925 const uint segment_size = data.segment_size;
4926
4927 char *dictfile = data.dictfile;
4928
4929 if (attack_mode == ATTACK_MODE_COMBI)
4930 {
4931 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4932 {
4933 dictfile = data.dictfile2;
4934 }
4935 }
4936
4937 FILE *fd = fopen (dictfile, "rb");
4938
4939 if (fd == NULL)
4940 {
4941 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4942
4943 return NULL;
4944 }
4945
4946 if (attack_mode == ATTACK_MODE_COMBI)
4947 {
4948 const uint combs_mode = data.combs_mode;
4949
4950 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4951 {
4952 const char *dictfilec = data.dictfile2;
4953
4954 FILE *combs_fp = fopen (dictfilec, "rb");
4955
4956 if (combs_fp == NULL)
4957 {
4958 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4959
4960 fclose (fd);
4961
4962 return NULL;
4963 }
4964
4965 device_param->combs_fp = combs_fp;
4966 }
4967 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4968 {
4969 const char *dictfilec = data.dictfile;
4970
4971 FILE *combs_fp = fopen (dictfilec, "rb");
4972
4973 if (combs_fp == NULL)
4974 {
4975 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4976
4977 fclose (fd);
4978
4979 return NULL;
4980 }
4981
4982 device_param->combs_fp = combs_fp;
4983 }
4984 }
4985
4986 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4987
4988 wl_data->buf = (char *) mymalloc (segment_size);
4989 wl_data->avail = segment_size;
4990 wl_data->incr = segment_size;
4991 wl_data->cnt = 0;
4992 wl_data->pos = 0;
4993
4994 u64 words_cur = 0;
4995
4996 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4997 {
4998 u64 words_off = 0;
4999 u64 words_fin = 0;
5000
5001 u64 max = -1;
5002
5003 while (max)
5004 {
5005 const uint work = get_work (device_param, max);
5006
5007 if (work == 0) break;
5008
5009 max = 0;
5010
5011 words_off = device_param->words_off;
5012 words_fin = words_off + work;
5013
5014 char *line_buf;
5015 uint line_len;
5016
5017 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
5018
5019 for ( ; words_cur < words_fin; words_cur++)
5020 {
5021 get_next_word (wl_data, fd, &line_buf, &line_len);
5022
5023 line_len = convert_from_hex (line_buf, line_len);
5024
5025 // post-process rule engine
5026
5027 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
5028 {
5029 char rule_buf_out[BLOCK_SIZE] = { 0 };
5030
5031 int rule_len_out = -1;
5032
5033 if (line_len < BLOCK_SIZE)
5034 {
5035 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
5036 }
5037
5038 if (rule_len_out < 0) continue;
5039
5040 line_buf = rule_buf_out;
5041 line_len = rule_len_out;
5042 }
5043
5044 if (attack_kern == ATTACK_KERN_STRAIGHT)
5045 {
5046 if ((line_len < data.pw_min) || (line_len > data.pw_max))
5047 {
5048 max++;
5049
5050 hc_thread_mutex_lock (mux_counter);
5051
5052 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5053 {
5054 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
5055 }
5056
5057 hc_thread_mutex_unlock (mux_counter);
5058
5059 continue;
5060 }
5061 }
5062 else if (attack_kern == ATTACK_KERN_COMBI)
5063 {
5064 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
5065 // since we still need to combine the plains
5066
5067 if (line_len > data.pw_max)
5068 {
5069 max++;
5070
5071 hc_thread_mutex_lock (mux_counter);
5072
5073 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
5074 {
5075 data.words_progress_rejected[salt_pos] += data.combs_cnt;
5076 }
5077
5078 hc_thread_mutex_unlock (mux_counter);
5079
5080 continue;
5081 }
5082 }
5083
5084 pw_add (device_param, (u8 *) line_buf, line_len);
5085
5086 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5087
5088 if (data.devices_status == STATUS_CRACKED) break;
5089 if (data.devices_status == STATUS_ABORTED) break;
5090 if (data.devices_status == STATUS_QUIT) break;
5091 if (data.devices_status == STATUS_BYPASS) break;
5092 }
5093
5094 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5095
5096 if (data.devices_status == STATUS_CRACKED) break;
5097 if (data.devices_status == STATUS_ABORTED) break;
5098 if (data.devices_status == STATUS_QUIT) break;
5099 if (data.devices_status == STATUS_BYPASS) break;
5100 }
5101
5102 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5103
5104 if (data.devices_status == STATUS_CRACKED) break;
5105 if (data.devices_status == STATUS_ABORTED) break;
5106 if (data.devices_status == STATUS_QUIT) break;
5107 if (data.devices_status == STATUS_BYPASS) break;
5108
5109 //
5110 // flush
5111 //
5112
5113 const uint pws_cnt = device_param->pws_cnt;
5114
5115 if (pws_cnt)
5116 {
5117 run_copy (device_param, pws_cnt);
5118
5119 run_cracker (device_param, pws_cnt);
5120
5121 device_param->pws_cnt = 0;
5122
5123 /*
5124 still required?
5125 if (attack_kern == ATTACK_KERN_STRAIGHT)
5126 {
5127 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
5128 }
5129 else if (attack_kern == ATTACK_KERN_COMBI)
5130 {
5131 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
5132 }
5133 */
5134 }
5135
5136 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
5137
5138 if (data.devices_status == STATUS_CRACKED) break;
5139 if (data.devices_status == STATUS_ABORTED) break;
5140 if (data.devices_status == STATUS_QUIT) break;
5141 if (data.devices_status == STATUS_BYPASS) break;
5142
5143 if (words_fin == 0) break;
5144
5145 device_param->words_done = words_fin;
5146 }
5147
5148 if (attack_mode == ATTACK_MODE_COMBI)
5149 {
5150 fclose (device_param->combs_fp);
5151 }
5152
5153 free (wl_data->buf);
5154 free (wl_data);
5155
5156 fclose (fd);
5157 }
5158
5159 device_param->kernel_accel = 0;
5160 device_param->kernel_loops = 0;
5161
5162 return NULL;
5163 }
5164
5165 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
5166 {
5167 if (!device_param)
5168 {
5169 log_error ("ERROR: %s : Invalid argument", __func__);
5170
5171 exit (-1);
5172 }
5173
5174 salt_t *salt_buf = &data.salts_buf[salt_pos];
5175
5176 device_param->kernel_params_buf32[24] = salt_pos;
5177 device_param->kernel_params_buf32[27] = 1;
5178 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
5179 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
5180 device_param->kernel_params_buf32[30] = 0;
5181 device_param->kernel_params_buf32[31] = 1;
5182
5183 char *dictfile_old = data.dictfile;
5184
5185 const char *weak_hash_check = "weak-hash-check";
5186
5187 data.dictfile = (char *) weak_hash_check;
5188
5189 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
5190
5191 data.kernel_rules_buf[0].cmds[0] = 0;
5192
5193 /**
5194 * run the kernel
5195 */
5196
5197 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
5198 {
5199 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5200 }
5201 else
5202 {
5203 run_kernel (KERN_RUN_1, device_param, 1, false, 0);
5204
5205 uint loop_step = 16;
5206
5207 const uint iter = salt_buf->salt_iter;
5208
5209 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
5210 {
5211 uint loop_left = iter - loop_pos;
5212
5213 loop_left = MIN (loop_left, loop_step);
5214
5215 device_param->kernel_params_buf32[25] = loop_pos;
5216 device_param->kernel_params_buf32[26] = loop_left;
5217
5218 run_kernel (KERN_RUN_2, device_param, 1, false, 0);
5219 }
5220
5221 run_kernel (KERN_RUN_3, device_param, 1, false, 0);
5222 }
5223
5224 /**
5225 * result
5226 */
5227
5228 check_cracked (device_param, salt_pos);
5229
5230 /**
5231 * cleanup
5232 */
5233
5234 device_param->kernel_params_buf32[24] = 0;
5235 device_param->kernel_params_buf32[25] = 0;
5236 device_param->kernel_params_buf32[26] = 0;
5237 device_param->kernel_params_buf32[27] = 0;
5238 device_param->kernel_params_buf32[28] = 0;
5239 device_param->kernel_params_buf32[29] = 0;
5240 device_param->kernel_params_buf32[30] = 0;
5241 device_param->kernel_params_buf32[31] = 0;
5242
5243 data.dictfile = dictfile_old;
5244
5245 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5246 }
5247
5248 // hlfmt hashcat
5249
5250 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5251 {
5252 if (data.username == 0)
5253 {
5254 *hashbuf_pos = line_buf;
5255 *hashbuf_len = line_len;
5256 }
5257 else
5258 {
5259 char *pos = line_buf;
5260 int len = line_len;
5261
5262 for (int i = 0; i < line_len; i++, pos++, len--)
5263 {
5264 if (line_buf[i] == data.separator)
5265 {
5266 pos++;
5267
5268 len--;
5269
5270 break;
5271 }
5272 }
5273
5274 *hashbuf_pos = pos;
5275 *hashbuf_len = len;
5276 }
5277 }
5278
5279 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5280 {
5281 char *pos = NULL;
5282 int len = 0;
5283
5284 int sep_cnt = 0;
5285
5286 for (int i = 0; i < line_len; i++)
5287 {
5288 if (line_buf[i] == data.separator)
5289 {
5290 sep_cnt++;
5291
5292 continue;
5293 }
5294
5295 if (sep_cnt == 0)
5296 {
5297 if (pos == NULL) pos = line_buf + i;
5298
5299 len++;
5300 }
5301 }
5302
5303 *userbuf_pos = pos;
5304 *userbuf_len = len;
5305 }
5306
5307 // hlfmt pwdump
5308
5309 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5310 {
5311 int sep_cnt = 0;
5312
5313 int sep2_len = 0;
5314 int sep3_len = 0;
5315
5316 for (int i = 0; i < line_len; i++)
5317 {
5318 if (line_buf[i] == ':')
5319 {
5320 sep_cnt++;
5321
5322 continue;
5323 }
5324
5325 if (sep_cnt == 2) sep2_len++;
5326 if (sep_cnt == 3) sep3_len++;
5327 }
5328
5329 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5330
5331 return 0;
5332 }
5333
5334 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5335 {
5336 char *pos = NULL;
5337 int len = 0;
5338
5339 int sep_cnt = 0;
5340
5341 for (int i = 0; i < line_len; i++)
5342 {
5343 if (line_buf[i] == ':')
5344 {
5345 sep_cnt++;
5346
5347 continue;
5348 }
5349
5350 if (data.hash_mode == 1000)
5351 {
5352 if (sep_cnt == 3)
5353 {
5354 if (pos == NULL) pos = line_buf + i;
5355
5356 len++;
5357 }
5358 }
5359 else if (data.hash_mode == 3000)
5360 {
5361 if (sep_cnt == 2)
5362 {
5363 if (pos == NULL) pos = line_buf + i;
5364
5365 len++;
5366 }
5367 }
5368 }
5369
5370 *hashbuf_pos = pos;
5371 *hashbuf_len = len;
5372 }
5373
5374 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5375 {
5376 char *pos = NULL;
5377 int len = 0;
5378
5379 int sep_cnt = 0;
5380
5381 for (int i = 0; i < line_len; i++)
5382 {
5383 if (line_buf[i] == ':')
5384 {
5385 sep_cnt++;
5386
5387 continue;
5388 }
5389
5390 if (sep_cnt == 0)
5391 {
5392 if (pos == NULL) pos = line_buf + i;
5393
5394 len++;
5395 }
5396 }
5397
5398 *userbuf_pos = pos;
5399 *userbuf_len = len;
5400 }
5401
5402 // hlfmt passwd
5403
5404 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5405 {
5406 int sep_cnt = 0;
5407
5408 char sep5_first = 0;
5409 char sep6_first = 0;
5410
5411 for (int i = 0; i < line_len; i++)
5412 {
5413 if (line_buf[i] == ':')
5414 {
5415 sep_cnt++;
5416
5417 continue;
5418 }
5419
5420 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5421 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5422 }
5423
5424 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5425
5426 return 0;
5427 }
5428
5429 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5430 {
5431 char *pos = NULL;
5432 int len = 0;
5433
5434 int sep_cnt = 0;
5435
5436 for (int i = 0; i < line_len; i++)
5437 {
5438 if (line_buf[i] == ':')
5439 {
5440 sep_cnt++;
5441
5442 continue;
5443 }
5444
5445 if (sep_cnt == 1)
5446 {
5447 if (pos == NULL) pos = line_buf + i;
5448
5449 len++;
5450 }
5451 }
5452
5453 *hashbuf_pos = pos;
5454 *hashbuf_len = len;
5455 }
5456
5457 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5458 {
5459 char *pos = NULL;
5460 int len = 0;
5461
5462 int sep_cnt = 0;
5463
5464 for (int i = 0; i < line_len; i++)
5465 {
5466 if (line_buf[i] == ':')
5467 {
5468 sep_cnt++;
5469
5470 continue;
5471 }
5472
5473 if (sep_cnt == 0)
5474 {
5475 if (pos == NULL) pos = line_buf + i;
5476
5477 len++;
5478 }
5479 }
5480
5481 *userbuf_pos = pos;
5482 *userbuf_len = len;
5483 }
5484
5485 // hlfmt shadow
5486
5487 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5488 {
5489 int sep_cnt = 0;
5490
5491 for (int i = 0; i < line_len; i++)
5492 {
5493 if (line_buf[i] == ':') sep_cnt++;
5494 }
5495
5496 if (sep_cnt == 8) return 1;
5497
5498 return 0;
5499 }
5500
5501 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5502 {
5503 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5504 }
5505
5506 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5507 {
5508 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5509 }
5510
5511 // hlfmt main
5512
5513 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5514 {
5515 switch (hashfile_format)
5516 {
5517 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5518 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5519 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5520 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5521 }
5522 }
5523
5524 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5525 {
5526 switch (hashfile_format)
5527 {
5528 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5529 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5530 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5531 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5532 }
5533 }
5534
5535 char *strhlfmt (const uint hashfile_format)
5536 {
5537 switch (hashfile_format)
5538 {
5539 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5540 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5541 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5542 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5543 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5544 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5545 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5546 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5547 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5548 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5549 }
5550
5551 return ((char *) "Unknown");
5552 }
5553
5554 static uint hlfmt_detect (FILE *fp, uint max_check)
5555 {
5556 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5557
5558 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5559 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5560
5561 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5562
5563 uint num_check = 0;
5564
5565 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5566
5567 while (!feof (fp))
5568 {
5569 int line_len = fgetl (fp, line_buf);
5570
5571 if (line_len == 0) continue;
5572
5573 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5574 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5575 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5576
5577 if (num_check == max_check) break;
5578
5579 num_check++;
5580 }
5581
5582 myfree (line_buf);
5583
5584 uint hashlist_format = HLFMT_HASHCAT;
5585
5586 for (int i = 1; i < HLFMTS_CNT; i++)
5587 {
5588 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5589
5590 hashlist_format = i;
5591 }
5592
5593 free (formats_cnt);
5594
5595 return hashlist_format;
5596 }
5597
5598 /**
5599 * some further helper function
5600 */
5601
5602 // wrapper around mymalloc for ADL
5603
5604 #if defined(HAVE_HWMON)
5605 void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize)
5606 {
5607 return mymalloc (iSize);
5608 }
5609 #endif
5610
5611 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)
5612 {
5613 u64 collisions = 0;
5614
5615 const uint dgst_pos0 = data.dgst_pos0;
5616 const uint dgst_pos1 = data.dgst_pos1;
5617 const uint dgst_pos2 = data.dgst_pos2;
5618 const uint dgst_pos3 = data.dgst_pos3;
5619
5620 memset (bitmap_a, 0, bitmap_size);
5621 memset (bitmap_b, 0, bitmap_size);
5622 memset (bitmap_c, 0, bitmap_size);
5623 memset (bitmap_d, 0, bitmap_size);
5624
5625 for (uint i = 0; i < digests_cnt; i++)
5626 {
5627 uint *digest_ptr = (uint *) digests_buf_ptr;
5628
5629 digests_buf_ptr += dgst_size;
5630
5631 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5632 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5633 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5634 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5635
5636 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5637 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5638 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5639 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5640
5641 if (bitmap_a[idx0] & val0) collisions++;
5642 if (bitmap_b[idx1] & val1) collisions++;
5643 if (bitmap_c[idx2] & val2) collisions++;
5644 if (bitmap_d[idx3] & val3) collisions++;
5645
5646 bitmap_a[idx0] |= val0;
5647 bitmap_b[idx1] |= val1;
5648 bitmap_c[idx2] |= val2;
5649 bitmap_d[idx3] |= val3;
5650
5651 if (collisions >= collisions_max) return 0x7fffffff;
5652 }
5653
5654 return collisions;
5655 }
5656
5657 /**
5658 * main
5659 */
5660
5661 #ifdef WIN
5662 void SetConsoleWindowSize (const int x)
5663 {
5664 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5665
5666 if (h == INVALID_HANDLE_VALUE) return;
5667
5668 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5669
5670 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5671
5672 SMALL_RECT *sr = &bufferInfo.srWindow;
5673
5674 sr->Right = MAX (sr->Right, x - 1);
5675
5676 COORD co;
5677
5678 co.X = sr->Right + 1;
5679 co.Y = 9999;
5680
5681 if (!SetConsoleScreenBufferSize (h, co)) return;
5682
5683 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5684 }
5685 #endif
5686
5687 int main (int argc, char **argv)
5688 {
5689 #ifdef WIN
5690 SetConsoleWindowSize (132);
5691 #endif
5692
5693 /**
5694 * To help users a bit
5695 */
5696
5697 char *compute = getenv ("COMPUTE");
5698
5699 if (compute)
5700 {
5701 static char display[100];
5702
5703 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5704
5705 putenv (display);
5706 }
5707 else
5708 {
5709 if (getenv ("DISPLAY") == NULL)
5710 putenv ((char *) "DISPLAY=:0");
5711 }
5712
5713 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5714 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5715
5716 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5717 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5718
5719 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5720 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5721
5722 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5723 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5724
5725 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5726 putenv ((char *) "POCL_KERNEL_CACHE=0");
5727
5728 umask (077);
5729
5730 /**
5731 * Real init
5732 */
5733
5734 memset (&data, 0, sizeof (hc_global_data_t));
5735
5736 time_t proc_start;
5737
5738 time (&proc_start);
5739
5740 data.proc_start = proc_start;
5741
5742 int myargc = argc;
5743 char **myargv = argv;
5744
5745 hc_thread_mutex_init (mux_dispatcher);
5746 hc_thread_mutex_init (mux_counter);
5747 hc_thread_mutex_init (mux_display);
5748 hc_thread_mutex_init (mux_adl);
5749
5750 /**
5751 * commandline parameters
5752 */
5753
5754 uint usage = USAGE;
5755 uint version = VERSION;
5756 uint quiet = QUIET;
5757 uint benchmark = BENCHMARK;
5758 uint stdout_flag = STDOUT_FLAG;
5759 uint show = SHOW;
5760 uint left = LEFT;
5761 uint username = USERNAME;
5762 uint remove = REMOVE;
5763 uint remove_timer = REMOVE_TIMER;
5764 u64 skip = SKIP;
5765 u64 limit = LIMIT;
5766 uint keyspace = KEYSPACE;
5767 uint potfile_disable = POTFILE_DISABLE;
5768 char *potfile_path = NULL;
5769 uint debug_mode = DEBUG_MODE;
5770 char *debug_file = NULL;
5771 char *induction_dir = NULL;
5772 char *outfile_check_dir = NULL;
5773 uint force = FORCE;
5774 uint runtime = RUNTIME;
5775 uint hash_mode = HASH_MODE;
5776 uint attack_mode = ATTACK_MODE;
5777 uint markov_disable = MARKOV_DISABLE;
5778 uint markov_classic = MARKOV_CLASSIC;
5779 uint markov_threshold = MARKOV_THRESHOLD;
5780 char *markov_hcstat = NULL;
5781 char *outfile = NULL;
5782 uint outfile_format = OUTFILE_FORMAT;
5783 uint outfile_autohex = OUTFILE_AUTOHEX;
5784 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5785 uint restore = RESTORE;
5786 uint restore_timer = RESTORE_TIMER;
5787 uint restore_disable = RESTORE_DISABLE;
5788 uint status = STATUS;
5789 uint status_timer = STATUS_TIMER;
5790 uint machine_readable = MACHINE_READABLE;
5791 uint loopback = LOOPBACK;
5792 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5793 char *session = NULL;
5794 uint hex_charset = HEX_CHARSET;
5795 uint hex_salt = HEX_SALT;
5796 uint hex_wordlist = HEX_WORDLIST;
5797 uint rp_gen = RP_GEN;
5798 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5799 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5800 uint rp_gen_seed = RP_GEN_SEED;
5801 char *rule_buf_l = (char *) RULE_BUF_L;
5802 char *rule_buf_r = (char *) RULE_BUF_R;
5803 uint increment = INCREMENT;
5804 uint increment_min = INCREMENT_MIN;
5805 uint increment_max = INCREMENT_MAX;
5806 char *cpu_affinity = NULL;
5807 OCL_PTR *ocl = NULL;
5808 char *opencl_devices = NULL;
5809 char *opencl_platforms = NULL;
5810 char *opencl_device_types = NULL;
5811 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5812 char *truecrypt_keyfiles = NULL;
5813 char *veracrypt_keyfiles = NULL;
5814 uint veracrypt_pim = 0;
5815 uint workload_profile = WORKLOAD_PROFILE;
5816 uint kernel_accel = KERNEL_ACCEL;
5817 uint kernel_loops = KERNEL_LOOPS;
5818 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5819 #ifdef HAVE_HWMON
5820 uint gpu_temp_abort = GPU_TEMP_ABORT;
5821 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5822 uint powertune_enable = POWERTUNE_ENABLE;
5823 #endif
5824 uint logfile_disable = LOGFILE_DISABLE;
5825 uint segment_size = SEGMENT_SIZE;
5826 uint scrypt_tmto = SCRYPT_TMTO;
5827 char separator = SEPARATOR;
5828 uint bitmap_min = BITMAP_MIN;
5829 uint bitmap_max = BITMAP_MAX;
5830 char *custom_charset_1 = NULL;
5831 char *custom_charset_2 = NULL;
5832 char *custom_charset_3 = NULL;
5833 char *custom_charset_4 = NULL;
5834
5835 #define IDX_HELP 'h'
5836 #define IDX_VERSION 'V'
5837 #define IDX_VERSION_LOWER 'v'
5838 #define IDX_QUIET 0xff02
5839 #define IDX_SHOW 0xff03
5840 #define IDX_LEFT 0xff04
5841 #define IDX_REMOVE 0xff05
5842 #define IDX_REMOVE_TIMER 0xff37
5843 #define IDX_SKIP 's'
5844 #define IDX_LIMIT 'l'
5845 #define IDX_KEYSPACE 0xff35
5846 #define IDX_POTFILE_DISABLE 0xff06
5847 #define IDX_POTFILE_PATH 0xffe0
5848 #define IDX_DEBUG_MODE 0xff43
5849 #define IDX_DEBUG_FILE 0xff44
5850 #define IDX_INDUCTION_DIR 0xff46
5851 #define IDX_OUTFILE_CHECK_DIR 0xff47
5852 #define IDX_USERNAME 0xff07
5853 #define IDX_FORCE 0xff08
5854 #define IDX_RUNTIME 0xff09
5855 #define IDX_BENCHMARK 'b'
5856 #define IDX_STDOUT_FLAG 0xff77
5857 #define IDX_HASH_MODE 'm'
5858 #define IDX_ATTACK_MODE 'a'
5859 #define IDX_RP_FILE 'r'
5860 #define IDX_RP_GEN 'g'
5861 #define IDX_RP_GEN_FUNC_MIN 0xff10
5862 #define IDX_RP_GEN_FUNC_MAX 0xff11
5863 #define IDX_RP_GEN_SEED 0xff34
5864 #define IDX_RULE_BUF_L 'j'
5865 #define IDX_RULE_BUF_R 'k'
5866 #define IDX_INCREMENT 'i'
5867 #define IDX_INCREMENT_MIN 0xff12
5868 #define IDX_INCREMENT_MAX 0xff13
5869 #define IDX_OUTFILE 'o'
5870 #define IDX_OUTFILE_FORMAT 0xff14
5871 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5872 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5873 #define IDX_RESTORE 0xff15
5874 #define IDX_RESTORE_DISABLE 0xff27
5875 #define IDX_STATUS 0xff17
5876 #define IDX_STATUS_TIMER 0xff18
5877 #define IDX_MACHINE_READABLE 0xff50
5878 #define IDX_LOOPBACK 0xff38
5879 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5880 #define IDX_SESSION 0xff19
5881 #define IDX_HEX_CHARSET 0xff20
5882 #define IDX_HEX_SALT 0xff21
5883 #define IDX_HEX_WORDLIST 0xff40
5884 #define IDX_MARKOV_DISABLE 0xff22
5885 #define IDX_MARKOV_CLASSIC 0xff23
5886 #define IDX_MARKOV_THRESHOLD 't'
5887 #define IDX_MARKOV_HCSTAT 0xff24
5888 #define IDX_CPU_AFFINITY 0xff25
5889 #define IDX_OPENCL_DEVICES 'd'
5890 #define IDX_OPENCL_PLATFORMS 0xff72
5891 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5892 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5893 #define IDX_WORKLOAD_PROFILE 'w'
5894 #define IDX_KERNEL_ACCEL 'n'
5895 #define IDX_KERNEL_LOOPS 'u'
5896 #define IDX_GPU_TEMP_DISABLE 0xff29
5897 #define IDX_GPU_TEMP_ABORT 0xff30
5898 #define IDX_GPU_TEMP_RETAIN 0xff31
5899 #define IDX_POWERTUNE_ENABLE 0xff41
5900 #define IDX_LOGFILE_DISABLE 0xff51
5901 #define IDX_TRUECRYPT_KEYFILES 0xff52
5902 #define IDX_VERACRYPT_KEYFILES 0xff53
5903 #define IDX_VERACRYPT_PIM 0xff54
5904 #define IDX_SCRYPT_TMTO 0xff61
5905 #define IDX_SEGMENT_SIZE 'c'
5906 #define IDX_SEPARATOR 'p'
5907 #define IDX_BITMAP_MIN 0xff70
5908 #define IDX_BITMAP_MAX 0xff71
5909 #define IDX_CUSTOM_CHARSET_1 '1'
5910 #define IDX_CUSTOM_CHARSET_2 '2'
5911 #define IDX_CUSTOM_CHARSET_3 '3'
5912 #define IDX_CUSTOM_CHARSET_4 '4'
5913
5914 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5915
5916 struct option long_options[] =
5917 {
5918 {"help", no_argument, 0, IDX_HELP},
5919 {"version", no_argument, 0, IDX_VERSION},
5920 {"quiet", no_argument, 0, IDX_QUIET},
5921 {"show", no_argument, 0, IDX_SHOW},
5922 {"left", no_argument, 0, IDX_LEFT},
5923 {"username", no_argument, 0, IDX_USERNAME},
5924 {"remove", no_argument, 0, IDX_REMOVE},
5925 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5926 {"skip", required_argument, 0, IDX_SKIP},
5927 {"limit", required_argument, 0, IDX_LIMIT},
5928 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5929 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5930 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5931 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5932 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5933 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5934 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5935 {"force", no_argument, 0, IDX_FORCE},
5936 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5937 {"stdout", no_argument, 0, IDX_STDOUT_FLAG},
5938 {"restore", no_argument, 0, IDX_RESTORE},
5939 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5940 {"status", no_argument, 0, IDX_STATUS},
5941 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5942 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5943 {"loopback", no_argument, 0, IDX_LOOPBACK},
5944 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5945 {"session", required_argument, 0, IDX_SESSION},
5946 {"runtime", required_argument, 0, IDX_RUNTIME},
5947 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5948 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5949 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5950 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5951 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5952 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5953 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5954 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5955 {"rules-file", required_argument, 0, IDX_RP_FILE},
5956 {"outfile", required_argument, 0, IDX_OUTFILE},
5957 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5958 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5959 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5960 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5961 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5962 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5963 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5964 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5965 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5966 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5967 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5968 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5969 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5970 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5971 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5972 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5973 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5974 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5975 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5976 #ifdef HAVE_HWMON
5977 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5978 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5979 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5980 #endif // HAVE_HWMON
5981 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5982 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5983 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5984 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5985 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5986 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5987 {"seperator", required_argument, 0, IDX_SEPARATOR},
5988 {"separator", required_argument, 0, IDX_SEPARATOR},
5989 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5990 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5991 {"increment", no_argument, 0, IDX_INCREMENT},
5992 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5993 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5994 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5995 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5996 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5997 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5998 {0, 0, 0, 0}
5999 };
6000
6001 uint rp_files_cnt = 0;
6002
6003 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
6004
6005 int option_index = 0;
6006 int c = -1;
6007
6008 optind = 1;
6009 optopt = 0;
6010
6011 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6012 {
6013 switch (c)
6014 {
6015 case IDX_HELP: usage = 1; break;
6016 case IDX_VERSION:
6017 case IDX_VERSION_LOWER: version = 1; break;
6018 case IDX_RESTORE: restore = 1; break;
6019 case IDX_SESSION: session = optarg; break;
6020 case IDX_SHOW: show = 1; break;
6021 case IDX_LEFT: left = 1; break;
6022 case '?': return (-1);
6023 }
6024 }
6025
6026 if (optopt != 0)
6027 {
6028 log_error ("ERROR: Invalid argument specified");
6029
6030 return (-1);
6031 }
6032
6033 /**
6034 * exit functions
6035 */
6036
6037 if (version)
6038 {
6039 log_info ("%s", VERSION_TAG);
6040
6041 return (0);
6042 }
6043
6044 if (usage)
6045 {
6046 usage_big_print (PROGNAME);
6047
6048 return (0);
6049 }
6050
6051 /**
6052 * session needs to be set, always!
6053 */
6054
6055 if (session == NULL) session = (char *) PROGNAME;
6056
6057 /**
6058 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
6059 */
6060
6061 char *exec_path = get_exec_path ();
6062
6063 #ifdef LINUX
6064
6065 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
6066 char *resolved_exec_path = realpath (exec_path, NULL);
6067
6068 char *install_dir = get_install_dir (resolved_exec_path);
6069 char *profile_dir = NULL;
6070 char *session_dir = NULL;
6071 char *shared_dir = NULL;
6072
6073 if (strcmp (install_dir, resolved_install_folder) == 0)
6074 {
6075 struct passwd *pw = getpwuid (getuid ());
6076
6077 const char *homedir = pw->pw_dir;
6078
6079 profile_dir = get_profile_dir (homedir);
6080 session_dir = get_session_dir (profile_dir);
6081 shared_dir = strdup (SHARED_FOLDER);
6082
6083 mkdir (profile_dir, 0700);
6084 mkdir (session_dir, 0700);
6085 }
6086 else
6087 {
6088 profile_dir = install_dir;
6089 session_dir = install_dir;
6090 shared_dir = install_dir;
6091 }
6092
6093 myfree (resolved_install_folder);
6094 myfree (resolved_exec_path);
6095
6096 #else
6097
6098 char *install_dir = get_install_dir (exec_path);
6099 char *profile_dir = install_dir;
6100 char *session_dir = install_dir;
6101 char *shared_dir = install_dir;
6102
6103 #endif
6104
6105 data.install_dir = install_dir;
6106 data.profile_dir = profile_dir;
6107 data.session_dir = session_dir;
6108 data.shared_dir = shared_dir;
6109
6110 myfree (exec_path);
6111
6112 /**
6113 * kernel cache, we need to make sure folder exist
6114 */
6115
6116 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
6117
6118 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
6119
6120 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
6121
6122 mkdir (kernels_folder, 0700);
6123
6124 myfree (kernels_folder);
6125
6126 /**
6127 * session
6128 */
6129
6130 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
6131
6132 data.session = session;
6133
6134 char *eff_restore_file = (char *) mymalloc (session_size);
6135 char *new_restore_file = (char *) mymalloc (session_size);
6136
6137 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
6138 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
6139
6140 data.eff_restore_file = eff_restore_file;
6141 data.new_restore_file = new_restore_file;
6142
6143 if (((show == 1) || (left == 1)) && (restore == 1))
6144 {
6145 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
6146 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
6147
6148 return (-1);
6149 }
6150
6151 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
6152 if ((show == 1) || (left == 1))
6153 {
6154 restore_disable = 1;
6155
6156 restore = 0;
6157 }
6158
6159 data.restore_disable = restore_disable;
6160
6161 restore_data_t *rd = init_restore (argc, argv);
6162
6163 data.rd = rd;
6164
6165 /**
6166 * restore file
6167 */
6168
6169 if (restore == 1)
6170 {
6171 read_restore (eff_restore_file, rd);
6172
6173 if (rd->version_bin < RESTORE_MIN)
6174 {
6175 log_error ("ERROR: Incompatible restore-file version");
6176
6177 return (-1);
6178 }
6179
6180 myargc = rd->argc;
6181 myargv = rd->argv;
6182
6183 #ifdef _POSIX
6184 rd->pid = getpid ();
6185 #elif _WIN
6186 rd->pid = GetCurrentProcessId ();
6187 #endif
6188 }
6189
6190 uint hash_mode_chgd = 0;
6191 uint runtime_chgd = 0;
6192 uint kernel_loops_chgd = 0;
6193 uint kernel_accel_chgd = 0;
6194 uint attack_mode_chgd = 0;
6195 uint outfile_format_chgd = 0;
6196 uint rp_gen_seed_chgd = 0;
6197 uint remove_timer_chgd = 0;
6198 uint increment_min_chgd = 0;
6199 uint increment_max_chgd = 0;
6200 uint workload_profile_chgd = 0;
6201 uint opencl_vector_width_chgd = 0;
6202
6203 optind = 1;
6204 optopt = 0;
6205 option_index = 0;
6206
6207 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
6208 {
6209 switch (c)
6210 {
6211 //case IDX_HELP: usage = 1; break;
6212 //case IDX_VERSION: version = 1; break;
6213 //case IDX_RESTORE: restore = 1; break;
6214 case IDX_QUIET: quiet = 1; break;
6215 //case IDX_SHOW: show = 1; break;
6216 case IDX_SHOW: break;
6217 //case IDX_LEFT: left = 1; break;
6218 case IDX_LEFT: break;
6219 case IDX_USERNAME: username = 1; break;
6220 case IDX_REMOVE: remove = 1; break;
6221 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
6222 remove_timer_chgd = 1; break;
6223 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
6224 case IDX_POTFILE_PATH: potfile_path = optarg; break;
6225 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
6226 case IDX_DEBUG_FILE: debug_file = optarg; break;
6227 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
6228 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
6229 case IDX_FORCE: force = 1; break;
6230 case IDX_SKIP: skip = atoll (optarg); break;
6231 case IDX_LIMIT: limit = atoll (optarg); break;
6232 case IDX_KEYSPACE: keyspace = 1; break;
6233 case IDX_BENCHMARK: benchmark = 1; break;
6234 case IDX_STDOUT_FLAG: stdout_flag = 1; break;
6235 case IDX_RESTORE: break;
6236 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6237 case IDX_STATUS: status = 1; break;
6238 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6239 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6240 case IDX_LOOPBACK: loopback = 1; break;
6241 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6242 //case IDX_SESSION: session = optarg; break;
6243 case IDX_SESSION: break;
6244 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6245 hash_mode_chgd = 1; break;
6246 case IDX_RUNTIME: runtime = atoi (optarg);
6247 runtime_chgd = 1; break;
6248 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6249 attack_mode_chgd = 1; break;
6250 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6251 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6252 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6253 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6254 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6255 rp_gen_seed_chgd = 1; break;
6256 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6257 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6258 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6259 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6260 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6261 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6262 case IDX_OUTFILE: outfile = optarg; break;
6263 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6264 outfile_format_chgd = 1; break;
6265 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6266 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6267 case IDX_HEX_CHARSET: hex_charset = 1; break;
6268 case IDX_HEX_SALT: hex_salt = 1; break;
6269 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6270 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6271 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6272 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6273 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6274 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6275 opencl_vector_width_chgd = 1; break;
6276 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6277 workload_profile_chgd = 1; break;
6278 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6279 kernel_accel_chgd = 1; break;
6280 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6281 kernel_loops_chgd = 1; break;
6282 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6283 #ifdef HAVE_HWMON
6284 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break;
6285 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break;
6286 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6287 #endif // HAVE_HWMON
6288 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6289 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6290 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6291 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6292 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6293 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6294 case IDX_SEPARATOR: separator = optarg[0]; break;
6295 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6296 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6297 case IDX_INCREMENT: increment = 1; break;
6298 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6299 increment_min_chgd = 1; break;
6300 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6301 increment_max_chgd = 1; break;
6302 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6303 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6304 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6305 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6306
6307 default:
6308 log_error ("ERROR: Invalid argument specified");
6309 return (-1);
6310 }
6311 }
6312
6313 if (optopt != 0)
6314 {
6315 log_error ("ERROR: Invalid argument specified");
6316
6317 return (-1);
6318 }
6319
6320 /**
6321 * Inform user things getting started,
6322 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6323 * - we do not need to check algorithm_pos
6324 */
6325
6326 if (quiet == 0)
6327 {
6328 if (benchmark == 1)
6329 {
6330 if (machine_readable == 0)
6331 {
6332 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6333 log_info ("");
6334 log_info ("Note: Reported benchmark cracking speed = real cracking speed");
6335 log_info ("To verify, run hashcat like this: only_one_hash.txt -a 3 -w 3 ?b?b?b?b?b?b?b");
6336 log_info ("");
6337 }
6338 else
6339 {
6340 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6341 }
6342 }
6343 else if (restore == 1)
6344 {
6345 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6346 log_info ("");
6347 }
6348 else if (stdout_flag == 1)
6349 {
6350 // do nothing
6351 }
6352 else
6353 {
6354 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6355 log_info ("");
6356 }
6357 }
6358
6359 /**
6360 * sanity check
6361 */
6362
6363 if (attack_mode > 7)
6364 {
6365 log_error ("ERROR: Invalid attack-mode specified");
6366
6367 return (-1);
6368 }
6369
6370 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6371 {
6372 log_error ("ERROR: Invalid runtime specified");
6373
6374 return (-1);
6375 }
6376
6377 if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd
6378 {
6379 log_error ("ERROR: Invalid hash-type specified");
6380
6381 return (-1);
6382 }
6383
6384 // renamed hash modes
6385
6386 if (hash_mode_chgd)
6387 {
6388 int n = -1;
6389
6390 switch (hash_mode)
6391 {
6392 case 123: n = 124;
6393 break;
6394 }
6395
6396 if (n >= 0)
6397 {
6398 log_error ("Old -m specified, use -m %d instead", n);
6399
6400 return (-1);
6401 }
6402 }
6403
6404 if (username == 1)
6405 {
6406 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6407 {
6408 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6409
6410 return (-1);
6411 }
6412 }
6413
6414 if (outfile_format > 16)
6415 {
6416 log_error ("ERROR: Invalid outfile-format specified");
6417
6418 return (-1);
6419 }
6420
6421 if (left == 1)
6422 {
6423 if (outfile_format_chgd == 1)
6424 {
6425 if (outfile_format > 1)
6426 {
6427 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6428
6429 return (-1);
6430 }
6431 }
6432 else
6433 {
6434 outfile_format = OUTFILE_FMT_HASH;
6435 }
6436 }
6437
6438 if (show == 1)
6439 {
6440 if (outfile_format_chgd == 1)
6441 {
6442 if ((outfile_format > 7) && (outfile_format < 16))
6443 {
6444 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6445
6446 return (-1);
6447 }
6448 }
6449 }
6450
6451 if (increment_min < INCREMENT_MIN)
6452 {
6453 log_error ("ERROR: Invalid increment-min specified");
6454
6455 return (-1);
6456 }
6457
6458 if (increment_max > INCREMENT_MAX)
6459 {
6460 log_error ("ERROR: Invalid increment-max specified");
6461
6462 return (-1);
6463 }
6464
6465 if (increment_min > increment_max)
6466 {
6467 log_error ("ERROR: Invalid increment-min specified");
6468
6469 return (-1);
6470 }
6471
6472 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6473 {
6474 log_error ("ERROR: increment is not allowed in attack-mode 0");
6475
6476 return (-1);
6477 }
6478
6479 if ((increment == 0) && (increment_min_chgd == 1))
6480 {
6481 log_error ("ERROR: increment-min is only supported together with increment switch");
6482
6483 return (-1);
6484 }
6485
6486 if ((increment == 0) && (increment_max_chgd == 1))
6487 {
6488 log_error ("ERROR: increment-max is only supported together with increment switch");
6489
6490 return (-1);
6491 }
6492
6493 if (rp_files_cnt && rp_gen)
6494 {
6495 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6496
6497 return (-1);
6498 }
6499
6500 if (rp_files_cnt || rp_gen)
6501 {
6502 if (attack_mode != ATTACK_MODE_STRAIGHT)
6503 {
6504 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6505
6506 return (-1);
6507 }
6508 }
6509
6510 if (rp_gen_func_min > rp_gen_func_max)
6511 {
6512 log_error ("ERROR: Invalid rp-gen-func-min specified");
6513
6514 return (-1);
6515 }
6516
6517 if (kernel_accel_chgd == 1)
6518 {
6519 if (force == 0)
6520 {
6521 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6522 log_info ("Please consider using the option -w instead");
6523 log_info ("You can use --force to override this but do not post error reports if you do so");
6524 log_info ("");
6525
6526 return (-1);
6527 }
6528
6529 if (kernel_accel < 1)
6530 {
6531 log_error ("ERROR: Invalid kernel-accel specified");
6532
6533 return (-1);
6534 }
6535
6536 if (kernel_accel > 1024)
6537 {
6538 log_error ("ERROR: Invalid kernel-accel specified");
6539
6540 return (-1);
6541 }
6542 }
6543
6544 if (kernel_loops_chgd == 1)
6545 {
6546 if (force == 0)
6547 {
6548 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6549 log_info ("Please consider using the option -w instead");
6550 log_info ("You can use --force to override this but do not post error reports if you do so");
6551 log_info ("");
6552
6553 return (-1);
6554 }
6555
6556 if (kernel_loops < 1)
6557 {
6558 log_error ("ERROR: Invalid kernel-loops specified");
6559
6560 return (-1);
6561 }
6562
6563 if (kernel_loops > 1024)
6564 {
6565 log_error ("ERROR: Invalid kernel-loops specified");
6566
6567 return (-1);
6568 }
6569 }
6570
6571 if ((workload_profile < 1) || (workload_profile > 4))
6572 {
6573 log_error ("ERROR: workload-profile %i not available", workload_profile);
6574
6575 return (-1);
6576 }
6577
6578 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6579 {
6580 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6581
6582 return (-1);
6583 }
6584
6585 if (show == 1 || left == 1)
6586 {
6587 attack_mode = ATTACK_MODE_NONE;
6588
6589 if (remove == 1)
6590 {
6591 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6592
6593 return (-1);
6594 }
6595
6596 if (potfile_disable == 1)
6597 {
6598 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6599
6600 return (-1);
6601 }
6602 }
6603
6604 uint attack_kern = ATTACK_KERN_NONE;
6605
6606 switch (attack_mode)
6607 {
6608 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6609 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6610 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6611 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6612 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6613 }
6614
6615 if (benchmark == 1)
6616 {
6617 if (myargv[optind] != 0)
6618 {
6619 log_error ("ERROR: Invalid argument for benchmark mode specified");
6620
6621 return (-1);
6622 }
6623
6624 if (attack_mode_chgd == 1)
6625 {
6626 if (attack_mode != ATTACK_MODE_BF)
6627 {
6628 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6629
6630 return (-1);
6631 }
6632 }
6633 }
6634 else
6635 {
6636 if (stdout_flag == 1) // no hash here
6637 {
6638 optind--;
6639 }
6640
6641 if (keyspace == 1)
6642 {
6643 int num_additional_params = 1;
6644
6645 if (attack_kern == ATTACK_KERN_COMBI)
6646 {
6647 num_additional_params = 2;
6648 }
6649
6650 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6651
6652 if (keyspace_wordlist_specified == 0) optind--;
6653 }
6654
6655 if (attack_kern == ATTACK_KERN_NONE)
6656 {
6657 if ((optind + 1) != myargc)
6658 {
6659 usage_mini_print (myargv[0]);
6660
6661 return (-1);
6662 }
6663 }
6664 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6665 {
6666 if ((optind + 1) > myargc)
6667 {
6668 usage_mini_print (myargv[0]);
6669
6670 return (-1);
6671 }
6672 }
6673 else if (attack_kern == ATTACK_KERN_COMBI)
6674 {
6675 if ((optind + 3) != myargc)
6676 {
6677 usage_mini_print (myargv[0]);
6678
6679 return (-1);
6680 }
6681 }
6682 else if (attack_kern == ATTACK_KERN_BF)
6683 {
6684 if ((optind + 1) > myargc)
6685 {
6686 usage_mini_print (myargv[0]);
6687
6688 return (-1);
6689 }
6690 }
6691 else
6692 {
6693 usage_mini_print (myargv[0]);
6694
6695 return (-1);
6696 }
6697 }
6698
6699 if (skip != 0 && limit != 0)
6700 {
6701 limit += skip;
6702 }
6703
6704 if (keyspace == 1)
6705 {
6706 if (show == 1)
6707 {
6708 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6709
6710 return (-1);
6711 }
6712 else if (left == 1)
6713 {
6714 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6715
6716 return (-1);
6717 }
6718
6719 potfile_disable = 1;
6720
6721 restore_disable = 1;
6722
6723 restore = 0;
6724
6725 weak_hash_threshold = 0;
6726
6727 quiet = 1;
6728 }
6729
6730 if (stdout_flag == 1)
6731 {
6732 status_timer = 0;
6733 restore_timer = 0;
6734 restore_disable = 1;
6735 restore = 0;
6736 potfile_disable = 1;
6737 weak_hash_threshold = 0;
6738 gpu_temp_disable = 1;
6739 hash_mode = 2000;
6740 quiet = 1;
6741 outfile_format = OUTFILE_FMT_PLAIN;
6742 kernel_accel = 1024;
6743 kernel_loops = 1024;
6744 force = 1;
6745 outfile_check_timer = 0;
6746 }
6747
6748 if (remove_timer_chgd == 1)
6749 {
6750 if (remove == 0)
6751 {
6752 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6753
6754 return (-1);
6755 }
6756
6757 if (remove_timer < 1)
6758 {
6759 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6760
6761 return (-1);
6762 }
6763 }
6764
6765 if (loopback == 1)
6766 {
6767 if (attack_mode == ATTACK_MODE_STRAIGHT)
6768 {
6769 if ((rp_files_cnt == 0) && (rp_gen == 0))
6770 {
6771 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6772
6773 return (-1);
6774 }
6775 }
6776 else
6777 {
6778 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6779
6780 return (-1);
6781 }
6782 }
6783
6784 if (debug_mode > 0)
6785 {
6786 if (attack_mode != ATTACK_MODE_STRAIGHT)
6787 {
6788 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6789
6790 return (-1);
6791 }
6792
6793 if ((rp_files_cnt == 0) && (rp_gen == 0))
6794 {
6795 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6796
6797 return (-1);
6798 }
6799 }
6800
6801 if (debug_mode > 4)
6802 {
6803 log_error ("ERROR: Invalid debug-mode specified");
6804
6805 return (-1);
6806 }
6807
6808 if (debug_file != NULL)
6809 {
6810 if (debug_mode < 1)
6811 {
6812 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6813
6814 return (-1);
6815 }
6816 }
6817
6818 if (induction_dir != NULL)
6819 {
6820 if (attack_mode == ATTACK_MODE_BF)
6821 {
6822 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6823
6824 return (-1);
6825 }
6826 }
6827
6828 if (attack_mode != ATTACK_MODE_STRAIGHT)
6829 {
6830 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6831 {
6832 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6833
6834 return (-1);
6835 }
6836
6837 weak_hash_threshold = 0;
6838 }
6839
6840 /**
6841 * induction directory
6842 */
6843
6844 char *induction_directory = NULL;
6845
6846 if (attack_mode != ATTACK_MODE_BF)
6847 {
6848 if (induction_dir == NULL)
6849 {
6850 induction_directory = (char *) mymalloc (session_size);
6851
6852 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6853
6854 // create induction folder if it does not already exist
6855
6856 if (keyspace == 0)
6857 {
6858 if (rmdir (induction_directory) == -1)
6859 {
6860 if (errno == ENOENT)
6861 {
6862 // good, we can ignore
6863 }
6864 else if (errno == ENOTEMPTY)
6865 {
6866 char *induction_directory_mv = (char *) mymalloc (session_size);
6867
6868 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6869
6870 if (rename (induction_directory, induction_directory_mv) != 0)
6871 {
6872 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6873
6874 return (-1);
6875 }
6876 }
6877 else
6878 {
6879 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6880
6881 return (-1);
6882 }
6883 }
6884
6885 if (mkdir (induction_directory, 0700) == -1)
6886 {
6887 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6888
6889 return (-1);
6890 }
6891 }
6892 }
6893 else
6894 {
6895 induction_directory = induction_dir;
6896 }
6897 }
6898
6899 data.induction_directory = induction_directory;
6900
6901 /**
6902 * loopback
6903 */
6904
6905 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6906
6907 char *loopback_file = (char *) mymalloc (loopback_size);
6908
6909 /**
6910 * tuning db
6911 */
6912
6913 char tuning_db_file[256] = { 0 };
6914
6915 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6916
6917 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6918
6919 /**
6920 * outfile-check directory
6921 */
6922
6923 char *outfile_check_directory = NULL;
6924
6925 if (outfile_check_dir == NULL)
6926 {
6927 outfile_check_directory = (char *) mymalloc (session_size);
6928
6929 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6930 }
6931 else
6932 {
6933 outfile_check_directory = outfile_check_dir;
6934 }
6935
6936 data.outfile_check_directory = outfile_check_directory;
6937
6938 if (keyspace == 0)
6939 {
6940 struct stat outfile_check_stat;
6941
6942 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6943 {
6944 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6945
6946 if (is_dir == 0)
6947 {
6948 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6949
6950 return (-1);
6951 }
6952 }
6953 else if (outfile_check_dir == NULL)
6954 {
6955 if (mkdir (outfile_check_directory, 0700) == -1)
6956 {
6957 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6958
6959 return (-1);
6960 }
6961 }
6962 }
6963
6964 /**
6965 * special other stuff
6966 */
6967
6968 if (hash_mode == 9710)
6969 {
6970 outfile_format = 5;
6971 outfile_format_chgd = 1;
6972 }
6973
6974 if (hash_mode == 9810)
6975 {
6976 outfile_format = 5;
6977 outfile_format_chgd = 1;
6978 }
6979
6980 if (hash_mode == 10410)
6981 {
6982 outfile_format = 5;
6983 outfile_format_chgd = 1;
6984 }
6985
6986 /**
6987 * store stuff
6988 */
6989
6990 data.hash_mode = hash_mode;
6991 data.restore = restore;
6992 data.restore_timer = restore_timer;
6993 data.restore_disable = restore_disable;
6994 data.status = status;
6995 data.status_timer = status_timer;
6996 data.machine_readable = machine_readable;
6997 data.loopback = loopback;
6998 data.runtime = runtime;
6999 data.remove = remove;
7000 data.remove_timer = remove_timer;
7001 data.debug_mode = debug_mode;
7002 data.debug_file = debug_file;
7003 data.username = username;
7004 data.quiet = quiet;
7005 data.outfile = outfile;
7006 data.outfile_format = outfile_format;
7007 data.outfile_autohex = outfile_autohex;
7008 data.hex_charset = hex_charset;
7009 data.hex_salt = hex_salt;
7010 data.hex_wordlist = hex_wordlist;
7011 data.separator = separator;
7012 data.rp_files = rp_files;
7013 data.rp_files_cnt = rp_files_cnt;
7014 data.rp_gen = rp_gen;
7015 data.rp_gen_seed = rp_gen_seed;
7016 data.force = force;
7017 data.benchmark = benchmark;
7018 data.skip = skip;
7019 data.limit = limit;
7020 #ifdef HAVE_HWMON
7021 data.powertune_enable = powertune_enable;
7022 #endif
7023 data.logfile_disable = logfile_disable;
7024 data.truecrypt_keyfiles = truecrypt_keyfiles;
7025 data.veracrypt_keyfiles = veracrypt_keyfiles;
7026 data.veracrypt_pim = veracrypt_pim;
7027 data.scrypt_tmto = scrypt_tmto;
7028 data.workload_profile = workload_profile;
7029
7030 /**
7031 * cpu affinity
7032 */
7033
7034 if (cpu_affinity)
7035 {
7036 set_cpu_affinity (cpu_affinity);
7037 }
7038
7039 if (rp_gen_seed_chgd == 0)
7040 {
7041 srand (proc_start);
7042 }
7043 else
7044 {
7045 srand (rp_gen_seed);
7046 }
7047
7048 /**
7049 * logfile init
7050 */
7051
7052 if (logfile_disable == 0)
7053 {
7054 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
7055
7056 char *logfile = (char *) mymalloc (logfile_size);
7057
7058 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
7059
7060 data.logfile = logfile;
7061
7062 char *topid = logfile_generate_topid ();
7063
7064 data.topid = topid;
7065 }
7066
7067 // logfile_append() checks for logfile_disable internally to make it easier from here
7068
7069 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
7070 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
7071 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
7072 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
7073 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
7074 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
7075 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
7076 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
7077 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
7078 #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));
7079
7080 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
7081 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
7082 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
7083 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
7084 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
7085 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
7086 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
7087 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
7088
7089 logfile_top_msg ("START");
7090
7091 logfile_top_uint (attack_mode);
7092 logfile_top_uint (attack_kern);
7093 logfile_top_uint (benchmark);
7094 logfile_top_uint (stdout_flag);
7095 logfile_top_uint (bitmap_min);
7096 logfile_top_uint (bitmap_max);
7097 logfile_top_uint (debug_mode);
7098 logfile_top_uint (force);
7099 logfile_top_uint (kernel_accel);
7100 logfile_top_uint (kernel_loops);
7101 logfile_top_uint (gpu_temp_disable);
7102 #ifdef HAVE_HWMON
7103 logfile_top_uint (gpu_temp_abort);
7104 logfile_top_uint (gpu_temp_retain);
7105 #endif
7106 logfile_top_uint (hash_mode);
7107 logfile_top_uint (hex_charset);
7108 logfile_top_uint (hex_salt);
7109 logfile_top_uint (hex_wordlist);
7110 logfile_top_uint (increment);
7111 logfile_top_uint (increment_max);
7112 logfile_top_uint (increment_min);
7113 logfile_top_uint (keyspace);
7114 logfile_top_uint (left);
7115 logfile_top_uint (logfile_disable);
7116 logfile_top_uint (loopback);
7117 logfile_top_uint (markov_classic);
7118 logfile_top_uint (markov_disable);
7119 logfile_top_uint (markov_threshold);
7120 logfile_top_uint (outfile_autohex);
7121 logfile_top_uint (outfile_check_timer);
7122 logfile_top_uint (outfile_format);
7123 logfile_top_uint (potfile_disable);
7124 logfile_top_string (potfile_path);
7125 #if defined(HAVE_HWMON)
7126 logfile_top_uint (powertune_enable);
7127 #endif
7128 logfile_top_uint (scrypt_tmto);
7129 logfile_top_uint (quiet);
7130 logfile_top_uint (remove);
7131 logfile_top_uint (remove_timer);
7132 logfile_top_uint (restore);
7133 logfile_top_uint (restore_disable);
7134 logfile_top_uint (restore_timer);
7135 logfile_top_uint (rp_gen);
7136 logfile_top_uint (rp_gen_func_max);
7137 logfile_top_uint (rp_gen_func_min);
7138 logfile_top_uint (rp_gen_seed);
7139 logfile_top_uint (runtime);
7140 logfile_top_uint (segment_size);
7141 logfile_top_uint (show);
7142 logfile_top_uint (status);
7143 logfile_top_uint (machine_readable);
7144 logfile_top_uint (status_timer);
7145 logfile_top_uint (usage);
7146 logfile_top_uint (username);
7147 logfile_top_uint (version);
7148 logfile_top_uint (weak_hash_threshold);
7149 logfile_top_uint (workload_profile);
7150 logfile_top_uint64 (limit);
7151 logfile_top_uint64 (skip);
7152 logfile_top_char (separator);
7153 logfile_top_string (cpu_affinity);
7154 logfile_top_string (custom_charset_1);
7155 logfile_top_string (custom_charset_2);
7156 logfile_top_string (custom_charset_3);
7157 logfile_top_string (custom_charset_4);
7158 logfile_top_string (debug_file);
7159 logfile_top_string (opencl_devices);
7160 logfile_top_string (opencl_platforms);
7161 logfile_top_string (opencl_device_types);
7162 logfile_top_uint (opencl_vector_width);
7163 logfile_top_string (induction_dir);
7164 logfile_top_string (markov_hcstat);
7165 logfile_top_string (outfile);
7166 logfile_top_string (outfile_check_dir);
7167 logfile_top_string (rule_buf_l);
7168 logfile_top_string (rule_buf_r);
7169 logfile_top_string (session);
7170 logfile_top_string (truecrypt_keyfiles);
7171 logfile_top_string (veracrypt_keyfiles);
7172 logfile_top_uint (veracrypt_pim);
7173
7174 /**
7175 * Init OpenCL library loader
7176 */
7177
7178 if (keyspace == 0)
7179 {
7180 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
7181
7182 ocl_init (ocl);
7183
7184 data.ocl = ocl;
7185 }
7186
7187 /**
7188 * OpenCL platform selection
7189 */
7190
7191 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
7192
7193 /**
7194 * OpenCL device selection
7195 */
7196
7197 u32 devices_filter = setup_devices_filter (opencl_devices);
7198
7199 /**
7200 * OpenCL device type selection
7201 */
7202
7203 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
7204
7205 /**
7206 * benchmark
7207 */
7208
7209 if (benchmark == 1)
7210 {
7211 /**
7212 * disable useless stuff for benchmark
7213 */
7214
7215 status_timer = 0;
7216 restore_timer = 0;
7217 restore_disable = 1;
7218 potfile_disable = 1;
7219 weak_hash_threshold = 0;
7220 gpu_temp_disable = 1;
7221 outfile_check_timer = 0;
7222
7223 #ifdef HAVE_HWMON
7224 if (powertune_enable == 1)
7225 {
7226 gpu_temp_disable = 0;
7227 }
7228 #endif
7229
7230 data.status_timer = status_timer;
7231 data.restore_timer = restore_timer;
7232 data.restore_disable = restore_disable;
7233 data.outfile_check_timer = outfile_check_timer;
7234
7235 /**
7236 * force attack mode to be bruteforce
7237 */
7238
7239 attack_mode = ATTACK_MODE_BF;
7240 attack_kern = ATTACK_KERN_BF;
7241
7242 if (workload_profile_chgd == 0)
7243 {
7244 workload_profile = 3;
7245
7246 data.workload_profile = workload_profile;
7247 }
7248 }
7249
7250 /**
7251 * config
7252 */
7253
7254 uint hash_type = 0;
7255 uint salt_type = 0;
7256 uint attack_exec = 0;
7257 uint opts_type = 0;
7258 uint kern_type = 0;
7259 uint dgst_size = 0;
7260 uint esalt_size = 0;
7261 uint opti_type = 0;
7262 uint dgst_pos0 = -1;
7263 uint dgst_pos1 = -1;
7264 uint dgst_pos2 = -1;
7265 uint dgst_pos3 = -1;
7266
7267 int (*parse_func) (char *, uint, hash_t *);
7268 int (*sort_by_digest) (const void *, const void *);
7269
7270 uint algorithm_pos = 0;
7271 uint algorithm_max = 1;
7272
7273 uint *algorithms = default_benchmark_algorithms;
7274
7275 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7276
7277 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7278 {
7279 /*
7280 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7281 * the following algos are skipped entirely
7282 */
7283
7284 if (algorithm_pos > 0)
7285 {
7286 local_free (rd);
7287
7288 rd = init_restore (argc, argv);
7289
7290 data.rd = rd;
7291 }
7292
7293 /**
7294 * update hash_mode in case of multihash benchmark
7295 */
7296
7297 if (benchmark == 1)
7298 {
7299 if (hash_mode_chgd == 0)
7300 {
7301 hash_mode = algorithms[algorithm_pos];
7302
7303 data.hash_mode = hash_mode;
7304 }
7305
7306 quiet = 1;
7307
7308 data.quiet = quiet;
7309 }
7310
7311 switch (hash_mode)
7312 {
7313 case 0: hash_type = HASH_TYPE_MD5;
7314 salt_type = SALT_TYPE_NONE;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_LE
7317 | OPTS_TYPE_PT_ADD80
7318 | OPTS_TYPE_PT_ADDBITS14;
7319 kern_type = KERN_TYPE_MD5;
7320 dgst_size = DGST_SIZE_4_4;
7321 parse_func = md5_parse_hash;
7322 sort_by_digest = sort_by_digest_4_4;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_PRECOMPUTE_INIT
7325 | OPTI_TYPE_PRECOMPUTE_MERKLE
7326 | OPTI_TYPE_MEET_IN_MIDDLE
7327 | OPTI_TYPE_EARLY_SKIP
7328 | OPTI_TYPE_NOT_ITERATED
7329 | OPTI_TYPE_NOT_SALTED
7330 | OPTI_TYPE_RAW_HASH;
7331 dgst_pos0 = 0;
7332 dgst_pos1 = 3;
7333 dgst_pos2 = 2;
7334 dgst_pos3 = 1;
7335 break;
7336
7337 case 10: hash_type = HASH_TYPE_MD5;
7338 salt_type = SALT_TYPE_INTERN;
7339 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7340 opts_type = OPTS_TYPE_PT_GENERATE_LE
7341 | OPTS_TYPE_ST_ADD80
7342 | OPTS_TYPE_ST_ADDBITS14;
7343 kern_type = KERN_TYPE_MD5_PWSLT;
7344 dgst_size = DGST_SIZE_4_4;
7345 parse_func = md5s_parse_hash;
7346 sort_by_digest = sort_by_digest_4_4;
7347 opti_type = OPTI_TYPE_ZERO_BYTE
7348 | OPTI_TYPE_PRECOMPUTE_INIT
7349 | OPTI_TYPE_PRECOMPUTE_MERKLE
7350 | OPTI_TYPE_MEET_IN_MIDDLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_APPENDED_SALT
7354 | OPTI_TYPE_RAW_HASH;
7355 dgst_pos0 = 0;
7356 dgst_pos1 = 3;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 11: hash_type = HASH_TYPE_MD5;
7362 salt_type = SALT_TYPE_INTERN;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_LE
7365 | OPTS_TYPE_ST_ADD80
7366 | OPTS_TYPE_ST_ADDBITS14;
7367 kern_type = KERN_TYPE_MD5_PWSLT;
7368 dgst_size = DGST_SIZE_4_4;
7369 parse_func = joomla_parse_hash;
7370 sort_by_digest = sort_by_digest_4_4;
7371 opti_type = OPTI_TYPE_ZERO_BYTE
7372 | OPTI_TYPE_PRECOMPUTE_INIT
7373 | OPTI_TYPE_PRECOMPUTE_MERKLE
7374 | OPTI_TYPE_MEET_IN_MIDDLE
7375 | OPTI_TYPE_EARLY_SKIP
7376 | OPTI_TYPE_NOT_ITERATED
7377 | OPTI_TYPE_APPENDED_SALT
7378 | OPTI_TYPE_RAW_HASH;
7379 dgst_pos0 = 0;
7380 dgst_pos1 = 3;
7381 dgst_pos2 = 2;
7382 dgst_pos3 = 1;
7383 break;
7384
7385 case 12: hash_type = HASH_TYPE_MD5;
7386 salt_type = SALT_TYPE_INTERN;
7387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7388 opts_type = OPTS_TYPE_PT_GENERATE_LE
7389 | OPTS_TYPE_ST_ADD80
7390 | OPTS_TYPE_ST_ADDBITS14;
7391 kern_type = KERN_TYPE_MD5_PWSLT;
7392 dgst_size = DGST_SIZE_4_4;
7393 parse_func = postgresql_parse_hash;
7394 sort_by_digest = sort_by_digest_4_4;
7395 opti_type = OPTI_TYPE_ZERO_BYTE
7396 | OPTI_TYPE_PRECOMPUTE_INIT
7397 | OPTI_TYPE_PRECOMPUTE_MERKLE
7398 | OPTI_TYPE_MEET_IN_MIDDLE
7399 | OPTI_TYPE_EARLY_SKIP
7400 | OPTI_TYPE_NOT_ITERATED
7401 | OPTI_TYPE_APPENDED_SALT
7402 | OPTI_TYPE_RAW_HASH;
7403 dgst_pos0 = 0;
7404 dgst_pos1 = 3;
7405 dgst_pos2 = 2;
7406 dgst_pos3 = 1;
7407 break;
7408
7409 case 20: hash_type = HASH_TYPE_MD5;
7410 salt_type = SALT_TYPE_INTERN;
7411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7412 opts_type = OPTS_TYPE_PT_GENERATE_LE
7413 | OPTS_TYPE_PT_ADD80
7414 | OPTS_TYPE_PT_ADDBITS14;
7415 kern_type = KERN_TYPE_MD5_SLTPW;
7416 dgst_size = DGST_SIZE_4_4;
7417 parse_func = md5s_parse_hash;
7418 sort_by_digest = sort_by_digest_4_4;
7419 opti_type = OPTI_TYPE_ZERO_BYTE
7420 | OPTI_TYPE_PRECOMPUTE_INIT
7421 | OPTI_TYPE_PRECOMPUTE_MERKLE
7422 | OPTI_TYPE_EARLY_SKIP
7423 | OPTI_TYPE_NOT_ITERATED
7424 | OPTI_TYPE_PREPENDED_SALT
7425 | OPTI_TYPE_RAW_HASH;
7426 dgst_pos0 = 0;
7427 dgst_pos1 = 3;
7428 dgst_pos2 = 2;
7429 dgst_pos3 = 1;
7430 break;
7431
7432 case 21: hash_type = HASH_TYPE_MD5;
7433 salt_type = SALT_TYPE_INTERN;
7434 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7435 opts_type = OPTS_TYPE_PT_GENERATE_LE
7436 | OPTS_TYPE_PT_ADD80
7437 | OPTS_TYPE_PT_ADDBITS14;
7438 kern_type = KERN_TYPE_MD5_SLTPW;
7439 dgst_size = DGST_SIZE_4_4;
7440 parse_func = osc_parse_hash;
7441 sort_by_digest = sort_by_digest_4_4;
7442 opti_type = OPTI_TYPE_ZERO_BYTE
7443 | OPTI_TYPE_PRECOMPUTE_INIT
7444 | OPTI_TYPE_PRECOMPUTE_MERKLE
7445 | OPTI_TYPE_EARLY_SKIP
7446 | OPTI_TYPE_NOT_ITERATED
7447 | OPTI_TYPE_PREPENDED_SALT
7448 | OPTI_TYPE_RAW_HASH;
7449 dgst_pos0 = 0;
7450 dgst_pos1 = 3;
7451 dgst_pos2 = 2;
7452 dgst_pos3 = 1;
7453 break;
7454
7455 case 22: hash_type = HASH_TYPE_MD5;
7456 salt_type = SALT_TYPE_EMBEDDED;
7457 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7458 opts_type = OPTS_TYPE_PT_GENERATE_LE
7459 | OPTS_TYPE_PT_ADD80
7460 | OPTS_TYPE_PT_ADDBITS14;
7461 kern_type = KERN_TYPE_MD5_SLTPW;
7462 dgst_size = DGST_SIZE_4_4;
7463 parse_func = netscreen_parse_hash;
7464 sort_by_digest = sort_by_digest_4_4;
7465 opti_type = OPTI_TYPE_ZERO_BYTE
7466 | OPTI_TYPE_PRECOMPUTE_INIT
7467 | OPTI_TYPE_PRECOMPUTE_MERKLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_PREPENDED_SALT
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 0;
7473 dgst_pos1 = 3;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 23: hash_type = HASH_TYPE_MD5;
7479 salt_type = SALT_TYPE_EMBEDDED;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_LE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS14;
7484 kern_type = KERN_TYPE_MD5_SLTPW;
7485 dgst_size = DGST_SIZE_4_4;
7486 parse_func = skype_parse_hash;
7487 sort_by_digest = sort_by_digest_4_4;
7488 opti_type = OPTI_TYPE_ZERO_BYTE
7489 | OPTI_TYPE_PRECOMPUTE_INIT
7490 | OPTI_TYPE_PRECOMPUTE_MERKLE
7491 | OPTI_TYPE_EARLY_SKIP
7492 | OPTI_TYPE_NOT_ITERATED
7493 | OPTI_TYPE_PREPENDED_SALT
7494 | OPTI_TYPE_RAW_HASH;
7495 dgst_pos0 = 0;
7496 dgst_pos1 = 3;
7497 dgst_pos2 = 2;
7498 dgst_pos3 = 1;
7499 break;
7500
7501 case 30: hash_type = HASH_TYPE_MD5;
7502 salt_type = SALT_TYPE_INTERN;
7503 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7504 opts_type = OPTS_TYPE_PT_GENERATE_LE
7505 | OPTS_TYPE_PT_UNICODE
7506 | OPTS_TYPE_ST_ADD80
7507 | OPTS_TYPE_ST_ADDBITS14;
7508 kern_type = KERN_TYPE_MD5_PWUSLT;
7509 dgst_size = DGST_SIZE_4_4;
7510 parse_func = md5s_parse_hash;
7511 sort_by_digest = sort_by_digest_4_4;
7512 opti_type = OPTI_TYPE_ZERO_BYTE
7513 | OPTI_TYPE_PRECOMPUTE_INIT
7514 | OPTI_TYPE_PRECOMPUTE_MERKLE
7515 | OPTI_TYPE_MEET_IN_MIDDLE
7516 | OPTI_TYPE_EARLY_SKIP
7517 | OPTI_TYPE_NOT_ITERATED
7518 | OPTI_TYPE_APPENDED_SALT
7519 | OPTI_TYPE_RAW_HASH;
7520 dgst_pos0 = 0;
7521 dgst_pos1 = 3;
7522 dgst_pos2 = 2;
7523 dgst_pos3 = 1;
7524 break;
7525
7526 case 40: hash_type = HASH_TYPE_MD5;
7527 salt_type = SALT_TYPE_INTERN;
7528 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7529 opts_type = OPTS_TYPE_PT_GENERATE_LE
7530 | OPTS_TYPE_PT_ADD80
7531 | OPTS_TYPE_PT_ADDBITS14
7532 | OPTS_TYPE_PT_UNICODE;
7533 kern_type = KERN_TYPE_MD5_SLTPWU;
7534 dgst_size = DGST_SIZE_4_4;
7535 parse_func = md5s_parse_hash;
7536 sort_by_digest = sort_by_digest_4_4;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_PRECOMPUTE_INIT
7539 | OPTI_TYPE_PRECOMPUTE_MERKLE
7540 | OPTI_TYPE_EARLY_SKIP
7541 | OPTI_TYPE_NOT_ITERATED
7542 | OPTI_TYPE_PREPENDED_SALT
7543 | OPTI_TYPE_RAW_HASH;
7544 dgst_pos0 = 0;
7545 dgst_pos1 = 3;
7546 dgst_pos2 = 2;
7547 dgst_pos3 = 1;
7548 break;
7549
7550 case 50: hash_type = HASH_TYPE_MD5;
7551 salt_type = SALT_TYPE_INTERN;
7552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7553 opts_type = OPTS_TYPE_PT_GENERATE_LE
7554 | OPTS_TYPE_ST_ADD80
7555 | OPTS_TYPE_ST_ADDBITS14;
7556 kern_type = KERN_TYPE_HMACMD5_PW;
7557 dgst_size = DGST_SIZE_4_4;
7558 parse_func = hmacmd5_parse_hash;
7559 sort_by_digest = sort_by_digest_4_4;
7560 opti_type = OPTI_TYPE_ZERO_BYTE
7561 | OPTI_TYPE_NOT_ITERATED;
7562 dgst_pos0 = 0;
7563 dgst_pos1 = 3;
7564 dgst_pos2 = 2;
7565 dgst_pos3 = 1;
7566 break;
7567
7568 case 60: hash_type = HASH_TYPE_MD5;
7569 salt_type = SALT_TYPE_INTERN;
7570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7571 opts_type = OPTS_TYPE_PT_GENERATE_LE
7572 | OPTS_TYPE_PT_ADD80
7573 | OPTS_TYPE_PT_ADDBITS14;
7574 kern_type = KERN_TYPE_HMACMD5_SLT;
7575 dgst_size = DGST_SIZE_4_4;
7576 parse_func = hmacmd5_parse_hash;
7577 sort_by_digest = sort_by_digest_4_4;
7578 opti_type = OPTI_TYPE_ZERO_BYTE
7579 | OPTI_TYPE_NOT_ITERATED;
7580 dgst_pos0 = 0;
7581 dgst_pos1 = 3;
7582 dgst_pos2 = 2;
7583 dgst_pos3 = 1;
7584 break;
7585
7586 case 100: hash_type = HASH_TYPE_SHA1;
7587 salt_type = SALT_TYPE_NONE;
7588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7589 opts_type = OPTS_TYPE_PT_GENERATE_BE
7590 | OPTS_TYPE_PT_ADD80
7591 | OPTS_TYPE_PT_ADDBITS15;
7592 kern_type = KERN_TYPE_SHA1;
7593 dgst_size = DGST_SIZE_4_5;
7594 parse_func = sha1_parse_hash;
7595 sort_by_digest = sort_by_digest_4_5;
7596 opti_type = OPTI_TYPE_ZERO_BYTE
7597 | OPTI_TYPE_PRECOMPUTE_INIT
7598 | OPTI_TYPE_PRECOMPUTE_MERKLE
7599 | OPTI_TYPE_EARLY_SKIP
7600 | OPTI_TYPE_NOT_ITERATED
7601 | OPTI_TYPE_NOT_SALTED
7602 | OPTI_TYPE_RAW_HASH;
7603 dgst_pos0 = 3;
7604 dgst_pos1 = 4;
7605 dgst_pos2 = 2;
7606 dgst_pos3 = 1;
7607 break;
7608
7609 case 101: hash_type = HASH_TYPE_SHA1;
7610 salt_type = SALT_TYPE_NONE;
7611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7612 opts_type = OPTS_TYPE_PT_GENERATE_BE
7613 | OPTS_TYPE_PT_ADD80
7614 | OPTS_TYPE_PT_ADDBITS15;
7615 kern_type = KERN_TYPE_SHA1;
7616 dgst_size = DGST_SIZE_4_5;
7617 parse_func = sha1b64_parse_hash;
7618 sort_by_digest = sort_by_digest_4_5;
7619 opti_type = OPTI_TYPE_ZERO_BYTE
7620 | OPTI_TYPE_PRECOMPUTE_INIT
7621 | OPTI_TYPE_PRECOMPUTE_MERKLE
7622 | OPTI_TYPE_EARLY_SKIP
7623 | OPTI_TYPE_NOT_ITERATED
7624 | OPTI_TYPE_NOT_SALTED
7625 | OPTI_TYPE_RAW_HASH;
7626 dgst_pos0 = 3;
7627 dgst_pos1 = 4;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 1;
7630 break;
7631
7632 case 110: hash_type = HASH_TYPE_SHA1;
7633 salt_type = SALT_TYPE_INTERN;
7634 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_BE
7636 | OPTS_TYPE_ST_ADD80
7637 | OPTS_TYPE_ST_ADDBITS15;
7638 kern_type = KERN_TYPE_SHA1_PWSLT;
7639 dgst_size = DGST_SIZE_4_5;
7640 parse_func = sha1s_parse_hash;
7641 sort_by_digest = sort_by_digest_4_5;
7642 opti_type = OPTI_TYPE_ZERO_BYTE
7643 | OPTI_TYPE_PRECOMPUTE_INIT
7644 | OPTI_TYPE_PRECOMPUTE_MERKLE
7645 | OPTI_TYPE_EARLY_SKIP
7646 | OPTI_TYPE_NOT_ITERATED
7647 | OPTI_TYPE_APPENDED_SALT
7648 | OPTI_TYPE_RAW_HASH;
7649 dgst_pos0 = 3;
7650 dgst_pos1 = 4;
7651 dgst_pos2 = 2;
7652 dgst_pos3 = 1;
7653 break;
7654
7655 case 111: hash_type = HASH_TYPE_SHA1;
7656 salt_type = SALT_TYPE_EMBEDDED;
7657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7658 opts_type = OPTS_TYPE_PT_GENERATE_BE
7659 | OPTS_TYPE_ST_ADD80
7660 | OPTS_TYPE_ST_ADDBITS15;
7661 kern_type = KERN_TYPE_SHA1_PWSLT;
7662 dgst_size = DGST_SIZE_4_5;
7663 parse_func = sha1b64s_parse_hash;
7664 sort_by_digest = sort_by_digest_4_5;
7665 opti_type = OPTI_TYPE_ZERO_BYTE
7666 | OPTI_TYPE_PRECOMPUTE_INIT
7667 | OPTI_TYPE_PRECOMPUTE_MERKLE
7668 | OPTI_TYPE_EARLY_SKIP
7669 | OPTI_TYPE_NOT_ITERATED
7670 | OPTI_TYPE_APPENDED_SALT
7671 | OPTI_TYPE_RAW_HASH;
7672 dgst_pos0 = 3;
7673 dgst_pos1 = 4;
7674 dgst_pos2 = 2;
7675 dgst_pos3 = 1;
7676 break;
7677
7678 case 112: hash_type = HASH_TYPE_SHA1;
7679 salt_type = SALT_TYPE_INTERN;
7680 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7681 opts_type = OPTS_TYPE_PT_GENERATE_BE
7682 | OPTS_TYPE_ST_ADD80
7683 | OPTS_TYPE_ST_ADDBITS15
7684 | OPTS_TYPE_ST_HEX;
7685 kern_type = KERN_TYPE_SHA1_PWSLT;
7686 dgst_size = DGST_SIZE_4_5;
7687 parse_func = oracles_parse_hash;
7688 sort_by_digest = sort_by_digest_4_5;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_EARLY_SKIP
7693 | OPTI_TYPE_NOT_ITERATED
7694 | OPTI_TYPE_APPENDED_SALT
7695 | OPTI_TYPE_RAW_HASH;
7696 dgst_pos0 = 3;
7697 dgst_pos1 = 4;
7698 dgst_pos2 = 2;
7699 dgst_pos3 = 1;
7700 break;
7701
7702 case 120: hash_type = HASH_TYPE_SHA1;
7703 salt_type = SALT_TYPE_INTERN;
7704 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7705 opts_type = OPTS_TYPE_PT_GENERATE_BE
7706 | OPTS_TYPE_PT_ADD80
7707 | OPTS_TYPE_PT_ADDBITS15;
7708 kern_type = KERN_TYPE_SHA1_SLTPW;
7709 dgst_size = DGST_SIZE_4_5;
7710 parse_func = sha1s_parse_hash;
7711 sort_by_digest = sort_by_digest_4_5;
7712 opti_type = OPTI_TYPE_ZERO_BYTE
7713 | OPTI_TYPE_PRECOMPUTE_INIT
7714 | OPTI_TYPE_PRECOMPUTE_MERKLE
7715 | OPTI_TYPE_EARLY_SKIP
7716 | OPTI_TYPE_NOT_ITERATED
7717 | OPTI_TYPE_PREPENDED_SALT
7718 | OPTI_TYPE_RAW_HASH;
7719 dgst_pos0 = 3;
7720 dgst_pos1 = 4;
7721 dgst_pos2 = 2;
7722 dgst_pos3 = 1;
7723 break;
7724
7725 case 121: hash_type = HASH_TYPE_SHA1;
7726 salt_type = SALT_TYPE_INTERN;
7727 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7728 opts_type = OPTS_TYPE_PT_GENERATE_BE
7729 | OPTS_TYPE_PT_ADD80
7730 | OPTS_TYPE_PT_ADDBITS15
7731 | OPTS_TYPE_ST_LOWER;
7732 kern_type = KERN_TYPE_SHA1_SLTPW;
7733 dgst_size = DGST_SIZE_4_5;
7734 parse_func = smf_parse_hash;
7735 sort_by_digest = sort_by_digest_4_5;
7736 opti_type = OPTI_TYPE_ZERO_BYTE
7737 | OPTI_TYPE_PRECOMPUTE_INIT
7738 | OPTI_TYPE_PRECOMPUTE_MERKLE
7739 | OPTI_TYPE_EARLY_SKIP
7740 | OPTI_TYPE_NOT_ITERATED
7741 | OPTI_TYPE_PREPENDED_SALT
7742 | OPTI_TYPE_RAW_HASH;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 4;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 1;
7747 break;
7748
7749 case 122: hash_type = HASH_TYPE_SHA1;
7750 salt_type = SALT_TYPE_EMBEDDED;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15
7755 | OPTS_TYPE_ST_HEX;
7756 kern_type = KERN_TYPE_SHA1_SLTPW;
7757 dgst_size = DGST_SIZE_4_5;
7758 parse_func = osx1_parse_hash;
7759 sort_by_digest = sort_by_digest_4_5;
7760 opti_type = OPTI_TYPE_ZERO_BYTE
7761 | OPTI_TYPE_PRECOMPUTE_INIT
7762 | OPTI_TYPE_PRECOMPUTE_MERKLE
7763 | OPTI_TYPE_EARLY_SKIP
7764 | OPTI_TYPE_NOT_ITERATED
7765 | OPTI_TYPE_PREPENDED_SALT
7766 | OPTI_TYPE_RAW_HASH;
7767 dgst_pos0 = 3;
7768 dgst_pos1 = 4;
7769 dgst_pos2 = 2;
7770 dgst_pos3 = 1;
7771 break;
7772
7773 case 124: hash_type = HASH_TYPE_SHA1;
7774 salt_type = SALT_TYPE_EMBEDDED;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_PT_ADD80
7778 | OPTS_TYPE_PT_ADDBITS15;
7779 kern_type = KERN_TYPE_SHA1_SLTPW;
7780 dgst_size = DGST_SIZE_4_5;
7781 parse_func = djangosha1_parse_hash;
7782 sort_by_digest = sort_by_digest_4_5;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_PREPENDED_SALT
7789 | OPTI_TYPE_RAW_HASH;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 4;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 1;
7794 break;
7795
7796 case 125: hash_type = HASH_TYPE_SHA1;
7797 salt_type = SALT_TYPE_EMBEDDED;
7798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_BE
7800 | OPTS_TYPE_PT_ADD80
7801 | OPTS_TYPE_PT_ADDBITS15
7802 | OPTS_TYPE_ST_HEX;
7803 kern_type = KERN_TYPE_SHA1_SLTPW;
7804 dgst_size = DGST_SIZE_4_5;
7805 parse_func = arubaos_parse_hash;
7806 sort_by_digest = sort_by_digest_4_5;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_PREPENDED_SALT
7813 | OPTI_TYPE_RAW_HASH;
7814 dgst_pos0 = 3;
7815 dgst_pos1 = 4;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 1;
7818 break;
7819
7820 case 130: hash_type = HASH_TYPE_SHA1;
7821 salt_type = SALT_TYPE_INTERN;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_BE
7824 | OPTS_TYPE_PT_UNICODE
7825 | OPTS_TYPE_ST_ADD80
7826 | OPTS_TYPE_ST_ADDBITS15;
7827 kern_type = KERN_TYPE_SHA1_PWUSLT;
7828 dgst_size = DGST_SIZE_4_5;
7829 parse_func = sha1s_parse_hash;
7830 sort_by_digest = sort_by_digest_4_5;
7831 opti_type = OPTI_TYPE_ZERO_BYTE
7832 | OPTI_TYPE_PRECOMPUTE_INIT
7833 | OPTI_TYPE_PRECOMPUTE_MERKLE
7834 | OPTI_TYPE_EARLY_SKIP
7835 | OPTI_TYPE_NOT_ITERATED
7836 | OPTI_TYPE_APPENDED_SALT
7837 | OPTI_TYPE_RAW_HASH;
7838 dgst_pos0 = 3;
7839 dgst_pos1 = 4;
7840 dgst_pos2 = 2;
7841 dgst_pos3 = 1;
7842 break;
7843
7844 case 131: hash_type = HASH_TYPE_SHA1;
7845 salt_type = SALT_TYPE_EMBEDDED;
7846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7847 opts_type = OPTS_TYPE_PT_GENERATE_BE
7848 | OPTS_TYPE_PT_UNICODE
7849 | OPTS_TYPE_PT_UPPER
7850 | OPTS_TYPE_ST_ADD80
7851 | OPTS_TYPE_ST_ADDBITS15
7852 | OPTS_TYPE_ST_HEX;
7853 kern_type = KERN_TYPE_SHA1_PWUSLT;
7854 dgst_size = DGST_SIZE_4_5;
7855 parse_func = mssql2000_parse_hash;
7856 sort_by_digest = sort_by_digest_4_5;
7857 opti_type = OPTI_TYPE_ZERO_BYTE
7858 | OPTI_TYPE_PRECOMPUTE_INIT
7859 | OPTI_TYPE_PRECOMPUTE_MERKLE
7860 | OPTI_TYPE_EARLY_SKIP
7861 | OPTI_TYPE_NOT_ITERATED
7862 | OPTI_TYPE_APPENDED_SALT
7863 | OPTI_TYPE_RAW_HASH;
7864 dgst_pos0 = 3;
7865 dgst_pos1 = 4;
7866 dgst_pos2 = 2;
7867 dgst_pos3 = 1;
7868 break;
7869
7870 case 132: hash_type = HASH_TYPE_SHA1;
7871 salt_type = SALT_TYPE_EMBEDDED;
7872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7873 opts_type = OPTS_TYPE_PT_GENERATE_BE
7874 | OPTS_TYPE_PT_UNICODE
7875 | OPTS_TYPE_ST_ADD80
7876 | OPTS_TYPE_ST_ADDBITS15
7877 | OPTS_TYPE_ST_HEX;
7878 kern_type = KERN_TYPE_SHA1_PWUSLT;
7879 dgst_size = DGST_SIZE_4_5;
7880 parse_func = mssql2005_parse_hash;
7881 sort_by_digest = sort_by_digest_4_5;
7882 opti_type = OPTI_TYPE_ZERO_BYTE
7883 | OPTI_TYPE_PRECOMPUTE_INIT
7884 | OPTI_TYPE_PRECOMPUTE_MERKLE
7885 | OPTI_TYPE_EARLY_SKIP
7886 | OPTI_TYPE_NOT_ITERATED
7887 | OPTI_TYPE_APPENDED_SALT
7888 | OPTI_TYPE_RAW_HASH;
7889 dgst_pos0 = 3;
7890 dgst_pos1 = 4;
7891 dgst_pos2 = 2;
7892 dgst_pos3 = 1;
7893 break;
7894
7895 case 133: hash_type = HASH_TYPE_SHA1;
7896 salt_type = SALT_TYPE_EMBEDDED;
7897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7898 opts_type = OPTS_TYPE_PT_GENERATE_BE
7899 | OPTS_TYPE_PT_UNICODE
7900 | OPTS_TYPE_ST_ADD80
7901 | OPTS_TYPE_ST_ADDBITS15;
7902 kern_type = KERN_TYPE_SHA1_PWUSLT;
7903 dgst_size = DGST_SIZE_4_5;
7904 parse_func = peoplesoft_parse_hash;
7905 sort_by_digest = sort_by_digest_4_5;
7906 opti_type = OPTI_TYPE_ZERO_BYTE
7907 | OPTI_TYPE_PRECOMPUTE_INIT
7908 | OPTI_TYPE_PRECOMPUTE_MERKLE
7909 | OPTI_TYPE_EARLY_SKIP
7910 | OPTI_TYPE_NOT_ITERATED
7911 | OPTI_TYPE_APPENDED_SALT
7912 | OPTI_TYPE_RAW_HASH;
7913 dgst_pos0 = 3;
7914 dgst_pos1 = 4;
7915 dgst_pos2 = 2;
7916 dgst_pos3 = 1;
7917 break;
7918
7919 case 140: hash_type = HASH_TYPE_SHA1;
7920 salt_type = SALT_TYPE_INTERN;
7921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7922 opts_type = OPTS_TYPE_PT_GENERATE_BE
7923 | OPTS_TYPE_PT_ADD80
7924 | OPTS_TYPE_PT_ADDBITS15
7925 | OPTS_TYPE_PT_UNICODE;
7926 kern_type = KERN_TYPE_SHA1_SLTPWU;
7927 dgst_size = DGST_SIZE_4_5;
7928 parse_func = sha1s_parse_hash;
7929 sort_by_digest = sort_by_digest_4_5;
7930 opti_type = OPTI_TYPE_ZERO_BYTE
7931 | OPTI_TYPE_PRECOMPUTE_INIT
7932 | OPTI_TYPE_PRECOMPUTE_MERKLE
7933 | OPTI_TYPE_EARLY_SKIP
7934 | OPTI_TYPE_NOT_ITERATED
7935 | OPTI_TYPE_PREPENDED_SALT
7936 | OPTI_TYPE_RAW_HASH;
7937 dgst_pos0 = 3;
7938 dgst_pos1 = 4;
7939 dgst_pos2 = 2;
7940 dgst_pos3 = 1;
7941 break;
7942
7943 case 141: hash_type = HASH_TYPE_SHA1;
7944 salt_type = SALT_TYPE_EMBEDDED;
7945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7946 opts_type = OPTS_TYPE_PT_GENERATE_BE
7947 | OPTS_TYPE_PT_ADD80
7948 | OPTS_TYPE_PT_ADDBITS15
7949 | OPTS_TYPE_PT_UNICODE
7950 | OPTS_TYPE_ST_BASE64;
7951 kern_type = KERN_TYPE_SHA1_SLTPWU;
7952 dgst_size = DGST_SIZE_4_5;
7953 parse_func = episerver_parse_hash;
7954 sort_by_digest = sort_by_digest_4_5;
7955 opti_type = OPTI_TYPE_ZERO_BYTE
7956 | OPTI_TYPE_PRECOMPUTE_INIT
7957 | OPTI_TYPE_PRECOMPUTE_MERKLE
7958 | OPTI_TYPE_EARLY_SKIP
7959 | OPTI_TYPE_NOT_ITERATED
7960 | OPTI_TYPE_PREPENDED_SALT
7961 | OPTI_TYPE_RAW_HASH;
7962 dgst_pos0 = 3;
7963 dgst_pos1 = 4;
7964 dgst_pos2 = 2;
7965 dgst_pos3 = 1;
7966 break;
7967
7968 case 150: hash_type = HASH_TYPE_SHA1;
7969 salt_type = SALT_TYPE_INTERN;
7970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7971 opts_type = OPTS_TYPE_PT_GENERATE_BE
7972 | OPTS_TYPE_ST_ADD80
7973 | OPTS_TYPE_ST_ADDBITS15;
7974 kern_type = KERN_TYPE_HMACSHA1_PW;
7975 dgst_size = DGST_SIZE_4_5;
7976 parse_func = hmacsha1_parse_hash;
7977 sort_by_digest = sort_by_digest_4_5;
7978 opti_type = OPTI_TYPE_ZERO_BYTE
7979 | OPTI_TYPE_NOT_ITERATED;
7980 dgst_pos0 = 3;
7981 dgst_pos1 = 4;
7982 dgst_pos2 = 2;
7983 dgst_pos3 = 1;
7984 break;
7985
7986 case 160: hash_type = HASH_TYPE_SHA1;
7987 salt_type = SALT_TYPE_INTERN;
7988 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7989 opts_type = OPTS_TYPE_PT_GENERATE_BE
7990 | OPTS_TYPE_PT_ADD80
7991 | OPTS_TYPE_PT_ADDBITS15;
7992 kern_type = KERN_TYPE_HMACSHA1_SLT;
7993 dgst_size = DGST_SIZE_4_5;
7994 parse_func = hmacsha1_parse_hash;
7995 sort_by_digest = sort_by_digest_4_5;
7996 opti_type = OPTI_TYPE_ZERO_BYTE
7997 | OPTI_TYPE_NOT_ITERATED;
7998 dgst_pos0 = 3;
7999 dgst_pos1 = 4;
8000 dgst_pos2 = 2;
8001 dgst_pos3 = 1;
8002 break;
8003
8004 case 190: hash_type = HASH_TYPE_SHA1;
8005 salt_type = SALT_TYPE_NONE;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_PT_ADD80
8009 | OPTS_TYPE_PT_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA1_LINKEDIN;
8011 dgst_size = DGST_SIZE_4_5;
8012 parse_func = sha1linkedin_parse_hash;
8013 sort_by_digest = sort_by_digest_4_5;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_EARLY_SKIP
8017 | OPTI_TYPE_NOT_ITERATED
8018 | OPTI_TYPE_NOT_SALTED;
8019 dgst_pos0 = 0;
8020 dgst_pos1 = 4;
8021 dgst_pos2 = 3;
8022 dgst_pos3 = 2;
8023 break;
8024
8025 case 200: hash_type = HASH_TYPE_MYSQL;
8026 salt_type = SALT_TYPE_NONE;
8027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8028 opts_type = 0;
8029 kern_type = KERN_TYPE_MYSQL;
8030 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8031 parse_func = mysql323_parse_hash;
8032 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8033 opti_type = OPTI_TYPE_ZERO_BYTE;
8034 dgst_pos0 = 0;
8035 dgst_pos1 = 1;
8036 dgst_pos2 = 2;
8037 dgst_pos3 = 3;
8038 break;
8039
8040 case 300: hash_type = HASH_TYPE_SHA1;
8041 salt_type = SALT_TYPE_NONE;
8042 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8043 opts_type = OPTS_TYPE_PT_GENERATE_BE
8044 | OPTS_TYPE_PT_ADD80
8045 | OPTS_TYPE_PT_ADDBITS15;
8046 kern_type = KERN_TYPE_MYSQL41;
8047 dgst_size = DGST_SIZE_4_5;
8048 parse_func = sha1_parse_hash;
8049 sort_by_digest = sort_by_digest_4_5;
8050 opti_type = OPTI_TYPE_ZERO_BYTE
8051 | OPTI_TYPE_PRECOMPUTE_INIT
8052 | OPTI_TYPE_PRECOMPUTE_MERKLE
8053 | OPTI_TYPE_EARLY_SKIP
8054 | OPTI_TYPE_NOT_ITERATED
8055 | OPTI_TYPE_NOT_SALTED;
8056 dgst_pos0 = 3;
8057 dgst_pos1 = 4;
8058 dgst_pos2 = 2;
8059 dgst_pos3 = 1;
8060 break;
8061
8062 case 400: hash_type = HASH_TYPE_MD5;
8063 salt_type = SALT_TYPE_EMBEDDED;
8064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8066 kern_type = KERN_TYPE_PHPASS;
8067 dgst_size = DGST_SIZE_4_4;
8068 parse_func = phpass_parse_hash;
8069 sort_by_digest = sort_by_digest_4_4;
8070 opti_type = OPTI_TYPE_ZERO_BYTE
8071 | OPTI_TYPE_SLOW_HASH_SIMD;
8072 dgst_pos0 = 0;
8073 dgst_pos1 = 1;
8074 dgst_pos2 = 2;
8075 dgst_pos3 = 3;
8076 break;
8077
8078 case 500: hash_type = HASH_TYPE_MD5;
8079 salt_type = SALT_TYPE_EMBEDDED;
8080 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8081 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8082 kern_type = KERN_TYPE_MD5CRYPT;
8083 dgst_size = DGST_SIZE_4_4;
8084 parse_func = md5crypt_parse_hash;
8085 sort_by_digest = sort_by_digest_4_4;
8086 opti_type = OPTI_TYPE_ZERO_BYTE;
8087 dgst_pos0 = 0;
8088 dgst_pos1 = 1;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 3;
8091 break;
8092
8093 case 501: hash_type = HASH_TYPE_MD5;
8094 salt_type = SALT_TYPE_EMBEDDED;
8095 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_LE
8097 | OPTS_TYPE_HASH_COPY;
8098 kern_type = KERN_TYPE_MD5CRYPT;
8099 dgst_size = DGST_SIZE_4_4;
8100 parse_func = juniper_parse_hash;
8101 sort_by_digest = sort_by_digest_4_4;
8102 opti_type = OPTI_TYPE_ZERO_BYTE;
8103 dgst_pos0 = 0;
8104 dgst_pos1 = 1;
8105 dgst_pos2 = 2;
8106 dgst_pos3 = 3;
8107 break;
8108
8109 case 900: hash_type = HASH_TYPE_MD4;
8110 salt_type = SALT_TYPE_NONE;
8111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8112 opts_type = OPTS_TYPE_PT_GENERATE_LE
8113 | OPTS_TYPE_PT_ADD80
8114 | OPTS_TYPE_PT_ADDBITS14;
8115 kern_type = KERN_TYPE_MD4;
8116 dgst_size = DGST_SIZE_4_4;
8117 parse_func = md4_parse_hash;
8118 sort_by_digest = sort_by_digest_4_4;
8119 opti_type = OPTI_TYPE_ZERO_BYTE
8120 | OPTI_TYPE_PRECOMPUTE_INIT
8121 | OPTI_TYPE_PRECOMPUTE_MERKLE
8122 | OPTI_TYPE_MEET_IN_MIDDLE
8123 | OPTI_TYPE_EARLY_SKIP
8124 | OPTI_TYPE_NOT_ITERATED
8125 | OPTI_TYPE_NOT_SALTED
8126 | OPTI_TYPE_RAW_HASH;
8127 dgst_pos0 = 0;
8128 dgst_pos1 = 3;
8129 dgst_pos2 = 2;
8130 dgst_pos3 = 1;
8131 break;
8132
8133 case 1000: hash_type = HASH_TYPE_MD4;
8134 salt_type = SALT_TYPE_NONE;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_LE
8137 | OPTS_TYPE_PT_ADD80
8138 | OPTS_TYPE_PT_ADDBITS14
8139 | OPTS_TYPE_PT_UNICODE;
8140 kern_type = KERN_TYPE_MD4_PWU;
8141 dgst_size = DGST_SIZE_4_4;
8142 parse_func = md4_parse_hash;
8143 sort_by_digest = sort_by_digest_4_4;
8144 opti_type = OPTI_TYPE_ZERO_BYTE
8145 | OPTI_TYPE_PRECOMPUTE_INIT
8146 | OPTI_TYPE_PRECOMPUTE_MERKLE
8147 | OPTI_TYPE_MEET_IN_MIDDLE
8148 | OPTI_TYPE_EARLY_SKIP
8149 | OPTI_TYPE_NOT_ITERATED
8150 | OPTI_TYPE_NOT_SALTED
8151 | OPTI_TYPE_RAW_HASH;
8152 dgst_pos0 = 0;
8153 dgst_pos1 = 3;
8154 dgst_pos2 = 2;
8155 dgst_pos3 = 1;
8156 break;
8157
8158 case 1100: hash_type = HASH_TYPE_MD4;
8159 salt_type = SALT_TYPE_INTERN;
8160 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8161 opts_type = OPTS_TYPE_PT_GENERATE_LE
8162 | OPTS_TYPE_PT_ADD80
8163 | OPTS_TYPE_PT_ADDBITS14
8164 | OPTS_TYPE_PT_UNICODE
8165 | OPTS_TYPE_ST_ADD80
8166 | OPTS_TYPE_ST_UNICODE
8167 | OPTS_TYPE_ST_LOWER;
8168 kern_type = KERN_TYPE_MD44_PWUSLT;
8169 dgst_size = DGST_SIZE_4_4;
8170 parse_func = dcc_parse_hash;
8171 sort_by_digest = sort_by_digest_4_4;
8172 opti_type = OPTI_TYPE_ZERO_BYTE
8173 | OPTI_TYPE_PRECOMPUTE_INIT
8174 | OPTI_TYPE_PRECOMPUTE_MERKLE
8175 | OPTI_TYPE_EARLY_SKIP
8176 | OPTI_TYPE_NOT_ITERATED;
8177 dgst_pos0 = 0;
8178 dgst_pos1 = 3;
8179 dgst_pos2 = 2;
8180 dgst_pos3 = 1;
8181 break;
8182
8183 case 1400: hash_type = HASH_TYPE_SHA256;
8184 salt_type = SALT_TYPE_NONE;
8185 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8186 opts_type = OPTS_TYPE_PT_GENERATE_BE
8187 | OPTS_TYPE_PT_ADD80
8188 | OPTS_TYPE_PT_ADDBITS15;
8189 kern_type = KERN_TYPE_SHA256;
8190 dgst_size = DGST_SIZE_4_8;
8191 parse_func = sha256_parse_hash;
8192 sort_by_digest = sort_by_digest_4_8;
8193 opti_type = OPTI_TYPE_ZERO_BYTE
8194 | OPTI_TYPE_PRECOMPUTE_INIT
8195 | OPTI_TYPE_PRECOMPUTE_MERKLE
8196 | OPTI_TYPE_EARLY_SKIP
8197 | OPTI_TYPE_NOT_ITERATED
8198 | OPTI_TYPE_NOT_SALTED
8199 | OPTI_TYPE_RAW_HASH;
8200 dgst_pos0 = 3;
8201 dgst_pos1 = 7;
8202 dgst_pos2 = 2;
8203 dgst_pos3 = 6;
8204 break;
8205
8206 case 1410: hash_type = HASH_TYPE_SHA256;
8207 salt_type = SALT_TYPE_INTERN;
8208 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8209 opts_type = OPTS_TYPE_PT_GENERATE_BE
8210 | OPTS_TYPE_ST_ADD80
8211 | OPTS_TYPE_ST_ADDBITS15;
8212 kern_type = KERN_TYPE_SHA256_PWSLT;
8213 dgst_size = DGST_SIZE_4_8;
8214 parse_func = sha256s_parse_hash;
8215 sort_by_digest = sort_by_digest_4_8;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_PRECOMPUTE_INIT
8218 | OPTI_TYPE_PRECOMPUTE_MERKLE
8219 | OPTI_TYPE_EARLY_SKIP
8220 | OPTI_TYPE_NOT_ITERATED
8221 | OPTI_TYPE_APPENDED_SALT
8222 | OPTI_TYPE_RAW_HASH;
8223 dgst_pos0 = 3;
8224 dgst_pos1 = 7;
8225 dgst_pos2 = 2;
8226 dgst_pos3 = 6;
8227 break;
8228
8229 case 1420: hash_type = HASH_TYPE_SHA256;
8230 salt_type = SALT_TYPE_INTERN;
8231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8232 opts_type = OPTS_TYPE_PT_GENERATE_BE
8233 | OPTS_TYPE_PT_ADD80
8234 | OPTS_TYPE_PT_ADDBITS15;
8235 kern_type = KERN_TYPE_SHA256_SLTPW;
8236 dgst_size = DGST_SIZE_4_8;
8237 parse_func = sha256s_parse_hash;
8238 sort_by_digest = sort_by_digest_4_8;
8239 opti_type = OPTI_TYPE_ZERO_BYTE
8240 | OPTI_TYPE_PRECOMPUTE_INIT
8241 | OPTI_TYPE_PRECOMPUTE_MERKLE
8242 | OPTI_TYPE_EARLY_SKIP
8243 | OPTI_TYPE_NOT_ITERATED
8244 | OPTI_TYPE_PREPENDED_SALT
8245 | OPTI_TYPE_RAW_HASH;
8246 dgst_pos0 = 3;
8247 dgst_pos1 = 7;
8248 dgst_pos2 = 2;
8249 dgst_pos3 = 6;
8250 break;
8251
8252 case 1421: hash_type = HASH_TYPE_SHA256;
8253 salt_type = SALT_TYPE_EMBEDDED;
8254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8255 opts_type = OPTS_TYPE_PT_GENERATE_BE
8256 | OPTS_TYPE_PT_ADD80
8257 | OPTS_TYPE_PT_ADDBITS15;
8258 kern_type = KERN_TYPE_SHA256_SLTPW;
8259 dgst_size = DGST_SIZE_4_8;
8260 parse_func = hmailserver_parse_hash;
8261 sort_by_digest = sort_by_digest_4_8;
8262 opti_type = OPTI_TYPE_ZERO_BYTE
8263 | OPTI_TYPE_PRECOMPUTE_INIT
8264 | OPTI_TYPE_PRECOMPUTE_MERKLE
8265 | OPTI_TYPE_EARLY_SKIP
8266 | OPTI_TYPE_NOT_ITERATED
8267 | OPTI_TYPE_PREPENDED_SALT
8268 | OPTI_TYPE_RAW_HASH;
8269 dgst_pos0 = 3;
8270 dgst_pos1 = 7;
8271 dgst_pos2 = 2;
8272 dgst_pos3 = 6;
8273 break;
8274
8275 case 1430: hash_type = HASH_TYPE_SHA256;
8276 salt_type = SALT_TYPE_INTERN;
8277 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8278 opts_type = OPTS_TYPE_PT_GENERATE_BE
8279 | OPTS_TYPE_PT_UNICODE
8280 | OPTS_TYPE_ST_ADD80
8281 | OPTS_TYPE_ST_ADDBITS15;
8282 kern_type = KERN_TYPE_SHA256_PWUSLT;
8283 dgst_size = DGST_SIZE_4_8;
8284 parse_func = sha256s_parse_hash;
8285 sort_by_digest = sort_by_digest_4_8;
8286 opti_type = OPTI_TYPE_ZERO_BYTE
8287 | OPTI_TYPE_PRECOMPUTE_INIT
8288 | OPTI_TYPE_PRECOMPUTE_MERKLE
8289 | OPTI_TYPE_EARLY_SKIP
8290 | OPTI_TYPE_NOT_ITERATED
8291 | OPTI_TYPE_APPENDED_SALT
8292 | OPTI_TYPE_RAW_HASH;
8293 dgst_pos0 = 3;
8294 dgst_pos1 = 7;
8295 dgst_pos2 = 2;
8296 dgst_pos3 = 6;
8297 break;
8298
8299 case 1440: hash_type = HASH_TYPE_SHA256;
8300 salt_type = SALT_TYPE_INTERN;
8301 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8302 opts_type = OPTS_TYPE_PT_GENERATE_BE
8303 | OPTS_TYPE_PT_ADD80
8304 | OPTS_TYPE_PT_ADDBITS15
8305 | OPTS_TYPE_PT_UNICODE;
8306 kern_type = KERN_TYPE_SHA256_SLTPWU;
8307 dgst_size = DGST_SIZE_4_8;
8308 parse_func = sha256s_parse_hash;
8309 sort_by_digest = sort_by_digest_4_8;
8310 opti_type = OPTI_TYPE_ZERO_BYTE
8311 | OPTI_TYPE_PRECOMPUTE_INIT
8312 | OPTI_TYPE_PRECOMPUTE_MERKLE
8313 | OPTI_TYPE_EARLY_SKIP
8314 | OPTI_TYPE_NOT_ITERATED
8315 | OPTI_TYPE_PREPENDED_SALT
8316 | OPTI_TYPE_RAW_HASH;
8317 dgst_pos0 = 3;
8318 dgst_pos1 = 7;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 6;
8321 break;
8322
8323 case 1441: hash_type = HASH_TYPE_SHA256;
8324 salt_type = SALT_TYPE_EMBEDDED;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_BE
8327 | OPTS_TYPE_PT_ADD80
8328 | OPTS_TYPE_PT_ADDBITS15
8329 | OPTS_TYPE_PT_UNICODE
8330 | OPTS_TYPE_ST_BASE64;
8331 kern_type = KERN_TYPE_SHA256_SLTPWU;
8332 dgst_size = DGST_SIZE_4_8;
8333 parse_func = episerver4_parse_hash;
8334 sort_by_digest = sort_by_digest_4_8;
8335 opti_type = OPTI_TYPE_ZERO_BYTE
8336 | OPTI_TYPE_PRECOMPUTE_INIT
8337 | OPTI_TYPE_PRECOMPUTE_MERKLE
8338 | OPTI_TYPE_EARLY_SKIP
8339 | OPTI_TYPE_NOT_ITERATED
8340 | OPTI_TYPE_PREPENDED_SALT
8341 | OPTI_TYPE_RAW_HASH;
8342 dgst_pos0 = 3;
8343 dgst_pos1 = 7;
8344 dgst_pos2 = 2;
8345 dgst_pos3 = 6;
8346 break;
8347
8348 case 1450: hash_type = HASH_TYPE_SHA256;
8349 salt_type = SALT_TYPE_INTERN;
8350 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8351 opts_type = OPTS_TYPE_PT_GENERATE_BE
8352 | OPTS_TYPE_ST_ADD80;
8353 kern_type = KERN_TYPE_HMACSHA256_PW;
8354 dgst_size = DGST_SIZE_4_8;
8355 parse_func = hmacsha256_parse_hash;
8356 sort_by_digest = sort_by_digest_4_8;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_NOT_ITERATED;
8359 dgst_pos0 = 3;
8360 dgst_pos1 = 7;
8361 dgst_pos2 = 2;
8362 dgst_pos3 = 6;
8363 break;
8364
8365 case 1460: hash_type = HASH_TYPE_SHA256;
8366 salt_type = SALT_TYPE_INTERN;
8367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8368 opts_type = OPTS_TYPE_PT_GENERATE_BE
8369 | OPTS_TYPE_PT_ADD80
8370 | OPTS_TYPE_PT_ADDBITS15;
8371 kern_type = KERN_TYPE_HMACSHA256_SLT;
8372 dgst_size = DGST_SIZE_4_8;
8373 parse_func = hmacsha256_parse_hash;
8374 sort_by_digest = sort_by_digest_4_8;
8375 opti_type = OPTI_TYPE_ZERO_BYTE
8376 | OPTI_TYPE_NOT_ITERATED;
8377 dgst_pos0 = 3;
8378 dgst_pos1 = 7;
8379 dgst_pos2 = 2;
8380 dgst_pos3 = 6;
8381 break;
8382
8383 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8384 salt_type = SALT_TYPE_EMBEDDED;
8385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8386 opts_type = OPTS_TYPE_PT_GENERATE_LE
8387 | OPTS_TYPE_PT_BITSLICE;
8388 kern_type = KERN_TYPE_DESCRYPT;
8389 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8390 parse_func = descrypt_parse_hash;
8391 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8392 opti_type = OPTI_TYPE_ZERO_BYTE
8393 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 1;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 3;
8398 break;
8399
8400 case 1600: hash_type = HASH_TYPE_MD5;
8401 salt_type = SALT_TYPE_EMBEDDED;
8402 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8404 kern_type = KERN_TYPE_APR1CRYPT;
8405 dgst_size = DGST_SIZE_4_4;
8406 parse_func = md5apr1_parse_hash;
8407 sort_by_digest = sort_by_digest_4_4;
8408 opti_type = OPTI_TYPE_ZERO_BYTE;
8409 dgst_pos0 = 0;
8410 dgst_pos1 = 1;
8411 dgst_pos2 = 2;
8412 dgst_pos3 = 3;
8413 break;
8414
8415 case 1700: hash_type = HASH_TYPE_SHA512;
8416 salt_type = SALT_TYPE_NONE;
8417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8418 opts_type = OPTS_TYPE_PT_GENERATE_BE
8419 | OPTS_TYPE_PT_ADD80
8420 | OPTS_TYPE_PT_ADDBITS15;
8421 kern_type = KERN_TYPE_SHA512;
8422 dgst_size = DGST_SIZE_8_8;
8423 parse_func = sha512_parse_hash;
8424 sort_by_digest = sort_by_digest_8_8;
8425 opti_type = OPTI_TYPE_ZERO_BYTE
8426 | OPTI_TYPE_PRECOMPUTE_INIT
8427 | OPTI_TYPE_PRECOMPUTE_MERKLE
8428 | OPTI_TYPE_EARLY_SKIP
8429 | OPTI_TYPE_NOT_ITERATED
8430 | OPTI_TYPE_NOT_SALTED
8431 | OPTI_TYPE_USES_BITS_64
8432 | OPTI_TYPE_RAW_HASH;
8433 dgst_pos0 = 14;
8434 dgst_pos1 = 15;
8435 dgst_pos2 = 6;
8436 dgst_pos3 = 7;
8437 break;
8438
8439 case 1710: hash_type = HASH_TYPE_SHA512;
8440 salt_type = SALT_TYPE_INTERN;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_BE
8443 | OPTS_TYPE_ST_ADD80
8444 | OPTS_TYPE_ST_ADDBITS15;
8445 kern_type = KERN_TYPE_SHA512_PWSLT;
8446 dgst_size = DGST_SIZE_8_8;
8447 parse_func = sha512s_parse_hash;
8448 sort_by_digest = sort_by_digest_8_8;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP
8453 | OPTI_TYPE_NOT_ITERATED
8454 | OPTI_TYPE_APPENDED_SALT
8455 | OPTI_TYPE_USES_BITS_64
8456 | OPTI_TYPE_RAW_HASH;
8457 dgst_pos0 = 14;
8458 dgst_pos1 = 15;
8459 dgst_pos2 = 6;
8460 dgst_pos3 = 7;
8461 break;
8462
8463 case 1711: hash_type = HASH_TYPE_SHA512;
8464 salt_type = SALT_TYPE_EMBEDDED;
8465 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8466 opts_type = OPTS_TYPE_PT_GENERATE_BE
8467 | OPTS_TYPE_ST_ADD80
8468 | OPTS_TYPE_ST_ADDBITS15;
8469 kern_type = KERN_TYPE_SHA512_PWSLT;
8470 dgst_size = DGST_SIZE_8_8;
8471 parse_func = sha512b64s_parse_hash;
8472 sort_by_digest = sort_by_digest_8_8;
8473 opti_type = OPTI_TYPE_ZERO_BYTE
8474 | OPTI_TYPE_PRECOMPUTE_INIT
8475 | OPTI_TYPE_PRECOMPUTE_MERKLE
8476 | OPTI_TYPE_EARLY_SKIP
8477 | OPTI_TYPE_NOT_ITERATED
8478 | OPTI_TYPE_APPENDED_SALT
8479 | OPTI_TYPE_USES_BITS_64
8480 | OPTI_TYPE_RAW_HASH;
8481 dgst_pos0 = 14;
8482 dgst_pos1 = 15;
8483 dgst_pos2 = 6;
8484 dgst_pos3 = 7;
8485 break;
8486
8487 case 1720: hash_type = HASH_TYPE_SHA512;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_BE
8491 | OPTS_TYPE_PT_ADD80
8492 | OPTS_TYPE_PT_ADDBITS15;
8493 kern_type = KERN_TYPE_SHA512_SLTPW;
8494 dgst_size = DGST_SIZE_8_8;
8495 parse_func = sha512s_parse_hash;
8496 sort_by_digest = sort_by_digest_8_8;
8497 opti_type = OPTI_TYPE_ZERO_BYTE
8498 | OPTI_TYPE_PRECOMPUTE_INIT
8499 | OPTI_TYPE_PRECOMPUTE_MERKLE
8500 | OPTI_TYPE_EARLY_SKIP
8501 | OPTI_TYPE_NOT_ITERATED
8502 | OPTI_TYPE_PREPENDED_SALT
8503 | OPTI_TYPE_USES_BITS_64
8504 | OPTI_TYPE_RAW_HASH;
8505 dgst_pos0 = 14;
8506 dgst_pos1 = 15;
8507 dgst_pos2 = 6;
8508 dgst_pos3 = 7;
8509 break;
8510
8511 case 1722: hash_type = HASH_TYPE_SHA512;
8512 salt_type = SALT_TYPE_EMBEDDED;
8513 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8514 opts_type = OPTS_TYPE_PT_GENERATE_BE
8515 | OPTS_TYPE_PT_ADD80
8516 | OPTS_TYPE_PT_ADDBITS15
8517 | OPTS_TYPE_ST_HEX;
8518 kern_type = KERN_TYPE_SHA512_SLTPW;
8519 dgst_size = DGST_SIZE_8_8;
8520 parse_func = osx512_parse_hash;
8521 sort_by_digest = sort_by_digest_8_8;
8522 opti_type = OPTI_TYPE_ZERO_BYTE
8523 | OPTI_TYPE_PRECOMPUTE_INIT
8524 | OPTI_TYPE_PRECOMPUTE_MERKLE
8525 | OPTI_TYPE_EARLY_SKIP
8526 | OPTI_TYPE_NOT_ITERATED
8527 | OPTI_TYPE_PREPENDED_SALT
8528 | OPTI_TYPE_USES_BITS_64
8529 | OPTI_TYPE_RAW_HASH;
8530 dgst_pos0 = 14;
8531 dgst_pos1 = 15;
8532 dgst_pos2 = 6;
8533 dgst_pos3 = 7;
8534 break;
8535
8536 case 1730: hash_type = HASH_TYPE_SHA512;
8537 salt_type = SALT_TYPE_INTERN;
8538 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8539 opts_type = OPTS_TYPE_PT_GENERATE_BE
8540 | OPTS_TYPE_PT_UNICODE
8541 | OPTS_TYPE_ST_ADD80
8542 | OPTS_TYPE_ST_ADDBITS15;
8543 kern_type = KERN_TYPE_SHA512_PWSLTU;
8544 dgst_size = DGST_SIZE_8_8;
8545 parse_func = sha512s_parse_hash;
8546 sort_by_digest = sort_by_digest_8_8;
8547 opti_type = OPTI_TYPE_ZERO_BYTE
8548 | OPTI_TYPE_PRECOMPUTE_INIT
8549 | OPTI_TYPE_PRECOMPUTE_MERKLE
8550 | OPTI_TYPE_EARLY_SKIP
8551 | OPTI_TYPE_NOT_ITERATED
8552 | OPTI_TYPE_APPENDED_SALT
8553 | OPTI_TYPE_USES_BITS_64
8554 | OPTI_TYPE_RAW_HASH;
8555 dgst_pos0 = 14;
8556 dgst_pos1 = 15;
8557 dgst_pos2 = 6;
8558 dgst_pos3 = 7;
8559 break;
8560
8561 case 1731: hash_type = HASH_TYPE_SHA512;
8562 salt_type = SALT_TYPE_EMBEDDED;
8563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8564 opts_type = OPTS_TYPE_PT_GENERATE_BE
8565 | OPTS_TYPE_PT_UNICODE
8566 | OPTS_TYPE_ST_ADD80
8567 | OPTS_TYPE_ST_ADDBITS15
8568 | OPTS_TYPE_ST_HEX;
8569 kern_type = KERN_TYPE_SHA512_PWSLTU;
8570 dgst_size = DGST_SIZE_8_8;
8571 parse_func = mssql2012_parse_hash;
8572 sort_by_digest = sort_by_digest_8_8;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_APPENDED_SALT
8579 | OPTI_TYPE_USES_BITS_64
8580 | OPTI_TYPE_RAW_HASH;
8581 dgst_pos0 = 14;
8582 dgst_pos1 = 15;
8583 dgst_pos2 = 6;
8584 dgst_pos3 = 7;
8585 break;
8586
8587 case 1740: hash_type = HASH_TYPE_SHA512;
8588 salt_type = SALT_TYPE_INTERN;
8589 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8590 opts_type = OPTS_TYPE_PT_GENERATE_BE
8591 | OPTS_TYPE_PT_ADD80
8592 | OPTS_TYPE_PT_ADDBITS15
8593 | OPTS_TYPE_PT_UNICODE;
8594 kern_type = KERN_TYPE_SHA512_SLTPWU;
8595 dgst_size = DGST_SIZE_8_8;
8596 parse_func = sha512s_parse_hash;
8597 sort_by_digest = sort_by_digest_8_8;
8598 opti_type = OPTI_TYPE_ZERO_BYTE
8599 | OPTI_TYPE_PRECOMPUTE_INIT
8600 | OPTI_TYPE_PRECOMPUTE_MERKLE
8601 | OPTI_TYPE_EARLY_SKIP
8602 | OPTI_TYPE_NOT_ITERATED
8603 | OPTI_TYPE_PREPENDED_SALT
8604 | OPTI_TYPE_USES_BITS_64
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 14;
8607 dgst_pos1 = 15;
8608 dgst_pos2 = 6;
8609 dgst_pos3 = 7;
8610 break;
8611
8612 case 1750: hash_type = HASH_TYPE_SHA512;
8613 salt_type = SALT_TYPE_INTERN;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_BE
8616 | OPTS_TYPE_ST_ADD80;
8617 kern_type = KERN_TYPE_HMACSHA512_PW;
8618 dgst_size = DGST_SIZE_8_8;
8619 parse_func = hmacsha512_parse_hash;
8620 sort_by_digest = sort_by_digest_8_8;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_USES_BITS_64
8623 | OPTI_TYPE_NOT_ITERATED;
8624 dgst_pos0 = 14;
8625 dgst_pos1 = 15;
8626 dgst_pos2 = 6;
8627 dgst_pos3 = 7;
8628 break;
8629
8630 case 1760: hash_type = HASH_TYPE_SHA512;
8631 salt_type = SALT_TYPE_INTERN;
8632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8633 opts_type = OPTS_TYPE_PT_GENERATE_BE
8634 | OPTS_TYPE_PT_ADD80
8635 | OPTS_TYPE_PT_ADDBITS15;
8636 kern_type = KERN_TYPE_HMACSHA512_SLT;
8637 dgst_size = DGST_SIZE_8_8;
8638 parse_func = hmacsha512_parse_hash;
8639 sort_by_digest = sort_by_digest_8_8;
8640 opti_type = OPTI_TYPE_ZERO_BYTE
8641 | OPTI_TYPE_USES_BITS_64
8642 | OPTI_TYPE_NOT_ITERATED;
8643 dgst_pos0 = 14;
8644 dgst_pos1 = 15;
8645 dgst_pos2 = 6;
8646 dgst_pos3 = 7;
8647 break;
8648
8649 case 1800: hash_type = HASH_TYPE_SHA512;
8650 salt_type = SALT_TYPE_EMBEDDED;
8651 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8652 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8653 kern_type = KERN_TYPE_SHA512CRYPT;
8654 dgst_size = DGST_SIZE_8_8;
8655 parse_func = sha512crypt_parse_hash;
8656 sort_by_digest = sort_by_digest_8_8;
8657 opti_type = OPTI_TYPE_ZERO_BYTE
8658 | OPTI_TYPE_USES_BITS_64;
8659 dgst_pos0 = 0;
8660 dgst_pos1 = 1;
8661 dgst_pos2 = 2;
8662 dgst_pos3 = 3;
8663 break;
8664
8665 case 2000: hash_type = HASH_TYPE_STDOUT;
8666 salt_type = SALT_TYPE_NONE;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8669 kern_type = 0;
8670 dgst_size = DGST_SIZE_4_4;
8671 parse_func = NULL;
8672 sort_by_digest = NULL;
8673 opti_type = 0;
8674 dgst_pos0 = 0;
8675 dgst_pos1 = 0;
8676 dgst_pos2 = 0;
8677 dgst_pos3 = 0;
8678 break;
8679
8680 case 2100: hash_type = HASH_TYPE_DCC2;
8681 salt_type = SALT_TYPE_EMBEDDED;
8682 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8683 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8684 | OPTS_TYPE_ST_LOWER
8685 | OPTS_TYPE_ST_UNICODE;
8686 kern_type = KERN_TYPE_DCC2;
8687 dgst_size = DGST_SIZE_4_4;
8688 parse_func = dcc2_parse_hash;
8689 sort_by_digest = sort_by_digest_4_4;
8690 opti_type = OPTI_TYPE_ZERO_BYTE
8691 | OPTI_TYPE_SLOW_HASH_SIMD;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 2400: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_NONE;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8702 kern_type = KERN_TYPE_MD5PIX;
8703 dgst_size = DGST_SIZE_4_4;
8704 parse_func = md5pix_parse_hash;
8705 sort_by_digest = sort_by_digest_4_4;
8706 opti_type = OPTI_TYPE_ZERO_BYTE
8707 | OPTI_TYPE_PRECOMPUTE_INIT
8708 | OPTI_TYPE_PRECOMPUTE_MERKLE
8709 | OPTI_TYPE_EARLY_SKIP
8710 | OPTI_TYPE_NOT_ITERATED
8711 | OPTI_TYPE_NOT_SALTED;
8712 dgst_pos0 = 0;
8713 dgst_pos1 = 3;
8714 dgst_pos2 = 2;
8715 dgst_pos3 = 1;
8716 break;
8717
8718 case 2410: hash_type = HASH_TYPE_MD5;
8719 salt_type = SALT_TYPE_INTERN;
8720 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8721 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8722 kern_type = KERN_TYPE_MD5ASA;
8723 dgst_size = DGST_SIZE_4_4;
8724 parse_func = md5asa_parse_hash;
8725 sort_by_digest = sort_by_digest_4_4;
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 dgst_pos0 = 0;
8732 dgst_pos1 = 3;
8733 dgst_pos2 = 2;
8734 dgst_pos3 = 1;
8735 break;
8736
8737 case 2500: hash_type = HASH_TYPE_WPA;
8738 salt_type = SALT_TYPE_EMBEDDED;
8739 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8740 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8741 kern_type = KERN_TYPE_WPA;
8742 dgst_size = DGST_SIZE_4_4;
8743 parse_func = wpa_parse_hash;
8744 sort_by_digest = sort_by_digest_4_4;
8745 opti_type = OPTI_TYPE_ZERO_BYTE
8746 | OPTI_TYPE_SLOW_HASH_SIMD;
8747 dgst_pos0 = 0;
8748 dgst_pos1 = 1;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 3;
8751 break;
8752
8753 case 2600: hash_type = HASH_TYPE_MD5;
8754 salt_type = SALT_TYPE_VIRTUAL;
8755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE
8757 | OPTS_TYPE_PT_ADD80
8758 | OPTS_TYPE_PT_ADDBITS14
8759 | OPTS_TYPE_ST_ADD80;
8760 kern_type = KERN_TYPE_MD55_PWSLT1;
8761 dgst_size = DGST_SIZE_4_4;
8762 parse_func = md5md5_parse_hash;
8763 sort_by_digest = sort_by_digest_4_4;
8764 opti_type = OPTI_TYPE_ZERO_BYTE
8765 | OPTI_TYPE_PRECOMPUTE_INIT
8766 | OPTI_TYPE_PRECOMPUTE_MERKLE
8767 | OPTI_TYPE_EARLY_SKIP;
8768 dgst_pos0 = 0;
8769 dgst_pos1 = 3;
8770 dgst_pos2 = 2;
8771 dgst_pos3 = 1;
8772 break;
8773
8774 case 2611: hash_type = HASH_TYPE_MD5;
8775 salt_type = SALT_TYPE_INTERN;
8776 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8777 opts_type = OPTS_TYPE_PT_GENERATE_LE
8778 | OPTS_TYPE_PT_ADD80
8779 | OPTS_TYPE_PT_ADDBITS14
8780 | OPTS_TYPE_ST_ADD80;
8781 kern_type = KERN_TYPE_MD55_PWSLT1;
8782 dgst_size = DGST_SIZE_4_4;
8783 parse_func = vb3_parse_hash;
8784 sort_by_digest = sort_by_digest_4_4;
8785 opti_type = OPTI_TYPE_ZERO_BYTE
8786 | OPTI_TYPE_PRECOMPUTE_INIT
8787 | OPTI_TYPE_PRECOMPUTE_MERKLE
8788 | OPTI_TYPE_EARLY_SKIP;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 3;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 1;
8793 break;
8794
8795 case 2612: hash_type = HASH_TYPE_MD5;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE
8799 | OPTS_TYPE_PT_ADD80
8800 | OPTS_TYPE_PT_ADDBITS14
8801 | OPTS_TYPE_ST_ADD80
8802 | OPTS_TYPE_ST_HEX;
8803 kern_type = KERN_TYPE_MD55_PWSLT1;
8804 dgst_size = DGST_SIZE_4_4;
8805 parse_func = phps_parse_hash;
8806 sort_by_digest = sort_by_digest_4_4;
8807 opti_type = OPTI_TYPE_ZERO_BYTE
8808 | OPTI_TYPE_PRECOMPUTE_INIT
8809 | OPTI_TYPE_PRECOMPUTE_MERKLE
8810 | OPTI_TYPE_EARLY_SKIP;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 3;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 1;
8815 break;
8816
8817 case 2711: hash_type = HASH_TYPE_MD5;
8818 salt_type = SALT_TYPE_INTERN;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_LE
8821 | OPTS_TYPE_PT_ADD80
8822 | OPTS_TYPE_PT_ADDBITS14
8823 | OPTS_TYPE_ST_ADD80;
8824 kern_type = KERN_TYPE_MD55_PWSLT2;
8825 dgst_size = DGST_SIZE_4_4;
8826 parse_func = vb30_parse_hash;
8827 sort_by_digest = sort_by_digest_4_4;
8828 opti_type = OPTI_TYPE_ZERO_BYTE
8829 | OPTI_TYPE_PRECOMPUTE_INIT
8830 | OPTI_TYPE_EARLY_SKIP;
8831 dgst_pos0 = 0;
8832 dgst_pos1 = 3;
8833 dgst_pos2 = 2;
8834 dgst_pos3 = 1;
8835 break;
8836
8837 case 2811: hash_type = HASH_TYPE_MD5;
8838 salt_type = SALT_TYPE_INTERN;
8839 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8840 opts_type = OPTS_TYPE_PT_GENERATE_LE
8841 | OPTS_TYPE_PT_ADD80
8842 | OPTS_TYPE_PT_ADDBITS14;
8843 kern_type = KERN_TYPE_MD55_SLTPW;
8844 dgst_size = DGST_SIZE_4_4;
8845 parse_func = ipb2_parse_hash;
8846 sort_by_digest = sort_by_digest_4_4;
8847 opti_type = OPTI_TYPE_ZERO_BYTE
8848 | OPTI_TYPE_PRECOMPUTE_INIT
8849 | OPTI_TYPE_EARLY_SKIP;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 3;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 1;
8854 break;
8855
8856 case 3000: hash_type = HASH_TYPE_LM;
8857 salt_type = SALT_TYPE_NONE;
8858 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE
8860 | OPTS_TYPE_PT_UPPER
8861 | OPTS_TYPE_PT_BITSLICE;
8862 kern_type = KERN_TYPE_LM;
8863 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8864 parse_func = lm_parse_hash;
8865 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8866 opti_type = OPTI_TYPE_ZERO_BYTE
8867 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 3100: hash_type = HASH_TYPE_ORACLEH;
8875 salt_type = SALT_TYPE_INTERN;
8876 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE
8878 | OPTS_TYPE_PT_UPPER
8879 | OPTS_TYPE_ST_UPPER;
8880 kern_type = KERN_TYPE_ORACLEH;
8881 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8882 parse_func = oracleh_parse_hash;
8883 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8884 opti_type = OPTI_TYPE_ZERO_BYTE;
8885 dgst_pos0 = 0;
8886 dgst_pos1 = 1;
8887 dgst_pos2 = 2;
8888 dgst_pos3 = 3;
8889 break;
8890
8891 case 3200: hash_type = HASH_TYPE_BCRYPT;
8892 salt_type = SALT_TYPE_EMBEDDED;
8893 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8894 opts_type = OPTS_TYPE_PT_GENERATE_LE
8895 | OPTS_TYPE_ST_GENERATE_LE;
8896 kern_type = KERN_TYPE_BCRYPT;
8897 dgst_size = DGST_SIZE_4_6;
8898 parse_func = bcrypt_parse_hash;
8899 sort_by_digest = sort_by_digest_4_6;
8900 opti_type = OPTI_TYPE_ZERO_BYTE;
8901 dgst_pos0 = 0;
8902 dgst_pos1 = 1;
8903 dgst_pos2 = 2;
8904 dgst_pos3 = 3;
8905 break;
8906
8907 case 3710: hash_type = HASH_TYPE_MD5;
8908 salt_type = SALT_TYPE_INTERN;
8909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8910 opts_type = OPTS_TYPE_PT_GENERATE_LE
8911 | OPTS_TYPE_PT_ADD80
8912 | OPTS_TYPE_PT_ADDBITS14;
8913 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8914 dgst_size = DGST_SIZE_4_4;
8915 parse_func = md5s_parse_hash;
8916 sort_by_digest = sort_by_digest_4_4;
8917 opti_type = OPTI_TYPE_ZERO_BYTE
8918 | OPTI_TYPE_PRECOMPUTE_INIT
8919 | OPTI_TYPE_PRECOMPUTE_MERKLE
8920 | OPTI_TYPE_EARLY_SKIP;
8921 dgst_pos0 = 0;
8922 dgst_pos1 = 3;
8923 dgst_pos2 = 2;
8924 dgst_pos3 = 1;
8925 break;
8926
8927 case 3711: hash_type = HASH_TYPE_MD5;
8928 salt_type = SALT_TYPE_EMBEDDED;
8929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8930 opts_type = OPTS_TYPE_PT_GENERATE_LE
8931 | OPTS_TYPE_PT_ADD80
8932 | OPTS_TYPE_PT_ADDBITS14;
8933 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8934 dgst_size = DGST_SIZE_4_4;
8935 parse_func = mediawiki_b_parse_hash;
8936 sort_by_digest = sort_by_digest_4_4;
8937 opti_type = OPTI_TYPE_ZERO_BYTE
8938 | OPTI_TYPE_PRECOMPUTE_INIT
8939 | OPTI_TYPE_PRECOMPUTE_MERKLE
8940 | OPTI_TYPE_EARLY_SKIP;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 3;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 1;
8945 break;
8946
8947 case 3800: hash_type = HASH_TYPE_MD5;
8948 salt_type = SALT_TYPE_INTERN;
8949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE
8951 | OPTS_TYPE_ST_ADDBITS14;
8952 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8953 dgst_size = DGST_SIZE_4_4;
8954 parse_func = md5s_parse_hash;
8955 sort_by_digest = sort_by_digest_4_4;
8956 opti_type = OPTI_TYPE_ZERO_BYTE
8957 | OPTI_TYPE_PRECOMPUTE_INIT
8958 | OPTI_TYPE_PRECOMPUTE_MERKLE
8959 | OPTI_TYPE_EARLY_SKIP
8960 | OPTI_TYPE_NOT_ITERATED
8961 | OPTI_TYPE_RAW_HASH;
8962 dgst_pos0 = 0;
8963 dgst_pos1 = 3;
8964 dgst_pos2 = 2;
8965 dgst_pos3 = 1;
8966 break;
8967
8968 case 4300: hash_type = HASH_TYPE_MD5;
8969 salt_type = SALT_TYPE_VIRTUAL;
8970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8971 opts_type = OPTS_TYPE_PT_GENERATE_LE
8972 | OPTS_TYPE_PT_ADD80
8973 | OPTS_TYPE_PT_ADDBITS14
8974 | OPTS_TYPE_ST_ADD80;
8975 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8976 dgst_size = DGST_SIZE_4_4;
8977 parse_func = md5md5_parse_hash;
8978 sort_by_digest = sort_by_digest_4_4;
8979 opti_type = OPTI_TYPE_ZERO_BYTE
8980 | OPTI_TYPE_PRECOMPUTE_INIT
8981 | OPTI_TYPE_PRECOMPUTE_MERKLE
8982 | OPTI_TYPE_EARLY_SKIP;
8983 dgst_pos0 = 0;
8984 dgst_pos1 = 3;
8985 dgst_pos2 = 2;
8986 dgst_pos3 = 1;
8987 break;
8988
8989
8990 case 4400: hash_type = HASH_TYPE_MD5;
8991 salt_type = SALT_TYPE_NONE;
8992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8993 opts_type = OPTS_TYPE_PT_GENERATE_BE
8994 | OPTS_TYPE_PT_ADD80
8995 | OPTS_TYPE_PT_ADDBITS15;
8996 kern_type = KERN_TYPE_MD5_SHA1;
8997 dgst_size = DGST_SIZE_4_4;
8998 parse_func = md5_parse_hash;
8999 sort_by_digest = sort_by_digest_4_4;
9000 opti_type = OPTI_TYPE_ZERO_BYTE
9001 | OPTI_TYPE_PRECOMPUTE_INIT
9002 | OPTI_TYPE_PRECOMPUTE_MERKLE
9003 | OPTI_TYPE_EARLY_SKIP
9004 | OPTI_TYPE_NOT_ITERATED
9005 | OPTI_TYPE_NOT_SALTED
9006 | OPTI_TYPE_RAW_HASH;
9007 dgst_pos0 = 0;
9008 dgst_pos1 = 3;
9009 dgst_pos2 = 2;
9010 dgst_pos3 = 1;
9011 break;
9012
9013 case 4500: hash_type = HASH_TYPE_SHA1;
9014 salt_type = SALT_TYPE_NONE;
9015 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9016 opts_type = OPTS_TYPE_PT_GENERATE_BE
9017 | OPTS_TYPE_PT_ADD80
9018 | OPTS_TYPE_PT_ADDBITS15;
9019 kern_type = KERN_TYPE_SHA11;
9020 dgst_size = DGST_SIZE_4_5;
9021 parse_func = sha1_parse_hash;
9022 sort_by_digest = sort_by_digest_4_5;
9023 opti_type = OPTI_TYPE_ZERO_BYTE
9024 | OPTI_TYPE_PRECOMPUTE_INIT
9025 | OPTI_TYPE_PRECOMPUTE_MERKLE
9026 | OPTI_TYPE_EARLY_SKIP
9027 | OPTI_TYPE_NOT_SALTED;
9028 dgst_pos0 = 3;
9029 dgst_pos1 = 4;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 1;
9032 break;
9033
9034 case 4700: hash_type = HASH_TYPE_SHA1;
9035 salt_type = SALT_TYPE_NONE;
9036 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE
9038 | OPTS_TYPE_PT_ADD80
9039 | OPTS_TYPE_PT_ADDBITS14;
9040 kern_type = KERN_TYPE_SHA1_MD5;
9041 dgst_size = DGST_SIZE_4_5;
9042 parse_func = sha1_parse_hash;
9043 sort_by_digest = sort_by_digest_4_5;
9044 opti_type = OPTI_TYPE_ZERO_BYTE
9045 | OPTI_TYPE_PRECOMPUTE_INIT
9046 | OPTI_TYPE_PRECOMPUTE_MERKLE
9047 | OPTI_TYPE_EARLY_SKIP
9048 | OPTI_TYPE_NOT_ITERATED
9049 | OPTI_TYPE_NOT_SALTED
9050 | OPTI_TYPE_RAW_HASH;
9051 dgst_pos0 = 3;
9052 dgst_pos1 = 4;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 1;
9055 break;
9056
9057 case 4800: hash_type = HASH_TYPE_MD5;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE
9061 | OPTS_TYPE_PT_ADDBITS14;
9062 kern_type = KERN_TYPE_MD5_CHAP;
9063 dgst_size = DGST_SIZE_4_4;
9064 parse_func = chap_parse_hash;
9065 sort_by_digest = sort_by_digest_4_4;
9066 opti_type = OPTI_TYPE_ZERO_BYTE
9067 | OPTI_TYPE_PRECOMPUTE_INIT
9068 | OPTI_TYPE_PRECOMPUTE_MERKLE
9069 | OPTI_TYPE_MEET_IN_MIDDLE
9070 | OPTI_TYPE_EARLY_SKIP
9071 | OPTI_TYPE_NOT_ITERATED
9072 | OPTI_TYPE_RAW_HASH;
9073 dgst_pos0 = 0;
9074 dgst_pos1 = 3;
9075 dgst_pos2 = 2;
9076 dgst_pos3 = 1;
9077 break;
9078
9079 case 4900: hash_type = HASH_TYPE_SHA1;
9080 salt_type = SALT_TYPE_INTERN;
9081 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9082 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9083 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
9084 dgst_size = DGST_SIZE_4_5;
9085 parse_func = sha1s_parse_hash;
9086 sort_by_digest = sort_by_digest_4_5;
9087 opti_type = OPTI_TYPE_ZERO_BYTE
9088 | OPTI_TYPE_PRECOMPUTE_INIT
9089 | OPTI_TYPE_PRECOMPUTE_MERKLE
9090 | OPTI_TYPE_EARLY_SKIP;
9091 dgst_pos0 = 3;
9092 dgst_pos1 = 4;
9093 dgst_pos2 = 2;
9094 dgst_pos3 = 1;
9095 break;
9096
9097 case 5000: hash_type = HASH_TYPE_KECCAK;
9098 salt_type = SALT_TYPE_EMBEDDED;
9099 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9100 opts_type = OPTS_TYPE_PT_GENERATE_LE
9101 | OPTS_TYPE_PT_ADD01;
9102 kern_type = KERN_TYPE_KECCAK;
9103 dgst_size = DGST_SIZE_8_25;
9104 parse_func = keccak_parse_hash;
9105 sort_by_digest = sort_by_digest_8_25;
9106 opti_type = OPTI_TYPE_ZERO_BYTE
9107 | OPTI_TYPE_USES_BITS_64
9108 | OPTI_TYPE_RAW_HASH;
9109 dgst_pos0 = 2;
9110 dgst_pos1 = 3;
9111 dgst_pos2 = 4;
9112 dgst_pos3 = 5;
9113 break;
9114
9115 case 5100: hash_type = HASH_TYPE_MD5H;
9116 salt_type = SALT_TYPE_NONE;
9117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9118 opts_type = OPTS_TYPE_PT_GENERATE_LE
9119 | OPTS_TYPE_PT_ADD80
9120 | OPTS_TYPE_PT_ADDBITS14;
9121 kern_type = KERN_TYPE_MD5H;
9122 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9123 parse_func = md5half_parse_hash;
9124 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9125 opti_type = OPTI_TYPE_ZERO_BYTE
9126 | OPTI_TYPE_RAW_HASH;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 5200: hash_type = HASH_TYPE_SHA256;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9137 kern_type = KERN_TYPE_PSAFE3;
9138 dgst_size = DGST_SIZE_4_8;
9139 parse_func = psafe3_parse_hash;
9140 sort_by_digest = sort_by_digest_4_8;
9141 opti_type = OPTI_TYPE_ZERO_BYTE;
9142 dgst_pos0 = 0;
9143 dgst_pos1 = 1;
9144 dgst_pos2 = 2;
9145 dgst_pos3 = 3;
9146 break;
9147
9148 case 5300: hash_type = HASH_TYPE_MD5;
9149 salt_type = SALT_TYPE_EMBEDDED;
9150 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9151 opts_type = OPTS_TYPE_PT_GENERATE_LE
9152 | OPTS_TYPE_ST_ADD80;
9153 kern_type = KERN_TYPE_IKEPSK_MD5;
9154 dgst_size = DGST_SIZE_4_4;
9155 parse_func = ikepsk_md5_parse_hash;
9156 sort_by_digest = sort_by_digest_4_4;
9157 opti_type = OPTI_TYPE_ZERO_BYTE;
9158 dgst_pos0 = 0;
9159 dgst_pos1 = 3;
9160 dgst_pos2 = 2;
9161 dgst_pos3 = 1;
9162 break;
9163
9164 case 5400: hash_type = HASH_TYPE_SHA1;
9165 salt_type = SALT_TYPE_EMBEDDED;
9166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9167 opts_type = OPTS_TYPE_PT_GENERATE_BE
9168 | OPTS_TYPE_ST_ADD80;
9169 kern_type = KERN_TYPE_IKEPSK_SHA1;
9170 dgst_size = DGST_SIZE_4_5;
9171 parse_func = ikepsk_sha1_parse_hash;
9172 sort_by_digest = sort_by_digest_4_5;
9173 opti_type = OPTI_TYPE_ZERO_BYTE;
9174 dgst_pos0 = 3;
9175 dgst_pos1 = 4;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 1;
9178 break;
9179
9180 case 5500: hash_type = HASH_TYPE_NETNTLM;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE
9184 | OPTS_TYPE_PT_ADD80
9185 | OPTS_TYPE_PT_ADDBITS14
9186 | OPTS_TYPE_PT_UNICODE
9187 | OPTS_TYPE_ST_HEX;
9188 kern_type = KERN_TYPE_NETNTLMv1;
9189 dgst_size = DGST_SIZE_4_4;
9190 parse_func = netntlmv1_parse_hash;
9191 sort_by_digest = sort_by_digest_4_4;
9192 opti_type = OPTI_TYPE_ZERO_BYTE
9193 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 5600: hash_type = HASH_TYPE_MD5;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE
9204 | OPTS_TYPE_PT_ADD80
9205 | OPTS_TYPE_PT_ADDBITS14
9206 | OPTS_TYPE_PT_UNICODE;
9207 kern_type = KERN_TYPE_NETNTLMv2;
9208 dgst_size = DGST_SIZE_4_4;
9209 parse_func = netntlmv2_parse_hash;
9210 sort_by_digest = sort_by_digest_4_4;
9211 opti_type = OPTI_TYPE_ZERO_BYTE;
9212 dgst_pos0 = 0;
9213 dgst_pos1 = 3;
9214 dgst_pos2 = 2;
9215 dgst_pos3 = 1;
9216 break;
9217
9218 case 5700: hash_type = HASH_TYPE_SHA256;
9219 salt_type = SALT_TYPE_NONE;
9220 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9221 opts_type = OPTS_TYPE_PT_GENERATE_BE
9222 | OPTS_TYPE_PT_ADD80
9223 | OPTS_TYPE_PT_ADDBITS15;
9224 kern_type = KERN_TYPE_SHA256;
9225 dgst_size = DGST_SIZE_4_8;
9226 parse_func = cisco4_parse_hash;
9227 sort_by_digest = sort_by_digest_4_8;
9228 opti_type = OPTI_TYPE_ZERO_BYTE
9229 | OPTI_TYPE_PRECOMPUTE_INIT
9230 | OPTI_TYPE_PRECOMPUTE_MERKLE
9231 | OPTI_TYPE_EARLY_SKIP
9232 | OPTI_TYPE_NOT_ITERATED
9233 | OPTI_TYPE_NOT_SALTED
9234 | OPTI_TYPE_RAW_HASH;
9235 dgst_pos0 = 3;
9236 dgst_pos1 = 7;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 6;
9239 break;
9240
9241 case 5800: hash_type = HASH_TYPE_SHA1;
9242 salt_type = SALT_TYPE_INTERN;
9243 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
9245 | OPTS_TYPE_ST_ADD80;
9246 kern_type = KERN_TYPE_ANDROIDPIN;
9247 dgst_size = DGST_SIZE_4_5;
9248 parse_func = androidpin_parse_hash;
9249 sort_by_digest = sort_by_digest_4_5;
9250 opti_type = OPTI_TYPE_ZERO_BYTE;
9251 dgst_pos0 = 0;
9252 dgst_pos1 = 1;
9253 dgst_pos2 = 2;
9254 dgst_pos3 = 3;
9255 break;
9256
9257 case 6000: hash_type = HASH_TYPE_RIPEMD160;
9258 salt_type = SALT_TYPE_NONE;
9259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9260 opts_type = OPTS_TYPE_PT_GENERATE_LE
9261 | OPTS_TYPE_PT_ADD80;
9262 kern_type = KERN_TYPE_RIPEMD160;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = ripemd160_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE;
9267 dgst_pos0 = 0;
9268 dgst_pos1 = 1;
9269 dgst_pos2 = 2;
9270 dgst_pos3 = 3;
9271 break;
9272
9273 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9274 salt_type = SALT_TYPE_NONE;
9275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9276 opts_type = OPTS_TYPE_PT_GENERATE_BE
9277 | OPTS_TYPE_PT_ADD80;
9278 kern_type = KERN_TYPE_WHIRLPOOL;
9279 dgst_size = DGST_SIZE_4_16;
9280 parse_func = whirlpool_parse_hash;
9281 sort_by_digest = sort_by_digest_4_16;
9282 opti_type = OPTI_TYPE_ZERO_BYTE;
9283 dgst_pos0 = 0;
9284 dgst_pos1 = 1;
9285 dgst_pos2 = 2;
9286 dgst_pos3 = 3;
9287 break;
9288
9289 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9290 salt_type = SALT_TYPE_EMBEDDED;
9291 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9292 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9293 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9294 dgst_size = DGST_SIZE_4_5;
9295 parse_func = truecrypt_parse_hash_2k;
9296 sort_by_digest = sort_by_digest_4_5;
9297 opti_type = OPTI_TYPE_ZERO_BYTE;
9298 dgst_pos0 = 0;
9299 dgst_pos1 = 1;
9300 dgst_pos2 = 2;
9301 dgst_pos3 = 3;
9302 break;
9303
9304 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9305 salt_type = SALT_TYPE_EMBEDDED;
9306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9308 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9309 dgst_size = DGST_SIZE_4_5;
9310 parse_func = truecrypt_parse_hash_2k;
9311 sort_by_digest = sort_by_digest_4_5;
9312 opti_type = OPTI_TYPE_ZERO_BYTE;
9313 dgst_pos0 = 0;
9314 dgst_pos1 = 1;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 3;
9317 break;
9318
9319 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9323 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9324 dgst_size = DGST_SIZE_4_5;
9325 parse_func = truecrypt_parse_hash_2k;
9326 sort_by_digest = sort_by_digest_4_5;
9327 opti_type = OPTI_TYPE_ZERO_BYTE;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 6221: hash_type = HASH_TYPE_SHA512;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9338 kern_type = KERN_TYPE_TCSHA512_XTS512;
9339 dgst_size = DGST_SIZE_8_8;
9340 parse_func = truecrypt_parse_hash_1k;
9341 sort_by_digest = sort_by_digest_8_8;
9342 opti_type = OPTI_TYPE_ZERO_BYTE
9343 | OPTI_TYPE_USES_BITS_64;
9344 dgst_pos0 = 0;
9345 dgst_pos1 = 1;
9346 dgst_pos2 = 2;
9347 dgst_pos3 = 3;
9348 break;
9349
9350 case 6222: hash_type = HASH_TYPE_SHA512;
9351 salt_type = SALT_TYPE_EMBEDDED;
9352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9353 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9354 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9355 dgst_size = DGST_SIZE_8_8;
9356 parse_func = truecrypt_parse_hash_1k;
9357 sort_by_digest = sort_by_digest_8_8;
9358 opti_type = OPTI_TYPE_ZERO_BYTE
9359 | OPTI_TYPE_USES_BITS_64;
9360 dgst_pos0 = 0;
9361 dgst_pos1 = 1;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 3;
9364 break;
9365
9366 case 6223: hash_type = HASH_TYPE_SHA512;
9367 salt_type = SALT_TYPE_EMBEDDED;
9368 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9370 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9371 dgst_size = DGST_SIZE_8_8;
9372 parse_func = truecrypt_parse_hash_1k;
9373 sort_by_digest = sort_by_digest_8_8;
9374 opti_type = OPTI_TYPE_ZERO_BYTE
9375 | OPTI_TYPE_USES_BITS_64;
9376 dgst_pos0 = 0;
9377 dgst_pos1 = 1;
9378 dgst_pos2 = 2;
9379 dgst_pos3 = 3;
9380 break;
9381
9382 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9383 salt_type = SALT_TYPE_EMBEDDED;
9384 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9385 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9386 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9387 dgst_size = DGST_SIZE_4_8;
9388 parse_func = truecrypt_parse_hash_1k;
9389 sort_by_digest = sort_by_digest_4_8;
9390 opti_type = OPTI_TYPE_ZERO_BYTE;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9398 salt_type = SALT_TYPE_EMBEDDED;
9399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9402 dgst_size = DGST_SIZE_4_8;
9403 parse_func = truecrypt_parse_hash_1k;
9404 sort_by_digest = sort_by_digest_4_8;
9405 opti_type = OPTI_TYPE_ZERO_BYTE;
9406 dgst_pos0 = 0;
9407 dgst_pos1 = 1;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 3;
9410 break;
9411
9412 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9416 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9417 dgst_size = DGST_SIZE_4_8;
9418 parse_func = truecrypt_parse_hash_1k;
9419 sort_by_digest = sort_by_digest_4_8;
9420 opti_type = OPTI_TYPE_ZERO_BYTE;
9421 dgst_pos0 = 0;
9422 dgst_pos1 = 1;
9423 dgst_pos2 = 2;
9424 dgst_pos3 = 3;
9425 break;
9426
9427 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9428 salt_type = SALT_TYPE_EMBEDDED;
9429 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9430 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9431 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9432 dgst_size = DGST_SIZE_4_5;
9433 parse_func = truecrypt_parse_hash_1k;
9434 sort_by_digest = sort_by_digest_4_5;
9435 opti_type = OPTI_TYPE_ZERO_BYTE;
9436 dgst_pos0 = 0;
9437 dgst_pos1 = 1;
9438 dgst_pos2 = 2;
9439 dgst_pos3 = 3;
9440 break;
9441
9442 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9443 salt_type = SALT_TYPE_EMBEDDED;
9444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9445 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9446 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9447 dgst_size = DGST_SIZE_4_5;
9448 parse_func = truecrypt_parse_hash_1k;
9449 sort_by_digest = sort_by_digest_4_5;
9450 opti_type = OPTI_TYPE_ZERO_BYTE;
9451 dgst_pos0 = 0;
9452 dgst_pos1 = 1;
9453 dgst_pos2 = 2;
9454 dgst_pos3 = 3;
9455 break;
9456
9457 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9458 salt_type = SALT_TYPE_EMBEDDED;
9459 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9460 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9461 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9462 dgst_size = DGST_SIZE_4_5;
9463 parse_func = truecrypt_parse_hash_1k;
9464 sort_by_digest = sort_by_digest_4_5;
9465 opti_type = OPTI_TYPE_ZERO_BYTE;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 6300: hash_type = HASH_TYPE_MD5;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9476 kern_type = KERN_TYPE_MD5AIX;
9477 dgst_size = DGST_SIZE_4_4;
9478 parse_func = md5aix_parse_hash;
9479 sort_by_digest = sort_by_digest_4_4;
9480 opti_type = OPTI_TYPE_ZERO_BYTE;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 6400: hash_type = HASH_TYPE_SHA256;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9491 kern_type = KERN_TYPE_SHA256AIX;
9492 dgst_size = DGST_SIZE_4_8;
9493 parse_func = sha256aix_parse_hash;
9494 sort_by_digest = sort_by_digest_4_8;
9495 opti_type = OPTI_TYPE_ZERO_BYTE;
9496 dgst_pos0 = 0;
9497 dgst_pos1 = 1;
9498 dgst_pos2 = 2;
9499 dgst_pos3 = 3;
9500 break;
9501
9502 case 6500: hash_type = HASH_TYPE_SHA512;
9503 salt_type = SALT_TYPE_EMBEDDED;
9504 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9505 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9506 kern_type = KERN_TYPE_SHA512AIX;
9507 dgst_size = DGST_SIZE_8_8;
9508 parse_func = sha512aix_parse_hash;
9509 sort_by_digest = sort_by_digest_8_8;
9510 opti_type = OPTI_TYPE_ZERO_BYTE
9511 | OPTI_TYPE_USES_BITS_64;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 6600: hash_type = HASH_TYPE_AES;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_AGILEKEY;
9523 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9524 parse_func = agilekey_parse_hash;
9525 sort_by_digest = sort_by_digest_4_5;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 6700: hash_type = HASH_TYPE_SHA1;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9537 kern_type = KERN_TYPE_SHA1AIX;
9538 dgst_size = DGST_SIZE_4_5;
9539 parse_func = sha1aix_parse_hash;
9540 sort_by_digest = sort_by_digest_4_5;
9541 opti_type = OPTI_TYPE_ZERO_BYTE;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 6800: hash_type = HASH_TYPE_AES;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_LASTPASS;
9553 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9554 parse_func = lastpass_parse_hash;
9555 sort_by_digest = sort_by_digest_4_8;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 6900: hash_type = HASH_TYPE_GOST;
9564 salt_type = SALT_TYPE_NONE;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9567 kern_type = KERN_TYPE_GOST;
9568 dgst_size = DGST_SIZE_4_8;
9569 parse_func = gost_parse_hash;
9570 sort_by_digest = sort_by_digest_4_8;
9571 opti_type = OPTI_TYPE_ZERO_BYTE;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 7100: hash_type = HASH_TYPE_SHA512;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9582 kern_type = KERN_TYPE_PBKDF2_SHA512;
9583 dgst_size = DGST_SIZE_8_16;
9584 parse_func = sha512osx_parse_hash;
9585 sort_by_digest = sort_by_digest_8_16;
9586 opti_type = OPTI_TYPE_ZERO_BYTE
9587 | OPTI_TYPE_USES_BITS_64
9588 | OPTI_TYPE_SLOW_HASH_SIMD;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 7200: hash_type = HASH_TYPE_SHA512;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9599 kern_type = KERN_TYPE_PBKDF2_SHA512;
9600 dgst_size = DGST_SIZE_8_16;
9601 parse_func = sha512grub_parse_hash;
9602 sort_by_digest = sort_by_digest_8_16;
9603 opti_type = OPTI_TYPE_ZERO_BYTE
9604 | OPTI_TYPE_USES_BITS_64
9605 | OPTI_TYPE_SLOW_HASH_SIMD;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 7300: hash_type = HASH_TYPE_SHA1;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_BE
9616 | OPTS_TYPE_ST_ADD80
9617 | OPTS_TYPE_ST_ADDBITS15;
9618 kern_type = KERN_TYPE_RAKP;
9619 dgst_size = DGST_SIZE_4_5;
9620 parse_func = rakp_parse_hash;
9621 sort_by_digest = sort_by_digest_4_5;
9622 opti_type = OPTI_TYPE_ZERO_BYTE
9623 | OPTI_TYPE_NOT_ITERATED;
9624 dgst_pos0 = 3;
9625 dgst_pos1 = 4;
9626 dgst_pos2 = 2;
9627 dgst_pos3 = 1;
9628 break;
9629
9630 case 7400: hash_type = HASH_TYPE_SHA256;
9631 salt_type = SALT_TYPE_EMBEDDED;
9632 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9633 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9634 kern_type = KERN_TYPE_SHA256CRYPT;
9635 dgst_size = DGST_SIZE_4_8;
9636 parse_func = sha256crypt_parse_hash;
9637 sort_by_digest = sort_by_digest_4_8;
9638 opti_type = OPTI_TYPE_ZERO_BYTE;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 7500: hash_type = HASH_TYPE_KRB5PA;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9649 kern_type = KERN_TYPE_KRB5PA;
9650 dgst_size = DGST_SIZE_4_4;
9651 parse_func = krb5pa_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4;
9653 opti_type = OPTI_TYPE_ZERO_BYTE
9654 | OPTI_TYPE_NOT_ITERATED;
9655 dgst_pos0 = 0;
9656 dgst_pos1 = 1;
9657 dgst_pos2 = 2;
9658 dgst_pos3 = 3;
9659 break;
9660
9661 case 7600: hash_type = HASH_TYPE_SHA1;
9662 salt_type = SALT_TYPE_INTERN;
9663 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9664 opts_type = OPTS_TYPE_PT_GENERATE_BE
9665 | OPTS_TYPE_PT_ADD80
9666 | OPTS_TYPE_PT_ADDBITS15;
9667 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9668 dgst_size = DGST_SIZE_4_5;
9669 parse_func = redmine_parse_hash;
9670 sort_by_digest = sort_by_digest_4_5;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_PRECOMPUTE_INIT
9673 | OPTI_TYPE_EARLY_SKIP
9674 | OPTI_TYPE_NOT_ITERATED
9675 | OPTI_TYPE_PREPENDED_SALT;
9676 dgst_pos0 = 3;
9677 dgst_pos1 = 4;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 1;
9680 break;
9681
9682 case 7700: hash_type = HASH_TYPE_SAPB;
9683 salt_type = SALT_TYPE_EMBEDDED;
9684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE
9686 | OPTS_TYPE_PT_UPPER
9687 | OPTS_TYPE_ST_UPPER;
9688 kern_type = KERN_TYPE_SAPB;
9689 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9690 parse_func = sapb_parse_hash;
9691 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9692 opti_type = OPTI_TYPE_ZERO_BYTE
9693 | OPTI_TYPE_PRECOMPUTE_INIT
9694 | OPTI_TYPE_NOT_ITERATED;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 1;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 3;
9699 break;
9700
9701 case 7800: hash_type = HASH_TYPE_SAPG;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_BE
9705 | OPTS_TYPE_ST_ADD80
9706 | OPTS_TYPE_ST_UPPER;
9707 kern_type = KERN_TYPE_SAPG;
9708 dgst_size = DGST_SIZE_4_5;
9709 parse_func = sapg_parse_hash;
9710 sort_by_digest = sort_by_digest_4_5;
9711 opti_type = OPTI_TYPE_ZERO_BYTE
9712 | OPTI_TYPE_PRECOMPUTE_INIT
9713 | OPTI_TYPE_NOT_ITERATED;
9714 dgst_pos0 = 3;
9715 dgst_pos1 = 4;
9716 dgst_pos2 = 2;
9717 dgst_pos3 = 1;
9718 break;
9719
9720 case 7900: hash_type = HASH_TYPE_SHA512;
9721 salt_type = SALT_TYPE_EMBEDDED;
9722 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9723 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9724 kern_type = KERN_TYPE_DRUPAL7;
9725 dgst_size = DGST_SIZE_8_8;
9726 parse_func = drupal7_parse_hash;
9727 sort_by_digest = sort_by_digest_8_8;
9728 opti_type = OPTI_TYPE_ZERO_BYTE
9729 | OPTI_TYPE_USES_BITS_64;
9730 dgst_pos0 = 0;
9731 dgst_pos1 = 1;
9732 dgst_pos2 = 2;
9733 dgst_pos3 = 3;
9734 break;
9735
9736 case 8000: hash_type = HASH_TYPE_SHA256;
9737 salt_type = SALT_TYPE_EMBEDDED;
9738 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9739 opts_type = OPTS_TYPE_PT_GENERATE_BE
9740 | OPTS_TYPE_PT_UNICODE
9741 | OPTS_TYPE_ST_ADD80
9742 | OPTS_TYPE_ST_HEX;
9743 kern_type = KERN_TYPE_SYBASEASE;
9744 dgst_size = DGST_SIZE_4_8;
9745 parse_func = sybasease_parse_hash;
9746 sort_by_digest = sort_by_digest_4_8;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_PRECOMPUTE_INIT
9749 | OPTI_TYPE_EARLY_SKIP
9750 | OPTI_TYPE_NOT_ITERATED
9751 | OPTI_TYPE_RAW_HASH;
9752 dgst_pos0 = 3;
9753 dgst_pos1 = 7;
9754 dgst_pos2 = 2;
9755 dgst_pos3 = 6;
9756 break;
9757
9758 case 8100: hash_type = HASH_TYPE_SHA1;
9759 salt_type = SALT_TYPE_EMBEDDED;
9760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9761 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9762 kern_type = KERN_TYPE_NETSCALER;
9763 dgst_size = DGST_SIZE_4_5;
9764 parse_func = netscaler_parse_hash;
9765 sort_by_digest = sort_by_digest_4_5;
9766 opti_type = OPTI_TYPE_ZERO_BYTE
9767 | OPTI_TYPE_PRECOMPUTE_INIT
9768 | OPTI_TYPE_PRECOMPUTE_MERKLE
9769 | OPTI_TYPE_EARLY_SKIP
9770 | OPTI_TYPE_NOT_ITERATED
9771 | OPTI_TYPE_PREPENDED_SALT
9772 | OPTI_TYPE_RAW_HASH;
9773 dgst_pos0 = 3;
9774 dgst_pos1 = 4;
9775 dgst_pos2 = 2;
9776 dgst_pos3 = 1;
9777 break;
9778
9779 case 8200: hash_type = HASH_TYPE_SHA256;
9780 salt_type = SALT_TYPE_EMBEDDED;
9781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9783 kern_type = KERN_TYPE_CLOUDKEY;
9784 dgst_size = DGST_SIZE_4_8;
9785 parse_func = cloudkey_parse_hash;
9786 sort_by_digest = sort_by_digest_4_8;
9787 opti_type = OPTI_TYPE_ZERO_BYTE;
9788 dgst_pos0 = 0;
9789 dgst_pos1 = 1;
9790 dgst_pos2 = 2;
9791 dgst_pos3 = 3;
9792 break;
9793
9794 case 8300: hash_type = HASH_TYPE_SHA1;
9795 salt_type = SALT_TYPE_EMBEDDED;
9796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9797 opts_type = OPTS_TYPE_PT_GENERATE_BE
9798 | OPTS_TYPE_ST_HEX
9799 | OPTS_TYPE_ST_ADD80;
9800 kern_type = KERN_TYPE_NSEC3;
9801 dgst_size = DGST_SIZE_4_5;
9802 parse_func = nsec3_parse_hash;
9803 sort_by_digest = sort_by_digest_4_5;
9804 opti_type = OPTI_TYPE_ZERO_BYTE;
9805 dgst_pos0 = 3;
9806 dgst_pos1 = 4;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 1;
9809 break;
9810
9811 case 8400: hash_type = HASH_TYPE_SHA1;
9812 salt_type = SALT_TYPE_INTERN;
9813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_BE
9815 | OPTS_TYPE_PT_ADD80
9816 | OPTS_TYPE_PT_ADDBITS15;
9817 kern_type = KERN_TYPE_WBB3;
9818 dgst_size = DGST_SIZE_4_5;
9819 parse_func = wbb3_parse_hash;
9820 sort_by_digest = sort_by_digest_4_5;
9821 opti_type = OPTI_TYPE_ZERO_BYTE
9822 | OPTI_TYPE_PRECOMPUTE_INIT
9823 | OPTI_TYPE_NOT_ITERATED;
9824 dgst_pos0 = 3;
9825 dgst_pos1 = 4;
9826 dgst_pos2 = 2;
9827 dgst_pos3 = 1;
9828 break;
9829
9830 case 8500: hash_type = HASH_TYPE_DESRACF;
9831 salt_type = SALT_TYPE_EMBEDDED;
9832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9833 opts_type = OPTS_TYPE_PT_GENERATE_LE
9834 | OPTS_TYPE_ST_UPPER;
9835 kern_type = KERN_TYPE_RACF;
9836 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9837 parse_func = racf_parse_hash;
9838 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9839 opti_type = OPTI_TYPE_ZERO_BYTE
9840 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9841 dgst_pos0 = 0;
9842 dgst_pos1 = 1;
9843 dgst_pos2 = 2;
9844 dgst_pos3 = 3;
9845 break;
9846
9847 case 8600: hash_type = HASH_TYPE_LOTUS5;
9848 salt_type = SALT_TYPE_NONE;
9849 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9850 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9851 kern_type = KERN_TYPE_LOTUS5;
9852 dgst_size = DGST_SIZE_4_4;
9853 parse_func = lotus5_parse_hash;
9854 sort_by_digest = sort_by_digest_4_4;
9855 opti_type = OPTI_TYPE_EARLY_SKIP
9856 | OPTI_TYPE_NOT_ITERATED
9857 | OPTI_TYPE_NOT_SALTED
9858 | OPTI_TYPE_RAW_HASH;
9859 dgst_pos0 = 0;
9860 dgst_pos1 = 1;
9861 dgst_pos2 = 2;
9862 dgst_pos3 = 3;
9863 break;
9864
9865 case 8700: hash_type = HASH_TYPE_LOTUS6;
9866 salt_type = SALT_TYPE_EMBEDDED;
9867 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9868 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9869 kern_type = KERN_TYPE_LOTUS6;
9870 dgst_size = DGST_SIZE_4_4;
9871 parse_func = lotus6_parse_hash;
9872 sort_by_digest = sort_by_digest_4_4;
9873 opti_type = OPTI_TYPE_EARLY_SKIP
9874 | OPTI_TYPE_NOT_ITERATED
9875 | OPTI_TYPE_RAW_HASH;
9876 dgst_pos0 = 0;
9877 dgst_pos1 = 1;
9878 dgst_pos2 = 2;
9879 dgst_pos3 = 3;
9880 break;
9881
9882 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9883 salt_type = SALT_TYPE_EMBEDDED;
9884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9885 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9886 kern_type = KERN_TYPE_ANDROIDFDE;
9887 dgst_size = DGST_SIZE_4_4;
9888 parse_func = androidfde_parse_hash;
9889 sort_by_digest = sort_by_digest_4_4;
9890 opti_type = OPTI_TYPE_ZERO_BYTE;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 8900: hash_type = HASH_TYPE_SCRYPT;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9901 kern_type = KERN_TYPE_SCRYPT;
9902 dgst_size = DGST_SIZE_4_8;
9903 parse_func = scrypt_parse_hash;
9904 sort_by_digest = sort_by_digest_4_8;
9905 opti_type = OPTI_TYPE_ZERO_BYTE;
9906 dgst_pos0 = 0;
9907 dgst_pos1 = 1;
9908 dgst_pos2 = 2;
9909 dgst_pos3 = 3;
9910 break;
9911
9912 case 9000: hash_type = HASH_TYPE_SHA1;
9913 salt_type = SALT_TYPE_EMBEDDED;
9914 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9915 opts_type = OPTS_TYPE_PT_GENERATE_LE
9916 | OPTS_TYPE_ST_GENERATE_LE;
9917 kern_type = KERN_TYPE_PSAFE2;
9918 dgst_size = DGST_SIZE_4_5;
9919 parse_func = psafe2_parse_hash;
9920 sort_by_digest = sort_by_digest_4_5;
9921 opti_type = OPTI_TYPE_ZERO_BYTE;
9922 dgst_pos0 = 0;
9923 dgst_pos1 = 1;
9924 dgst_pos2 = 2;
9925 dgst_pos3 = 3;
9926 break;
9927
9928 case 9100: hash_type = HASH_TYPE_LOTUS8;
9929 salt_type = SALT_TYPE_EMBEDDED;
9930 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9931 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9932 kern_type = KERN_TYPE_LOTUS8;
9933 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9934 parse_func = lotus8_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9936 opti_type = OPTI_TYPE_ZERO_BYTE;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 9200: hash_type = HASH_TYPE_SHA256;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9947 kern_type = KERN_TYPE_PBKDF2_SHA256;
9948 dgst_size = DGST_SIZE_4_32;
9949 parse_func = cisco8_parse_hash;
9950 sort_by_digest = sort_by_digest_4_32;
9951 opti_type = OPTI_TYPE_ZERO_BYTE
9952 | OPTI_TYPE_SLOW_HASH_SIMD;
9953 dgst_pos0 = 0;
9954 dgst_pos1 = 1;
9955 dgst_pos2 = 2;
9956 dgst_pos3 = 3;
9957 break;
9958
9959 case 9300: hash_type = HASH_TYPE_SCRYPT;
9960 salt_type = SALT_TYPE_EMBEDDED;
9961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9963 kern_type = KERN_TYPE_SCRYPT;
9964 dgst_size = DGST_SIZE_4_8;
9965 parse_func = cisco9_parse_hash;
9966 sort_by_digest = sort_by_digest_4_8;
9967 opti_type = OPTI_TYPE_ZERO_BYTE;
9968 dgst_pos0 = 0;
9969 dgst_pos1 = 1;
9970 dgst_pos2 = 2;
9971 dgst_pos3 = 3;
9972 break;
9973
9974 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9975 salt_type = SALT_TYPE_EMBEDDED;
9976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9978 kern_type = KERN_TYPE_OFFICE2007;
9979 dgst_size = DGST_SIZE_4_4;
9980 parse_func = office2007_parse_hash;
9981 sort_by_digest = sort_by_digest_4_4;
9982 opti_type = OPTI_TYPE_ZERO_BYTE;
9983 dgst_pos0 = 0;
9984 dgst_pos1 = 1;
9985 dgst_pos2 = 2;
9986 dgst_pos3 = 3;
9987 break;
9988
9989 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9990 salt_type = SALT_TYPE_EMBEDDED;
9991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9993 kern_type = KERN_TYPE_OFFICE2010;
9994 dgst_size = DGST_SIZE_4_4;
9995 parse_func = office2010_parse_hash;
9996 sort_by_digest = sort_by_digest_4_4;
9997 opti_type = OPTI_TYPE_ZERO_BYTE;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 1;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 3;
10002 break;
10003
10004 case 9600: hash_type = HASH_TYPE_OFFICE2013;
10005 salt_type = SALT_TYPE_EMBEDDED;
10006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10008 kern_type = KERN_TYPE_OFFICE2013;
10009 dgst_size = DGST_SIZE_4_4;
10010 parse_func = office2013_parse_hash;
10011 sort_by_digest = sort_by_digest_4_4;
10012 opti_type = OPTI_TYPE_ZERO_BYTE;
10013 dgst_pos0 = 0;
10014 dgst_pos1 = 1;
10015 dgst_pos2 = 2;
10016 dgst_pos3 = 3;
10017 break;
10018
10019 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
10020 salt_type = SALT_TYPE_EMBEDDED;
10021 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10022 opts_type = OPTS_TYPE_PT_GENERATE_LE
10023 | OPTS_TYPE_PT_ADD80
10024 | OPTS_TYPE_PT_UNICODE;
10025 kern_type = KERN_TYPE_OLDOFFICE01;
10026 dgst_size = DGST_SIZE_4_4;
10027 parse_func = oldoffice01_parse_hash;
10028 sort_by_digest = sort_by_digest_4_4;
10029 opti_type = OPTI_TYPE_ZERO_BYTE
10030 | OPTI_TYPE_PRECOMPUTE_INIT
10031 | OPTI_TYPE_NOT_ITERATED;
10032 dgst_pos0 = 0;
10033 dgst_pos1 = 1;
10034 dgst_pos2 = 2;
10035 dgst_pos3 = 3;
10036 break;
10037
10038 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
10039 salt_type = SALT_TYPE_EMBEDDED;
10040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10041 opts_type = OPTS_TYPE_PT_GENERATE_LE
10042 | OPTS_TYPE_PT_ADD80;
10043 kern_type = KERN_TYPE_OLDOFFICE01CM1;
10044 dgst_size = DGST_SIZE_4_4;
10045 parse_func = oldoffice01cm1_parse_hash;
10046 sort_by_digest = sort_by_digest_4_4;
10047 opti_type = OPTI_TYPE_ZERO_BYTE
10048 | OPTI_TYPE_PRECOMPUTE_INIT
10049 | OPTI_TYPE_NOT_ITERATED;
10050 dgst_pos0 = 0;
10051 dgst_pos1 = 1;
10052 dgst_pos2 = 2;
10053 dgst_pos3 = 3;
10054 break;
10055
10056 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
10057 salt_type = SALT_TYPE_EMBEDDED;
10058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10059 opts_type = OPTS_TYPE_PT_GENERATE_LE
10060 | OPTS_TYPE_PT_ADD80
10061 | OPTS_TYPE_PT_UNICODE
10062 | OPTS_TYPE_PT_NEVERCRACK;
10063 kern_type = KERN_TYPE_OLDOFFICE01CM2;
10064 dgst_size = DGST_SIZE_4_4;
10065 parse_func = oldoffice01cm2_parse_hash;
10066 sort_by_digest = sort_by_digest_4_4;
10067 opti_type = OPTI_TYPE_ZERO_BYTE
10068 | OPTI_TYPE_PRECOMPUTE_INIT
10069 | OPTI_TYPE_NOT_ITERATED;
10070 dgst_pos0 = 0;
10071 dgst_pos1 = 1;
10072 dgst_pos2 = 2;
10073 dgst_pos3 = 3;
10074 break;
10075
10076 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_BE
10080 | OPTS_TYPE_PT_ADD80
10081 | OPTS_TYPE_PT_UNICODE;
10082 kern_type = KERN_TYPE_OLDOFFICE34;
10083 dgst_size = DGST_SIZE_4_4;
10084 parse_func = oldoffice34_parse_hash;
10085 sort_by_digest = sort_by_digest_4_4;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_PRECOMPUTE_INIT
10088 | OPTI_TYPE_NOT_ITERATED;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10099 kern_type = KERN_TYPE_OLDOFFICE34CM1;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = oldoffice34cm1_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_NOT_ITERATED;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_BE
10116 | OPTS_TYPE_PT_ADD80
10117 | OPTS_TYPE_PT_UNICODE
10118 | OPTS_TYPE_PT_NEVERCRACK;
10119 kern_type = KERN_TYPE_OLDOFFICE34CM2;
10120 dgst_size = DGST_SIZE_4_4;
10121 parse_func = oldoffice34cm2_parse_hash;
10122 sort_by_digest = sort_by_digest_4_4;
10123 opti_type = OPTI_TYPE_ZERO_BYTE
10124 | OPTI_TYPE_PRECOMPUTE_INIT
10125 | OPTI_TYPE_NOT_ITERATED;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 1;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 3;
10130 break;
10131
10132 case 9900: hash_type = HASH_TYPE_MD5;
10133 salt_type = SALT_TYPE_NONE;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10136 kern_type = KERN_TYPE_RADMIN2;
10137 dgst_size = DGST_SIZE_4_4;
10138 parse_func = radmin2_parse_hash;
10139 sort_by_digest = sort_by_digest_4_4;
10140 opti_type = OPTI_TYPE_ZERO_BYTE
10141 | OPTI_TYPE_PRECOMPUTE_INIT
10142 | OPTI_TYPE_EARLY_SKIP
10143 | OPTI_TYPE_NOT_ITERATED
10144 | OPTI_TYPE_NOT_SALTED;
10145 dgst_pos0 = 0;
10146 dgst_pos1 = 3;
10147 dgst_pos2 = 2;
10148 dgst_pos3 = 1;
10149 break;
10150
10151 case 10000: hash_type = HASH_TYPE_SHA256;
10152 salt_type = SALT_TYPE_EMBEDDED;
10153 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10154 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10155 kern_type = KERN_TYPE_PBKDF2_SHA256;
10156 dgst_size = DGST_SIZE_4_32;
10157 parse_func = djangopbkdf2_parse_hash;
10158 sort_by_digest = sort_by_digest_4_32;
10159 opti_type = OPTI_TYPE_ZERO_BYTE
10160 | OPTI_TYPE_SLOW_HASH_SIMD;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 10100: hash_type = HASH_TYPE_SIPHASH;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10171 kern_type = KERN_TYPE_SIPHASH;
10172 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10173 parse_func = siphash_parse_hash;
10174 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10175 opti_type = OPTI_TYPE_ZERO_BYTE
10176 | OPTI_TYPE_NOT_ITERATED
10177 | OPTI_TYPE_RAW_HASH;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 10200: hash_type = HASH_TYPE_MD5;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_ADD80
10189 | OPTS_TYPE_ST_ADDBITS14;
10190 kern_type = KERN_TYPE_HMACMD5_PW;
10191 dgst_size = DGST_SIZE_4_4;
10192 parse_func = crammd5_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4;
10194 opti_type = OPTI_TYPE_ZERO_BYTE
10195 | OPTI_TYPE_NOT_ITERATED;
10196 dgst_pos0 = 0;
10197 dgst_pos1 = 3;
10198 dgst_pos2 = 2;
10199 dgst_pos3 = 1;
10200 break;
10201
10202 case 10300: hash_type = HASH_TYPE_SHA1;
10203 salt_type = SALT_TYPE_EMBEDDED;
10204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10205 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10206 kern_type = KERN_TYPE_SAPH_SHA1;
10207 dgst_size = DGST_SIZE_4_5;
10208 parse_func = saph_sha1_parse_hash;
10209 sort_by_digest = sort_by_digest_4_5;
10210 opti_type = OPTI_TYPE_ZERO_BYTE;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 10400: hash_type = HASH_TYPE_PDFU16;
10218 salt_type = SALT_TYPE_EMBEDDED;
10219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10221 kern_type = KERN_TYPE_PDF11;
10222 dgst_size = DGST_SIZE_4_4;
10223 parse_func = pdf11_parse_hash;
10224 sort_by_digest = sort_by_digest_4_4;
10225 opti_type = OPTI_TYPE_ZERO_BYTE
10226 | OPTI_TYPE_NOT_ITERATED;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 10410: hash_type = HASH_TYPE_PDFU16;
10234 salt_type = SALT_TYPE_EMBEDDED;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10237 kern_type = KERN_TYPE_PDF11CM1;
10238 dgst_size = DGST_SIZE_4_4;
10239 parse_func = pdf11cm1_parse_hash;
10240 sort_by_digest = sort_by_digest_4_4;
10241 opti_type = OPTI_TYPE_ZERO_BYTE
10242 | OPTI_TYPE_NOT_ITERATED;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 10420: hash_type = HASH_TYPE_PDFU16;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10253 kern_type = KERN_TYPE_PDF11CM2;
10254 dgst_size = DGST_SIZE_4_4;
10255 parse_func = pdf11cm2_parse_hash;
10256 sort_by_digest = sort_by_digest_4_4;
10257 opti_type = OPTI_TYPE_ZERO_BYTE
10258 | OPTI_TYPE_NOT_ITERATED;
10259 dgst_pos0 = 0;
10260 dgst_pos1 = 1;
10261 dgst_pos2 = 2;
10262 dgst_pos3 = 3;
10263 break;
10264
10265 case 10500: hash_type = HASH_TYPE_PDFU16;
10266 salt_type = SALT_TYPE_EMBEDDED;
10267 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10268 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10269 kern_type = KERN_TYPE_PDF14;
10270 dgst_size = DGST_SIZE_4_4;
10271 parse_func = pdf14_parse_hash;
10272 sort_by_digest = sort_by_digest_4_4;
10273 opti_type = OPTI_TYPE_ZERO_BYTE
10274 | OPTI_TYPE_NOT_ITERATED;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 1;
10277 dgst_pos2 = 2;
10278 dgst_pos3 = 3;
10279 break;
10280
10281 case 10600: hash_type = HASH_TYPE_SHA256;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_BE
10285 | OPTS_TYPE_ST_ADD80
10286 | OPTS_TYPE_ST_ADDBITS15
10287 | OPTS_TYPE_HASH_COPY;
10288 kern_type = KERN_TYPE_SHA256_PWSLT;
10289 dgst_size = DGST_SIZE_4_8;
10290 parse_func = pdf17l3_parse_hash;
10291 sort_by_digest = sort_by_digest_4_8;
10292 opti_type = OPTI_TYPE_ZERO_BYTE
10293 | OPTI_TYPE_PRECOMPUTE_INIT
10294 | OPTI_TYPE_PRECOMPUTE_MERKLE
10295 | OPTI_TYPE_EARLY_SKIP
10296 | OPTI_TYPE_NOT_ITERATED
10297 | OPTI_TYPE_APPENDED_SALT
10298 | OPTI_TYPE_RAW_HASH;
10299 dgst_pos0 = 3;
10300 dgst_pos1 = 7;
10301 dgst_pos2 = 2;
10302 dgst_pos3 = 6;
10303 break;
10304
10305 case 10700: hash_type = HASH_TYPE_PDFU32;
10306 salt_type = SALT_TYPE_EMBEDDED;
10307 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10308 opts_type = OPTS_TYPE_PT_GENERATE_LE
10309 | OPTS_TYPE_HASH_COPY;
10310 kern_type = KERN_TYPE_PDF17L8;
10311 dgst_size = DGST_SIZE_4_8;
10312 parse_func = pdf17l8_parse_hash;
10313 sort_by_digest = sort_by_digest_4_8;
10314 opti_type = OPTI_TYPE_ZERO_BYTE
10315 | OPTI_TYPE_NOT_ITERATED;
10316 dgst_pos0 = 0;
10317 dgst_pos1 = 1;
10318 dgst_pos2 = 2;
10319 dgst_pos3 = 3;
10320 break;
10321
10322 case 10800: hash_type = HASH_TYPE_SHA384;
10323 salt_type = SALT_TYPE_NONE;
10324 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10325 opts_type = OPTS_TYPE_PT_GENERATE_BE
10326 | OPTS_TYPE_PT_ADD80
10327 | OPTS_TYPE_PT_ADDBITS15;
10328 kern_type = KERN_TYPE_SHA384;
10329 dgst_size = DGST_SIZE_8_8;
10330 parse_func = sha384_parse_hash;
10331 sort_by_digest = sort_by_digest_8_8;
10332 opti_type = OPTI_TYPE_ZERO_BYTE
10333 | OPTI_TYPE_PRECOMPUTE_INIT
10334 | OPTI_TYPE_PRECOMPUTE_MERKLE
10335 | OPTI_TYPE_EARLY_SKIP
10336 | OPTI_TYPE_NOT_ITERATED
10337 | OPTI_TYPE_NOT_SALTED
10338 | OPTI_TYPE_USES_BITS_64
10339 | OPTI_TYPE_RAW_HASH;
10340 dgst_pos0 = 6;
10341 dgst_pos1 = 7;
10342 dgst_pos2 = 4;
10343 dgst_pos3 = 5;
10344 break;
10345
10346 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10347 salt_type = SALT_TYPE_EMBEDDED;
10348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10349 opts_type = OPTS_TYPE_PT_GENERATE_LE
10350 | OPTS_TYPE_ST_BASE64
10351 | OPTS_TYPE_HASH_COPY;
10352 kern_type = KERN_TYPE_PBKDF2_SHA256;
10353 dgst_size = DGST_SIZE_4_32;
10354 parse_func = pbkdf2_sha256_parse_hash;
10355 sort_by_digest = sort_by_digest_4_32;
10356 opti_type = OPTI_TYPE_ZERO_BYTE
10357 | OPTI_TYPE_SLOW_HASH_SIMD;
10358 dgst_pos0 = 0;
10359 dgst_pos1 = 1;
10360 dgst_pos2 = 2;
10361 dgst_pos3 = 3;
10362 break;
10363
10364 case 11000: hash_type = HASH_TYPE_MD5;
10365 salt_type = SALT_TYPE_INTERN;
10366 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10367 opts_type = OPTS_TYPE_PT_GENERATE_LE
10368 | OPTS_TYPE_PT_ADD80;
10369 kern_type = KERN_TYPE_PRESTASHOP;
10370 dgst_size = DGST_SIZE_4_4;
10371 parse_func = prestashop_parse_hash;
10372 sort_by_digest = sort_by_digest_4_4;
10373 opti_type = OPTI_TYPE_ZERO_BYTE
10374 | OPTI_TYPE_PRECOMPUTE_INIT
10375 | OPTI_TYPE_NOT_ITERATED
10376 | OPTI_TYPE_PREPENDED_SALT;
10377 dgst_pos0 = 0;
10378 dgst_pos1 = 3;
10379 dgst_pos2 = 2;
10380 dgst_pos3 = 1;
10381 break;
10382
10383 case 11100: hash_type = HASH_TYPE_MD5;
10384 salt_type = SALT_TYPE_EMBEDDED;
10385 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10386 opts_type = OPTS_TYPE_PT_GENERATE_LE
10387 | OPTS_TYPE_ST_ADD80;
10388 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10389 dgst_size = DGST_SIZE_4_4;
10390 parse_func = postgresql_auth_parse_hash;
10391 sort_by_digest = sort_by_digest_4_4;
10392 opti_type = OPTI_TYPE_ZERO_BYTE
10393 | OPTI_TYPE_PRECOMPUTE_INIT
10394 | OPTI_TYPE_PRECOMPUTE_MERKLE
10395 | OPTI_TYPE_EARLY_SKIP;
10396 dgst_pos0 = 0;
10397 dgst_pos1 = 3;
10398 dgst_pos2 = 2;
10399 dgst_pos3 = 1;
10400 break;
10401
10402 case 11200: hash_type = HASH_TYPE_SHA1;
10403 salt_type = SALT_TYPE_EMBEDDED;
10404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10405 opts_type = OPTS_TYPE_PT_GENERATE_BE
10406 | OPTS_TYPE_PT_ADD80
10407 | OPTS_TYPE_ST_HEX;
10408 kern_type = KERN_TYPE_MYSQL_AUTH;
10409 dgst_size = DGST_SIZE_4_5;
10410 parse_func = mysql_auth_parse_hash;
10411 sort_by_digest = sort_by_digest_4_5;
10412 opti_type = OPTI_TYPE_ZERO_BYTE
10413 | OPTI_TYPE_EARLY_SKIP;
10414 dgst_pos0 = 3;
10415 dgst_pos1 = 4;
10416 dgst_pos2 = 2;
10417 dgst_pos3 = 1;
10418 break;
10419
10420 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10421 salt_type = SALT_TYPE_EMBEDDED;
10422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10423 opts_type = OPTS_TYPE_PT_GENERATE_LE
10424 | OPTS_TYPE_ST_HEX
10425 | OPTS_TYPE_ST_ADD80;
10426 kern_type = KERN_TYPE_BITCOIN_WALLET;
10427 dgst_size = DGST_SIZE_4_4;
10428 parse_func = bitcoin_wallet_parse_hash;
10429 sort_by_digest = sort_by_digest_4_4;
10430 opti_type = OPTI_TYPE_ZERO_BYTE;
10431 dgst_pos0 = 0;
10432 dgst_pos1 = 1;
10433 dgst_pos2 = 2;
10434 dgst_pos3 = 3;
10435 break;
10436
10437 case 11400: hash_type = HASH_TYPE_MD5;
10438 salt_type = SALT_TYPE_EMBEDDED;
10439 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10440 opts_type = OPTS_TYPE_PT_GENERATE_LE
10441 | OPTS_TYPE_PT_ADD80
10442 | OPTS_TYPE_HASH_COPY;
10443 kern_type = KERN_TYPE_SIP_AUTH;
10444 dgst_size = DGST_SIZE_4_4;
10445 parse_func = sip_auth_parse_hash;
10446 sort_by_digest = sort_by_digest_4_4;
10447 opti_type = OPTI_TYPE_ZERO_BYTE;
10448 dgst_pos0 = 0;
10449 dgst_pos1 = 3;
10450 dgst_pos2 = 2;
10451 dgst_pos3 = 1;
10452 break;
10453
10454 case 11500: hash_type = HASH_TYPE_CRC32;
10455 salt_type = SALT_TYPE_INTERN;
10456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10457 opts_type = OPTS_TYPE_PT_GENERATE_LE
10458 | OPTS_TYPE_ST_GENERATE_LE
10459 | OPTS_TYPE_ST_HEX;
10460 kern_type = KERN_TYPE_CRC32;
10461 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10462 parse_func = crc32_parse_hash;
10463 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10464 opti_type = OPTI_TYPE_ZERO_BYTE;
10465 dgst_pos0 = 0;
10466 dgst_pos1 = 1;
10467 dgst_pos2 = 2;
10468 dgst_pos3 = 3;
10469 break;
10470
10471 case 11600: hash_type = HASH_TYPE_AES;
10472 salt_type = SALT_TYPE_EMBEDDED;
10473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10474 opts_type = OPTS_TYPE_PT_GENERATE_LE
10475 | OPTS_TYPE_PT_NEVERCRACK;
10476 kern_type = KERN_TYPE_SEVEN_ZIP;
10477 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10478 parse_func = seven_zip_parse_hash;
10479 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10480 opti_type = OPTI_TYPE_ZERO_BYTE;
10481 dgst_pos0 = 0;
10482 dgst_pos1 = 1;
10483 dgst_pos2 = 2;
10484 dgst_pos3 = 3;
10485 break;
10486
10487 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10488 salt_type = SALT_TYPE_NONE;
10489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10490 opts_type = OPTS_TYPE_PT_GENERATE_LE
10491 | OPTS_TYPE_PT_ADD01;
10492 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10493 dgst_size = DGST_SIZE_4_8;
10494 parse_func = gost2012sbog_256_parse_hash;
10495 sort_by_digest = sort_by_digest_4_8;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10504 salt_type = SALT_TYPE_NONE;
10505 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_LE
10507 | OPTS_TYPE_PT_ADD01;
10508 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10509 dgst_size = DGST_SIZE_4_16;
10510 parse_func = gost2012sbog_512_parse_hash;
10511 sort_by_digest = sort_by_digest_4_16;
10512 opti_type = OPTI_TYPE_ZERO_BYTE;
10513 dgst_pos0 = 0;
10514 dgst_pos1 = 1;
10515 dgst_pos2 = 2;
10516 dgst_pos3 = 3;
10517 break;
10518
10519 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10520 salt_type = SALT_TYPE_EMBEDDED;
10521 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10522 opts_type = OPTS_TYPE_PT_GENERATE_LE
10523 | OPTS_TYPE_ST_BASE64
10524 | OPTS_TYPE_HASH_COPY;
10525 kern_type = KERN_TYPE_PBKDF2_MD5;
10526 dgst_size = DGST_SIZE_4_32;
10527 parse_func = pbkdf2_md5_parse_hash;
10528 sort_by_digest = sort_by_digest_4_32;
10529 opti_type = OPTI_TYPE_ZERO_BYTE
10530 | OPTI_TYPE_SLOW_HASH_SIMD;
10531 dgst_pos0 = 0;
10532 dgst_pos1 = 1;
10533 dgst_pos2 = 2;
10534 dgst_pos3 = 3;
10535 break;
10536
10537 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10538 salt_type = SALT_TYPE_EMBEDDED;
10539 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10540 opts_type = OPTS_TYPE_PT_GENERATE_LE
10541 | OPTS_TYPE_ST_BASE64
10542 | OPTS_TYPE_HASH_COPY;
10543 kern_type = KERN_TYPE_PBKDF2_SHA1;
10544 dgst_size = DGST_SIZE_4_32;
10545 parse_func = pbkdf2_sha1_parse_hash;
10546 sort_by_digest = sort_by_digest_4_32;
10547 opti_type = OPTI_TYPE_ZERO_BYTE
10548 | OPTI_TYPE_SLOW_HASH_SIMD;
10549 dgst_pos0 = 0;
10550 dgst_pos1 = 1;
10551 dgst_pos2 = 2;
10552 dgst_pos3 = 3;
10553 break;
10554
10555 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10556 salt_type = SALT_TYPE_EMBEDDED;
10557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10558 opts_type = OPTS_TYPE_PT_GENERATE_LE
10559 | OPTS_TYPE_ST_BASE64
10560 | OPTS_TYPE_HASH_COPY;
10561 kern_type = KERN_TYPE_PBKDF2_SHA512;
10562 dgst_size = DGST_SIZE_8_16;
10563 parse_func = pbkdf2_sha512_parse_hash;
10564 sort_by_digest = sort_by_digest_8_16;
10565 opti_type = OPTI_TYPE_ZERO_BYTE
10566 | OPTI_TYPE_USES_BITS_64
10567 | OPTI_TYPE_SLOW_HASH_SIMD;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10578 kern_type = KERN_TYPE_ECRYPTFS;
10579 dgst_size = DGST_SIZE_8_8;
10580 parse_func = ecryptfs_parse_hash;
10581 sort_by_digest = sort_by_digest_8_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE
10583 | OPTI_TYPE_USES_BITS_64;
10584 dgst_pos0 = 0;
10585 dgst_pos1 = 1;
10586 dgst_pos2 = 2;
10587 dgst_pos3 = 3;
10588 break;
10589
10590 case 12300: hash_type = HASH_TYPE_ORACLET;
10591 salt_type = SALT_TYPE_EMBEDDED;
10592 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10593 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10594 kern_type = KERN_TYPE_ORACLET;
10595 dgst_size = DGST_SIZE_8_16;
10596 parse_func = oraclet_parse_hash;
10597 sort_by_digest = sort_by_digest_8_16;
10598 opti_type = OPTI_TYPE_ZERO_BYTE
10599 | OPTI_TYPE_USES_BITS_64;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10607 salt_type = SALT_TYPE_EMBEDDED;
10608 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10609 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10610 kern_type = KERN_TYPE_BSDICRYPT;
10611 dgst_size = DGST_SIZE_4_4;
10612 parse_func = bsdicrypt_parse_hash;
10613 sort_by_digest = sort_by_digest_4_4;
10614 opti_type = OPTI_TYPE_ZERO_BYTE
10615 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10616 dgst_pos0 = 0;
10617 dgst_pos1 = 1;
10618 dgst_pos2 = 2;
10619 dgst_pos3 = 3;
10620 break;
10621
10622 case 12500: hash_type = HASH_TYPE_RAR3HP;
10623 salt_type = SALT_TYPE_EMBEDDED;
10624 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10625 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10626 kern_type = KERN_TYPE_RAR3;
10627 dgst_size = DGST_SIZE_4_4;
10628 parse_func = rar3hp_parse_hash;
10629 sort_by_digest = sort_by_digest_4_4;
10630 opti_type = OPTI_TYPE_ZERO_BYTE;
10631 dgst_pos0 = 0;
10632 dgst_pos1 = 1;
10633 dgst_pos2 = 2;
10634 dgst_pos3 = 3;
10635 break;
10636
10637 case 12600: hash_type = HASH_TYPE_SHA256;
10638 salt_type = SALT_TYPE_INTERN;
10639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10640 opts_type = OPTS_TYPE_PT_GENERATE_BE
10641 | OPTS_TYPE_PT_ADD80;
10642 kern_type = KERN_TYPE_CF10;
10643 dgst_size = DGST_SIZE_4_8;
10644 parse_func = cf10_parse_hash;
10645 sort_by_digest = sort_by_digest_4_8;
10646 opti_type = OPTI_TYPE_ZERO_BYTE
10647 | OPTI_TYPE_PRECOMPUTE_INIT
10648 | OPTI_TYPE_EARLY_SKIP
10649 | OPTI_TYPE_NOT_ITERATED;
10650 dgst_pos0 = 3;
10651 dgst_pos1 = 7;
10652 dgst_pos2 = 2;
10653 dgst_pos3 = 6;
10654 break;
10655
10656 case 12700: hash_type = HASH_TYPE_AES;
10657 salt_type = SALT_TYPE_EMBEDDED;
10658 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10659 opts_type = OPTS_TYPE_PT_GENERATE_LE
10660 | OPTS_TYPE_HASH_COPY;
10661 kern_type = KERN_TYPE_MYWALLET;
10662 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10663 parse_func = mywallet_parse_hash;
10664 sort_by_digest = sort_by_digest_4_5;
10665 opti_type = OPTI_TYPE_ZERO_BYTE;
10666 dgst_pos0 = 0;
10667 dgst_pos1 = 1;
10668 dgst_pos2 = 2;
10669 dgst_pos3 = 3;
10670 break;
10671
10672 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10673 salt_type = SALT_TYPE_EMBEDDED;
10674 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10676 kern_type = KERN_TYPE_MS_DRSR;
10677 dgst_size = DGST_SIZE_4_8;
10678 parse_func = ms_drsr_parse_hash;
10679 sort_by_digest = sort_by_digest_4_8;
10680 opti_type = OPTI_TYPE_ZERO_BYTE;
10681 dgst_pos0 = 0;
10682 dgst_pos1 = 1;
10683 dgst_pos2 = 2;
10684 dgst_pos3 = 3;
10685 break;
10686
10687 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10688 salt_type = SALT_TYPE_EMBEDDED;
10689 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10691 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10692 dgst_size = DGST_SIZE_4_8;
10693 parse_func = androidfde_samsung_parse_hash;
10694 sort_by_digest = sort_by_digest_4_8;
10695 opti_type = OPTI_TYPE_ZERO_BYTE;
10696 dgst_pos0 = 0;
10697 dgst_pos1 = 1;
10698 dgst_pos2 = 2;
10699 dgst_pos3 = 3;
10700 break;
10701
10702 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10703 salt_type = SALT_TYPE_EMBEDDED;
10704 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10705 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10706 kern_type = KERN_TYPE_RAR5;
10707 dgst_size = DGST_SIZE_4_4;
10708 parse_func = rar5_parse_hash;
10709 sort_by_digest = sort_by_digest_4_4;
10710 opti_type = OPTI_TYPE_ZERO_BYTE;
10711 dgst_pos0 = 0;
10712 dgst_pos1 = 1;
10713 dgst_pos2 = 2;
10714 dgst_pos3 = 3;
10715 break;
10716
10717 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10718 salt_type = SALT_TYPE_EMBEDDED;
10719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10721 kern_type = KERN_TYPE_KRB5TGS;
10722 dgst_size = DGST_SIZE_4_4;
10723 parse_func = krb5tgs_parse_hash;
10724 sort_by_digest = sort_by_digest_4_4;
10725 opti_type = OPTI_TYPE_ZERO_BYTE
10726 | OPTI_TYPE_NOT_ITERATED;
10727 dgst_pos0 = 0;
10728 dgst_pos1 = 1;
10729 dgst_pos2 = 2;
10730 dgst_pos3 = 3;
10731 break;
10732
10733 case 13200: hash_type = HASH_TYPE_AES;
10734 salt_type = SALT_TYPE_EMBEDDED;
10735 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10736 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10737 kern_type = KERN_TYPE_AXCRYPT;
10738 dgst_size = DGST_SIZE_4_4;
10739 parse_func = axcrypt_parse_hash;
10740 sort_by_digest = sort_by_digest_4_4;
10741 opti_type = OPTI_TYPE_ZERO_BYTE;
10742 dgst_pos0 = 0;
10743 dgst_pos1 = 1;
10744 dgst_pos2 = 2;
10745 dgst_pos3 = 3;
10746 break;
10747
10748 case 13300: hash_type = HASH_TYPE_SHA1;
10749 salt_type = SALT_TYPE_NONE;
10750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10751 opts_type = OPTS_TYPE_PT_GENERATE_BE
10752 | OPTS_TYPE_PT_ADD80
10753 | OPTS_TYPE_PT_ADDBITS15;
10754 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10755 dgst_size = DGST_SIZE_4_5;
10756 parse_func = sha1axcrypt_parse_hash;
10757 sort_by_digest = sort_by_digest_4_5;
10758 opti_type = OPTI_TYPE_ZERO_BYTE
10759 | OPTI_TYPE_PRECOMPUTE_INIT
10760 | OPTI_TYPE_EARLY_SKIP
10761 | OPTI_TYPE_NOT_ITERATED
10762 | OPTI_TYPE_NOT_SALTED;
10763 dgst_pos0 = 0;
10764 dgst_pos1 = 4;
10765 dgst_pos2 = 3;
10766 dgst_pos3 = 2;
10767 break;
10768
10769 case 13400: hash_type = HASH_TYPE_AES;
10770 salt_type = SALT_TYPE_EMBEDDED;
10771 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10772 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10773 kern_type = KERN_TYPE_KEEPASS;
10774 dgst_size = DGST_SIZE_4_4;
10775 parse_func = keepass_parse_hash;
10776 sort_by_digest = sort_by_digest_4_4;
10777 opti_type = OPTI_TYPE_ZERO_BYTE;
10778 dgst_pos0 = 0;
10779 dgst_pos1 = 1;
10780 dgst_pos2 = 2;
10781 dgst_pos3 = 3;
10782 break;
10783
10784 case 13500: hash_type = HASH_TYPE_SHA1;
10785 salt_type = SALT_TYPE_EMBEDDED;
10786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10787 opts_type = OPTS_TYPE_PT_GENERATE_BE
10788 | OPTS_TYPE_PT_UNICODE
10789 | OPTS_TYPE_PT_ADD80;
10790 kern_type = KERN_TYPE_PSTOKEN;
10791 dgst_size = DGST_SIZE_4_5;
10792 parse_func = pstoken_parse_hash;
10793 sort_by_digest = sort_by_digest_4_5;
10794 opti_type = OPTI_TYPE_ZERO_BYTE
10795 | OPTI_TYPE_PRECOMPUTE_INIT
10796 | OPTI_TYPE_EARLY_SKIP
10797 | OPTI_TYPE_NOT_ITERATED
10798 | OPTI_TYPE_PREPENDED_SALT
10799 | OPTI_TYPE_RAW_HASH;
10800 dgst_pos0 = 3;
10801 dgst_pos1 = 4;
10802 dgst_pos2 = 2;
10803 dgst_pos3 = 1;
10804 break;
10805
10806 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10807 salt_type = SALT_TYPE_EMBEDDED;
10808 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10809 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10810 kern_type = KERN_TYPE_ZIP2;
10811 dgst_size = DGST_SIZE_4_4;
10812 parse_func = zip2_parse_hash;
10813 sort_by_digest = sort_by_digest_4_4;
10814 opti_type = OPTI_TYPE_ZERO_BYTE;
10815 dgst_pos0 = 0;
10816 dgst_pos1 = 1;
10817 dgst_pos2 = 2;
10818 dgst_pos3 = 3;
10819 break;
10820
10821 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10822 salt_type = SALT_TYPE_EMBEDDED;
10823 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10824 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10825 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10826 dgst_size = DGST_SIZE_4_5;
10827 parse_func = veracrypt_parse_hash_655331;
10828 sort_by_digest = sort_by_digest_4_5;
10829 opti_type = OPTI_TYPE_ZERO_BYTE;
10830 dgst_pos0 = 0;
10831 dgst_pos1 = 1;
10832 dgst_pos2 = 2;
10833 dgst_pos3 = 3;
10834 break;
10835
10836 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10837 salt_type = SALT_TYPE_EMBEDDED;
10838 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10839 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10840 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10841 dgst_size = DGST_SIZE_4_5;
10842 parse_func = veracrypt_parse_hash_655331;
10843 sort_by_digest = sort_by_digest_4_5;
10844 opti_type = OPTI_TYPE_ZERO_BYTE;
10845 dgst_pos0 = 0;
10846 dgst_pos1 = 1;
10847 dgst_pos2 = 2;
10848 dgst_pos3 = 3;
10849 break;
10850
10851 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10852 salt_type = SALT_TYPE_EMBEDDED;
10853 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10854 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10855 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10856 dgst_size = DGST_SIZE_4_5;
10857 parse_func = veracrypt_parse_hash_655331;
10858 sort_by_digest = sort_by_digest_4_5;
10859 opti_type = OPTI_TYPE_ZERO_BYTE;
10860 dgst_pos0 = 0;
10861 dgst_pos1 = 1;
10862 dgst_pos2 = 2;
10863 dgst_pos3 = 3;
10864 break;
10865
10866 case 13721: hash_type = HASH_TYPE_SHA512;
10867 salt_type = SALT_TYPE_EMBEDDED;
10868 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10869 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10870 kern_type = KERN_TYPE_TCSHA512_XTS512;
10871 dgst_size = DGST_SIZE_8_8;
10872 parse_func = veracrypt_parse_hash_500000;
10873 sort_by_digest = sort_by_digest_8_8;
10874 opti_type = OPTI_TYPE_ZERO_BYTE
10875 | OPTI_TYPE_USES_BITS_64;
10876 dgst_pos0 = 0;
10877 dgst_pos1 = 1;
10878 dgst_pos2 = 2;
10879 dgst_pos3 = 3;
10880 break;
10881
10882 case 13722: hash_type = HASH_TYPE_SHA512;
10883 salt_type = SALT_TYPE_EMBEDDED;
10884 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10885 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10886 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10887 dgst_size = DGST_SIZE_8_8;
10888 parse_func = veracrypt_parse_hash_500000;
10889 sort_by_digest = sort_by_digest_8_8;
10890 opti_type = OPTI_TYPE_ZERO_BYTE
10891 | OPTI_TYPE_USES_BITS_64;
10892 dgst_pos0 = 0;
10893 dgst_pos1 = 1;
10894 dgst_pos2 = 2;
10895 dgst_pos3 = 3;
10896 break;
10897
10898 case 13723: hash_type = HASH_TYPE_SHA512;
10899 salt_type = SALT_TYPE_EMBEDDED;
10900 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10901 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10902 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10903 dgst_size = DGST_SIZE_8_8;
10904 parse_func = veracrypt_parse_hash_500000;
10905 sort_by_digest = sort_by_digest_8_8;
10906 opti_type = OPTI_TYPE_ZERO_BYTE
10907 | OPTI_TYPE_USES_BITS_64;
10908 dgst_pos0 = 0;
10909 dgst_pos1 = 1;
10910 dgst_pos2 = 2;
10911 dgst_pos3 = 3;
10912 break;
10913
10914 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10915 salt_type = SALT_TYPE_EMBEDDED;
10916 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10917 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10918 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10919 dgst_size = DGST_SIZE_4_8;
10920 parse_func = veracrypt_parse_hash_500000;
10921 sort_by_digest = sort_by_digest_4_8;
10922 opti_type = OPTI_TYPE_ZERO_BYTE;
10923 dgst_pos0 = 0;
10924 dgst_pos1 = 1;
10925 dgst_pos2 = 2;
10926 dgst_pos3 = 3;
10927 break;
10928
10929 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10930 salt_type = SALT_TYPE_EMBEDDED;
10931 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10932 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10933 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10934 dgst_size = DGST_SIZE_4_8;
10935 parse_func = veracrypt_parse_hash_500000;
10936 sort_by_digest = sort_by_digest_4_8;
10937 opti_type = OPTI_TYPE_ZERO_BYTE;
10938 dgst_pos0 = 0;
10939 dgst_pos1 = 1;
10940 dgst_pos2 = 2;
10941 dgst_pos3 = 3;
10942 break;
10943
10944 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10945 salt_type = SALT_TYPE_EMBEDDED;
10946 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10947 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10948 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10949 dgst_size = DGST_SIZE_4_8;
10950 parse_func = veracrypt_parse_hash_500000;
10951 sort_by_digest = sort_by_digest_4_8;
10952 opti_type = OPTI_TYPE_ZERO_BYTE;
10953 dgst_pos0 = 0;
10954 dgst_pos1 = 1;
10955 dgst_pos2 = 2;
10956 dgst_pos3 = 3;
10957 break;
10958
10959 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10960 salt_type = SALT_TYPE_EMBEDDED;
10961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10963 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10964 dgst_size = DGST_SIZE_4_5;
10965 parse_func = veracrypt_parse_hash_327661;
10966 sort_by_digest = sort_by_digest_4_5;
10967 opti_type = OPTI_TYPE_ZERO_BYTE;
10968 dgst_pos0 = 0;
10969 dgst_pos1 = 1;
10970 dgst_pos2 = 2;
10971 dgst_pos3 = 3;
10972 break;
10973
10974 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10975 salt_type = SALT_TYPE_EMBEDDED;
10976 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10977 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10978 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10979 dgst_size = DGST_SIZE_4_5;
10980 parse_func = veracrypt_parse_hash_327661;
10981 sort_by_digest = sort_by_digest_4_5;
10982 opti_type = OPTI_TYPE_ZERO_BYTE;
10983 dgst_pos0 = 0;
10984 dgst_pos1 = 1;
10985 dgst_pos2 = 2;
10986 dgst_pos3 = 3;
10987 break;
10988
10989 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10990 salt_type = SALT_TYPE_EMBEDDED;
10991 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10992 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10993 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10994 dgst_size = DGST_SIZE_4_5;
10995 parse_func = veracrypt_parse_hash_327661;
10996 sort_by_digest = sort_by_digest_4_5;
10997 opti_type = OPTI_TYPE_ZERO_BYTE;
10998 dgst_pos0 = 0;
10999 dgst_pos1 = 1;
11000 dgst_pos2 = 2;
11001 dgst_pos3 = 3;
11002 break;
11003
11004 case 13751: hash_type = HASH_TYPE_SHA256;
11005 salt_type = SALT_TYPE_EMBEDDED;
11006 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11007 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11008 kern_type = KERN_TYPE_VCSHA256_XTS512;
11009 dgst_size = DGST_SIZE_4_8;
11010 parse_func = veracrypt_parse_hash_500000;
11011 sort_by_digest = sort_by_digest_4_8;
11012 opti_type = OPTI_TYPE_ZERO_BYTE;
11013 dgst_pos0 = 0;
11014 dgst_pos1 = 1;
11015 dgst_pos2 = 2;
11016 dgst_pos3 = 3;
11017 break;
11018
11019 case 13752: hash_type = HASH_TYPE_SHA256;
11020 salt_type = SALT_TYPE_EMBEDDED;
11021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11022 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11023 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11024 dgst_size = DGST_SIZE_4_8;
11025 parse_func = veracrypt_parse_hash_500000;
11026 sort_by_digest = sort_by_digest_4_8;
11027 opti_type = OPTI_TYPE_ZERO_BYTE;
11028 dgst_pos0 = 0;
11029 dgst_pos1 = 1;
11030 dgst_pos2 = 2;
11031 dgst_pos3 = 3;
11032 break;
11033
11034 case 13753: hash_type = HASH_TYPE_SHA256;
11035 salt_type = SALT_TYPE_EMBEDDED;
11036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11037 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11038 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11039 dgst_size = DGST_SIZE_4_8;
11040 parse_func = veracrypt_parse_hash_500000;
11041 sort_by_digest = sort_by_digest_4_8;
11042 opti_type = OPTI_TYPE_ZERO_BYTE;
11043 dgst_pos0 = 0;
11044 dgst_pos1 = 1;
11045 dgst_pos2 = 2;
11046 dgst_pos3 = 3;
11047 break;
11048
11049 case 13761: hash_type = HASH_TYPE_SHA256;
11050 salt_type = SALT_TYPE_EMBEDDED;
11051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11052 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11053 kern_type = KERN_TYPE_VCSHA256_XTS512;
11054 dgst_size = DGST_SIZE_4_8;
11055 parse_func = veracrypt_parse_hash_200000;
11056 sort_by_digest = sort_by_digest_4_8;
11057 opti_type = OPTI_TYPE_ZERO_BYTE;
11058 dgst_pos0 = 0;
11059 dgst_pos1 = 1;
11060 dgst_pos2 = 2;
11061 dgst_pos3 = 3;
11062 break;
11063
11064 case 13762: hash_type = HASH_TYPE_SHA256;
11065 salt_type = SALT_TYPE_EMBEDDED;
11066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11068 kern_type = KERN_TYPE_VCSHA256_XTS1024;
11069 dgst_size = DGST_SIZE_4_8;
11070 parse_func = veracrypt_parse_hash_200000;
11071 sort_by_digest = sort_by_digest_4_8;
11072 opti_type = OPTI_TYPE_ZERO_BYTE;
11073 dgst_pos0 = 0;
11074 dgst_pos1 = 1;
11075 dgst_pos2 = 2;
11076 dgst_pos3 = 3;
11077 break;
11078
11079 case 13763: hash_type = HASH_TYPE_SHA256;
11080 salt_type = SALT_TYPE_EMBEDDED;
11081 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
11082 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
11083 kern_type = KERN_TYPE_VCSHA256_XTS1536;
11084 dgst_size = DGST_SIZE_4_8;
11085 parse_func = veracrypt_parse_hash_200000;
11086 sort_by_digest = sort_by_digest_4_8;
11087 opti_type = OPTI_TYPE_ZERO_BYTE;
11088 dgst_pos0 = 0;
11089 dgst_pos1 = 1;
11090 dgst_pos2 = 2;
11091 dgst_pos3 = 3;
11092 break;
11093
11094 case 13800: hash_type = HASH_TYPE_SHA256;
11095 salt_type = SALT_TYPE_EMBEDDED;
11096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
11097 opts_type = OPTS_TYPE_PT_GENERATE_BE
11098 | OPTS_TYPE_PT_UNICODE;
11099 kern_type = KERN_TYPE_WIN8PHONE;
11100 dgst_size = DGST_SIZE_4_8;
11101 parse_func = win8phone_parse_hash;
11102 sort_by_digest = sort_by_digest_4_8;
11103 opti_type = OPTI_TYPE_ZERO_BYTE
11104 | OPTI_TYPE_PRECOMPUTE_INIT
11105 | OPTI_TYPE_EARLY_SKIP
11106 | OPTI_TYPE_NOT_ITERATED
11107 | OPTI_TYPE_RAW_HASH;
11108 dgst_pos0 = 3;
11109 dgst_pos1 = 7;
11110 dgst_pos2 = 2;
11111 dgst_pos3 = 6;
11112 break;
11113
11114 default: usage_mini_print (PROGNAME); return (-1);
11115 }
11116
11117 /**
11118 * parser
11119 */
11120
11121 data.parse_func = parse_func;
11122
11123 /**
11124 * misc stuff
11125 */
11126
11127 if (hex_salt)
11128 {
11129 if (salt_type == SALT_TYPE_INTERN)
11130 {
11131 opts_type |= OPTS_TYPE_ST_HEX;
11132 }
11133 else
11134 {
11135 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
11136
11137 return (-1);
11138 }
11139 }
11140
11141 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
11142 | (salt_type == SALT_TYPE_EXTERN)
11143 | (salt_type == SALT_TYPE_EMBEDDED)
11144 | (salt_type == SALT_TYPE_VIRTUAL));
11145
11146 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
11147
11148 data.hash_type = hash_type;
11149 data.attack_mode = attack_mode;
11150 data.attack_kern = attack_kern;
11151 data.attack_exec = attack_exec;
11152 data.kern_type = kern_type;
11153 data.opts_type = opts_type;
11154 data.dgst_size = dgst_size;
11155 data.salt_type = salt_type;
11156 data.isSalted = isSalted;
11157 data.sort_by_digest = sort_by_digest;
11158 data.dgst_pos0 = dgst_pos0;
11159 data.dgst_pos1 = dgst_pos1;
11160 data.dgst_pos2 = dgst_pos2;
11161 data.dgst_pos3 = dgst_pos3;
11162
11163 esalt_size = 0;
11164
11165 switch (hash_mode)
11166 {
11167 case 2500: esalt_size = sizeof (wpa_t); break;
11168 case 5300: esalt_size = sizeof (ikepsk_t); break;
11169 case 5400: esalt_size = sizeof (ikepsk_t); break;
11170 case 5500: esalt_size = sizeof (netntlm_t); break;
11171 case 5600: esalt_size = sizeof (netntlm_t); break;
11172 case 6211: esalt_size = sizeof (tc_t); break;
11173 case 6212: esalt_size = sizeof (tc_t); break;
11174 case 6213: esalt_size = sizeof (tc_t); break;
11175 case 6221: esalt_size = sizeof (tc_t); break;
11176 case 6222: esalt_size = sizeof (tc_t); break;
11177 case 6223: esalt_size = sizeof (tc_t); break;
11178 case 6231: esalt_size = sizeof (tc_t); break;
11179 case 6232: esalt_size = sizeof (tc_t); break;
11180 case 6233: esalt_size = sizeof (tc_t); break;
11181 case 6241: esalt_size = sizeof (tc_t); break;
11182 case 6242: esalt_size = sizeof (tc_t); break;
11183 case 6243: esalt_size = sizeof (tc_t); break;
11184 case 6600: esalt_size = sizeof (agilekey_t); break;
11185 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11186 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
11187 case 7300: esalt_size = sizeof (rakp_t); break;
11188 case 7500: esalt_size = sizeof (krb5pa_t); break;
11189 case 8200: esalt_size = sizeof (cloudkey_t); break;
11190 case 8800: esalt_size = sizeof (androidfde_t); break;
11191 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
11192 case 9400: esalt_size = sizeof (office2007_t); break;
11193 case 9500: esalt_size = sizeof (office2010_t); break;
11194 case 9600: esalt_size = sizeof (office2013_t); break;
11195 case 9700: esalt_size = sizeof (oldoffice01_t); break;
11196 case 9710: esalt_size = sizeof (oldoffice01_t); break;
11197 case 9720: esalt_size = sizeof (oldoffice01_t); break;
11198 case 9800: esalt_size = sizeof (oldoffice34_t); break;
11199 case 9810: esalt_size = sizeof (oldoffice34_t); break;
11200 case 9820: esalt_size = sizeof (oldoffice34_t); break;
11201 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
11202 case 10200: esalt_size = sizeof (cram_md5_t); break;
11203 case 10400: esalt_size = sizeof (pdf_t); break;
11204 case 10410: esalt_size = sizeof (pdf_t); break;
11205 case 10420: esalt_size = sizeof (pdf_t); break;
11206 case 10500: esalt_size = sizeof (pdf_t); break;
11207 case 10600: esalt_size = sizeof (pdf_t); break;
11208 case 10700: esalt_size = sizeof (pdf_t); break;
11209 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
11210 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
11211 case 11400: esalt_size = sizeof (sip_t); break;
11212 case 11600: esalt_size = sizeof (seven_zip_t); break;
11213 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
11214 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
11215 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
11216 case 13000: esalt_size = sizeof (rar5_t); break;
11217 case 13100: esalt_size = sizeof (krb5tgs_t); break;
11218 case 13400: esalt_size = sizeof (keepass_t); break;
11219 case 13500: esalt_size = sizeof (pstoken_t); break;
11220 case 13600: esalt_size = sizeof (zip2_t); break;
11221 case 13711: esalt_size = sizeof (tc_t); break;
11222 case 13712: esalt_size = sizeof (tc_t); break;
11223 case 13713: esalt_size = sizeof (tc_t); break;
11224 case 13721: esalt_size = sizeof (tc_t); break;
11225 case 13722: esalt_size = sizeof (tc_t); break;
11226 case 13723: esalt_size = sizeof (tc_t); break;
11227 case 13731: esalt_size = sizeof (tc_t); break;
11228 case 13732: esalt_size = sizeof (tc_t); break;
11229 case 13733: esalt_size = sizeof (tc_t); break;
11230 case 13741: esalt_size = sizeof (tc_t); break;
11231 case 13742: esalt_size = sizeof (tc_t); break;
11232 case 13743: esalt_size = sizeof (tc_t); break;
11233 case 13751: esalt_size = sizeof (tc_t); break;
11234 case 13752: esalt_size = sizeof (tc_t); break;
11235 case 13753: esalt_size = sizeof (tc_t); break;
11236 case 13761: esalt_size = sizeof (tc_t); break;
11237 case 13762: esalt_size = sizeof (tc_t); break;
11238 case 13763: esalt_size = sizeof (tc_t); break;
11239 case 13800: esalt_size = sizeof (win8phone_t); break;
11240 }
11241
11242 data.esalt_size = esalt_size;
11243
11244 /**
11245 * choose dictionary parser
11246 */
11247
11248 if (hash_type == HASH_TYPE_LM)
11249 {
11250 get_next_word_func = get_next_word_lm;
11251 }
11252 else if (opts_type & OPTS_TYPE_PT_UPPER)
11253 {
11254 get_next_word_func = get_next_word_uc;
11255 }
11256 else
11257 {
11258 get_next_word_func = get_next_word_std;
11259 }
11260
11261 /**
11262 * dictstat
11263 */
11264
11265 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
11266
11267 #ifdef _POSIX
11268 size_t dictstat_nmemb = 0;
11269 #endif
11270
11271 #ifdef _WIN
11272 uint dictstat_nmemb = 0;
11273 #endif
11274
11275 char dictstat[256] = { 0 };
11276
11277 FILE *dictstat_fp = NULL;
11278
11279 if (keyspace == 0)
11280 {
11281 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
11282
11283 dictstat_fp = fopen (dictstat, "rb");
11284
11285 if (dictstat_fp)
11286 {
11287 #ifdef _POSIX
11288 struct stat tmpstat;
11289
11290 fstat (fileno (dictstat_fp), &tmpstat);
11291 #endif
11292
11293 #ifdef _WIN
11294 struct stat64 tmpstat;
11295
11296 _fstat64 (fileno (dictstat_fp), &tmpstat);
11297 #endif
11298
11299 if (tmpstat.st_mtime < COMPTIME)
11300 {
11301 /* with v0.15 the format changed so we have to ensure user is using a good version
11302 since there is no version-header in the dictstat file */
11303
11304 fclose (dictstat_fp);
11305
11306 unlink (dictstat);
11307 }
11308 else
11309 {
11310 while (!feof (dictstat_fp))
11311 {
11312 dictstat_t d;
11313
11314 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11315
11316 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11317
11318 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11319 {
11320 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11321
11322 return -1;
11323 }
11324 }
11325
11326 fclose (dictstat_fp);
11327 }
11328 }
11329 }
11330
11331 /**
11332 * potfile
11333 */
11334
11335 char potfile[256] = { 0 };
11336
11337 if (potfile_path == NULL)
11338 {
11339 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11340 }
11341 else
11342 {
11343 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11344 }
11345
11346 data.pot_fp = NULL;
11347
11348 FILE *out_fp = NULL;
11349 FILE *pot_fp = NULL;
11350
11351 if (show == 1 || left == 1)
11352 {
11353 pot_fp = fopen (potfile, "rb");
11354
11355 if (pot_fp == NULL)
11356 {
11357 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11358
11359 return (-1);
11360 }
11361
11362 if (outfile != NULL)
11363 {
11364 if ((out_fp = fopen (outfile, "ab")) == NULL)
11365 {
11366 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11367
11368 fclose (pot_fp);
11369
11370 return (-1);
11371 }
11372 }
11373 else
11374 {
11375 out_fp = stdout;
11376 }
11377 }
11378 else
11379 {
11380 if (potfile_disable == 0)
11381 {
11382 pot_fp = fopen (potfile, "ab");
11383
11384 if (pot_fp == NULL)
11385 {
11386 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11387
11388 return (-1);
11389 }
11390
11391 data.pot_fp = pot_fp;
11392 }
11393 }
11394
11395 pot_t *pot = NULL;
11396
11397 uint pot_cnt = 0;
11398 uint pot_avail = 0;
11399
11400 if (show == 1 || left == 1)
11401 {
11402 SUPPRESS_OUTPUT = 1;
11403
11404 pot_avail = count_lines (pot_fp);
11405
11406 rewind (pot_fp);
11407
11408 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11409
11410 uint pot_hashes_avail = 0;
11411
11412 uint line_num = 0;
11413
11414 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11415
11416 while (!feof (pot_fp))
11417 {
11418 line_num++;
11419
11420 int line_len = fgetl (pot_fp, line_buf);
11421
11422 if (line_len == 0) continue;
11423
11424 char *plain_buf = line_buf + line_len;
11425
11426 pot_t *pot_ptr = &pot[pot_cnt];
11427
11428 hash_t *hashes_buf = &pot_ptr->hash;
11429
11430 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11431 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11432
11433 if (pot_cnt == pot_hashes_avail)
11434 {
11435 uint pos = 0;
11436
11437 for (pos = 0; pos < INCR_POT; pos++)
11438 {
11439 if ((pot_cnt + pos) >= pot_avail) break;
11440
11441 pot_t *tmp_pot = &pot[pot_cnt + pos];
11442
11443 hash_t *tmp_hash = &tmp_pot->hash;
11444
11445 tmp_hash->digest = mymalloc (dgst_size);
11446
11447 if (isSalted)
11448 {
11449 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11450 }
11451
11452 if (esalt_size)
11453 {
11454 tmp_hash->esalt = mymalloc (esalt_size);
11455 }
11456
11457 pot_hashes_avail++;
11458 }
11459 }
11460
11461 int plain_len = 0;
11462
11463 int parser_status;
11464
11465 int iter = MAX_CUT_TRIES;
11466
11467 do
11468 {
11469 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11470 {
11471 if (line_buf[i] == ':')
11472 {
11473 line_len--;
11474
11475 break;
11476 }
11477 }
11478
11479 if (data.hash_mode != 2500)
11480 {
11481 parser_status = parse_func (line_buf, line_len, hashes_buf);
11482 }
11483 else
11484 {
11485 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11486
11487 if (line_len > max_salt_size)
11488 {
11489 parser_status = PARSER_GLOBAL_LENGTH;
11490 }
11491 else
11492 {
11493 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11494
11495 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11496
11497 hashes_buf->salt->salt_len = line_len;
11498
11499 parser_status = PARSER_OK;
11500 }
11501 }
11502
11503 // if NOT parsed without error, we add the ":" to the plain
11504
11505 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11506 {
11507 plain_len++;
11508 plain_buf--;
11509 }
11510
11511 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11512
11513 if (parser_status < PARSER_GLOBAL_ZERO)
11514 {
11515 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11516
11517 continue;
11518 }
11519
11520 if (plain_len >= 255) continue;
11521
11522 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11523
11524 pot_ptr->plain_len = plain_len;
11525
11526 pot_cnt++;
11527 }
11528
11529 myfree (line_buf);
11530
11531 fclose (pot_fp);
11532
11533 SUPPRESS_OUTPUT = 0;
11534
11535 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11536 }
11537
11538 /**
11539 * word len
11540 */
11541
11542 uint pw_min = PW_MIN;
11543 uint pw_max = PW_MAX;
11544
11545 switch (hash_mode)
11546 {
11547 case 125: if (pw_max > 32) pw_max = 32;
11548 break;
11549 case 400: if (pw_max > 40) pw_max = 40;
11550 break;
11551 case 500: if (pw_max > 16) pw_max = 16;
11552 break;
11553 case 1500: if (pw_max > 8) pw_max = 8;
11554 break;
11555 case 1600: if (pw_max > 16) pw_max = 16;
11556 break;
11557 case 1800: if (pw_max > 16) pw_max = 16;
11558 break;
11559 case 2100: if (pw_max > 16) pw_max = 16;
11560 break;
11561 case 2500: if (pw_min < 8) pw_min = 8;
11562 break;
11563 case 3000: if (pw_max > 7) pw_max = 7;
11564 break;
11565 case 5200: if (pw_max > 24) pw_max = 24;
11566 break;
11567 case 5800: if (pw_max > 16) pw_max = 16;
11568 break;
11569 case 6300: if (pw_max > 16) pw_max = 16;
11570 break;
11571 case 7400: if (pw_max > 16) pw_max = 16;
11572 break;
11573 case 7700: if (pw_max > 8) pw_max = 8;
11574 break;
11575 case 7900: if (pw_max > 48) pw_max = 48;
11576 break;
11577 case 8500: if (pw_max > 8) pw_max = 8;
11578 break;
11579 case 8600: if (pw_max > 16) pw_max = 16;
11580 break;
11581 case 9710: pw_min = 5;
11582 pw_max = 5;
11583 break;
11584 case 9810: pw_min = 5;
11585 pw_max = 5;
11586 break;
11587 case 10410: pw_min = 5;
11588 pw_max = 5;
11589 break;
11590 case 10300: if (pw_max < 3) pw_min = 3;
11591 if (pw_max > 40) pw_max = 40;
11592 break;
11593 case 10500: if (pw_max < 3) pw_min = 3;
11594 if (pw_max > 40) pw_max = 40;
11595 break;
11596 case 10700: if (pw_max > 16) pw_max = 16;
11597 break;
11598 case 11300: if (pw_max > 40) pw_max = 40;
11599 break;
11600 case 11600: if (pw_max > 32) pw_max = 32;
11601 break;
11602 case 12500: if (pw_max > 20) pw_max = 20;
11603 break;
11604 case 12800: if (pw_max > 24) pw_max = 24;
11605 break;
11606 }
11607
11608 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11609 {
11610 switch (attack_kern)
11611 {
11612 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11613 break;
11614 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11615 break;
11616 }
11617 }
11618
11619 /**
11620 * charsets : keep them together for more easy maintainnce
11621 */
11622
11623 cs_t mp_sys[6] = { { { 0 }, 0 } };
11624 cs_t mp_usr[4] = { { { 0 }, 0 } };
11625
11626 mp_setup_sys (mp_sys);
11627
11628 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11629 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11630 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11631 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11632
11633 /**
11634 * load hashes, part I: find input mode, count hashes
11635 */
11636
11637 uint hashlist_mode = 0;
11638 uint hashlist_format = HLFMT_HASHCAT;
11639
11640 uint hashes_avail = 0;
11641
11642 if ((benchmark == 0) && (stdout_flag == 0))
11643 {
11644 struct stat f;
11645
11646 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11647
11648 if ((hash_mode == 2500) ||
11649 (hash_mode == 5200) ||
11650 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11651 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11652 (hash_mode == 9000))
11653 {
11654 hashlist_mode = HL_MODE_ARG;
11655
11656 char *hashfile = myargv[optind];
11657
11658 data.hashfile = hashfile;
11659
11660 logfile_top_var_string ("target", hashfile);
11661 }
11662
11663 if (hashlist_mode == HL_MODE_ARG)
11664 {
11665 if (hash_mode == 2500)
11666 {
11667 struct stat st;
11668
11669 if (stat (data.hashfile, &st) == -1)
11670 {
11671 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11672
11673 return (-1);
11674 }
11675
11676 hashes_avail = st.st_size / sizeof (hccap_t);
11677 }
11678 else
11679 {
11680 hashes_avail = 1;
11681 }
11682 }
11683 else if (hashlist_mode == HL_MODE_FILE)
11684 {
11685 char *hashfile = myargv[optind];
11686
11687 data.hashfile = hashfile;
11688
11689 logfile_top_var_string ("target", hashfile);
11690
11691 FILE *fp = NULL;
11692
11693 if ((fp = fopen (hashfile, "rb")) == NULL)
11694 {
11695 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11696
11697 return (-1);
11698 }
11699
11700 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11701
11702 hashes_avail = count_lines (fp);
11703
11704 rewind (fp);
11705
11706 if (hashes_avail == 0)
11707 {
11708 log_error ("ERROR: hashfile is empty or corrupt");
11709
11710 fclose (fp);
11711
11712 return (-1);
11713 }
11714
11715 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11716
11717 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11718 {
11719 log_error ("ERROR: remove not supported in native hashfile-format mode");
11720
11721 fclose (fp);
11722
11723 return (-1);
11724 }
11725
11726 fclose (fp);
11727 }
11728 }
11729 else
11730 {
11731 hashlist_mode = HL_MODE_ARG;
11732
11733 hashes_avail = 1;
11734 }
11735
11736 if (hash_mode == 3000) hashes_avail *= 2;
11737
11738 data.hashlist_mode = hashlist_mode;
11739 data.hashlist_format = hashlist_format;
11740
11741 logfile_top_uint (hashlist_mode);
11742 logfile_top_uint (hashlist_format);
11743
11744 /**
11745 * load hashes, part II: allocate required memory, set pointers
11746 */
11747
11748 hash_t *hashes_buf = NULL;
11749 void *digests_buf = NULL;
11750 salt_t *salts_buf = NULL;
11751 void *esalts_buf = NULL;
11752
11753 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11754
11755 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11756
11757 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11758 {
11759 u32 hash_pos;
11760
11761 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11762 {
11763 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11764
11765 hashes_buf[hash_pos].hash_info = hash_info;
11766
11767 if (username && (remove || show || left))
11768 {
11769 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11770 }
11771
11772 if (benchmark)
11773 {
11774 hash_info->orighash = (char *) mymalloc (256);
11775 }
11776 }
11777 }
11778
11779 if (isSalted)
11780 {
11781 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11782
11783 if (esalt_size)
11784 {
11785 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11786 }
11787 }
11788 else
11789 {
11790 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11791 }
11792
11793 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11794 {
11795 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11796
11797 if (isSalted)
11798 {
11799 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11800
11801 if (esalt_size)
11802 {
11803 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11804 }
11805 }
11806 else
11807 {
11808 hashes_buf[hash_pos].salt = &salts_buf[0];
11809 }
11810 }
11811
11812 /**
11813 * load hashes, part III: parse hashes or generate them if benchmark
11814 */
11815
11816 uint hashes_cnt = 0;
11817
11818 if (benchmark == 0)
11819 {
11820 if (keyspace == 1)
11821 {
11822 // useless to read hash file for keyspace, cheat a little bit w/ optind
11823 }
11824 else if (stdout_flag == 1)
11825 {
11826 // useless to read hash file for stdout, cheat a little bit w/ optind
11827 }
11828 else if (hashes_avail == 0)
11829 {
11830 }
11831 else if (hashlist_mode == HL_MODE_ARG)
11832 {
11833 char *input_buf = myargv[optind];
11834
11835 uint input_len = strlen (input_buf);
11836
11837 logfile_top_var_string ("target", input_buf);
11838
11839 char *hash_buf = NULL;
11840 int hash_len = 0;
11841
11842 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11843
11844 bool hash_fmt_error = 0;
11845
11846 if (hash_len < 1) hash_fmt_error = 1;
11847 if (hash_buf == NULL) hash_fmt_error = 1;
11848
11849 if (hash_fmt_error)
11850 {
11851 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11852 }
11853 else
11854 {
11855 if (opts_type & OPTS_TYPE_HASH_COPY)
11856 {
11857 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11858
11859 hash_info_tmp->orighash = mystrdup (hash_buf);
11860 }
11861
11862 if (isSalted)
11863 {
11864 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11865 }
11866
11867 int parser_status = PARSER_OK;
11868
11869 if (hash_mode == 2500)
11870 {
11871 if (hash_len == 0)
11872 {
11873 log_error ("ERROR: hccap file not specified");
11874
11875 return (-1);
11876 }
11877
11878 hashlist_mode = HL_MODE_FILE;
11879
11880 data.hashlist_mode = hashlist_mode;
11881
11882 FILE *fp = fopen (hash_buf, "rb");
11883
11884 if (fp == NULL)
11885 {
11886 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11887
11888 return (-1);
11889 }
11890
11891 if (hashes_avail < 1)
11892 {
11893 log_error ("ERROR: hccap file is empty or corrupt");
11894
11895 fclose (fp);
11896
11897 return (-1);
11898 }
11899
11900 uint hccap_size = sizeof (hccap_t);
11901
11902 char *in = (char *) mymalloc (hccap_size);
11903
11904 while (!feof (fp))
11905 {
11906 int n = fread (in, hccap_size, 1, fp);
11907
11908 if (n != 1)
11909 {
11910 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11911
11912 break;
11913 }
11914
11915 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11916
11917 if (parser_status != PARSER_OK)
11918 {
11919 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11920
11921 continue;
11922 }
11923
11924 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11925
11926 if ((show == 1) || (left == 1))
11927 {
11928 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11929
11930 char *salt_ptr = (char *) tmp_salt->salt_buf;
11931
11932 int cur_pos = tmp_salt->salt_len;
11933 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11934
11935 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11936
11937 // do the appending task
11938
11939 snprintf (salt_ptr + cur_pos,
11940 rem_len,
11941 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11942 wpa->orig_mac1[0],
11943 wpa->orig_mac1[1],
11944 wpa->orig_mac1[2],
11945 wpa->orig_mac1[3],
11946 wpa->orig_mac1[4],
11947 wpa->orig_mac1[5],
11948 wpa->orig_mac2[0],
11949 wpa->orig_mac2[1],
11950 wpa->orig_mac2[2],
11951 wpa->orig_mac2[3],
11952 wpa->orig_mac2[4],
11953 wpa->orig_mac2[5]);
11954
11955 // memset () the remaining part of the salt
11956
11957 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11958 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11959
11960 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11961
11962 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11963 }
11964
11965 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);
11966 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);
11967
11968 hashes_cnt++;
11969 }
11970
11971 fclose (fp);
11972
11973 myfree (in);
11974 }
11975 else if (hash_mode == 3000)
11976 {
11977 if (hash_len == 32)
11978 {
11979 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11980
11981 hash_t *lm_hash_left = NULL;
11982
11983 if (parser_status == PARSER_OK)
11984 {
11985 lm_hash_left = &hashes_buf[hashes_cnt];
11986
11987 hashes_cnt++;
11988 }
11989 else
11990 {
11991 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11992 }
11993
11994 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11995
11996 hash_t *lm_hash_right = NULL;
11997
11998 if (parser_status == PARSER_OK)
11999 {
12000 lm_hash_right = &hashes_buf[hashes_cnt];
12001
12002 hashes_cnt++;
12003 }
12004 else
12005 {
12006 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12007 }
12008
12009 // show / left
12010
12011 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
12012 {
12013 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);
12014 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);
12015 }
12016 }
12017 else
12018 {
12019 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12020
12021 if (parser_status == PARSER_OK)
12022 {
12023 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12024 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12025 }
12026
12027 if (parser_status == PARSER_OK)
12028 {
12029 hashes_cnt++;
12030 }
12031 else
12032 {
12033 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12034 }
12035 }
12036 }
12037 else
12038 {
12039 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12040
12041 if (parser_status == PARSER_OK)
12042 {
12043 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12044 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12045 }
12046
12047 if (parser_status == PARSER_OK)
12048 {
12049 hashes_cnt++;
12050 }
12051 else
12052 {
12053 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
12054 }
12055 }
12056 }
12057 }
12058 else if (hashlist_mode == HL_MODE_FILE)
12059 {
12060 char *hashfile = data.hashfile;
12061
12062 FILE *fp;
12063
12064 if ((fp = fopen (hashfile, "rb")) == NULL)
12065 {
12066 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
12067
12068 return (-1);
12069 }
12070
12071 uint line_num = 0;
12072
12073 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12074
12075 while (!feof (fp))
12076 {
12077 line_num++;
12078
12079 int line_len = fgetl (fp, line_buf);
12080
12081 if (line_len == 0) continue;
12082
12083 char *hash_buf = NULL;
12084 int hash_len = 0;
12085
12086 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
12087
12088 bool hash_fmt_error = 0;
12089
12090 if (hash_len < 1) hash_fmt_error = 1;
12091 if (hash_buf == NULL) hash_fmt_error = 1;
12092
12093 if (hash_fmt_error)
12094 {
12095 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
12096
12097 continue;
12098 }
12099
12100 if (username)
12101 {
12102 char *user_buf = NULL;
12103 int user_len = 0;
12104
12105 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
12106
12107 if (remove || show)
12108 {
12109 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
12110
12111 *user = (user_t *) mymalloc (sizeof (user_t));
12112
12113 user_t *user_ptr = *user;
12114
12115 if (user_buf != NULL)
12116 {
12117 user_ptr->user_name = mystrdup (user_buf);
12118 }
12119 else
12120 {
12121 user_ptr->user_name = mystrdup ("");
12122 }
12123
12124 user_ptr->user_len = user_len;
12125 }
12126 }
12127
12128 if (opts_type & OPTS_TYPE_HASH_COPY)
12129 {
12130 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
12131
12132 hash_info_tmp->orighash = mystrdup (hash_buf);
12133 }
12134
12135 if (isSalted)
12136 {
12137 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
12138 }
12139
12140 if (hash_mode == 3000)
12141 {
12142 if (hash_len == 32)
12143 {
12144 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
12145
12146 if (parser_status < PARSER_GLOBAL_ZERO)
12147 {
12148 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12149
12150 continue;
12151 }
12152
12153 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
12154
12155 hashes_cnt++;
12156
12157 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
12158
12159 if (parser_status < PARSER_GLOBAL_ZERO)
12160 {
12161 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12162
12163 continue;
12164 }
12165
12166 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
12167
12168 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);
12169
12170 hashes_cnt++;
12171
12172 // show / left
12173
12174 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);
12175 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);
12176 }
12177 else
12178 {
12179 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12180
12181 if (parser_status < PARSER_GLOBAL_ZERO)
12182 {
12183 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12184
12185 continue;
12186 }
12187
12188 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);
12189
12190 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12191 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12192
12193 hashes_cnt++;
12194 }
12195 }
12196 else
12197 {
12198 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
12199
12200 if (parser_status < PARSER_GLOBAL_ZERO)
12201 {
12202 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
12203
12204 continue;
12205 }
12206
12207 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);
12208
12209 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12210 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
12211
12212 hashes_cnt++;
12213 }
12214 }
12215
12216 myfree (line_buf);
12217
12218 fclose (fp);
12219
12220 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
12221
12222 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
12223 }
12224 }
12225 else
12226 {
12227 if (isSalted)
12228 {
12229 hashes_buf[0].salt->salt_len = 8;
12230
12231 // special salt handling
12232
12233 switch (hash_mode)
12234 {
12235 case 1500: hashes_buf[0].salt->salt_len = 2;
12236 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
12237 break;
12238 case 1731: hashes_buf[0].salt->salt_len = 4;
12239 break;
12240 case 2410: hashes_buf[0].salt->salt_len = 4;
12241 break;
12242 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
12243 break;
12244 case 3100: hashes_buf[0].salt->salt_len = 1;
12245 break;
12246 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
12247 break;
12248 case 5800: hashes_buf[0].salt->salt_len = 16;
12249 break;
12250 case 6800: hashes_buf[0].salt->salt_len = 32;
12251 break;
12252 case 8400: hashes_buf[0].salt->salt_len = 40;
12253 break;
12254 case 8800: hashes_buf[0].salt->salt_len = 16;
12255 break;
12256 case 8900: hashes_buf[0].salt->salt_len = 16;
12257 hashes_buf[0].salt->scrypt_N = 1024;
12258 hashes_buf[0].salt->scrypt_r = 1;
12259 hashes_buf[0].salt->scrypt_p = 1;
12260 break;
12261 case 9100: hashes_buf[0].salt->salt_len = 16;
12262 break;
12263 case 9300: hashes_buf[0].salt->salt_len = 14;
12264 hashes_buf[0].salt->scrypt_N = 16384;
12265 hashes_buf[0].salt->scrypt_r = 1;
12266 hashes_buf[0].salt->scrypt_p = 1;
12267 break;
12268 case 9400: hashes_buf[0].salt->salt_len = 16;
12269 break;
12270 case 9500: hashes_buf[0].salt->salt_len = 16;
12271 break;
12272 case 9600: hashes_buf[0].salt->salt_len = 16;
12273 break;
12274 case 9700: hashes_buf[0].salt->salt_len = 16;
12275 break;
12276 case 9710: hashes_buf[0].salt->salt_len = 16;
12277 break;
12278 case 9720: hashes_buf[0].salt->salt_len = 16;
12279 break;
12280 case 9800: hashes_buf[0].salt->salt_len = 16;
12281 break;
12282 case 9810: hashes_buf[0].salt->salt_len = 16;
12283 break;
12284 case 9820: hashes_buf[0].salt->salt_len = 16;
12285 break;
12286 case 10300: hashes_buf[0].salt->salt_len = 12;
12287 break;
12288 case 11500: hashes_buf[0].salt->salt_len = 4;
12289 break;
12290 case 11600: hashes_buf[0].salt->salt_len = 4;
12291 break;
12292 case 12400: hashes_buf[0].salt->salt_len = 4;
12293 break;
12294 case 12500: hashes_buf[0].salt->salt_len = 8;
12295 break;
12296 case 12600: hashes_buf[0].salt->salt_len = 64;
12297 break;
12298 }
12299
12300 // special esalt handling
12301
12302 switch (hash_mode)
12303 {
12304 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12305 break;
12306 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12307 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12308 break;
12309 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12310 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12311 break;
12312 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12313 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12314 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12315 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12316 break;
12317 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12318 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12319 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12320 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12321 break;
12322 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12323 break;
12324 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12325 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12326 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12327 break;
12328 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12329 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12330 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12331 break;
12332 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12333 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12334 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12335 break;
12336 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12337 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12338 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12339 break;
12340 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12341 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12342 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12343 break;
12344 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12345 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12346 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12347 break;
12348 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12349 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12350 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12351 break;
12352 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12353 break;
12354 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12355 break;
12356 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12357 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12358 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12359 break;
12360 }
12361 }
12362
12363 // set hashfile
12364
12365 switch (hash_mode)
12366 {
12367 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12368 break;
12369 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12370 break;
12371 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12372 break;
12373 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12374 break;
12375 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12376 break;
12377 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12378 break;
12379 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12380 break;
12381 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12382 break;
12383 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12384 break;
12385 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12386 break;
12387 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12388 break;
12389 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12390 break;
12391 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12392 break;
12393 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12394 break;
12395 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12396 break;
12397 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12398 break;
12399 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12400 break;
12401 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12402 break;
12403 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12404 break;
12405 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12406 break;
12407 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12408 break;
12409 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12410 break;
12411 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12412 break;
12413 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12414 break;
12415 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12416 break;
12417 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12418 break;
12419 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12420 break;
12421 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12422 break;
12423 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12424 break;
12425 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12426 break;
12427 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12428 break;
12429 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12430 break;
12431 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12432 break;
12433 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12434 break;
12435 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12436 break;
12437 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12438 break;
12439 }
12440
12441 // set default iterations
12442
12443 switch (hash_mode)
12444 {
12445 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12446 break;
12447 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12448 break;
12449 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12450 break;
12451 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12452 break;
12453 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12454 break;
12455 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12456 break;
12457 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12458 break;
12459 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12460 break;
12461 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12462 break;
12463 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12464 break;
12465 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12466 break;
12467 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12468 break;
12469 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12470 break;
12471 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12472 break;
12473 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12474 break;
12475 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12476 break;
12477 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12478 break;
12479 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12480 break;
12481 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12482 break;
12483 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12484 break;
12485 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12486 break;
12487 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12488 break;
12489 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12490 break;
12491 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12492 break;
12493 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12494 break;
12495 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12496 break;
12497 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12498 break;
12499 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12500 break;
12501 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12502 break;
12503 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12504 break;
12505 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12506 break;
12507 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12508 break;
12509 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12510 break;
12511 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12512 break;
12513 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12514 break;
12515 case 8900: hashes_buf[0].salt->salt_iter = 1;
12516 break;
12517 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12518 break;
12519 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12520 break;
12521 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12522 break;
12523 case 9300: hashes_buf[0].salt->salt_iter = 1;
12524 break;
12525 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12526 break;
12527 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12528 break;
12529 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12530 break;
12531 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12532 break;
12533 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12534 break;
12535 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12536 break;
12537 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12538 break;
12539 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12540 break;
12541 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12542 break;
12543 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12544 break;
12545 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12546 break;
12547 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12548 break;
12549 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12550 break;
12551 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12552 break;
12553 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12554 break;
12555 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12556 break;
12557 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12558 break;
12559 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12560 break;
12561 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12562 break;
12563 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12564 break;
12565 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12566 break;
12567 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12568 break;
12569 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12570 break;
12571 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12572 break;
12573 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12574 break;
12575 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12576 break;
12577 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12578 break;
12579 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12580 break;
12581 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12582 break;
12583 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12584 break;
12585 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12586 break;
12587 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12588 break;
12589 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12590 break;
12591 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12592 break;
12593 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12594 break;
12595 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12596 break;
12597 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12598 break;
12599 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12600 break;
12601 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12602 break;
12603 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12604 break;
12605 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12606 break;
12607 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12608 break;
12609 }
12610
12611 hashes_cnt = 1;
12612 }
12613
12614 if (show == 1 || left == 1)
12615 {
12616 for (uint i = 0; i < pot_cnt; i++)
12617 {
12618 pot_t *pot_ptr = &pot[i];
12619
12620 hash_t *hashes_buf = &pot_ptr->hash;
12621
12622 local_free (hashes_buf->digest);
12623
12624 if (isSalted)
12625 {
12626 local_free (hashes_buf->salt);
12627 }
12628 }
12629
12630 local_free (pot);
12631
12632 if (data.quiet == 0) log_info_nn ("");
12633
12634 return (0);
12635 }
12636
12637 if ((keyspace == 0) && (stdout_flag == 0))
12638 {
12639 if (hashes_cnt == 0)
12640 {
12641 log_error ("ERROR: No hashes loaded");
12642
12643 return (-1);
12644 }
12645 }
12646
12647 /**
12648 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12649 */
12650
12651 if (data.outfile != NULL)
12652 {
12653 if (data.hashfile != NULL)
12654 {
12655 #ifdef _POSIX
12656 struct stat tmpstat_outfile;
12657 struct stat tmpstat_hashfile;
12658 #endif
12659
12660 #ifdef _WIN
12661 struct stat64 tmpstat_outfile;
12662 struct stat64 tmpstat_hashfile;
12663 #endif
12664
12665 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12666
12667 if (tmp_outfile_fp)
12668 {
12669 #ifdef _POSIX
12670 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12671 #endif
12672
12673 #ifdef _WIN
12674 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12675 #endif
12676
12677 fclose (tmp_outfile_fp);
12678 }
12679
12680 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12681
12682 if (tmp_hashfile_fp)
12683 {
12684 #ifdef _POSIX
12685 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12686 #endif
12687
12688 #ifdef _WIN
12689 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12690 #endif
12691
12692 fclose (tmp_hashfile_fp);
12693 }
12694
12695 if (tmp_outfile_fp && tmp_outfile_fp)
12696 {
12697 tmpstat_outfile.st_mode = 0;
12698 tmpstat_outfile.st_nlink = 0;
12699 tmpstat_outfile.st_uid = 0;
12700 tmpstat_outfile.st_gid = 0;
12701 tmpstat_outfile.st_rdev = 0;
12702 tmpstat_outfile.st_atime = 0;
12703
12704 tmpstat_hashfile.st_mode = 0;
12705 tmpstat_hashfile.st_nlink = 0;
12706 tmpstat_hashfile.st_uid = 0;
12707 tmpstat_hashfile.st_gid = 0;
12708 tmpstat_hashfile.st_rdev = 0;
12709 tmpstat_hashfile.st_atime = 0;
12710
12711 #ifdef _POSIX
12712 tmpstat_outfile.st_blksize = 0;
12713 tmpstat_outfile.st_blocks = 0;
12714
12715 tmpstat_hashfile.st_blksize = 0;
12716 tmpstat_hashfile.st_blocks = 0;
12717 #endif
12718
12719 #ifdef _POSIX
12720 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12721 {
12722 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12723
12724 return (-1);
12725 }
12726 #endif
12727
12728 #ifdef _WIN
12729 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12730 {
12731 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12732
12733 return (-1);
12734 }
12735 #endif
12736 }
12737 }
12738 }
12739
12740 /**
12741 * Remove duplicates
12742 */
12743
12744 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12745
12746 if (isSalted)
12747 {
12748 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12749 }
12750 else
12751 {
12752 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12753 }
12754
12755 uint hashes_cnt_orig = hashes_cnt;
12756
12757 hashes_cnt = 1;
12758
12759 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12760 {
12761 if (isSalted)
12762 {
12763 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12764 {
12765 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12766 }
12767 }
12768 else
12769 {
12770 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12771 }
12772
12773 if (hashes_pos > hashes_cnt)
12774 {
12775 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12776 }
12777
12778 hashes_cnt++;
12779 }
12780
12781 /**
12782 * Potfile removes
12783 */
12784
12785 uint potfile_remove_cracks = 0;
12786
12787 if (potfile_disable == 0)
12788 {
12789 hash_t hash_buf;
12790
12791 hash_buf.digest = mymalloc (dgst_size);
12792 hash_buf.salt = NULL;
12793 hash_buf.esalt = NULL;
12794 hash_buf.hash_info = NULL;
12795 hash_buf.cracked = 0;
12796
12797 if (isSalted)
12798 {
12799 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12800 }
12801
12802 if (esalt_size)
12803 {
12804 hash_buf.esalt = mymalloc (esalt_size);
12805 }
12806
12807 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12808
12809 // no solution for these special hash types (for instane because they use hashfile in output etc)
12810 if ((hash_mode != 5200) &&
12811 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12812 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12813 (hash_mode != 9000))
12814 {
12815 FILE *fp = fopen (potfile, "rb");
12816
12817 if (fp != NULL)
12818 {
12819 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12820
12821 // to be safe work with a copy (because of line_len loop, i etc)
12822 // moved up here because it's easier to handle continue case
12823 // it's just 64kb
12824
12825 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12826
12827 while (!feof (fp))
12828 {
12829 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12830
12831 if (ptr == NULL) break;
12832
12833 int line_len = strlen (line_buf);
12834
12835 if (line_len == 0) continue;
12836
12837 int iter = MAX_CUT_TRIES;
12838
12839 for (int i = line_len - 1; i && iter; i--, line_len--)
12840 {
12841 if (line_buf[i] != ':') continue;
12842
12843 if (isSalted)
12844 {
12845 memset (hash_buf.salt, 0, sizeof (salt_t));
12846 }
12847
12848 hash_t *found = NULL;
12849
12850 if (hash_mode == 6800)
12851 {
12852 if (i < 64) // 64 = 16 * uint in salt_buf[]
12853 {
12854 // manipulate salt_buf
12855 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12856
12857 hash_buf.salt->salt_len = i;
12858
12859 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12860 }
12861 }
12862 else if (hash_mode == 2500)
12863 {
12864 if (i < 64) // 64 = 16 * uint in salt_buf[]
12865 {
12866 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12867 // manipulate salt_buf
12868
12869 memcpy (line_buf_cpy, line_buf, i);
12870
12871 char *mac2_pos = strrchr (line_buf_cpy, ':');
12872
12873 if (mac2_pos == NULL) continue;
12874
12875 mac2_pos[0] = 0;
12876 mac2_pos++;
12877
12878 if (strlen (mac2_pos) != 12) continue;
12879
12880 char *mac1_pos = strrchr (line_buf_cpy, ':');
12881
12882 if (mac1_pos == NULL) continue;
12883
12884 mac1_pos[0] = 0;
12885 mac1_pos++;
12886
12887 if (strlen (mac1_pos) != 12) continue;
12888
12889 uint essid_length = mac1_pos - line_buf_cpy - 1;
12890
12891 // here we need the ESSID
12892 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12893
12894 hash_buf.salt->salt_len = essid_length;
12895
12896 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12897
12898 if (found)
12899 {
12900 wpa_t *wpa = (wpa_t *) found->esalt;
12901
12902 // compare hex string(s) vs binary MAC address(es)
12903
12904 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12905 {
12906 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12907 {
12908 found = NULL;
12909
12910 break;
12911 }
12912 }
12913
12914 // early skip ;)
12915 if (!found) continue;
12916
12917 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12918 {
12919 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12920 {
12921 found = NULL;
12922
12923 break;
12924 }
12925 }
12926 }
12927 }
12928 }
12929 else
12930 {
12931 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12932
12933 if (parser_status == PARSER_OK)
12934 {
12935 if (isSalted)
12936 {
12937 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12938 }
12939 else
12940 {
12941 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12942 }
12943 }
12944 }
12945
12946 if (found == NULL) continue;
12947
12948 if (!found->cracked) potfile_remove_cracks++;
12949
12950 found->cracked = 1;
12951
12952 if (found) break;
12953
12954 iter--;
12955 }
12956 }
12957
12958 myfree (line_buf_cpy);
12959
12960 myfree (line_buf);
12961
12962 fclose (fp);
12963 }
12964 }
12965
12966 if (esalt_size)
12967 {
12968 local_free (hash_buf.esalt);
12969 }
12970
12971 if (isSalted)
12972 {
12973 local_free (hash_buf.salt);
12974 }
12975
12976 local_free (hash_buf.digest);
12977 }
12978
12979 /**
12980 * Now generate all the buffers required for later
12981 */
12982
12983 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12984
12985 salt_t *salts_buf_new = NULL;
12986 void *esalts_buf_new = NULL;
12987
12988 if (isSalted)
12989 {
12990 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12991
12992 if (esalt_size)
12993 {
12994 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12995 }
12996 }
12997 else
12998 {
12999 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
13000 }
13001
13002 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
13003
13004 uint digests_cnt = hashes_cnt;
13005 uint digests_done = 0;
13006
13007 size_t size_digests = digests_cnt * dgst_size;
13008 size_t size_shown = digests_cnt * sizeof (uint);
13009
13010 uint *digests_shown = (uint *) mymalloc (size_shown);
13011 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
13012
13013 uint salts_cnt = 0;
13014 uint salts_done = 0;
13015
13016 hashinfo_t **hash_info = NULL;
13017
13018 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13019 {
13020 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
13021
13022 if (username && (remove || show))
13023 {
13024 uint user_pos;
13025
13026 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
13027 {
13028 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
13029
13030 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
13031 }
13032 }
13033 }
13034
13035 uint *salts_shown = (uint *) mymalloc (size_shown);
13036
13037 salt_t *salt_buf;
13038
13039 {
13040 // copied from inner loop
13041
13042 salt_buf = &salts_buf_new[salts_cnt];
13043
13044 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
13045
13046 if (esalt_size)
13047 {
13048 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
13049 }
13050
13051 salt_buf->digests_cnt = 0;
13052 salt_buf->digests_done = 0;
13053 salt_buf->digests_offset = 0;
13054
13055 salts_cnt++;
13056 }
13057
13058 if (hashes_buf[0].cracked == 1)
13059 {
13060 digests_shown[0] = 1;
13061
13062 digests_done++;
13063
13064 salt_buf->digests_done++;
13065 }
13066
13067 salt_buf->digests_cnt++;
13068
13069 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
13070
13071 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13072 {
13073 hash_info[0] = hashes_buf[0].hash_info;
13074 }
13075
13076 // copy from inner loop
13077
13078 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
13079 {
13080 if (isSalted)
13081 {
13082 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
13083 {
13084 salt_buf = &salts_buf_new[salts_cnt];
13085
13086 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
13087
13088 if (esalt_size)
13089 {
13090 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
13091 }
13092
13093 salt_buf->digests_cnt = 0;
13094 salt_buf->digests_done = 0;
13095 salt_buf->digests_offset = hashes_pos;
13096
13097 salts_cnt++;
13098 }
13099 }
13100
13101 if (hashes_buf[hashes_pos].cracked == 1)
13102 {
13103 digests_shown[hashes_pos] = 1;
13104
13105 digests_done++;
13106
13107 salt_buf->digests_done++;
13108 }
13109
13110 salt_buf->digests_cnt++;
13111
13112 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
13113
13114 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
13115 {
13116 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
13117 }
13118 }
13119
13120 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
13121 {
13122 salt_t *salt_buf = &salts_buf_new[salt_pos];
13123
13124 if (salt_buf->digests_done == salt_buf->digests_cnt)
13125 {
13126 salts_shown[salt_pos] = 1;
13127
13128 salts_done++;
13129 }
13130
13131 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
13132 }
13133
13134 local_free (digests_buf);
13135 local_free (salts_buf);
13136 local_free (esalts_buf);
13137
13138 digests_buf = digests_buf_new;
13139 salts_buf = salts_buf_new;
13140 esalts_buf = esalts_buf_new;
13141
13142 local_free (hashes_buf);
13143
13144 /**
13145 * special modification not set from parser
13146 */
13147
13148 switch (hash_mode)
13149 {
13150 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
13151 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
13152 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
13153 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
13154 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
13155 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
13156 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
13157 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
13158 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
13159 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
13160 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
13161 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
13162 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
13163 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
13164 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
13165 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
13166 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
13167 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
13168 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
13169 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
13170 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
13171 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
13172 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
13173 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
13174 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
13175 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
13176 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
13177 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
13178 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
13179 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
13180 }
13181
13182 if (truecrypt_keyfiles)
13183 {
13184 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13185
13186 char *keyfiles = strdup (truecrypt_keyfiles);
13187
13188 char *keyfile = strtok (keyfiles, ",");
13189
13190 do
13191 {
13192 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13193
13194 } while ((keyfile = strtok (NULL, ",")) != NULL);
13195
13196 free (keyfiles);
13197 }
13198
13199 if (veracrypt_keyfiles)
13200 {
13201 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
13202
13203 char *keyfiles = strdup (veracrypt_keyfiles);
13204
13205 char *keyfile = strtok (keyfiles, ",");
13206
13207 do
13208 {
13209 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
13210
13211 } while ((keyfile = strtok (NULL, ",")) != NULL);
13212
13213 free (keyfiles);
13214 }
13215
13216 data.digests_cnt = digests_cnt;
13217 data.digests_done = digests_done;
13218 data.digests_buf = digests_buf;
13219 data.digests_shown = digests_shown;
13220 data.digests_shown_tmp = digests_shown_tmp;
13221
13222 data.salts_cnt = salts_cnt;
13223 data.salts_done = salts_done;
13224 data.salts_buf = salts_buf;
13225 data.salts_shown = salts_shown;
13226
13227 data.esalts_buf = esalts_buf;
13228 data.hash_info = hash_info;
13229
13230 /**
13231 * Automatic Optimizers
13232 */
13233
13234 if (salts_cnt == 1)
13235 opti_type |= OPTI_TYPE_SINGLE_SALT;
13236
13237 if (digests_cnt == 1)
13238 opti_type |= OPTI_TYPE_SINGLE_HASH;
13239
13240 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
13241 opti_type |= OPTI_TYPE_NOT_ITERATED;
13242
13243 if (attack_mode == ATTACK_MODE_BF)
13244 opti_type |= OPTI_TYPE_BRUTE_FORCE;
13245
13246 data.opti_type = opti_type;
13247
13248 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
13249 {
13250 if (opti_type & OPTI_TYPE_SINGLE_HASH)
13251 {
13252 if (opti_type & OPTI_TYPE_APPENDED_SALT)
13253 {
13254 if (opts_type & OPTS_TYPE_ST_ADD80)
13255 {
13256 opts_type &= ~OPTS_TYPE_ST_ADD80;
13257 opts_type |= OPTS_TYPE_PT_ADD80;
13258 }
13259
13260 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
13261 {
13262 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
13263 opts_type |= OPTS_TYPE_PT_ADDBITS14;
13264 }
13265
13266 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
13267 {
13268 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
13269 opts_type |= OPTS_TYPE_PT_ADDBITS15;
13270 }
13271 }
13272 }
13273 }
13274
13275 /**
13276 * Some algorithm, like descrypt, can benefit from JIT compilation
13277 */
13278
13279 int force_jit_compilation = -1;
13280
13281 if (hash_mode == 8900)
13282 {
13283 force_jit_compilation = 8900;
13284 }
13285 else if (hash_mode == 9300)
13286 {
13287 force_jit_compilation = 8900;
13288 }
13289 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
13290 {
13291 force_jit_compilation = 1500;
13292 }
13293
13294 /**
13295 * generate bitmap tables
13296 */
13297
13298 const uint bitmap_shift1 = 5;
13299 const uint bitmap_shift2 = 13;
13300
13301 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13302
13303 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13304 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13305 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13306 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13307 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13308 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13309 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13310 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13311
13312 uint bitmap_bits;
13313 uint bitmap_nums;
13314 uint bitmap_mask;
13315 uint bitmap_size;
13316
13317 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13318 {
13319 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13320
13321 bitmap_nums = 1 << bitmap_bits;
13322
13323 bitmap_mask = bitmap_nums - 1;
13324
13325 bitmap_size = bitmap_nums * sizeof (uint);
13326
13327 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13328
13329 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;
13330 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;
13331
13332 break;
13333 }
13334
13335 bitmap_nums = 1 << bitmap_bits;
13336
13337 bitmap_mask = bitmap_nums - 1;
13338
13339 bitmap_size = bitmap_nums * sizeof (uint);
13340
13341 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);
13342 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);
13343
13344 /**
13345 * prepare quick rule
13346 */
13347
13348 data.rule_buf_l = rule_buf_l;
13349 data.rule_buf_r = rule_buf_r;
13350
13351 int rule_len_l = (int) strlen (rule_buf_l);
13352 int rule_len_r = (int) strlen (rule_buf_r);
13353
13354 data.rule_len_l = rule_len_l;
13355 data.rule_len_r = rule_len_r;
13356
13357 /**
13358 * load rules
13359 */
13360
13361 uint *all_kernel_rules_cnt = NULL;
13362
13363 kernel_rule_t **all_kernel_rules_buf = NULL;
13364
13365 if (rp_files_cnt)
13366 {
13367 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13368
13369 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13370 }
13371
13372 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13373
13374 int rule_len = 0;
13375
13376 for (uint i = 0; i < rp_files_cnt; i++)
13377 {
13378 uint kernel_rules_avail = 0;
13379
13380 uint kernel_rules_cnt = 0;
13381
13382 kernel_rule_t *kernel_rules_buf = NULL;
13383
13384 char *rp_file = rp_files[i];
13385
13386 char in[BLOCK_SIZE] = { 0 };
13387 char out[BLOCK_SIZE] = { 0 };
13388
13389 FILE *fp = NULL;
13390
13391 uint rule_line = 0;
13392
13393 if ((fp = fopen (rp_file, "rb")) == NULL)
13394 {
13395 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13396
13397 return (-1);
13398 }
13399
13400 while (!feof (fp))
13401 {
13402 memset (rule_buf, 0, HCBUFSIZ);
13403
13404 rule_len = fgetl (fp, rule_buf);
13405
13406 rule_line++;
13407
13408 if (rule_len == 0) continue;
13409
13410 if (rule_buf[0] == '#') continue;
13411
13412 if (kernel_rules_avail == kernel_rules_cnt)
13413 {
13414 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13415
13416 kernel_rules_avail += INCR_RULES;
13417 }
13418
13419 memset (in, 0, BLOCK_SIZE);
13420 memset (out, 0, BLOCK_SIZE);
13421
13422 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13423
13424 if (result == -1)
13425 {
13426 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13427
13428 continue;
13429 }
13430
13431 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13432 {
13433 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13434
13435 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13436
13437 continue;
13438 }
13439
13440 /* its so slow
13441 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13442 {
13443 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13444
13445 continue;
13446 }
13447 */
13448
13449 kernel_rules_cnt++;
13450 }
13451
13452 fclose (fp);
13453
13454 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13455
13456 all_kernel_rules_buf[i] = kernel_rules_buf;
13457 }
13458
13459 /**
13460 * merge rules or automatic rule generator
13461 */
13462
13463 uint kernel_rules_cnt = 0;
13464
13465 kernel_rule_t *kernel_rules_buf = NULL;
13466
13467 if (attack_mode == ATTACK_MODE_STRAIGHT)
13468 {
13469 if (rp_files_cnt)
13470 {
13471 kernel_rules_cnt = 1;
13472
13473 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13474
13475 repeats[0] = kernel_rules_cnt;
13476
13477 for (uint i = 0; i < rp_files_cnt; i++)
13478 {
13479 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13480
13481 repeats[i + 1] = kernel_rules_cnt;
13482 }
13483
13484 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13485
13486 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13487
13488 for (uint i = 0; i < kernel_rules_cnt; i++)
13489 {
13490 uint out_pos = 0;
13491
13492 kernel_rule_t *out = &kernel_rules_buf[i];
13493
13494 for (uint j = 0; j < rp_files_cnt; j++)
13495 {
13496 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13497 uint in_pos;
13498
13499 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13500
13501 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13502 {
13503 if (out_pos == RULES_MAX - 1)
13504 {
13505 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13506
13507 break;
13508 }
13509
13510 out->cmds[out_pos] = in->cmds[in_pos];
13511 }
13512 }
13513 }
13514
13515 local_free (repeats);
13516 }
13517 else if (rp_gen)
13518 {
13519 uint kernel_rules_avail = 0;
13520
13521 while (kernel_rules_cnt < rp_gen)
13522 {
13523 if (kernel_rules_avail == kernel_rules_cnt)
13524 {
13525 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13526
13527 kernel_rules_avail += INCR_RULES;
13528 }
13529
13530 memset (rule_buf, 0, HCBUFSIZ);
13531
13532 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13533
13534 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13535
13536 kernel_rules_cnt++;
13537 }
13538 }
13539 }
13540
13541 myfree (rule_buf);
13542
13543 /**
13544 * generate NOP rules
13545 */
13546
13547 if (kernel_rules_cnt == 0)
13548 {
13549 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13550
13551 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13552
13553 kernel_rules_cnt++;
13554 }
13555
13556 data.kernel_rules_cnt = kernel_rules_cnt;
13557 data.kernel_rules_buf = kernel_rules_buf;
13558
13559 /**
13560 * OpenCL platforms: detect
13561 */
13562
13563 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13564 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13565
13566 cl_uint platforms_cnt = 0;
13567 cl_uint platform_devices_cnt = 0;
13568
13569 if (keyspace == 0)
13570 {
13571 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13572
13573 if (platforms_cnt == 0)
13574 {
13575 log_info ("");
13576 log_info ("ATTENTION! No OpenCL compatible platform found");
13577 log_info ("");
13578 log_info ("You're probably missing the OpenCL runtime installation");
13579 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13580 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13581 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13582 log_info ("");
13583
13584 return (-1);
13585 }
13586
13587 if (opencl_platforms_filter != (uint) -1)
13588 {
13589 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13590
13591 if (opencl_platforms_filter > platform_cnt_mask)
13592 {
13593 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13594
13595 return (-1);
13596 }
13597 }
13598 }
13599
13600 /**
13601 * OpenCL device types:
13602 * 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.
13603 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13604 */
13605
13606 if (opencl_device_types == NULL)
13607 {
13608 cl_device_type device_types_all = 0;
13609
13610 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13611 {
13612 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13613
13614 cl_platform_id platform = platforms[platform_id];
13615
13616 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13617
13618 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13619 {
13620 cl_device_id device = platform_devices[platform_devices_id];
13621
13622 cl_device_type device_type;
13623
13624 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13625
13626 device_types_all |= device_type;
13627 }
13628 }
13629
13630 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13631 {
13632 device_types_filter |= CL_DEVICE_TYPE_CPU;
13633 }
13634 }
13635
13636 /**
13637 * OpenCL devices: simply push all devices from all platforms into the same device array
13638 */
13639
13640 int need_adl = 0;
13641 int need_nvapi = 0;
13642 int need_nvml = 0;
13643
13644 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13645
13646 data.devices_param = devices_param;
13647
13648 uint devices_cnt = 0;
13649
13650 uint devices_active = 0;
13651
13652 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13653 {
13654 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13655
13656 cl_platform_id platform = platforms[platform_id];
13657
13658 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13659
13660 char platform_vendor[INFOSZ] = { 0 };
13661
13662 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13663
13664 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13665 // this causes trouble with vendor id based macros
13666 // we'll assign generic to those without special optimization available
13667
13668 cl_uint platform_vendor_id = 0;
13669
13670 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13671 {
13672 platform_vendor_id = VENDOR_ID_AMD;
13673 }
13674 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13675 {
13676 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13677 }
13678 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13679 {
13680 platform_vendor_id = VENDOR_ID_APPLE;
13681 }
13682 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13683 {
13684 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13685 }
13686 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13687 {
13688 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13689 }
13690 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13691 {
13692 platform_vendor_id = VENDOR_ID_MESA;
13693 }
13694 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13695 {
13696 platform_vendor_id = VENDOR_ID_NV;
13697 }
13698 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13699 {
13700 platform_vendor_id = VENDOR_ID_POCL;
13701 }
13702 else
13703 {
13704 platform_vendor_id = VENDOR_ID_GENERIC;
13705 }
13706
13707 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13708 {
13709 size_t param_value_size = 0;
13710
13711 const uint device_id = devices_cnt;
13712
13713 hc_device_param_t *device_param = &data.devices_param[device_id];
13714
13715 device_param->platform_vendor_id = platform_vendor_id;
13716
13717 device_param->device = platform_devices[platform_devices_id];
13718
13719 device_param->device_id = device_id;
13720
13721 device_param->platform_devices_id = platform_devices_id;
13722
13723 // device_type
13724
13725 cl_device_type device_type;
13726
13727 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13728
13729 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13730
13731 device_param->device_type = device_type;
13732
13733 // device_name
13734
13735 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13736
13737 char *device_name = (char *) mymalloc (param_value_size);
13738
13739 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13740
13741 device_param->device_name = device_name;
13742
13743 // device_vendor
13744
13745 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13746
13747 char *device_vendor = (char *) mymalloc (param_value_size);
13748
13749 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13750
13751 device_param->device_vendor = device_vendor;
13752
13753 cl_uint device_vendor_id = 0;
13754
13755 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13756 {
13757 device_vendor_id = VENDOR_ID_AMD;
13758 }
13759 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13760 {
13761 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13762 }
13763 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13764 {
13765 device_vendor_id = VENDOR_ID_APPLE;
13766 }
13767 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13768 {
13769 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13770 }
13771 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13772 {
13773 device_vendor_id = VENDOR_ID_INTEL_SDK;
13774 }
13775 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13776 {
13777 device_vendor_id = VENDOR_ID_MESA;
13778 }
13779 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13780 {
13781 device_vendor_id = VENDOR_ID_NV;
13782 }
13783 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13784 {
13785 device_vendor_id = VENDOR_ID_POCL;
13786 }
13787 else
13788 {
13789 device_vendor_id = VENDOR_ID_GENERIC;
13790 }
13791
13792 device_param->device_vendor_id = device_vendor_id;
13793
13794 // tuning db
13795
13796 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13797
13798 // device_version
13799
13800 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13801
13802 char *device_version = (char *) mymalloc (param_value_size);
13803
13804 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13805
13806 device_param->device_version = device_version;
13807
13808 // device_opencl_version
13809
13810 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13811
13812 char *device_opencl_version = (char *) mymalloc (param_value_size);
13813
13814 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13815
13816 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13817
13818 myfree (device_opencl_version);
13819
13820 // vector_width
13821
13822 cl_uint vector_width;
13823
13824 if (opencl_vector_width_chgd == 0)
13825 {
13826 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13827 {
13828 if (opti_type & OPTI_TYPE_USES_BITS_64)
13829 {
13830 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13831 }
13832 else
13833 {
13834 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13835 }
13836 }
13837 else
13838 {
13839 vector_width = (cl_uint) tuningdb_entry->vector_width;
13840 }
13841 }
13842 else
13843 {
13844 vector_width = opencl_vector_width;
13845 }
13846
13847 if (vector_width > 16) vector_width = 16;
13848
13849 device_param->vector_width = vector_width;
13850
13851 // max_compute_units
13852
13853 cl_uint device_processors;
13854
13855 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13856
13857 device_param->device_processors = device_processors;
13858
13859 // device_maxmem_alloc
13860 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13861
13862 cl_ulong device_maxmem_alloc;
13863
13864 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13865
13866 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13867
13868 // device_global_mem
13869
13870 cl_ulong device_global_mem;
13871
13872 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13873
13874 device_param->device_global_mem = device_global_mem;
13875
13876 // max_work_group_size
13877
13878 size_t device_maxworkgroup_size;
13879
13880 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13881
13882 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13883
13884 // max_clock_frequency
13885
13886 cl_uint device_maxclock_frequency;
13887
13888 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13889
13890 device_param->device_maxclock_frequency = device_maxclock_frequency;
13891
13892 // device_endian_little
13893
13894 cl_bool device_endian_little;
13895
13896 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13897
13898 if (device_endian_little == CL_FALSE)
13899 {
13900 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13901
13902 device_param->skipped = 1;
13903 }
13904
13905 // device_available
13906
13907 cl_bool device_available;
13908
13909 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13910
13911 if (device_available == CL_FALSE)
13912 {
13913 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13914
13915 device_param->skipped = 1;
13916 }
13917
13918 // device_compiler_available
13919
13920 cl_bool device_compiler_available;
13921
13922 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13923
13924 if (device_compiler_available == CL_FALSE)
13925 {
13926 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13927
13928 device_param->skipped = 1;
13929 }
13930
13931 // device_execution_capabilities
13932
13933 cl_device_exec_capabilities device_execution_capabilities;
13934
13935 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13936
13937 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13938 {
13939 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13940
13941 device_param->skipped = 1;
13942 }
13943
13944 // device_extensions
13945
13946 size_t device_extensions_size;
13947
13948 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13949
13950 char *device_extensions = mymalloc (device_extensions_size + 1);
13951
13952 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13953
13954 if (strstr (device_extensions, "base_atomics") == 0)
13955 {
13956 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13957
13958 device_param->skipped = 1;
13959 }
13960
13961 if (strstr (device_extensions, "byte_addressable_store") == 0)
13962 {
13963 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13964
13965 device_param->skipped = 1;
13966 }
13967
13968 myfree (device_extensions);
13969
13970 // device_local_mem_size
13971
13972 cl_ulong device_local_mem_size;
13973
13974 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13975
13976 if (device_local_mem_size < 32768)
13977 {
13978 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13979
13980 device_param->skipped = 1;
13981 }
13982
13983 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13984 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13985 // This results in both utilizing it for 50%
13986 // However, Intel has much better SIMD control over their own hardware
13987 // It makes sense to give them full control over their own hardware
13988
13989 if (device_type & CL_DEVICE_TYPE_CPU)
13990 {
13991 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13992 {
13993 if (data.force == 0)
13994 {
13995 if (algorithm_pos == 0)
13996 {
13997 log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
13998 log_info (" You can use --force to override this but do not post error reports if you do so");
13999 }
14000
14001 device_param->skipped = 1;
14002 }
14003 }
14004 }
14005
14006 // skipped
14007
14008 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
14009 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
14010
14011 // driver_version
14012
14013 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
14014
14015 char *driver_version = (char *) mymalloc (param_value_size);
14016
14017 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
14018
14019 device_param->driver_version = driver_version;
14020
14021 // device_name_chksum
14022
14023 char *device_name_chksum = (char *) mymalloc (INFOSZ);
14024
14025 #if __x86_64__
14026 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);
14027 #else
14028 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);
14029 #endif
14030
14031 uint device_name_digest[4] = { 0 };
14032
14033 md5_64 ((uint *) device_name_chksum, device_name_digest);
14034
14035 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
14036
14037 device_param->device_name_chksum = device_name_chksum;
14038
14039 // device_processor_cores
14040
14041 if (device_param->device_type & CL_DEVICE_TYPE_GPU)
14042 {
14043 if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD))
14044 {
14045 need_adl = 1;
14046 }
14047
14048 if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV))
14049 {
14050 need_nvml = 1;
14051
14052 #ifdef _WIN
14053 need_nvapi = 1;
14054 #endif
14055 }
14056 }
14057
14058 // device_processor_cores
14059
14060 if (device_type & CL_DEVICE_TYPE_CPU)
14061 {
14062 cl_uint device_processor_cores = 1;
14063
14064 device_param->device_processor_cores = device_processor_cores;
14065 }
14066
14067 if (device_type & CL_DEVICE_TYPE_GPU)
14068 {
14069 if (device_vendor_id == VENDOR_ID_AMD)
14070 {
14071 cl_uint device_processor_cores = 0;
14072
14073 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
14074
14075 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
14076
14077 device_param->device_processor_cores = device_processor_cores;
14078 }
14079 else if (device_vendor_id == VENDOR_ID_NV)
14080 {
14081 cl_uint kernel_exec_timeout = 0;
14082
14083 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
14084
14085 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
14086
14087 device_param->kernel_exec_timeout = kernel_exec_timeout;
14088
14089 cl_uint device_processor_cores = 0;
14090
14091 #define CL_DEVICE_WARP_SIZE_NV 0x4003
14092
14093 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
14094
14095 device_param->device_processor_cores = device_processor_cores;
14096
14097 cl_uint sm_minor = 0;
14098 cl_uint sm_major = 0;
14099
14100 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
14101 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
14102
14103 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
14104 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
14105
14106 device_param->sm_minor = sm_minor;
14107 device_param->sm_major = sm_major;
14108 }
14109 else
14110 {
14111 cl_uint device_processor_cores = 1;
14112
14113 device_param->device_processor_cores = device_processor_cores;
14114 }
14115 }
14116
14117 // display results
14118
14119 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14120 {
14121 if (machine_readable == 0)
14122 {
14123 if (device_param->skipped == 0)
14124 {
14125 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
14126 device_id + 1,
14127 device_name,
14128 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
14129 (unsigned int) (device_global_mem / 1024 / 1024),
14130 (unsigned int) device_processors);
14131 }
14132 else
14133 {
14134 log_info ("Device #%u: %s, skipped",
14135 device_id + 1,
14136 device_name);
14137 }
14138 }
14139 }
14140
14141 // common driver check
14142
14143 if (device_param->skipped == 0)
14144 {
14145 if (device_type & CL_DEVICE_TYPE_GPU)
14146 {
14147 if (platform_vendor_id == VENDOR_ID_AMD)
14148 {
14149 int catalyst_check = (force == 1) ? 0 : 1;
14150
14151 int catalyst_warn = 0;
14152
14153 int catalyst_broken = 0;
14154
14155 if (catalyst_check == 1)
14156 {
14157 catalyst_warn = 1;
14158
14159 // v14.9 and higher
14160 if (atoi (device_param->driver_version) >= 1573)
14161 {
14162 catalyst_warn = 0;
14163 }
14164
14165 catalyst_check = 0;
14166 }
14167
14168 if (catalyst_broken == 1)
14169 {
14170 log_info ("");
14171 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
14172 log_info ("It will pass over cracked hashes and does not report them as cracked");
14173 log_info ("You are STRONGLY encouraged not to use it");
14174 log_info ("You can use --force to override this but do not post error reports if you do so");
14175 log_info ("");
14176
14177 return (-1);
14178 }
14179
14180 if (catalyst_warn == 1)
14181 {
14182 log_info ("");
14183 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
14184 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
14185 log_info ("See hashcat's homepage for official supported catalyst drivers");
14186 #ifdef _WIN
14187 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
14188 #endif
14189 log_info ("You can use --force to override this but do not post error reports if you do so");
14190 log_info ("");
14191
14192 return (-1);
14193 }
14194 }
14195 else if (platform_vendor_id == VENDOR_ID_NV)
14196 {
14197 if (device_param->kernel_exec_timeout != 0)
14198 {
14199 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);
14200 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
14201 }
14202 }
14203 }
14204
14205 /* turns out pocl still creates segfaults (because of llvm)
14206 if (device_type & CL_DEVICE_TYPE_CPU)
14207 {
14208 if (platform_vendor_id == VENDOR_ID_AMD)
14209 {
14210 if (force == 0)
14211 {
14212 log_info ("");
14213 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
14214 log_info ("You are STRONGLY encouraged not to use it");
14215 log_info ("You can use --force to override this but do not post error reports if you do so");
14216 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
14217 log_info ("");
14218
14219 return (-1);
14220 }
14221 }
14222 }
14223 */
14224
14225 /**
14226 * kernel accel and loops tuning db adjustment
14227 */
14228
14229 device_param->kernel_accel_min = 1;
14230 device_param->kernel_accel_max = 1024;
14231
14232 device_param->kernel_loops_min = 1;
14233 device_param->kernel_loops_max = 1024;
14234
14235 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
14236
14237 if (tuningdb_entry)
14238 {
14239 u32 _kernel_accel = tuningdb_entry->kernel_accel;
14240 u32 _kernel_loops = tuningdb_entry->kernel_loops;
14241
14242 if (_kernel_accel)
14243 {
14244 device_param->kernel_accel_min = _kernel_accel;
14245 device_param->kernel_accel_max = _kernel_accel;
14246 }
14247
14248 if (_kernel_loops)
14249 {
14250 if (workload_profile == 1)
14251 {
14252 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
14253 }
14254 else if (workload_profile == 2)
14255 {
14256 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
14257 }
14258
14259 device_param->kernel_loops_min = _kernel_loops;
14260 device_param->kernel_loops_max = _kernel_loops;
14261 }
14262 }
14263
14264 // commandline parameters overwrite tuningdb entries
14265
14266 if (kernel_accel)
14267 {
14268 device_param->kernel_accel_min = kernel_accel;
14269 device_param->kernel_accel_max = kernel_accel;
14270 }
14271
14272 if (kernel_loops)
14273 {
14274 device_param->kernel_loops_min = kernel_loops;
14275 device_param->kernel_loops_max = kernel_loops;
14276 }
14277
14278 /**
14279 * activate device
14280 */
14281
14282 devices_active++;
14283 }
14284
14285 // next please
14286
14287 devices_cnt++;
14288 }
14289 }
14290
14291 if (keyspace == 0 && devices_active == 0)
14292 {
14293 log_error ("ERROR: No devices found/left");
14294
14295 return (-1);
14296 }
14297
14298 // 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)
14299
14300 if (devices_filter != (uint) -1)
14301 {
14302 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14303
14304 if (devices_filter > devices_cnt_mask)
14305 {
14306 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14307
14308 return (-1);
14309 }
14310 }
14311
14312 data.devices_cnt = devices_cnt;
14313
14314 data.devices_active = devices_active;
14315
14316 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14317 {
14318 if (machine_readable == 0)
14319 {
14320 log_info ("");
14321 }
14322 }
14323
14324 /**
14325 * HM devices: init
14326 */
14327
14328 #ifdef HAVE_HWMON
14329 hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } };
14330 hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } };
14331 hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } };
14332
14333 if (gpu_temp_disable == 0)
14334 {
14335 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14336 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14337 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14338
14339 data.hm_adl = NULL;
14340 data.hm_nvapi = NULL;
14341 data.hm_nvml = NULL;
14342
14343 if ((need_nvml == 1) && (nvml_init (nvml) == 0))
14344 {
14345 data.hm_nvml = nvml;
14346 }
14347
14348 if (data.hm_nvml)
14349 {
14350 if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS)
14351 {
14352 HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 };
14353
14354 int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle);
14355
14356 int tmp_out = 0;
14357
14358 for (int i = 0; i < tmp_in; i++)
14359 {
14360 hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i];
14361 }
14362
14363 for (int i = 0; i < tmp_out; i++)
14364 {
14365 unsigned int speed;
14366
14367 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1;
14368
14369 hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS);
14370
14371 hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON);
14372 }
14373 }
14374 }
14375
14376 if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0))
14377 {
14378 data.hm_nvapi = nvapi;
14379 }
14380
14381 if (data.hm_nvapi)
14382 {
14383 if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK)
14384 {
14385 HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 };
14386
14387 int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle);
14388
14389 int tmp_out = 0;
14390
14391 for (int i = 0; i < tmp_in; i++)
14392 {
14393 hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i];
14394 }
14395 }
14396 }
14397
14398 if ((need_adl == 1) && (adl_init (adl) == 0))
14399 {
14400 data.hm_adl = adl;
14401 }
14402
14403 if (data.hm_adl)
14404 {
14405 if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14406 {
14407 // total number of adapters
14408
14409 int hm_adapters_num;
14410
14411 if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1);
14412
14413 // adapter info
14414
14415 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num);
14416
14417 if (lpAdapterInfo == NULL) return (-1);
14418
14419 // get a list (of ids of) valid/usable adapters
14420
14421 int num_adl_adapters = 0;
14422
14423 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14424
14425 if (num_adl_adapters > 0)
14426 {
14427 hc_thread_mutex_lock (mux_adl);
14428
14429 // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all);
14430
14431 hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14432
14433 hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14434 hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14435
14436 hc_thread_mutex_unlock (mux_adl);
14437 }
14438
14439 myfree (valid_adl_device_list);
14440 myfree (lpAdapterInfo);
14441 }
14442 }
14443
14444 if (data.hm_adl == NULL && data.hm_nvml == NULL)
14445 {
14446 gpu_temp_disable = 1;
14447 }
14448 }
14449
14450 /**
14451 * OpenCL devices: allocate buffer for device specific information
14452 */
14453
14454 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14455 int *temp_retain_fanpolicy_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14456
14457 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14458
14459 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14460
14461 unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int));
14462
14463 /**
14464 * User-defined GPU temp handling
14465 */
14466
14467 if (gpu_temp_disable == 1)
14468 {
14469 gpu_temp_abort = 0;
14470 gpu_temp_retain = 0;
14471 }
14472
14473 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14474 {
14475 if (gpu_temp_abort < gpu_temp_retain)
14476 {
14477 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14478
14479 return (-1);
14480 }
14481 }
14482
14483 data.gpu_temp_disable = gpu_temp_disable;
14484 data.gpu_temp_abort = gpu_temp_abort;
14485 data.gpu_temp_retain = gpu_temp_retain;
14486 #endif
14487
14488 /**
14489 * enable custom signal handler(s)
14490 */
14491
14492 if (benchmark == 0)
14493 {
14494 hc_signal (sigHandler_default);
14495 }
14496 else
14497 {
14498 hc_signal (sigHandler_benchmark);
14499 }
14500
14501 /**
14502 * inform the user
14503 */
14504
14505 if (data.quiet == 0)
14506 {
14507 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14508
14509 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);
14510
14511 if (attack_mode == ATTACK_MODE_STRAIGHT)
14512 {
14513 log_info ("Rules: %u", kernel_rules_cnt);
14514 }
14515
14516 if (opti_type)
14517 {
14518 log_info ("Applicable Optimizers:");
14519
14520 for (uint i = 0; i < 32; i++)
14521 {
14522 const uint opti_bit = 1u << i;
14523
14524 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14525 }
14526 }
14527
14528 /**
14529 * Watchdog and Temperature balance
14530 */
14531
14532 #ifdef HAVE_HWMON
14533 if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL)
14534 {
14535 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14536 }
14537
14538 if (gpu_temp_abort == 0)
14539 {
14540 log_info ("Watchdog: Temperature abort trigger disabled");
14541 }
14542 else
14543 {
14544 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14545 }
14546
14547 if (gpu_temp_retain == 0)
14548 {
14549 log_info ("Watchdog: Temperature retain trigger disabled");
14550 }
14551 else
14552 {
14553 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14554 }
14555
14556 if (data.quiet == 0) log_info ("");
14557 #endif
14558 }
14559
14560 #ifdef HAVE_HWMON
14561
14562 /**
14563 * HM devices: copy
14564 */
14565
14566 if (gpu_temp_disable == 0)
14567 {
14568 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14569 {
14570 hc_device_param_t *device_param = &data.devices_param[device_id];
14571
14572 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14573
14574 if (device_param->skipped) continue;
14575
14576 const uint platform_devices_id = device_param->platform_devices_id;
14577
14578 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14579 {
14580 data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl;
14581 data.hm_device[device_id].nvapi = 0;
14582 data.hm_device[device_id].nvml = 0;
14583 data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version;
14584 data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported;
14585 data.hm_device[device_id].fan_set_supported = hm_adapters_adl[platform_devices_id].fan_set_supported;
14586 }
14587
14588 if (device_param->device_vendor_id == VENDOR_ID_NV)
14589 {
14590 data.hm_device[device_id].adl = 0;
14591 data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi;
14592 data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml;
14593 data.hm_device[device_id].od_version = 0;
14594 data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported;
14595 data.hm_device[device_id].fan_set_supported = 0;
14596 }
14597 }
14598 }
14599
14600 /**
14601 * powertune on user request
14602 */
14603
14604 if (powertune_enable == 1)
14605 {
14606 hc_thread_mutex_lock (mux_adl);
14607
14608 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14609 {
14610 hc_device_param_t *device_param = &data.devices_param[device_id];
14611
14612 if (device_param->skipped) continue;
14613
14614 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
14615 {
14616 /**
14617 * Temporary fix:
14618 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14619 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14620 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14621 * Driver / ADL bug?
14622 */
14623
14624 if (data.hm_device[device_id].od_version == 6)
14625 {
14626 int ADL_rc;
14627
14628 // check powertune capabilities first, if not available then skip device
14629
14630 int powertune_supported = 0;
14631
14632 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
14633 {
14634 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14635
14636 return (-1);
14637 }
14638
14639 // first backup current value, we will restore it later
14640
14641 if (powertune_supported != 0)
14642 {
14643 // powercontrol settings
14644
14645 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14646
14647 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK)
14648 {
14649 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]);
14650 }
14651
14652 if (ADL_rc != ADL_OK)
14653 {
14654 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14655
14656 return (-1);
14657 }
14658
14659 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14660 {
14661 log_error ("ERROR: Failed to set new ADL PowerControl values");
14662
14663 return (-1);
14664 }
14665
14666 // clocks
14667
14668 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
14669
14670 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
14671
14672 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)
14673 {
14674 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
14675
14676 return (-1);
14677 }
14678
14679 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
14680
14681 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
14682
14683 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK)
14684 {
14685 log_error ("ERROR: Failed to get ADL device capabilities");
14686
14687 return (-1);
14688 }
14689
14690 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
14691 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
14692
14693 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
14694 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
14695
14696 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
14697 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
14698
14699 // warning if profile has too low max values
14700
14701 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
14702 {
14703 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
14704 }
14705
14706 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
14707 {
14708 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
14709 }
14710
14711 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
14712
14713 performance_state->iNumberOfPerformanceLevels = 2;
14714
14715 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
14716 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
14717 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
14718 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
14719
14720 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)
14721 {
14722 log_info ("ERROR: Failed to set ADL performance state");
14723
14724 return (-1);
14725 }
14726
14727 local_free (performance_state);
14728 }
14729
14730 // set powertune value only
14731
14732 if (powertune_supported != 0)
14733 {
14734 // powertune set
14735 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14736
14737 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK)
14738 {
14739 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14740
14741 return (-1);
14742 }
14743
14744 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK)
14745 {
14746 log_error ("ERROR: Failed to set new ADL PowerControl values");
14747
14748 return (-1);
14749 }
14750 }
14751 }
14752 }
14753
14754 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
14755 {
14756 // first backup current value, we will restore it later
14757
14758 unsigned int limit;
14759
14760 int powertune_supported = 0;
14761
14762 if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS)
14763 {
14764 powertune_supported = 1;
14765 }
14766
14767 // if backup worked, activate the maximum allowed
14768
14769 if (powertune_supported != 0)
14770 {
14771 unsigned int minLimit;
14772 unsigned int maxLimit;
14773
14774 if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS)
14775 {
14776 if (maxLimit > 0)
14777 {
14778 if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS)
14779 {
14780 // now we can be sure we need to reset later
14781
14782 nvml_power_limit[device_id] = limit;
14783 }
14784 }
14785 }
14786 }
14787 }
14788 }
14789
14790 hc_thread_mutex_unlock (mux_adl);
14791 }
14792
14793 #endif // HAVE_HWMON
14794
14795 #ifdef DEBUG
14796 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14797 #endif
14798
14799 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14800
14801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14802 {
14803 /**
14804 * host buffer
14805 */
14806
14807 hc_device_param_t *device_param = &data.devices_param[device_id];
14808
14809 if (device_param->skipped) continue;
14810
14811 /**
14812 * device properties
14813 */
14814
14815 const char *device_name_chksum = device_param->device_name_chksum;
14816 const u32 device_processors = device_param->device_processors;
14817 const u32 device_processor_cores = device_param->device_processor_cores;
14818
14819 /**
14820 * create context for each device
14821 */
14822
14823 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14824
14825 /**
14826 * create command-queue
14827 */
14828
14829 // not supported with NV
14830 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14831
14832 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14833
14834 /**
14835 * kernel threads: some algorithms need a fixed kernel-threads count
14836 * because of shared memory usage or bitslice
14837 * there needs to be some upper limit, otherwise there's too much overhead
14838 */
14839
14840 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14841
14842 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14843 {
14844 kernel_threads = KERNEL_THREADS_MAX_CPU;
14845 }
14846
14847 if (hash_mode == 1500) kernel_threads = 64; // DES
14848 if (hash_mode == 3000) kernel_threads = 64; // DES
14849 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14850 if (hash_mode == 7500) kernel_threads = 64; // RC4
14851 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14852 if (hash_mode == 9700) kernel_threads = 64; // RC4
14853 if (hash_mode == 9710) kernel_threads = 64; // RC4
14854 if (hash_mode == 9800) kernel_threads = 64; // RC4
14855 if (hash_mode == 9810) kernel_threads = 64; // RC4
14856 if (hash_mode == 10400) kernel_threads = 64; // RC4
14857 if (hash_mode == 10410) kernel_threads = 64; // RC4
14858 if (hash_mode == 10500) kernel_threads = 64; // RC4
14859 if (hash_mode == 13100) kernel_threads = 64; // RC4
14860
14861 device_param->kernel_threads = kernel_threads;
14862
14863 device_param->hardware_power = device_processors * kernel_threads;
14864
14865 /**
14866 * create input buffers on device : calculate size of fixed memory buffers
14867 */
14868
14869 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14870 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14871
14872 device_param->size_root_css = size_root_css;
14873 device_param->size_markov_css = size_markov_css;
14874
14875 size_t size_results = sizeof (uint);
14876
14877 device_param->size_results = size_results;
14878
14879 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14880 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14881
14882 size_t size_plains = digests_cnt * sizeof (plain_t);
14883 size_t size_salts = salts_cnt * sizeof (salt_t);
14884 size_t size_esalts = salts_cnt * esalt_size;
14885
14886 device_param->size_plains = size_plains;
14887 device_param->size_digests = size_digests;
14888 device_param->size_shown = size_shown;
14889 device_param->size_salts = size_salts;
14890
14891 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14892 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14893 size_t size_tm = 32 * sizeof (bs_word_t);
14894
14895 // scryptV stuff
14896
14897 size_t size_scryptV = 1;
14898
14899 if ((hash_mode == 8900) || (hash_mode == 9300))
14900 {
14901 uint tmto_start = 0;
14902 uint tmto_stop = 10;
14903
14904 if (scrypt_tmto)
14905 {
14906 tmto_start = scrypt_tmto;
14907 }
14908 else
14909 {
14910 // in case the user did not specify the tmto manually
14911 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14912 // but set the lower end only in case the user has a device with too less memory
14913
14914 if (hash_mode == 8900)
14915 {
14916 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14917 {
14918 tmto_start = 1;
14919 }
14920 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14921 {
14922 tmto_start = 2;
14923 }
14924 }
14925 else if (hash_mode == 9300)
14926 {
14927 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14928 {
14929 tmto_start = 2;
14930 }
14931 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14932 {
14933 tmto_start = 2;
14934 }
14935 }
14936 }
14937
14938 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14939 {
14940 // TODO: in theory the following calculation needs to be done per salt, not global
14941 // we assume all hashes have the same scrypt settings
14942
14943 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14944
14945 size_scryptV /= 1 << tmto;
14946
14947 size_scryptV *= device_processors * device_processor_cores;
14948
14949 if (size_scryptV > device_param->device_maxmem_alloc)
14950 {
14951 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14952
14953 continue;
14954 }
14955
14956 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14957 {
14958 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14959 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14960 }
14961
14962 break;
14963 }
14964
14965 if (data.salts_buf[0].scrypt_phy == 0)
14966 {
14967 log_error ("ERROR: can't allocate enough device memory");
14968
14969 return -1;
14970 }
14971
14972 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14973 }
14974
14975 /**
14976 * some algorithms need a fixed kernel-loops count
14977 */
14978
14979 if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF)
14980 {
14981 const u32 kernel_loops_fixed = 1024;
14982
14983 device_param->kernel_loops_min = kernel_loops_fixed;
14984 device_param->kernel_loops_max = kernel_loops_fixed;
14985 }
14986
14987 if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF)
14988 {
14989 const u32 kernel_loops_fixed = 1024;
14990
14991 device_param->kernel_loops_min = kernel_loops_fixed;
14992 device_param->kernel_loops_max = kernel_loops_fixed;
14993 }
14994
14995 if (hash_mode == 8900)
14996 {
14997 const u32 kernel_loops_fixed = 1;
14998
14999 device_param->kernel_loops_min = kernel_loops_fixed;
15000 device_param->kernel_loops_max = kernel_loops_fixed;
15001 }
15002
15003 if (hash_mode == 9300)
15004 {
15005 const u32 kernel_loops_fixed = 1;
15006
15007 device_param->kernel_loops_min = kernel_loops_fixed;
15008 device_param->kernel_loops_max = kernel_loops_fixed;
15009 }
15010
15011 if (hash_mode == 12500)
15012 {
15013 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
15014
15015 device_param->kernel_loops_min = kernel_loops_fixed;
15016 device_param->kernel_loops_max = kernel_loops_fixed;
15017 }
15018
15019 /**
15020 * some algorithms have a maximum kernel-loops count
15021 */
15022
15023 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
15024 {
15025 u32 innerloop_cnt = 0;
15026
15027 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15028 {
15029 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
15030 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
15031 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
15032 }
15033 else
15034 {
15035 innerloop_cnt = data.salts_buf[0].salt_iter;
15036 }
15037
15038 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
15039 (innerloop_cnt <= device_param->kernel_loops_max))
15040 {
15041 device_param->kernel_loops_max = innerloop_cnt;
15042 }
15043 }
15044
15045 u32 kernel_accel_min = device_param->kernel_accel_min;
15046 u32 kernel_accel_max = device_param->kernel_accel_max;
15047
15048 // find out if we would request too much memory on memory blocks which are based on kernel_accel
15049
15050 size_t size_pws = 4;
15051 size_t size_tmps = 4;
15052 size_t size_hooks = 4;
15053
15054 while (kernel_accel_max >= kernel_accel_min)
15055 {
15056 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
15057
15058 // size_pws
15059
15060 size_pws = kernel_power_max * sizeof (pw_t);
15061
15062 // size_tmps
15063
15064 switch (hash_mode)
15065 {
15066 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
15067 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15068 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15069 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15070 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
15071 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
15072 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
15073 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
15074 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
15075 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
15076 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15077 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15078 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15079 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15080 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15081 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15082 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15083 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15084 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15085 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15086 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15087 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15088 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
15089 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
15090 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
15091 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
15092 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
15093 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
15094 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15095 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15096 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
15097 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
15098 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15099 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
15100 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15101 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
15102 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
15103 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15104 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
15105 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
15106 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
15107 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
15108 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15109 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
15110 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
15111 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
15112 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
15113 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15114 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
15115 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
15116 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
15117 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15118 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
15119 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
15120 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
15121 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
15122 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
15123 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
15124 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15125 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15126 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
15127 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
15128 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
15129 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
15130 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15131 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15132 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15133 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15134 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15135 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
15136 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15137 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15138 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15139 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15140 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15141 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15142 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15143 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15144 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15145 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15146 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15147 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
15148 };
15149
15150 // size_hooks
15151
15152 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
15153 {
15154 switch (hash_mode)
15155 {
15156 }
15157 }
15158
15159 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
15160 // if not, decrease amplifier and try again
15161
15162 int skip = 0;
15163
15164 const u64 size_total
15165 = bitmap_size
15166 + bitmap_size
15167 + bitmap_size
15168 + bitmap_size
15169 + bitmap_size
15170 + bitmap_size
15171 + bitmap_size
15172 + bitmap_size
15173 + size_bfs
15174 + size_combs
15175 + size_digests
15176 + size_esalts
15177 + size_hooks
15178 + size_markov_css
15179 + size_plains
15180 + size_pws
15181 + size_pws // not a bug
15182 + size_results
15183 + size_root_css
15184 + size_rules
15185 + size_rules_c
15186 + size_salts
15187 + size_scryptV
15188 + size_shown
15189 + size_tm
15190 + size_tmps;
15191
15192 // Don't ask me, ask AMD!
15193
15194 if (size_total > device_param->device_maxmem_alloc) skip = 1;
15195 if (size_total > device_param->device_global_mem) skip = 1;
15196
15197 if (skip == 1)
15198 {
15199 kernel_accel_max--;
15200
15201 continue;
15202 }
15203
15204 break;
15205 }
15206
15207 /*
15208 if (kernel_accel_max == 0)
15209 {
15210 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
15211
15212 return -1;
15213 }
15214 */
15215
15216 device_param->kernel_accel_min = kernel_accel_min;
15217 device_param->kernel_accel_max = kernel_accel_max;
15218
15219 /*
15220 if (kernel_accel_max < kernel_accel)
15221 {
15222 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
15223
15224 device_param->kernel_accel = kernel_accel_max;
15225 }
15226 */
15227
15228 device_param->size_bfs = size_bfs;
15229 device_param->size_combs = size_combs;
15230 device_param->size_rules = size_rules;
15231 device_param->size_rules_c = size_rules_c;
15232 device_param->size_pws = size_pws;
15233 device_param->size_tmps = size_tmps;
15234 device_param->size_hooks = size_hooks;
15235
15236 /**
15237 * default building options
15238 */
15239
15240 char build_opts[1024] = { 0 };
15241
15242 // we don't have sm_* on vendors not NV but it doesn't matter
15243
15244 #if _WIN
15245 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15246 #else
15247 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
15248 #endif
15249
15250 char build_opts_new[1024] = { 0 };
15251
15252 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
15253
15254 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15255
15256 /*
15257 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
15258 {
15259 // we do vectorizing much better than the auto-vectorizer
15260
15261 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
15262
15263 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
15264 }
15265 */
15266
15267 #ifdef DEBUG
15268 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
15269 #endif
15270
15271 /**
15272 * main kernel
15273 */
15274
15275 {
15276 /**
15277 * kernel source filename
15278 */
15279
15280 char source_file[256] = { 0 };
15281
15282 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
15283
15284 struct stat sst;
15285
15286 if (stat (source_file, &sst) == -1)
15287 {
15288 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15289
15290 return -1;
15291 }
15292
15293 /**
15294 * kernel cached filename
15295 */
15296
15297 char cached_file[256] = { 0 };
15298
15299 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
15300
15301 int cached = 1;
15302
15303 struct stat cst;
15304
15305 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
15306 {
15307 cached = 0;
15308 }
15309
15310 /**
15311 * kernel compile or load
15312 */
15313
15314 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15315
15316 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15317
15318 if (force_jit_compilation == -1)
15319 {
15320 if (cached == 0)
15321 {
15322 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15323
15324 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15325
15326 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15327
15328 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
15329
15330 #ifdef DEBUG
15331 size_t build_log_size = 0;
15332
15333 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15334
15335 if (build_log_size > 1)
15336 {
15337 char *build_log = (char *) malloc (build_log_size + 1);
15338
15339 memset (build_log, 0, build_log_size + 1);
15340
15341 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15342
15343 puts (build_log);
15344
15345 free (build_log);
15346 }
15347 #endif
15348
15349 if (rc != 0)
15350 {
15351 device_param->skipped = true;
15352
15353 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15354
15355 continue;
15356 }
15357
15358 size_t binary_size;
15359
15360 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15361
15362 u8 *binary = (u8 *) mymalloc (binary_size);
15363
15364 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15365
15366 writeProgramBin (cached_file, binary, binary_size);
15367
15368 local_free (binary);
15369 }
15370 else
15371 {
15372 #ifdef DEBUG
15373 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15374 #endif
15375
15376 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15377
15378 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15379
15380 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
15381 }
15382 }
15383 else
15384 {
15385 #ifdef DEBUG
15386 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
15387 #endif
15388
15389 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15390
15391 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15392
15393 char build_opts_update[1024] = { 0 };
15394
15395 if (force_jit_compilation == 1500)
15396 {
15397 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
15398 }
15399 else if (force_jit_compilation == 8900)
15400 {
15401 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto);
15402 }
15403 else
15404 {
15405 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
15406 }
15407
15408 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
15409
15410 #ifdef DEBUG
15411 size_t build_log_size = 0;
15412
15413 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
15414
15415 if (build_log_size > 1)
15416 {
15417 char *build_log = (char *) malloc (build_log_size + 1);
15418
15419 memset (build_log, 0, build_log_size + 1);
15420
15421 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
15422
15423 puts (build_log);
15424
15425 free (build_log);
15426 }
15427 #endif
15428
15429 if (rc != 0)
15430 {
15431 device_param->skipped = true;
15432
15433 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15434 }
15435 }
15436
15437 local_free (kernel_lengths);
15438 local_free (kernel_sources[0]);
15439 local_free (kernel_sources);
15440 }
15441
15442 /**
15443 * word generator kernel
15444 */
15445
15446 if (attack_mode != ATTACK_MODE_STRAIGHT)
15447 {
15448 /**
15449 * kernel mp source filename
15450 */
15451
15452 char source_file[256] = { 0 };
15453
15454 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15455
15456 struct stat sst;
15457
15458 if (stat (source_file, &sst) == -1)
15459 {
15460 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15461
15462 return -1;
15463 }
15464
15465 /**
15466 * kernel mp cached filename
15467 */
15468
15469 char cached_file[256] = { 0 };
15470
15471 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15472
15473 int cached = 1;
15474
15475 struct stat cst;
15476
15477 if (stat (cached_file, &cst) == -1)
15478 {
15479 cached = 0;
15480 }
15481
15482 /**
15483 * kernel compile or load
15484 */
15485
15486 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15487
15488 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15489
15490 if (cached == 0)
15491 {
15492 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15493 if (quiet == 0) log_info ("");
15494
15495 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15496
15497 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15498
15499 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15500
15501 if (rc != 0)
15502 {
15503 device_param->skipped = true;
15504
15505 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15506
15507 continue;
15508 }
15509
15510 size_t binary_size;
15511
15512 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15513
15514 u8 *binary = (u8 *) mymalloc (binary_size);
15515
15516 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15517
15518 writeProgramBin (cached_file, binary, binary_size);
15519
15520 local_free (binary);
15521 }
15522 else
15523 {
15524 #ifdef DEBUG
15525 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15526 #endif
15527
15528 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15529
15530 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15531
15532 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15533 }
15534
15535 local_free (kernel_lengths);
15536 local_free (kernel_sources[0]);
15537 local_free (kernel_sources);
15538 }
15539
15540 /**
15541 * amplifier kernel
15542 */
15543
15544 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15545 {
15546
15547 }
15548 else
15549 {
15550 /**
15551 * kernel amp source filename
15552 */
15553
15554 char source_file[256] = { 0 };
15555
15556 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15557
15558 struct stat sst;
15559
15560 if (stat (source_file, &sst) == -1)
15561 {
15562 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15563
15564 return -1;
15565 }
15566
15567 /**
15568 * kernel amp cached filename
15569 */
15570
15571 char cached_file[256] = { 0 };
15572
15573 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15574
15575 int cached = 1;
15576
15577 struct stat cst;
15578
15579 if (stat (cached_file, &cst) == -1)
15580 {
15581 cached = 0;
15582 }
15583
15584 /**
15585 * kernel compile or load
15586 */
15587
15588 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15589
15590 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15591
15592 if (cached == 0)
15593 {
15594 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15595 if (quiet == 0) log_info ("");
15596
15597 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15598
15599 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15600
15601 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15602
15603 if (rc != 0)
15604 {
15605 device_param->skipped = true;
15606
15607 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15608
15609 continue;
15610 }
15611
15612 size_t binary_size;
15613
15614 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15615
15616 u8 *binary = (u8 *) mymalloc (binary_size);
15617
15618 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15619
15620 writeProgramBin (cached_file, binary, binary_size);
15621
15622 local_free (binary);
15623 }
15624 else
15625 {
15626 #ifdef DEBUG
15627 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15628 #endif
15629
15630 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15631
15632 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15633
15634 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15635 }
15636
15637 local_free (kernel_lengths);
15638 local_free (kernel_sources[0]);
15639 local_free (kernel_sources);
15640 }
15641
15642 // some algorithm collide too fast, make that impossible
15643
15644 if (benchmark == 1)
15645 {
15646 ((uint *) digests_buf)[0] = -1;
15647 ((uint *) digests_buf)[1] = -1;
15648 ((uint *) digests_buf)[2] = -1;
15649 ((uint *) digests_buf)[3] = -1;
15650 }
15651
15652 /**
15653 * global buffers
15654 */
15655
15656 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15657 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15658 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15659 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15660 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15661 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15662 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15663 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15664 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15665 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15666 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15667 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15668 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15669 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15670 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15671 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15672 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15673 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15674
15675 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);
15676 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);
15677 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);
15678 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);
15679 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);
15680 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);
15681 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);
15682 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);
15683 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15684 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15685 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15686
15687 /**
15688 * special buffers
15689 */
15690
15691 if (attack_kern == ATTACK_KERN_STRAIGHT)
15692 {
15693 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15694 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15695
15696 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15697 }
15698 else if (attack_kern == ATTACK_KERN_COMBI)
15699 {
15700 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15701 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15702 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15703 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15704 }
15705 else if (attack_kern == ATTACK_KERN_BF)
15706 {
15707 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15708 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15709 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15710 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15711 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15712 }
15713
15714 if (size_esalts)
15715 {
15716 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15717
15718 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15719 }
15720
15721 /**
15722 * main host data
15723 */
15724
15725 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15726
15727 device_param->pws_buf = pws_buf;
15728
15729 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15730
15731 device_param->combs_buf = combs_buf;
15732
15733 void *hooks_buf = mymalloc (size_hooks);
15734
15735 device_param->hooks_buf = hooks_buf;
15736
15737 /**
15738 * kernel args
15739 */
15740
15741 device_param->kernel_params_buf32[21] = bitmap_mask;
15742 device_param->kernel_params_buf32[22] = bitmap_shift1;
15743 device_param->kernel_params_buf32[23] = bitmap_shift2;
15744 device_param->kernel_params_buf32[24] = 0; // salt_pos
15745 device_param->kernel_params_buf32[25] = 0; // loop_pos
15746 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15747 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15748 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15749 device_param->kernel_params_buf32[29] = 0; // digests_offset
15750 device_param->kernel_params_buf32[30] = 0; // combs_mode
15751 device_param->kernel_params_buf32[31] = 0; // gid_max
15752
15753 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15754 ? &device_param->d_pws_buf
15755 : &device_param->d_pws_amp_buf;
15756 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15757 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15758 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15759 device_param->kernel_params[ 4] = &device_param->d_tmps;
15760 device_param->kernel_params[ 5] = &device_param->d_hooks;
15761 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15762 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15763 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15764 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15765 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15766 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15767 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15768 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15769 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15770 device_param->kernel_params[15] = &device_param->d_digests_buf;
15771 device_param->kernel_params[16] = &device_param->d_digests_shown;
15772 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15773 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15774 device_param->kernel_params[19] = &device_param->d_result;
15775 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15776 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15777 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15778 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15779 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15780 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15781 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15782 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15783 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15784 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15785 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15786 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15787
15788 device_param->kernel_params_mp_buf64[3] = 0;
15789 device_param->kernel_params_mp_buf32[4] = 0;
15790 device_param->kernel_params_mp_buf32[5] = 0;
15791 device_param->kernel_params_mp_buf32[6] = 0;
15792 device_param->kernel_params_mp_buf32[7] = 0;
15793 device_param->kernel_params_mp_buf32[8] = 0;
15794
15795 device_param->kernel_params_mp[0] = NULL;
15796 device_param->kernel_params_mp[1] = NULL;
15797 device_param->kernel_params_mp[2] = NULL;
15798 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15799 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15800 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15801 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15802 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15803 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15804
15805 device_param->kernel_params_mp_l_buf64[3] = 0;
15806 device_param->kernel_params_mp_l_buf32[4] = 0;
15807 device_param->kernel_params_mp_l_buf32[5] = 0;
15808 device_param->kernel_params_mp_l_buf32[6] = 0;
15809 device_param->kernel_params_mp_l_buf32[7] = 0;
15810 device_param->kernel_params_mp_l_buf32[8] = 0;
15811 device_param->kernel_params_mp_l_buf32[9] = 0;
15812
15813 device_param->kernel_params_mp_l[0] = NULL;
15814 device_param->kernel_params_mp_l[1] = NULL;
15815 device_param->kernel_params_mp_l[2] = NULL;
15816 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15817 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15818 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15819 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15820 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15821 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15822 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15823
15824 device_param->kernel_params_mp_r_buf64[3] = 0;
15825 device_param->kernel_params_mp_r_buf32[4] = 0;
15826 device_param->kernel_params_mp_r_buf32[5] = 0;
15827 device_param->kernel_params_mp_r_buf32[6] = 0;
15828 device_param->kernel_params_mp_r_buf32[7] = 0;
15829 device_param->kernel_params_mp_r_buf32[8] = 0;
15830
15831 device_param->kernel_params_mp_r[0] = NULL;
15832 device_param->kernel_params_mp_r[1] = NULL;
15833 device_param->kernel_params_mp_r[2] = NULL;
15834 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15835 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15836 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15837 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15838 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15839 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15840
15841 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15842 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15843
15844 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15845 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15846 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15847 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15848 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15849 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15850 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15851
15852 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15853 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15854
15855 device_param->kernel_params_memset_buf32[1] = 0; // value
15856 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15857
15858 device_param->kernel_params_memset[0] = NULL;
15859 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15860 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15861
15862 /**
15863 * kernel name
15864 */
15865
15866 size_t kernel_wgs_tmp;
15867
15868 char kernel_name[64] = { 0 };
15869
15870 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15871 {
15872 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15873 {
15874 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15875
15876 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15877
15878 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15879
15880 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15881
15882 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15883
15884 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15885 }
15886 else
15887 {
15888 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15889
15890 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15891
15892 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15893
15894 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15895
15896 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15897
15898 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15899 }
15900
15901 if (data.attack_mode == ATTACK_MODE_BF)
15902 {
15903 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15904 {
15905 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15906
15907 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15908
15909 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);
15910 }
15911 }
15912 }
15913 else
15914 {
15915 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15916
15917 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15918
15919 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15920
15921 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15922
15923 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15924
15925 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15926
15927 if (opts_type & OPTS_TYPE_HOOK12)
15928 {
15929 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15930
15931 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15932
15933 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);
15934 }
15935
15936 if (opts_type & OPTS_TYPE_HOOK23)
15937 {
15938 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15939
15940 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15941
15942 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);
15943 }
15944 }
15945
15946 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);
15947 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);
15948 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);
15949
15950 for (uint i = 0; i <= 20; i++)
15951 {
15952 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15953 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15954 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15955
15956 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15957 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15958 }
15959
15960 for (uint i = 21; i <= 31; i++)
15961 {
15962 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15963 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15964 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15965
15966 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15967 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15968 }
15969
15970 // GPU memset
15971
15972 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15973
15974 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);
15975
15976 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15977 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15978 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15979
15980 // MP start
15981
15982 if (attack_mode == ATTACK_MODE_BF)
15983 {
15984 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15985 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15986
15987 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);
15988 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);
15989
15990 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15991 {
15992 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15993 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15994 }
15995 }
15996 else if (attack_mode == ATTACK_MODE_HYBRID1)
15997 {
15998 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15999
16000 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);
16001 }
16002 else if (attack_mode == ATTACK_MODE_HYBRID2)
16003 {
16004 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
16005
16006 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);
16007 }
16008
16009 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16010 {
16011 // nothing to do
16012 }
16013 else
16014 {
16015 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
16016
16017 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);
16018 }
16019
16020 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
16021 {
16022 // nothing to do
16023 }
16024 else
16025 {
16026 for (uint i = 0; i < 5; i++)
16027 {
16028 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
16029 }
16030
16031 for (uint i = 5; i < 7; i++)
16032 {
16033 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
16034 }
16035 }
16036
16037 // maybe this has been updated by clGetKernelWorkGroupInfo()
16038 // value can only be decreased, so we don't need to reallocate buffers
16039
16040 device_param->kernel_threads = kernel_threads;
16041
16042 // zero some data buffers
16043
16044 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
16045 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
16046 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
16047 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
16048 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
16049 run_kernel_bzero (device_param, device_param->d_result, size_results);
16050
16051 /**
16052 * special buffers
16053 */
16054
16055 if (attack_kern == ATTACK_KERN_STRAIGHT)
16056 {
16057 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
16058 }
16059 else if (attack_kern == ATTACK_KERN_COMBI)
16060 {
16061 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
16062 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
16063 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16064 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16065 }
16066 else if (attack_kern == ATTACK_KERN_BF)
16067 {
16068 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
16069 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
16070 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
16071 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
16072 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
16073 }
16074
16075 #if defined(HAVE_HWMON)
16076
16077 /**
16078 * Store initial fanspeed if gpu_temp_retain is enabled
16079 */
16080
16081 if (gpu_temp_disable == 0)
16082 {
16083 if (gpu_temp_retain != 0)
16084 {
16085 hc_thread_mutex_lock (mux_adl);
16086
16087 if (data.hm_device[device_id].fan_get_supported == 1)
16088 {
16089 const int fanspeed = hm_get_fanspeed_with_device_id (device_id);
16090 const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id);
16091
16092 temp_retain_fanspeed_value[device_id] = fanspeed;
16093 temp_retain_fanpolicy_value[device_id] = fanpolicy;
16094
16095 // we also set it to tell the OS we take control over the fan and it's automatic controller
16096 // if it was set to automatic. we do not control user-defined fanspeeds.
16097
16098 if (fanpolicy == 1)
16099 {
16100 data.hm_device[device_id].fan_set_supported = 1;
16101
16102 int rc = -1;
16103
16104 if (device_param->device_vendor_id == VENDOR_ID_AMD)
16105 {
16106 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1);
16107 }
16108 else if (device_param->device_vendor_id == VENDOR_ID_NV)
16109 {
16110
16111 }
16112
16113 if (rc == 0)
16114 {
16115 data.hm_device[device_id].fan_set_supported = 1;
16116 }
16117 else
16118 {
16119 log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1);
16120
16121 data.hm_device[device_id].fan_set_supported = 0;
16122 }
16123 }
16124 else
16125 {
16126 data.hm_device[device_id].fan_set_supported = 0;
16127 }
16128 }
16129
16130 hc_thread_mutex_unlock (mux_adl);
16131 }
16132 }
16133
16134 #endif // HAVE_HWMON
16135 }
16136
16137 if (data.quiet == 0) log_info_nn ("");
16138
16139 /**
16140 * In benchmark-mode, inform user which algorithm is checked
16141 */
16142
16143 if (benchmark == 1)
16144 {
16145 if (machine_readable == 0)
16146 {
16147 quiet = 0;
16148
16149 data.quiet = quiet;
16150
16151 char *hash_type = strhashtype (data.hash_mode); // not a bug
16152
16153 log_info ("Hashtype: %s", hash_type);
16154 log_info ("");
16155 }
16156 }
16157
16158 /**
16159 * keep track of the progress
16160 */
16161
16162 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16163 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16164 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
16165
16166 /**
16167 * open filehandles
16168 */
16169
16170 #if _WIN
16171 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
16172 {
16173 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
16174
16175 return (-1);
16176 }
16177
16178 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
16179 {
16180 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
16181
16182 return (-1);
16183 }
16184
16185 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
16186 {
16187 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
16188
16189 return (-1);
16190 }
16191 #endif
16192
16193 /**
16194 * dictionary pad
16195 */
16196
16197 segment_size *= (1024 * 1024);
16198
16199 data.segment_size = segment_size;
16200
16201 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
16202
16203 wl_data->buf = (char *) mymalloc (segment_size);
16204 wl_data->avail = segment_size;
16205 wl_data->incr = segment_size;
16206 wl_data->cnt = 0;
16207 wl_data->pos = 0;
16208
16209 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
16210
16211 data.wordlist_mode = wordlist_mode;
16212
16213 cs_t *css_buf = NULL;
16214 uint css_cnt = 0;
16215 uint dictcnt = 0;
16216 uint maskcnt = 1;
16217 char **masks = NULL;
16218 char **dictfiles = NULL;
16219
16220 uint mask_from_file = 0;
16221
16222 if (attack_mode == ATTACK_MODE_STRAIGHT)
16223 {
16224 if (wordlist_mode == WL_MODE_FILE)
16225 {
16226 int wls_left = myargc - (optind + 1);
16227
16228 for (int i = 0; i < wls_left; i++)
16229 {
16230 char *l0_filename = myargv[optind + 1 + i];
16231
16232 struct stat l0_stat;
16233
16234 if (stat (l0_filename, &l0_stat) == -1)
16235 {
16236 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
16237
16238 return (-1);
16239 }
16240
16241 uint is_dir = S_ISDIR (l0_stat.st_mode);
16242
16243 if (is_dir == 0)
16244 {
16245 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16246
16247 dictcnt++;
16248
16249 dictfiles[dictcnt - 1] = l0_filename;
16250 }
16251 else
16252 {
16253 // do not allow --keyspace w/ a directory
16254
16255 if (keyspace == 1)
16256 {
16257 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16258
16259 return (-1);
16260 }
16261
16262 char **dictionary_files = NULL;
16263
16264 dictionary_files = scan_directory (l0_filename);
16265
16266 if (dictionary_files != NULL)
16267 {
16268 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16269
16270 for (int d = 0; dictionary_files[d] != NULL; d++)
16271 {
16272 char *l1_filename = dictionary_files[d];
16273
16274 struct stat l1_stat;
16275
16276 if (stat (l1_filename, &l1_stat) == -1)
16277 {
16278 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16279
16280 return (-1);
16281 }
16282
16283 if (S_ISREG (l1_stat.st_mode))
16284 {
16285 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16286
16287 dictcnt++;
16288
16289 dictfiles[dictcnt - 1] = strdup (l1_filename);
16290 }
16291 }
16292 }
16293
16294 local_free (dictionary_files);
16295 }
16296 }
16297
16298 if (dictcnt < 1)
16299 {
16300 log_error ("ERROR: No usable dictionary file found.");
16301
16302 return (-1);
16303 }
16304 }
16305 else if (wordlist_mode == WL_MODE_STDIN)
16306 {
16307 dictcnt = 1;
16308 }
16309 }
16310 else if (attack_mode == ATTACK_MODE_COMBI)
16311 {
16312 // display
16313
16314 char *dictfile1 = myargv[optind + 1 + 0];
16315 char *dictfile2 = myargv[optind + 1 + 1];
16316
16317 // find the bigger dictionary and use as base
16318
16319 FILE *fp1 = NULL;
16320 FILE *fp2 = NULL;
16321
16322 struct stat tmp_stat;
16323
16324 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16325 {
16326 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16327
16328 return (-1);
16329 }
16330
16331 if (stat (dictfile1, &tmp_stat) == -1)
16332 {
16333 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16334
16335 fclose (fp1);
16336
16337 return (-1);
16338 }
16339
16340 if (S_ISDIR (tmp_stat.st_mode))
16341 {
16342 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16343
16344 fclose (fp1);
16345
16346 return (-1);
16347 }
16348
16349 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16350 {
16351 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16352
16353 fclose (fp1);
16354
16355 return (-1);
16356 }
16357
16358 if (stat (dictfile2, &tmp_stat) == -1)
16359 {
16360 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16361
16362 fclose (fp1);
16363 fclose (fp2);
16364
16365 return (-1);
16366 }
16367
16368 if (S_ISDIR (tmp_stat.st_mode))
16369 {
16370 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16371
16372 fclose (fp1);
16373 fclose (fp2);
16374
16375 return (-1);
16376 }
16377
16378 data.combs_cnt = 1;
16379
16380 data.quiet = 1;
16381
16382 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16383
16384 data.quiet = quiet;
16385
16386 if (words1_cnt == 0)
16387 {
16388 log_error ("ERROR: %s: empty file", dictfile1);
16389
16390 fclose (fp1);
16391 fclose (fp2);
16392
16393 return (-1);
16394 }
16395
16396 data.combs_cnt = 1;
16397
16398 data.quiet = 1;
16399
16400 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16401
16402 data.quiet = quiet;
16403
16404 if (words2_cnt == 0)
16405 {
16406 log_error ("ERROR: %s: empty file", dictfile2);
16407
16408 fclose (fp1);
16409 fclose (fp2);
16410
16411 return (-1);
16412 }
16413
16414 fclose (fp1);
16415 fclose (fp2);
16416
16417 data.dictfile = dictfile1;
16418 data.dictfile2 = dictfile2;
16419
16420 if (words1_cnt >= words2_cnt)
16421 {
16422 data.combs_cnt = words2_cnt;
16423 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16424
16425 dictfiles = &data.dictfile;
16426
16427 dictcnt = 1;
16428 }
16429 else
16430 {
16431 data.combs_cnt = words1_cnt;
16432 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16433
16434 dictfiles = &data.dictfile2;
16435
16436 dictcnt = 1;
16437
16438 // we also have to switch wordlist related rules!
16439
16440 char *tmpc = data.rule_buf_l;
16441
16442 data.rule_buf_l = data.rule_buf_r;
16443 data.rule_buf_r = tmpc;
16444
16445 int tmpi = data.rule_len_l;
16446
16447 data.rule_len_l = data.rule_len_r;
16448 data.rule_len_r = tmpi;
16449 }
16450 }
16451 else if (attack_mode == ATTACK_MODE_BF)
16452 {
16453 char *mask = NULL;
16454
16455 maskcnt = 0;
16456
16457 if (benchmark == 0)
16458 {
16459 mask = myargv[optind + 1];
16460
16461 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16462
16463 if ((optind + 2) <= myargc)
16464 {
16465 struct stat file_stat;
16466
16467 if (stat (mask, &file_stat) == -1)
16468 {
16469 maskcnt = 1;
16470
16471 masks[maskcnt - 1] = mystrdup (mask);
16472 }
16473 else
16474 {
16475 int wls_left = myargc - (optind + 1);
16476
16477 uint masks_avail = INCR_MASKS;
16478
16479 for (int i = 0; i < wls_left; i++)
16480 {
16481 if (i != 0)
16482 {
16483 mask = myargv[optind + 1 + i];
16484
16485 if (stat (mask, &file_stat) == -1)
16486 {
16487 log_error ("ERROR: %s: %s", mask, strerror (errno));
16488
16489 return (-1);
16490 }
16491 }
16492
16493 uint is_file = S_ISREG (file_stat.st_mode);
16494
16495 if (is_file == 1)
16496 {
16497 FILE *mask_fp;
16498
16499 if ((mask_fp = fopen (mask, "r")) == NULL)
16500 {
16501 log_error ("ERROR: %s: %s", mask, strerror (errno));
16502
16503 return (-1);
16504 }
16505
16506 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16507
16508 while (!feof (mask_fp))
16509 {
16510 memset (line_buf, 0, HCBUFSIZ);
16511
16512 int line_len = fgetl (mask_fp, line_buf);
16513
16514 if (line_len == 0) continue;
16515
16516 if (line_buf[0] == '#') continue;
16517
16518 if (masks_avail == maskcnt)
16519 {
16520 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16521
16522 masks_avail += INCR_MASKS;
16523 }
16524
16525 masks[maskcnt] = mystrdup (line_buf);
16526
16527 maskcnt++;
16528 }
16529
16530 myfree (line_buf);
16531
16532 fclose (mask_fp);
16533 }
16534 else
16535 {
16536 log_error ("ERROR: %s: unsupported file-type", mask);
16537
16538 return (-1);
16539 }
16540 }
16541
16542 mask_from_file = 1;
16543 }
16544 }
16545 else
16546 {
16547 custom_charset_1 = (char *) "?l?d?u";
16548 custom_charset_2 = (char *) "?l?d";
16549 custom_charset_3 = (char *) "?l?d*!$@_";
16550
16551 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16552 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16553 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16554
16555 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16556
16557 wordlist_mode = WL_MODE_MASK;
16558
16559 data.wordlist_mode = wordlist_mode;
16560
16561 increment = 1;
16562
16563 maskcnt = 1;
16564 }
16565 }
16566 else
16567 {
16568 /**
16569 * generate full masks and charsets
16570 */
16571
16572 masks = (char **) mymalloc (sizeof (char *));
16573
16574 switch (hash_mode)
16575 {
16576 case 1731: pw_min = 5;
16577 pw_max = 5;
16578 mask = mystrdup ("?b?b?b?b?b");
16579 break;
16580 case 12500: pw_min = 5;
16581 pw_max = 5;
16582 mask = mystrdup ("?b?b?b?b?b");
16583 break;
16584 default: pw_min = 7;
16585 pw_max = 7;
16586 mask = mystrdup ("?b?b?b?b?b?b?b");
16587 break;
16588 }
16589
16590 maskcnt = 1;
16591
16592 masks[maskcnt - 1] = mystrdup (mask);
16593
16594 wordlist_mode = WL_MODE_MASK;
16595
16596 data.wordlist_mode = wordlist_mode;
16597
16598 increment = 1;
16599 }
16600
16601 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16602
16603 if (increment)
16604 {
16605 if (increment_min > pw_min) pw_min = increment_min;
16606
16607 if (increment_max < pw_max) pw_max = increment_max;
16608 }
16609 }
16610 else if (attack_mode == ATTACK_MODE_HYBRID1)
16611 {
16612 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16613
16614 // display
16615
16616 char *mask = myargv[myargc - 1];
16617
16618 maskcnt = 0;
16619
16620 masks = (char **) mymalloc (1 * sizeof (char *));
16621
16622 // mod
16623
16624 struct stat file_stat;
16625
16626 if (stat (mask, &file_stat) == -1)
16627 {
16628 maskcnt = 1;
16629
16630 masks[maskcnt - 1] = mystrdup (mask);
16631 }
16632 else
16633 {
16634 uint is_file = S_ISREG (file_stat.st_mode);
16635
16636 if (is_file == 1)
16637 {
16638 FILE *mask_fp;
16639
16640 if ((mask_fp = fopen (mask, "r")) == NULL)
16641 {
16642 log_error ("ERROR: %s: %s", mask, strerror (errno));
16643
16644 return (-1);
16645 }
16646
16647 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16648
16649 uint masks_avail = 1;
16650
16651 while (!feof (mask_fp))
16652 {
16653 memset (line_buf, 0, HCBUFSIZ);
16654
16655 int line_len = fgetl (mask_fp, line_buf);
16656
16657 if (line_len == 0) continue;
16658
16659 if (line_buf[0] == '#') continue;
16660
16661 if (masks_avail == maskcnt)
16662 {
16663 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16664
16665 masks_avail += INCR_MASKS;
16666 }
16667
16668 masks[maskcnt] = mystrdup (line_buf);
16669
16670 maskcnt++;
16671 }
16672
16673 myfree (line_buf);
16674
16675 fclose (mask_fp);
16676
16677 mask_from_file = 1;
16678 }
16679 else
16680 {
16681 maskcnt = 1;
16682
16683 masks[maskcnt - 1] = mystrdup (mask);
16684 }
16685 }
16686
16687 // base
16688
16689 int wls_left = myargc - (optind + 2);
16690
16691 for (int i = 0; i < wls_left; i++)
16692 {
16693 char *filename = myargv[optind + 1 + i];
16694
16695 struct stat file_stat;
16696
16697 if (stat (filename, &file_stat) == -1)
16698 {
16699 log_error ("ERROR: %s: %s", filename, strerror (errno));
16700
16701 return (-1);
16702 }
16703
16704 uint is_dir = S_ISDIR (file_stat.st_mode);
16705
16706 if (is_dir == 0)
16707 {
16708 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16709
16710 dictcnt++;
16711
16712 dictfiles[dictcnt - 1] = filename;
16713 }
16714 else
16715 {
16716 // do not allow --keyspace w/ a directory
16717
16718 if (keyspace == 1)
16719 {
16720 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16721
16722 return (-1);
16723 }
16724
16725 char **dictionary_files = NULL;
16726
16727 dictionary_files = scan_directory (filename);
16728
16729 if (dictionary_files != NULL)
16730 {
16731 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16732
16733 for (int d = 0; dictionary_files[d] != NULL; d++)
16734 {
16735 char *l1_filename = dictionary_files[d];
16736
16737 struct stat l1_stat;
16738
16739 if (stat (l1_filename, &l1_stat) == -1)
16740 {
16741 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16742
16743 return (-1);
16744 }
16745
16746 if (S_ISREG (l1_stat.st_mode))
16747 {
16748 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16749
16750 dictcnt++;
16751
16752 dictfiles[dictcnt - 1] = strdup (l1_filename);
16753 }
16754 }
16755 }
16756
16757 local_free (dictionary_files);
16758 }
16759 }
16760
16761 if (dictcnt < 1)
16762 {
16763 log_error ("ERROR: No usable dictionary file found.");
16764
16765 return (-1);
16766 }
16767
16768 if (increment)
16769 {
16770 maskcnt = 0;
16771
16772 uint mask_min = increment_min; // we can't reject smaller masks here
16773 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16774
16775 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16776 {
16777 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16778
16779 if (cur_mask == NULL) break;
16780
16781 masks[maskcnt] = cur_mask;
16782
16783 maskcnt++;
16784
16785 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16786 }
16787 }
16788 }
16789 else if (attack_mode == ATTACK_MODE_HYBRID2)
16790 {
16791 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16792
16793 // display
16794
16795 char *mask = myargv[optind + 1 + 0];
16796
16797 maskcnt = 0;
16798
16799 masks = (char **) mymalloc (1 * sizeof (char *));
16800
16801 // mod
16802
16803 struct stat file_stat;
16804
16805 if (stat (mask, &file_stat) == -1)
16806 {
16807 maskcnt = 1;
16808
16809 masks[maskcnt - 1] = mystrdup (mask);
16810 }
16811 else
16812 {
16813 uint is_file = S_ISREG (file_stat.st_mode);
16814
16815 if (is_file == 1)
16816 {
16817 FILE *mask_fp;
16818
16819 if ((mask_fp = fopen (mask, "r")) == NULL)
16820 {
16821 log_error ("ERROR: %s: %s", mask, strerror (errno));
16822
16823 return (-1);
16824 }
16825
16826 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16827
16828 uint masks_avail = 1;
16829
16830 while (!feof (mask_fp))
16831 {
16832 memset (line_buf, 0, HCBUFSIZ);
16833
16834 int line_len = fgetl (mask_fp, line_buf);
16835
16836 if (line_len == 0) continue;
16837
16838 if (line_buf[0] == '#') continue;
16839
16840 if (masks_avail == maskcnt)
16841 {
16842 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16843
16844 masks_avail += INCR_MASKS;
16845 }
16846
16847 masks[maskcnt] = mystrdup (line_buf);
16848
16849 maskcnt++;
16850 }
16851
16852 myfree (line_buf);
16853
16854 fclose (mask_fp);
16855
16856 mask_from_file = 1;
16857 }
16858 else
16859 {
16860 maskcnt = 1;
16861
16862 masks[maskcnt - 1] = mystrdup (mask);
16863 }
16864 }
16865
16866 // base
16867
16868 int wls_left = myargc - (optind + 2);
16869
16870 for (int i = 0; i < wls_left; i++)
16871 {
16872 char *filename = myargv[optind + 2 + i];
16873
16874 struct stat file_stat;
16875
16876 if (stat (filename, &file_stat) == -1)
16877 {
16878 log_error ("ERROR: %s: %s", filename, strerror (errno));
16879
16880 return (-1);
16881 }
16882
16883 uint is_dir = S_ISDIR (file_stat.st_mode);
16884
16885 if (is_dir == 0)
16886 {
16887 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16888
16889 dictcnt++;
16890
16891 dictfiles[dictcnt - 1] = filename;
16892 }
16893 else
16894 {
16895 // do not allow --keyspace w/ a directory
16896
16897 if (keyspace == 1)
16898 {
16899 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16900
16901 return (-1);
16902 }
16903
16904 char **dictionary_files = NULL;
16905
16906 dictionary_files = scan_directory (filename);
16907
16908 if (dictionary_files != NULL)
16909 {
16910 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16911
16912 for (int d = 0; dictionary_files[d] != NULL; d++)
16913 {
16914 char *l1_filename = dictionary_files[d];
16915
16916 struct stat l1_stat;
16917
16918 if (stat (l1_filename, &l1_stat) == -1)
16919 {
16920 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16921
16922 return (-1);
16923 }
16924
16925 if (S_ISREG (l1_stat.st_mode))
16926 {
16927 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16928
16929 dictcnt++;
16930
16931 dictfiles[dictcnt - 1] = strdup (l1_filename);
16932 }
16933 }
16934 }
16935
16936 local_free (dictionary_files);
16937 }
16938 }
16939
16940 if (dictcnt < 1)
16941 {
16942 log_error ("ERROR: No usable dictionary file found.");
16943
16944 return (-1);
16945 }
16946
16947 if (increment)
16948 {
16949 maskcnt = 0;
16950
16951 uint mask_min = increment_min; // we can't reject smaller masks here
16952 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16953
16954 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16955 {
16956 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16957
16958 if (cur_mask == NULL) break;
16959
16960 masks[maskcnt] = cur_mask;
16961
16962 maskcnt++;
16963
16964 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16965 }
16966 }
16967 }
16968
16969 data.pw_min = pw_min;
16970 data.pw_max = pw_max;
16971
16972 /**
16973 * weak hash check
16974 */
16975
16976 if (weak_hash_threshold >= salts_cnt)
16977 {
16978 hc_device_param_t *device_param = NULL;
16979
16980 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16981 {
16982 device_param = &data.devices_param[device_id];
16983
16984 if (device_param->skipped) continue;
16985
16986 break;
16987 }
16988
16989 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16990
16991 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16992 {
16993 weak_hash_check (device_param, salt_pos);
16994 }
16995
16996 // Display hack, guarantee that there is at least one \r before real start
16997
16998 //if (data.quiet == 0) log_info ("");
16999 }
17000
17001 /**
17002 * status and monitor threads
17003 */
17004
17005 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
17006
17007 uint i_threads_cnt = 0;
17008
17009 hc_thread_t *i_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17010
17011 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17012 {
17013 if (stdout_flag == 0)
17014 {
17015 hc_thread_create (i_threads[i_threads_cnt], thread_keypress, &benchmark);
17016
17017 i_threads_cnt++;
17018 }
17019 }
17020
17021 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
17022
17023 uint ni_threads_cnt = 0;
17024
17025 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
17026
17027 if (stdout_flag == 0)
17028 {
17029 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
17030
17031 ni_threads_cnt++;
17032 }
17033
17034 /**
17035 * Outfile remove
17036 */
17037
17038 if (keyspace == 0)
17039 {
17040 if (outfile_check_timer != 0)
17041 {
17042 if (data.outfile_check_directory != NULL)
17043 {
17044 if ((hash_mode != 5200) &&
17045 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
17046 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
17047 (hash_mode != 9000))
17048 {
17049 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
17050
17051 ni_threads_cnt++;
17052 }
17053 else
17054 {
17055 outfile_check_timer = 0;
17056 }
17057 }
17058 else
17059 {
17060 outfile_check_timer = 0;
17061 }
17062 }
17063 }
17064
17065 /**
17066 * Inform the user if we got some hashes remove because of the pot file remove feature
17067 */
17068
17069 if (data.quiet == 0)
17070 {
17071 if (potfile_remove_cracks > 0)
17072 {
17073 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
17074 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
17075 }
17076 }
17077
17078 data.outfile_check_timer = outfile_check_timer;
17079
17080 /**
17081 * main loop
17082 */
17083
17084 char **induction_dictionaries = NULL;
17085
17086 int induction_dictionaries_cnt = 0;
17087
17088 hcstat_table_t *root_table_buf = NULL;
17089 hcstat_table_t *markov_table_buf = NULL;
17090
17091 uint initial_restore_done = 0;
17092
17093 data.maskcnt = maskcnt;
17094
17095 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
17096 {
17097 if (data.devices_status == STATUS_CRACKED) break;
17098
17099 data.devices_status = STATUS_INIT;
17100
17101 if (maskpos > rd->maskpos)
17102 {
17103 rd->dictpos = 0;
17104 }
17105
17106 rd->maskpos = maskpos;
17107 data.maskpos = maskpos;
17108
17109 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
17110 {
17111 char *mask = masks[maskpos];
17112
17113 if (mask_from_file == 1)
17114 {
17115 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
17116
17117 char *str_ptr;
17118 uint str_pos;
17119
17120 uint mask_offset = 0;
17121
17122 uint separator_cnt;
17123
17124 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
17125 {
17126 str_ptr = strstr (mask + mask_offset, ",");
17127
17128 if (str_ptr == NULL) break;
17129
17130 str_pos = str_ptr - mask;
17131
17132 // escaped separator, i.e. "\,"
17133
17134 if (str_pos > 0)
17135 {
17136 if (mask[str_pos - 1] == '\\')
17137 {
17138 separator_cnt --;
17139
17140 mask_offset = str_pos + 1;
17141
17142 continue;
17143 }
17144 }
17145
17146 // reset the offset
17147
17148 mask_offset = 0;
17149
17150 mask[str_pos] = '\0';
17151
17152 switch (separator_cnt)
17153 {
17154 case 0:
17155 mp_reset_usr (mp_usr, 0);
17156
17157 custom_charset_1 = mask;
17158 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
17159 break;
17160
17161 case 1:
17162 mp_reset_usr (mp_usr, 1);
17163
17164 custom_charset_2 = mask;
17165 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
17166 break;
17167
17168 case 2:
17169 mp_reset_usr (mp_usr, 2);
17170
17171 custom_charset_3 = mask;
17172 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
17173 break;
17174
17175 case 3:
17176 mp_reset_usr (mp_usr, 3);
17177
17178 custom_charset_4 = mask;
17179 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
17180 break;
17181 }
17182
17183 mask = mask + str_pos + 1;
17184 }
17185 }
17186
17187 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17188 {
17189 if (maskpos > 0)
17190 {
17191 local_free (css_buf);
17192 local_free (data.root_css_buf);
17193 local_free (data.markov_css_buf);
17194
17195 local_free (masks[maskpos - 1]);
17196 }
17197
17198 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17199
17200 data.mask = mask;
17201 data.css_cnt = css_cnt;
17202 data.css_buf = css_buf;
17203
17204 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17205
17206 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17207
17208 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17209 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17210
17211 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17212
17213 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17214
17215 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17216 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17217
17218 data.root_css_buf = root_css_buf;
17219 data.markov_css_buf = markov_css_buf;
17220
17221 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17222
17223 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17224
17225 local_free (root_table_buf);
17226 local_free (markov_table_buf);
17227
17228 // args
17229
17230 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17231 {
17232 hc_device_param_t *device_param = &data.devices_param[device_id];
17233
17234 if (device_param->skipped) continue;
17235
17236 device_param->kernel_params_mp[0] = &device_param->d_combs;
17237 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
17238 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
17239
17240 device_param->kernel_params_mp_buf64[3] = 0;
17241 device_param->kernel_params_mp_buf32[4] = css_cnt;
17242 device_param->kernel_params_mp_buf32[5] = 0;
17243 device_param->kernel_params_mp_buf32[6] = 0;
17244 device_param->kernel_params_mp_buf32[7] = 0;
17245
17246 if (attack_mode == ATTACK_MODE_HYBRID1)
17247 {
17248 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
17249 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
17250 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
17251 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
17252 }
17253 else if (attack_mode == ATTACK_MODE_HYBRID2)
17254 {
17255 device_param->kernel_params_mp_buf32[5] = 0;
17256 device_param->kernel_params_mp_buf32[6] = 0;
17257 device_param->kernel_params_mp_buf32[7] = 0;
17258 }
17259
17260 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp[i]);
17261 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp[i]);
17262 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp[i]);
17263
17264 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);
17265 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);
17266 }
17267 }
17268 else if (attack_mode == ATTACK_MODE_BF)
17269 {
17270 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
17271
17272 if (increment)
17273 {
17274 for (uint i = 0; i < dictcnt; i++)
17275 {
17276 local_free (dictfiles[i]);
17277 }
17278
17279 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
17280 {
17281 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
17282
17283 if (l1_filename == NULL) break;
17284
17285 dictcnt++;
17286
17287 dictfiles[dictcnt - 1] = l1_filename;
17288 }
17289 }
17290 else
17291 {
17292 dictcnt++;
17293
17294 dictfiles[dictcnt - 1] = mask;
17295 }
17296
17297 if (dictcnt == 0)
17298 {
17299 log_error ("ERROR: Mask is too small");
17300
17301 return (-1);
17302 }
17303 }
17304 }
17305
17306 free (induction_dictionaries);
17307
17308 // induction_dictionaries_cnt = 0; // implied
17309
17310 if (attack_mode != ATTACK_MODE_BF)
17311 {
17312 if (keyspace == 0)
17313 {
17314 induction_dictionaries = scan_directory (induction_directory);
17315
17316 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17317 }
17318 }
17319
17320 if (induction_dictionaries_cnt)
17321 {
17322 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17323 }
17324
17325 /**
17326 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17327 */
17328 if (keyspace == 1)
17329 {
17330 if ((maskcnt > 1) || (dictcnt > 1))
17331 {
17332 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17333
17334 return (-1);
17335 }
17336 }
17337
17338 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17339 {
17340 char *subid = logfile_generate_subid ();
17341
17342 data.subid = subid;
17343
17344 logfile_sub_msg ("START");
17345
17346 data.devices_status = STATUS_INIT;
17347
17348 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17349 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17350 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17351
17352 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17353
17354 data.cpt_pos = 0;
17355
17356 data.cpt_start = time (NULL);
17357
17358 data.cpt_total = 0;
17359
17360 if (data.restore == 0)
17361 {
17362 rd->words_cur = skip;
17363
17364 skip = 0;
17365
17366 data.skip = 0;
17367 }
17368
17369 data.ms_paused = 0;
17370
17371 data.kernel_power_final = 0;
17372
17373 data.words_cur = rd->words_cur;
17374
17375 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17376 {
17377 hc_device_param_t *device_param = &data.devices_param[device_id];
17378
17379 if (device_param->skipped) continue;
17380
17381 device_param->speed_pos = 0;
17382
17383 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17384 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17385
17386 device_param->exec_pos = 0;
17387
17388 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17389
17390 device_param->outerloop_pos = 0;
17391 device_param->outerloop_left = 0;
17392 device_param->innerloop_pos = 0;
17393 device_param->innerloop_left = 0;
17394
17395 // some more resets:
17396
17397 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17398
17399 device_param->pws_cnt = 0;
17400
17401 device_param->words_off = 0;
17402 device_param->words_done = 0;
17403 }
17404
17405 // figure out some workload
17406
17407 if (attack_mode == ATTACK_MODE_STRAIGHT)
17408 {
17409 if (data.wordlist_mode == WL_MODE_FILE)
17410 {
17411 char *dictfile = NULL;
17412
17413 if (induction_dictionaries_cnt)
17414 {
17415 dictfile = induction_dictionaries[0];
17416 }
17417 else
17418 {
17419 dictfile = dictfiles[dictpos];
17420 }
17421
17422 data.dictfile = dictfile;
17423
17424 logfile_sub_string (dictfile);
17425
17426 for (uint i = 0; i < rp_files_cnt; i++)
17427 {
17428 logfile_sub_var_string ("rulefile", rp_files[i]);
17429 }
17430
17431 FILE *fd2 = fopen (dictfile, "rb");
17432
17433 if (fd2 == NULL)
17434 {
17435 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17436
17437 return (-1);
17438 }
17439
17440 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17441
17442 fclose (fd2);
17443
17444 if (data.words_cnt == 0)
17445 {
17446 if (data.devices_status == STATUS_CRACKED) break;
17447 if (data.devices_status == STATUS_ABORTED) break;
17448
17449 dictpos++;
17450
17451 continue;
17452 }
17453 }
17454 }
17455 else if (attack_mode == ATTACK_MODE_COMBI)
17456 {
17457 char *dictfile = data.dictfile;
17458 char *dictfile2 = data.dictfile2;
17459
17460 logfile_sub_string (dictfile);
17461 logfile_sub_string (dictfile2);
17462
17463 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17464 {
17465 FILE *fd2 = fopen (dictfile, "rb");
17466
17467 if (fd2 == NULL)
17468 {
17469 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17470
17471 return (-1);
17472 }
17473
17474 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17475
17476 fclose (fd2);
17477 }
17478 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17479 {
17480 FILE *fd2 = fopen (dictfile2, "rb");
17481
17482 if (fd2 == NULL)
17483 {
17484 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17485
17486 return (-1);
17487 }
17488
17489 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17490
17491 fclose (fd2);
17492 }
17493
17494 if (data.words_cnt == 0)
17495 {
17496 if (data.devices_status == STATUS_CRACKED) break;
17497 if (data.devices_status == STATUS_ABORTED) break;
17498
17499 dictpos++;
17500
17501 continue;
17502 }
17503 }
17504 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17505 {
17506 char *dictfile = NULL;
17507
17508 if (induction_dictionaries_cnt)
17509 {
17510 dictfile = induction_dictionaries[0];
17511 }
17512 else
17513 {
17514 dictfile = dictfiles[dictpos];
17515 }
17516
17517 data.dictfile = dictfile;
17518
17519 char *mask = data.mask;
17520
17521 logfile_sub_string (dictfile);
17522 logfile_sub_string (mask);
17523
17524 FILE *fd2 = fopen (dictfile, "rb");
17525
17526 if (fd2 == NULL)
17527 {
17528 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17529
17530 return (-1);
17531 }
17532
17533 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17534
17535 fclose (fd2);
17536
17537 if (data.words_cnt == 0)
17538 {
17539 if (data.devices_status == STATUS_CRACKED) break;
17540 if (data.devices_status == STATUS_ABORTED) break;
17541
17542 dictpos++;
17543
17544 continue;
17545 }
17546 }
17547 else if (attack_mode == ATTACK_MODE_BF)
17548 {
17549 local_free (css_buf);
17550 local_free (data.root_css_buf);
17551 local_free (data.markov_css_buf);
17552
17553 char *mask = dictfiles[dictpos];
17554
17555 logfile_sub_string (mask);
17556
17557 // base
17558
17559 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17560
17561 if (opts_type & OPTS_TYPE_PT_UNICODE)
17562 {
17563 uint css_cnt_unicode = css_cnt * 2;
17564
17565 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17566
17567 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17568 {
17569 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17570
17571 css_buf_unicode[j + 1].cs_buf[0] = 0;
17572 css_buf_unicode[j + 1].cs_len = 1;
17573 }
17574
17575 free (css_buf);
17576
17577 css_buf = css_buf_unicode;
17578 css_cnt = css_cnt_unicode;
17579 }
17580
17581 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17582
17583 uint mask_min = pw_min;
17584 uint mask_max = pw_max;
17585
17586 if (opts_type & OPTS_TYPE_PT_UNICODE)
17587 {
17588 mask_min *= 2;
17589 mask_max *= 2;
17590 }
17591
17592 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17593 {
17594 if (css_cnt < mask_min)
17595 {
17596 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17597 }
17598
17599 if (css_cnt > mask_max)
17600 {
17601 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17602 }
17603
17604 // skip to next mask
17605
17606 dictpos++;
17607
17608 rd->dictpos = dictpos;
17609
17610 logfile_sub_msg ("STOP");
17611
17612 continue;
17613 }
17614
17615 uint save_css_cnt = css_cnt;
17616
17617 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17618 {
17619 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17620 {
17621 uint salt_len = (uint) data.salts_buf[0].salt_len;
17622 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17623
17624 uint css_cnt_salt = css_cnt + salt_len;
17625
17626 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17627
17628 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17629
17630 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17631 {
17632 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17633 css_buf_salt[j].cs_len = 1;
17634 }
17635
17636 free (css_buf);
17637
17638 css_buf = css_buf_salt;
17639 css_cnt = css_cnt_salt;
17640 }
17641 }
17642
17643 data.mask = mask;
17644 data.css_cnt = css_cnt;
17645 data.css_buf = css_buf;
17646
17647 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17648
17649 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17650
17651 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17652
17653 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17654 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17655
17656 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17657
17658 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17659
17660 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17661 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17662
17663 data.root_css_buf = root_css_buf;
17664 data.markov_css_buf = markov_css_buf;
17665
17666 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17667
17668 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17669
17670 local_free (root_table_buf);
17671 local_free (markov_table_buf);
17672
17673 // copy + args
17674
17675 uint css_cnt_l = css_cnt;
17676 uint css_cnt_r;
17677
17678 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17679 {
17680 if (save_css_cnt < 6)
17681 {
17682 css_cnt_r = 1;
17683 }
17684 else if (save_css_cnt == 6)
17685 {
17686 css_cnt_r = 2;
17687 }
17688 else
17689 {
17690 if (opts_type & OPTS_TYPE_PT_UNICODE)
17691 {
17692 if (save_css_cnt == 8 || save_css_cnt == 10)
17693 {
17694 css_cnt_r = 2;
17695 }
17696 else
17697 {
17698 css_cnt_r = 4;
17699 }
17700 }
17701 else
17702 {
17703 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17704 {
17705 css_cnt_r = 3;
17706 }
17707 else
17708 {
17709 css_cnt_r = 4;
17710 }
17711 }
17712 }
17713 }
17714 else
17715 {
17716 css_cnt_r = 1;
17717
17718 /* unfinished code?
17719 int sum = css_buf[css_cnt_r - 1].cs_len;
17720
17721 for (uint i = 1; i < 4 && i < css_cnt; i++)
17722 {
17723 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17724
17725 css_cnt_r++;
17726
17727 sum *= css_buf[css_cnt_r - 1].cs_len;
17728 }
17729 */
17730 }
17731
17732 css_cnt_l -= css_cnt_r;
17733
17734 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17735
17736 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17737 {
17738 hc_device_param_t *device_param = &data.devices_param[device_id];
17739
17740 if (device_param->skipped) continue;
17741
17742 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17743 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17744 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17745
17746 device_param->kernel_params_mp_l_buf64[3] = 0;
17747 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17748 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17749 device_param->kernel_params_mp_l_buf32[6] = 0;
17750 device_param->kernel_params_mp_l_buf32[7] = 0;
17751 device_param->kernel_params_mp_l_buf32[8] = 0;
17752
17753 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17754 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17755 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17756 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17757
17758 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17759 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17760 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17761
17762 device_param->kernel_params_mp_r_buf64[3] = 0;
17763 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17764 device_param->kernel_params_mp_r_buf32[5] = 0;
17765 device_param->kernel_params_mp_r_buf32[6] = 0;
17766 device_param->kernel_params_mp_r_buf32[7] = 0;
17767
17768 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_l[i]);
17769 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_l[i]);
17770 for (uint i = 4; i < 9; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_l, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_l[i]);
17771
17772 for (uint i = 0; i < 3; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_mem), (void *) device_param->kernel_params_mp_r[i]);
17773 for (uint i = 3; i < 4; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_ulong), (void *) device_param->kernel_params_mp_r[i]);
17774 for (uint i = 4; i < 8; i++) hc_clSetKernelArg (data.ocl, device_param->kernel_mp_r, i, sizeof (cl_uint), (void *) device_param->kernel_params_mp_r[i]);
17775
17776 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);
17777 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);
17778 }
17779 }
17780
17781 u64 words_base = data.words_cnt;
17782
17783 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17784 {
17785 if (data.kernel_rules_cnt)
17786 {
17787 words_base /= data.kernel_rules_cnt;
17788 }
17789 }
17790 else if (data.attack_kern == ATTACK_KERN_COMBI)
17791 {
17792 if (data.combs_cnt)
17793 {
17794 words_base /= data.combs_cnt;
17795 }
17796 }
17797 else if (data.attack_kern == ATTACK_KERN_BF)
17798 {
17799 if (data.bfs_cnt)
17800 {
17801 words_base /= data.bfs_cnt;
17802 }
17803 }
17804
17805 data.words_base = words_base;
17806
17807 if (keyspace == 1)
17808 {
17809 log_info ("%llu", (unsigned long long int) words_base);
17810
17811 return (0);
17812 }
17813
17814 if (data.words_cur > data.words_base)
17815 {
17816 log_error ("ERROR: restore value greater keyspace");
17817
17818 return (-1);
17819 }
17820
17821 if (data.words_cur)
17822 {
17823 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17824 {
17825 for (uint i = 0; i < data.salts_cnt; i++)
17826 {
17827 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17828 }
17829 }
17830 else if (data.attack_kern == ATTACK_KERN_COMBI)
17831 {
17832 for (uint i = 0; i < data.salts_cnt; i++)
17833 {
17834 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17835 }
17836 }
17837 else if (data.attack_kern == ATTACK_KERN_BF)
17838 {
17839 for (uint i = 0; i < data.salts_cnt; i++)
17840 {
17841 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17842 }
17843 }
17844 }
17845
17846 /*
17847 * Update loopback file
17848 */
17849
17850 if (loopback == 1)
17851 {
17852 time_t now;
17853
17854 time (&now);
17855
17856 uint random_num = get_random_num (0, 9999);
17857
17858 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17859
17860 data.loopback_file = loopback_file;
17861 }
17862
17863 /*
17864 * Update dictionary statistic
17865 */
17866
17867 if (keyspace == 0)
17868 {
17869 dictstat_fp = fopen (dictstat, "wb");
17870
17871 if (dictstat_fp)
17872 {
17873 lock_file (dictstat_fp);
17874
17875 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17876
17877 fclose (dictstat_fp);
17878 }
17879 }
17880
17881 /**
17882 * create autotune threads
17883 */
17884
17885 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17886
17887 data.devices_status = STATUS_AUTOTUNE;
17888
17889 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17890 {
17891 hc_device_param_t *device_param = &devices_param[device_id];
17892
17893 hc_thread_create (c_threads[device_id], thread_autotune, device_param);
17894 }
17895
17896 hc_thread_wait (data.devices_cnt, c_threads);
17897
17898 /*
17899 * Inform user about possible slow speeds
17900 */
17901
17902 uint hardware_power_all = 0;
17903
17904 uint kernel_power_all = 0;
17905
17906 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17907 {
17908 hc_device_param_t *device_param = &devices_param[device_id];
17909
17910 hardware_power_all += device_param->hardware_power;
17911
17912 kernel_power_all += device_param->kernel_power;
17913 }
17914
17915 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
17916
17917 data.kernel_power_all = kernel_power_all;
17918
17919 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17920 {
17921 if (data.words_base < kernel_power_all)
17922 {
17923 if (quiet == 0)
17924 {
17925 log_info ("ATTENTION!");
17926 log_info (" The wordlist or mask you are using is too small.");
17927 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17928 log_info (" The cracking speed will drop.");
17929 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17930 log_info ("");
17931 }
17932 }
17933 }
17934
17935 /**
17936 * create cracker threads
17937 */
17938
17939 data.devices_status = STATUS_RUNNING;
17940
17941 if (initial_restore_done == 0)
17942 {
17943 if (data.restore_disable == 0) cycle_restore ();
17944
17945 initial_restore_done = 1;
17946 }
17947
17948 hc_timer_set (&data.timer_running);
17949
17950 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17951 {
17952 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17953 {
17954 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17955 if (quiet == 0) fflush (stdout);
17956 }
17957 }
17958 else if (wordlist_mode == WL_MODE_STDIN)
17959 {
17960 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17961 if (data.quiet == 0) log_info ("");
17962 }
17963
17964 time_t runtime_start;
17965
17966 time (&runtime_start);
17967
17968 data.runtime_start = runtime_start;
17969
17970 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17971 {
17972 hc_device_param_t *device_param = &devices_param[device_id];
17973
17974 if (wordlist_mode == WL_MODE_STDIN)
17975 {
17976 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17977 }
17978 else
17979 {
17980 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17981 }
17982 }
17983
17984 hc_thread_wait (data.devices_cnt, c_threads);
17985
17986 local_free (c_threads);
17987
17988 data.restore = 0;
17989
17990 // finalize task
17991
17992 logfile_sub_var_uint ("status-after-work", data.devices_status);
17993
17994 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17995
17996 if (data.devices_status == STATUS_CRACKED) break;
17997 if (data.devices_status == STATUS_ABORTED) break;
17998
17999 if (data.devices_status == STATUS_BYPASS)
18000 {
18001 data.devices_status = STATUS_RUNNING;
18002 }
18003
18004 if (induction_dictionaries_cnt)
18005 {
18006 unlink (induction_dictionaries[0]);
18007 }
18008
18009 free (induction_dictionaries);
18010
18011 if (attack_mode != ATTACK_MODE_BF)
18012 {
18013 induction_dictionaries = scan_directory (induction_directory);
18014
18015 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
18016 }
18017
18018 if (benchmark == 0)
18019 {
18020 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
18021 {
18022 if (quiet == 0) clear_prompt ();
18023
18024 if (quiet == 0) log_info ("");
18025
18026 if (status == 1)
18027 {
18028 status_display ();
18029 }
18030 else
18031 {
18032 if (quiet == 0) status_display ();
18033 }
18034
18035 if (quiet == 0) log_info ("");
18036 }
18037 }
18038
18039 if (attack_mode == ATTACK_MODE_BF)
18040 {
18041 dictpos++;
18042
18043 rd->dictpos = dictpos;
18044 }
18045 else
18046 {
18047 if (induction_dictionaries_cnt)
18048 {
18049 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
18050 }
18051 else
18052 {
18053 dictpos++;
18054
18055 rd->dictpos = dictpos;
18056 }
18057 }
18058
18059 time_t runtime_stop;
18060
18061 time (&runtime_stop);
18062
18063 data.runtime_stop = runtime_stop;
18064
18065 logfile_sub_uint (runtime_start);
18066 logfile_sub_uint (runtime_stop);
18067
18068 logfile_sub_msg ("STOP");
18069
18070 global_free (subid);
18071 }
18072
18073 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
18074
18075 if (data.devices_status == STATUS_CRACKED) break;
18076 if (data.devices_status == STATUS_ABORTED) break;
18077 if (data.devices_status == STATUS_QUIT) break;
18078
18079 if (data.devices_status == STATUS_BYPASS)
18080 {
18081 data.devices_status = STATUS_RUNNING;
18082 }
18083 }
18084
18085 // 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
18086
18087 if (attack_mode == ATTACK_MODE_STRAIGHT)
18088 {
18089 if (data.wordlist_mode == WL_MODE_FILE)
18090 {
18091 if (data.dictfile == NULL)
18092 {
18093 if (dictfiles != NULL)
18094 {
18095 data.dictfile = dictfiles[0];
18096
18097 hc_timer_set (&data.timer_running);
18098 }
18099 }
18100 }
18101 }
18102 // NOTE: combi is okay because it is already set beforehand
18103 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
18104 {
18105 if (data.dictfile == NULL)
18106 {
18107 if (dictfiles != NULL)
18108 {
18109 hc_timer_set (&data.timer_running);
18110
18111 data.dictfile = dictfiles[0];
18112 }
18113 }
18114 }
18115 else if (attack_mode == ATTACK_MODE_BF)
18116 {
18117 if (data.mask == NULL)
18118 {
18119 hc_timer_set (&data.timer_running);
18120
18121 data.mask = masks[0];
18122 }
18123 }
18124
18125 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
18126 {
18127 data.devices_status = STATUS_EXHAUSTED;
18128 }
18129
18130 // if cracked / aborted remove last induction dictionary
18131
18132 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
18133 {
18134 struct stat induct_stat;
18135
18136 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
18137 {
18138 unlink (induction_dictionaries[file_pos]);
18139 }
18140 }
18141
18142 // wait for non-interactive threads
18143
18144 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
18145 {
18146 hc_thread_wait (1, &ni_threads[thread_idx]);
18147 }
18148
18149 local_free (ni_threads);
18150
18151 // wait for interactive threads
18152
18153 for (uint thread_idx = 0; thread_idx < i_threads_cnt; thread_idx++)
18154 {
18155 hc_thread_wait (1, &i_threads[thread_idx]);
18156 }
18157
18158 local_free (i_threads);
18159
18160 // we dont need restore file anymore
18161 if (data.restore_disable == 0)
18162 {
18163 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
18164 {
18165 unlink (eff_restore_file);
18166 unlink (new_restore_file);
18167 }
18168 else
18169 {
18170 cycle_restore ();
18171 }
18172 }
18173
18174 // finally save left hashes
18175
18176 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
18177 {
18178 save_hash ();
18179 }
18180
18181 /**
18182 * Clean up
18183 */
18184
18185 if (benchmark == 1)
18186 {
18187 status_benchmark ();
18188
18189 if (machine_readable == 0)
18190 {
18191 log_info ("");
18192 }
18193 }
18194 else
18195 {
18196 if (quiet == 0) clear_prompt ();
18197
18198 if (quiet == 0) log_info ("");
18199
18200 if (status == 1)
18201 {
18202 status_display ();
18203 }
18204 else
18205 {
18206 if (quiet == 0) status_display ();
18207 }
18208
18209 if (quiet == 0) log_info ("");
18210 }
18211
18212 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18213 {
18214 hc_device_param_t *device_param = &data.devices_param[device_id];
18215
18216 if (device_param->skipped) continue;
18217
18218 local_free (device_param->combs_buf);
18219
18220 local_free (device_param->hooks_buf);
18221
18222 local_free (device_param->device_name);
18223
18224 local_free (device_param->device_name_chksum);
18225
18226 local_free (device_param->device_version);
18227
18228 local_free (device_param->driver_version);
18229
18230 if (device_param->pws_buf) myfree (device_param->pws_buf);
18231 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
18232 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
18233 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
18234 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
18235 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
18236 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
18237 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
18238 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
18239 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
18240 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
18241 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
18242 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
18243 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
18244 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
18245 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
18246 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
18247 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
18248 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
18249 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
18250 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
18251 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
18252 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
18253 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
18254 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
18255 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
18256 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
18257 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
18258 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
18259
18260 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
18261 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
18262 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
18263 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
18264 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
18265 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
18266 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
18267 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
18268 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
18269 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
18270 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
18271
18272 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
18273 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
18274 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
18275
18276 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
18277 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
18278 }
18279
18280 // reset default fan speed
18281
18282 #ifdef HAVE_HWMON
18283 if (gpu_temp_disable == 0)
18284 {
18285 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
18286 {
18287 hc_thread_mutex_lock (mux_adl);
18288
18289 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18290 {
18291 hc_device_param_t *device_param = &data.devices_param[device_id];
18292
18293 if (device_param->skipped) continue;
18294
18295 if (data.hm_device[device_id].fan_set_supported == 1)
18296 {
18297 int fanspeed = temp_retain_fanspeed_value[device_id];
18298 int fanpolicy = temp_retain_fanpolicy_value[device_id];
18299
18300 if (fanpolicy == 1)
18301 {
18302 int rc = -1;
18303
18304 if (device_param->device_vendor_id == VENDOR_ID_AMD)
18305 {
18306 rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 0);
18307 }
18308 else if (device_param->device_vendor_id == VENDOR_ID_NV)
18309 {
18310
18311 }
18312
18313 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1);
18314 }
18315 }
18316 }
18317
18318 hc_thread_mutex_unlock (mux_adl);
18319 }
18320 }
18321
18322 // reset power tuning
18323
18324 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
18325 {
18326 hc_thread_mutex_lock (mux_adl);
18327
18328 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
18329 {
18330 hc_device_param_t *device_param = &data.devices_param[device_id];
18331
18332 if (device_param->skipped) continue;
18333
18334 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD)
18335 {
18336 if (data.hm_device[device_id].od_version == 6)
18337 {
18338 // check powertune capabilities first, if not available then skip device
18339
18340 int powertune_supported = 0;
18341
18342 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK)
18343 {
18344 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18345
18346 return (-1);
18347 }
18348
18349 if (powertune_supported != 0)
18350 {
18351 // powercontrol settings
18352
18353 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK)
18354 {
18355 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18356
18357 return (-1);
18358 }
18359
18360 // clocks
18361
18362 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18363
18364 performance_state->iNumberOfPerformanceLevels = 2;
18365
18366 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18367 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18368 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18369 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18370
18371 if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
18372 {
18373 log_info ("ERROR: Failed to restore ADL performance state");
18374
18375 return (-1);
18376 }
18377
18378 local_free (performance_state);
18379 }
18380 }
18381 }
18382
18383 if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV)
18384 {
18385 unsigned int limit = nvml_power_limit[device_id];
18386
18387 if (limit > 0)
18388 {
18389 hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit);
18390 }
18391 }
18392 }
18393
18394 hc_thread_mutex_unlock (mux_adl);
18395 }
18396
18397 if (gpu_temp_disable == 0)
18398 {
18399 if (data.hm_nvml)
18400 {
18401 hm_NVML_nvmlShutdown (data.hm_nvml);
18402
18403 nvml_close (data.hm_nvml);
18404
18405 data.hm_nvml = NULL;
18406 }
18407
18408 if (data.hm_adl)
18409 {
18410 hm_ADL_Main_Control_Destroy (data.hm_adl);
18411
18412 adl_close (data.hm_adl);
18413
18414 data.hm_adl = NULL;
18415 }
18416 }
18417 #endif // HAVE_HWMON
18418
18419 // free memory
18420
18421 local_free (masks);
18422
18423 local_free (dictstat_base);
18424
18425 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18426 {
18427 pot_t *pot_ptr = &pot[pot_pos];
18428
18429 hash_t *hash = &pot_ptr->hash;
18430
18431 local_free (hash->digest);
18432
18433 if (isSalted)
18434 {
18435 local_free (hash->salt);
18436 }
18437 }
18438
18439 local_free (pot);
18440
18441 local_free (all_kernel_rules_cnt);
18442 local_free (all_kernel_rules_buf);
18443
18444 local_free (wl_data->buf);
18445 local_free (wl_data);
18446
18447 local_free (bitmap_s1_a);
18448 local_free (bitmap_s1_b);
18449 local_free (bitmap_s1_c);
18450 local_free (bitmap_s1_d);
18451 local_free (bitmap_s2_a);
18452 local_free (bitmap_s2_b);
18453 local_free (bitmap_s2_c);
18454 local_free (bitmap_s2_d);
18455
18456 #ifdef HAVE_HWMON
18457 local_free (temp_retain_fanspeed_value);
18458 local_free (od_clock_mem_status);
18459 local_free (od_power_control_status);
18460 local_free (nvml_power_limit);
18461 #endif
18462
18463 global_free (devices_param);
18464
18465 global_free (kernel_rules_buf);
18466
18467 global_free (root_css_buf);
18468 global_free (markov_css_buf);
18469
18470 global_free (digests_buf);
18471 global_free (digests_shown);
18472 global_free (digests_shown_tmp);
18473
18474 global_free (salts_buf);
18475 global_free (salts_shown);
18476
18477 global_free (esalts_buf);
18478
18479 global_free (words_progress_done);
18480 global_free (words_progress_rejected);
18481 global_free (words_progress_restored);
18482
18483 if (pot_fp) fclose (pot_fp);
18484
18485 if (data.devices_status == STATUS_QUIT) break;
18486 }
18487
18488 // destroy others mutex
18489
18490 hc_thread_mutex_delete (mux_dispatcher);
18491 hc_thread_mutex_delete (mux_counter);
18492 hc_thread_mutex_delete (mux_display);
18493 hc_thread_mutex_delete (mux_adl);
18494
18495 // free memory
18496
18497 local_free (eff_restore_file);
18498 local_free (new_restore_file);
18499
18500 local_free (rd);
18501
18502 // tuning db
18503
18504 tuning_db_destroy (tuning_db);
18505
18506 // loopback
18507
18508 local_free (loopback_file);
18509
18510 if (loopback == 1) unlink (loopback_file);
18511
18512 // induction directory
18513
18514 if (induction_dir == NULL)
18515 {
18516 if (attack_mode != ATTACK_MODE_BF)
18517 {
18518 if (rmdir (induction_directory) == -1)
18519 {
18520 if (errno == ENOENT)
18521 {
18522 // good, we can ignore
18523 }
18524 else if (errno == ENOTEMPTY)
18525 {
18526 // good, we can ignore
18527 }
18528 else
18529 {
18530 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18531
18532 return (-1);
18533 }
18534 }
18535
18536 local_free (induction_directory);
18537 }
18538 }
18539
18540 // outfile-check directory
18541
18542 if (outfile_check_dir == NULL)
18543 {
18544 if (rmdir (outfile_check_directory) == -1)
18545 {
18546 if (errno == ENOENT)
18547 {
18548 // good, we can ignore
18549 }
18550 else if (errno == ENOTEMPTY)
18551 {
18552 // good, we can ignore
18553 }
18554 else
18555 {
18556 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18557
18558 return (-1);
18559 }
18560 }
18561
18562 local_free (outfile_check_directory);
18563 }
18564
18565 time_t proc_stop;
18566
18567 time (&proc_stop);
18568
18569 logfile_top_uint (proc_start);
18570 logfile_top_uint (proc_stop);
18571
18572 logfile_top_msg ("STOP");
18573
18574 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18575 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18576
18577 if (data.ocl) ocl_close (data.ocl);
18578
18579 if (data.devices_status == STATUS_ABORTED) return 2;
18580 if (data.devices_status == STATUS_QUIT) return 2;
18581 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18582 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18583 if (data.devices_status == STATUS_CRACKED) return 0;
18584
18585 return -1;
18586 }
Hashcat additions to support pwdhash