projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
More vendor related changes
[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 RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 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);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 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);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->device_vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->device_vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 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)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 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)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 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);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 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);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 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);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2613 {
2614 int rc = -1;
2615
2616 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2617 {
2618 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2619
2620 const cl_uchar zero = 0;
2621
2622 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2623 }
2624
2625 if (rc != 0)
2626 {
2627 // NOTE: clEnqueueFillBuffer () always fails with -59
2628 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2629 // How's that possible, OpenCL 1.2 support is advertised??
2630 // We need to workaround...
2631
2632 #define FILLSZ 0x100000
2633
2634 char *tmp = (char *) mymalloc (FILLSZ);
2635
2636 for (size_t i = 0; i < size; i += FILLSZ)
2637 {
2638 const size_t left = size - i;
2639
2640 const size_t fillsz = MIN (FILLSZ, left);
2641
2642 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2643 }
2644
2645 myfree (tmp);
2646 }
2647 }
2648
2649 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)
2650 {
2651 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2652 {
2653 if (attack_mode == ATTACK_MODE_BF)
2654 {
2655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2656 {
2657 const uint size_tm = 32 * sizeof (bs_word_t);
2658
2659 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2660
2661 run_kernel_tm (device_param);
2662
2663 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);
2664 }
2665 }
2666
2667 if (highest_pw_len < 16)
2668 {
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2670 }
2671 else if (highest_pw_len < 32)
2672 {
2673 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2674 }
2675 else
2676 {
2677 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2678 }
2679 }
2680 else
2681 {
2682 run_kernel_amp (device_param, pws_cnt);
2683
2684 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2685
2686 if (opts_type & OPTS_TYPE_HOOK12)
2687 {
2688 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2689 }
2690
2691 uint iter = salt_buf->salt_iter;
2692
2693 uint loop_step = device_param->kernel_loops;
2694
2695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2696 {
2697 uint loop_left = iter - loop_pos;
2698
2699 loop_left = MIN (loop_left, loop_step);
2700
2701 device_param->kernel_params_buf32[25] = loop_pos;
2702 device_param->kernel_params_buf32[26] = loop_left;
2703
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705
2706 if (data.devices_status == STATUS_CRACKED) break;
2707 if (data.devices_status == STATUS_ABORTED) break;
2708 if (data.devices_status == STATUS_QUIT) break;
2709
2710 /**
2711 * speed
2712 */
2713
2714 const float iter_part = (float) (loop_pos + loop_left) / iter;
2715
2716 const u64 perf_sum_all = pws_cnt * iter_part;
2717
2718 double speed_ms;
2719
2720 hc_timer_get (device_param->timer_speed, speed_ms);
2721
2722 const u32 speed_pos = device_param->speed_pos;
2723
2724 device_param->speed_cnt[speed_pos] = perf_sum_all;
2725
2726 device_param->speed_ms[speed_pos] = speed_ms;
2727
2728 if (data.benchmark == 1)
2729 {
2730 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2731 }
2732 }
2733
2734 if (opts_type & OPTS_TYPE_HOOK23)
2735 {
2736 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2737
2738 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);
2739
2740 // do something with data
2741
2742 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);
2743 }
2744
2745 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2746 }
2747 }
2748
2749 static int run_rule_engine (const int rule_len, const char *rule_buf)
2750 {
2751 if (rule_len == 0)
2752 {
2753 return 0;
2754 }
2755 else if (rule_len == 1)
2756 {
2757 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2758 }
2759
2760 return 1;
2761 }
2762
2763 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2764 {
2765 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2766 {
2767 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);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_COMBI)
2770 {
2771 if (data.attack_mode == ATTACK_MODE_COMBI)
2772 {
2773 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2774 {
2775 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2776 {
2777 for (u32 i = 0; i < pws_cnt; i++)
2778 {
2779 const u32 pw_len = device_param->pws_buf[i].pw_len;
2780
2781 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2782
2783 ptr[pw_len] = 0x01;
2784 }
2785 }
2786 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2787 {
2788 for (u32 i = 0; i < pws_cnt; i++)
2789 {
2790 const u32 pw_len = device_param->pws_buf[i].pw_len;
2791
2792 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2793
2794 ptr[pw_len] = 0x80;
2795 }
2796 }
2797 }
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x01;
2810 }
2811 }
2812 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x80;
2821 }
2822 }
2823 }
2824
2825 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);
2826 }
2827 else if (data.attack_kern == ATTACK_KERN_BF)
2828 {
2829 const u64 off = device_param->words_off;
2830
2831 device_param->kernel_params_mp_l_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2834 }
2835 }
2836
2837 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2838 {
2839 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2840
2841 device_param->kernel_params_buf32[25] = 0;
2842 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2843 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2844
2845 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2846 {
2847 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2848 }
2849 else
2850 {
2851 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2852 }
2853
2854 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2855
2856 return exec_ms_prev;
2857 }
2858
2859 static void autotune (hc_device_param_t *device_param)
2860 {
2861 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2862
2863 const u32 kernel_accel_min = device_param->kernel_accel_min;
2864 const u32 kernel_accel_max = device_param->kernel_accel_max;
2865
2866 const u32 kernel_loops_min = device_param->kernel_loops_min;
2867 const u32 kernel_loops_max = device_param->kernel_loops_max;
2868
2869 u32 kernel_accel = kernel_accel_min;
2870 u32 kernel_loops = kernel_loops_min;
2871
2872 // in this case the user specified a fixed -u and -n on the commandline
2873 // no way to tune anything
2874 // but we need to run a few caching rounds
2875
2876 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2877 {
2878 try_run (device_param, kernel_accel, kernel_loops);
2879 try_run (device_param, kernel_accel, kernel_loops);
2880 try_run (device_param, kernel_accel, kernel_loops);
2881 try_run (device_param, kernel_accel, kernel_loops);
2882
2883 device_param->kernel_accel = kernel_accel;
2884 device_param->kernel_loops = kernel_loops;
2885
2886 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2887
2888 device_param->kernel_power = kernel_power;
2889
2890 return;
2891 }
2892
2893 // from here it's clear we are allowed to autotune
2894 // so let's init some fake words
2895
2896 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].i[0] = i;
2901 device_param->pws_buf[i].i[1] = 0x01234567;
2902 device_param->pws_buf[i].pw_len = 7;
2903 }
2904
2905 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);
2906
2907 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2908 {
2909 run_kernel_amp (device_param, kernel_power_max);
2910 }
2911
2912 #define VERIFIER_CNT 1
2913
2914 // first find out highest kernel-loops that stays below target_ms
2915
2916 if (kernel_loops_min < kernel_loops_max)
2917 {
2918 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2919 {
2920 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2921
2922 for (int i = 0; i < VERIFIER_CNT; i++)
2923 {
2924 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2925
2926 exec_ms = MIN (exec_ms, exec_ms_v);
2927 }
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931 }
2932
2933 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2934
2935 #define STEPS_CNT 10
2936
2937 if (kernel_accel_min < kernel_accel_max)
2938 {
2939 for (int i = 0; i < STEPS_CNT; i++)
2940 {
2941 const u32 kernel_accel_try = 1 << i;
2942
2943 if (kernel_accel_try < kernel_accel_min) continue;
2944 if (kernel_accel_try > kernel_accel_max) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms > target_ms) break;
2956
2957 kernel_accel = kernel_accel_try;
2958 }
2959 }
2960
2961 // at this point we want to know the actual runtime for the following reason:
2962 // we need a reference for the balancing loop following up, and this
2963 // the balancing loop can have an effect that the creates a new opportunity, for example:
2964 // if the target is 95 ms and the current runtime is 48ms the above loop
2965 // stopped the execution because the previous exec_ms was > 95ms
2966 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2967 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2968
2969 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2970
2971 for (int i = 0; i < VERIFIER_CNT; i++)
2972 {
2973 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2974
2975 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2976 }
2977
2978 u32 diff = kernel_loops - kernel_accel;
2979
2980 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2981 {
2982 u32 kernel_accel_orig = kernel_accel;
2983 u32 kernel_loops_orig = kernel_loops;
2984
2985 for (u32 f = 1; f < 1024; f++)
2986 {
2987 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
2988 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
2989
2990 if (kernel_accel_try > kernel_accel_max) break;
2991 if (kernel_loops_try < kernel_loops_min) break;
2992
2993 u32 diff_new = kernel_loops_try - kernel_accel_try;
2994
2995 if (diff_new > diff) break;
2996
2997 diff_new = diff;
2998
2999 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3000
3001 for (int i = 0; i < VERIFIER_CNT; i++)
3002 {
3003 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3004
3005 exec_ms = MIN (exec_ms, exec_ms_v);
3006 }
3007
3008 if (exec_ms < exec_ms_pre_final)
3009 {
3010 exec_ms_pre_final = exec_ms;
3011
3012 kernel_accel = kernel_accel_try;
3013 kernel_loops = kernel_loops_try;
3014 }
3015 }
3016 }
3017
3018 const double exec_left = target_ms / exec_ms_pre_final;
3019
3020 const double accel_left = kernel_accel_max / kernel_accel;
3021
3022 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3023
3024 if (exec_accel_min >= 1.0)
3025 {
3026 // this is safe to not overflow kernel_accel_max because of accel_left
3027
3028 kernel_accel = (double) kernel_accel * exec_accel_min;
3029 }
3030
3031 // reset them fake words
3032
3033 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3034
3035 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);
3036 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);
3037
3038 // reset timer
3039
3040 device_param->exec_pos = 0;
3041
3042 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3043
3044 // store
3045
3046 device_param->kernel_accel = kernel_accel;
3047 device_param->kernel_loops = kernel_loops;
3048
3049 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3050
3051 device_param->kernel_power = kernel_power;
3052
3053 #ifdef DEBUG
3054
3055 if (data.quiet == 0)
3056 {
3057 clear_prompt ();
3058
3059 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3060 "Device #%u: autotuned kernel-loops to %u\n",
3061 device_param->device_id + 1, kernel_accel,
3062 device_param->device_id + 1, kernel_loops);
3063
3064 fprintf (stdout, "%s", PROMPT);
3065
3066 fflush (stdout);
3067 }
3068
3069 #endif
3070 }
3071
3072 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3073 {
3074 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3075
3076 // init speed timer
3077
3078 uint speed_pos = device_param->speed_pos;
3079
3080 #ifdef _POSIX
3081 if (device_param->timer_speed.tv_sec == 0)
3082 {
3083 hc_timer_set (&device_param->timer_speed);
3084 }
3085 #endif
3086
3087 #ifdef _WIN
3088 if (device_param->timer_speed.QuadPart == 0)
3089 {
3090 hc_timer_set (&device_param->timer_speed);
3091 }
3092 #endif
3093
3094 // find higest password length, this is for optimization stuff
3095
3096 uint highest_pw_len = 0;
3097
3098 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3099 {
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 }
3104 else if (data.attack_kern == ATTACK_KERN_BF)
3105 {
3106 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3107 + device_param->kernel_params_mp_l_buf32[5];
3108 }
3109
3110 // iteration type
3111
3112 uint innerloop_step = 0;
3113 uint innerloop_cnt = 0;
3114
3115 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3116 else innerloop_step = 1;
3117
3118 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3119 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3120 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3121
3122 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3123
3124 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3125 {
3126 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3127
3128 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3129
3130 if (data.devices_status == STATUS_CRACKED) break;
3131 if (data.devices_status == STATUS_ABORTED) break;
3132 if (data.devices_status == STATUS_QUIT) break;
3133 if (data.devices_status == STATUS_BYPASS) break;
3134
3135 salt_t *salt_buf = &data.salts_buf[salt_pos];
3136
3137 device_param->kernel_params_buf32[24] = salt_pos;
3138 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3139 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3140
3141 FILE *combs_fp = device_param->combs_fp;
3142
3143 if (data.attack_mode == ATTACK_MODE_COMBI)
3144 {
3145 rewind (combs_fp);
3146 }
3147
3148 // innerloops
3149
3150 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3151 {
3152 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3153
3154 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3155
3156 if (data.devices_status == STATUS_CRACKED) break;
3157 if (data.devices_status == STATUS_ABORTED) break;
3158 if (data.devices_status == STATUS_QUIT) break;
3159 if (data.devices_status == STATUS_BYPASS) break;
3160
3161 uint innerloop_left = innerloop_cnt - innerloop_pos;
3162
3163 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3164
3165 device_param->innerloop_pos = innerloop_pos;
3166 device_param->innerloop_left = innerloop_left;
3167
3168 device_param->kernel_params_buf32[27] = innerloop_left;
3169
3170 // i think we can get rid of this
3171 if (innerloop_left == 0)
3172 {
3173 puts ("bug, how should this happen????\n");
3174
3175 continue;
3176 }
3177
3178 if (data.salts_shown[salt_pos] == 1)
3179 {
3180 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3181
3182 continue;
3183 }
3184
3185 // initialize amplifiers
3186
3187 if (data.attack_mode == ATTACK_MODE_COMBI)
3188 {
3189 uint i = 0;
3190
3191 while (i < innerloop_left)
3192 {
3193 if (feof (combs_fp)) break;
3194
3195 int line_len = fgetl (combs_fp, line_buf);
3196
3197 if (line_len >= PW_MAX1) continue;
3198
3199 line_len = convert_from_hex (line_buf, line_len);
3200
3201 char *line_buf_new = line_buf;
3202
3203 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3204 {
3205 char rule_buf_out[BLOCK_SIZE] = { 0 };
3206
3207 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3208
3209 if (rule_len_out < 0)
3210 {
3211 data.words_progress_rejected[salt_pos] += pws_cnt;
3212
3213 continue;
3214 }
3215
3216 line_len = rule_len_out;
3217
3218 line_buf_new = rule_buf_out;
3219 }
3220
3221 line_len = MIN (line_len, PW_DICTMAX);
3222
3223 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3224
3225 memcpy (ptr, line_buf_new, line_len);
3226
3227 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3228
3229 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3230 {
3231 uppercase (ptr, line_len);
3232 }
3233
3234 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3235 {
3236 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3237 {
3238 ptr[line_len] = 0x80;
3239 }
3240
3241 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3242 {
3243 ptr[line_len] = 0x01;
3244 }
3245 }
3246
3247 device_param->combs_buf[i].pw_len = line_len;
3248
3249 i++;
3250 }
3251
3252 for (uint j = i; j < innerloop_left; j++)
3253 {
3254 device_param->combs_buf[j].i[0] = 0;
3255 device_param->combs_buf[j].i[1] = 0;
3256 device_param->combs_buf[j].i[2] = 0;
3257 device_param->combs_buf[j].i[3] = 0;
3258 device_param->combs_buf[j].i[4] = 0;
3259 device_param->combs_buf[j].i[5] = 0;
3260 device_param->combs_buf[j].i[6] = 0;
3261 device_param->combs_buf[j].i[7] = 0;
3262
3263 device_param->combs_buf[j].pw_len = 0;
3264 }
3265
3266 innerloop_left = i;
3267 }
3268 else if (data.attack_mode == ATTACK_MODE_BF)
3269 {
3270 u64 off = innerloop_pos;
3271
3272 device_param->kernel_params_mp_r_buf64[3] = off;
3273
3274 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3275 }
3276 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3277 {
3278 u64 off = innerloop_pos;
3279
3280 device_param->kernel_params_mp_buf64[3] = off;
3281
3282 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3285 {
3286 u64 off = innerloop_pos;
3287
3288 device_param->kernel_params_mp_buf64[3] = off;
3289
3290 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3291 }
3292
3293 // copy amplifiers
3294
3295 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3296 {
3297 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);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_COMBI)
3300 {
3301 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);
3302 }
3303 else if (data.attack_mode == ATTACK_MODE_BF)
3304 {
3305 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);
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3308 {
3309 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);
3310 }
3311 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3312 {
3313 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);
3314 }
3315
3316 if (data.benchmark == 1)
3317 {
3318 hc_timer_set (&device_param->timer_speed);
3319 }
3320
3321 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3322
3323 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3324
3325 if (data.devices_status == STATUS_CRACKED) break;
3326 if (data.devices_status == STATUS_ABORTED) break;
3327 if (data.devices_status == STATUS_QUIT) break;
3328
3329 /**
3330 * result
3331 */
3332
3333 check_cracked (device_param, salt_pos);
3334
3335 /**
3336 * progress
3337 */
3338
3339 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3340
3341 hc_thread_mutex_lock (mux_counter);
3342
3343 data.words_progress_done[salt_pos] += perf_sum_all;
3344
3345 hc_thread_mutex_unlock (mux_counter);
3346
3347 /**
3348 * speed
3349 */
3350
3351 double speed_ms;
3352
3353 hc_timer_get (device_param->timer_speed, speed_ms);
3354
3355 hc_timer_set (&device_param->timer_speed);
3356
3357 // current speed
3358
3359 //hc_thread_mutex_lock (mux_display);
3360
3361 device_param->speed_cnt[speed_pos] = perf_sum_all;
3362
3363 device_param->speed_ms[speed_pos] = speed_ms;
3364
3365 //hc_thread_mutex_unlock (mux_display);
3366
3367 speed_pos++;
3368
3369 if (speed_pos == SPEED_CACHE)
3370 {
3371 speed_pos = 0;
3372 }
3373
3374 /**
3375 * benchmark
3376 */
3377
3378 if (data.benchmark == 1) break;
3379 }
3380 }
3381
3382 device_param->speed_pos = speed_pos;
3383
3384 myfree (line_buf);
3385 }
3386
3387 static void load_segment (wl_data_t *wl_data, FILE *fd)
3388 {
3389 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3390
3391 wl_data->pos = 0;
3392
3393 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3394
3395 wl_data->buf[wl_data->cnt] = 0;
3396
3397 if (wl_data->cnt == 0) return;
3398
3399 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3400
3401 while (!feof (fd))
3402 {
3403 if (wl_data->cnt == wl_data->avail)
3404 {
3405 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3406
3407 wl_data->avail += wl_data->incr;
3408 }
3409
3410 const int c = fgetc (fd);
3411
3412 if (c == EOF) break;
3413
3414 wl_data->buf[wl_data->cnt] = (char) c;
3415
3416 wl_data->cnt++;
3417
3418 if (c == '\n') break;
3419 }
3420
3421 // ensure stream ends with a newline
3422
3423 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3424 {
3425 wl_data->cnt++;
3426
3427 wl_data->buf[wl_data->cnt - 1] = '\n';
3428 }
3429
3430 return;
3431 }
3432
3433 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3434 {
3435 char *ptr = buf;
3436
3437 for (u32 i = 0; i < sz; i++, ptr++)
3438 {
3439 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3440
3441 if (i == 7)
3442 {
3443 *off = i;
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 if (*ptr != '\n') continue;
3450
3451 *off = i + 1;
3452
3453 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3454
3455 *len = i;
3456
3457 return;
3458 }
3459
3460 *off = sz;
3461 *len = sz;
3462 }
3463
3464 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3465 {
3466 char *ptr = buf;
3467
3468 for (u32 i = 0; i < sz; i++, ptr++)
3469 {
3470 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3471
3472 if (*ptr != '\n') continue;
3473
3474 *off = i + 1;
3475
3476 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3477
3478 *len = i;
3479
3480 return;
3481 }
3482
3483 *off = sz;
3484 *len = sz;
3485 }
3486
3487 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3488 {
3489 char *ptr = buf;
3490
3491 for (u32 i = 0; i < sz; i++, ptr++)
3492 {
3493 if (*ptr != '\n') continue;
3494
3495 *off = i + 1;
3496
3497 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3498
3499 *len = i;
3500
3501 return;
3502 }
3503
3504 *off = sz;
3505 *len = sz;
3506 }
3507
3508 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3509 {
3510 while (wl_data->pos < wl_data->cnt)
3511 {
3512 uint off;
3513 uint len;
3514
3515 char *ptr = wl_data->buf + wl_data->pos;
3516
3517 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3518
3519 wl_data->pos += off;
3520
3521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3522 {
3523 char rule_buf_out[BLOCK_SIZE] = { 0 };
3524
3525 int rule_len_out = -1;
3526
3527 if (len < BLOCK_SIZE)
3528 {
3529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3530 }
3531
3532 if (rule_len_out < 0)
3533 {
3534 continue;
3535 }
3536
3537 if (rule_len_out > PW_MAX)
3538 {
3539 continue;
3540 }
3541 }
3542 else
3543 {
3544 if (len > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549
3550 *out_buf = ptr;
3551 *out_len = len;
3552
3553 return;
3554 }
3555
3556 if (feof (fd))
3557 {
3558 fprintf (stderr, "BUG feof()!!\n");
3559
3560 return;
3561 }
3562
3563 load_segment (wl_data, fd);
3564
3565 get_next_word (wl_data, fd, out_buf, out_len);
3566 }
3567
3568 #ifdef _POSIX
3569 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3570 #endif
3571
3572 #ifdef _WIN
3573 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3574 #endif
3575 {
3576 hc_signal (NULL);
3577
3578 dictstat_t d;
3579
3580 d.cnt = 0;
3581
3582 #ifdef _POSIX
3583 fstat (fileno (fd), &d.stat);
3584 #endif
3585
3586 #ifdef _WIN
3587 _fstat64 (fileno (fd), &d.stat);
3588 #endif
3589
3590 d.stat.st_mode = 0;
3591 d.stat.st_nlink = 0;
3592 d.stat.st_uid = 0;
3593 d.stat.st_gid = 0;
3594 d.stat.st_rdev = 0;
3595 d.stat.st_atime = 0;
3596
3597 #ifdef _POSIX
3598 d.stat.st_blksize = 0;
3599 d.stat.st_blocks = 0;
3600 #endif
3601
3602 if (d.stat.st_size == 0) return 0;
3603
3604 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3605
3606 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3607 {
3608 if (d_cache)
3609 {
3610 u64 cnt = d_cache->cnt;
3611
3612 u64 keyspace = cnt;
3613
3614 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3615 {
3616 keyspace *= data.kernel_rules_cnt;
3617 }
3618 else if (data.attack_kern == ATTACK_KERN_COMBI)
3619 {
3620 keyspace *= data.combs_cnt;
3621 }
3622
3623 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);
3624 if (data.quiet == 0) log_info ("");
3625
3626 hc_signal (sigHandler_default);
3627
3628 return (keyspace);
3629 }
3630 }
3631
3632 time_t now = 0;
3633 time_t prev = 0;
3634
3635 u64 comp = 0;
3636 u64 cnt = 0;
3637 u64 cnt2 = 0;
3638
3639 while (!feof (fd))
3640 {
3641 load_segment (wl_data, fd);
3642
3643 comp += wl_data->cnt;
3644
3645 u32 i = 0;
3646
3647 while (i < wl_data->cnt)
3648 {
3649 u32 len;
3650 u32 off;
3651
3652 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3653
3654 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3655 {
3656 char rule_buf_out[BLOCK_SIZE] = { 0 };
3657
3658 int rule_len_out = -1;
3659
3660 if (len < BLOCK_SIZE)
3661 {
3662 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3663 }
3664
3665 if (rule_len_out < 0)
3666 {
3667 len = PW_MAX1;
3668 }
3669 else
3670 {
3671 len = rule_len_out;
3672 }
3673 }
3674
3675 if (len < PW_MAX1)
3676 {
3677 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3678 {
3679 cnt += data.kernel_rules_cnt;
3680 }
3681 else if (data.attack_kern == ATTACK_KERN_COMBI)
3682 {
3683 cnt += data.combs_cnt;
3684 }
3685
3686 d.cnt++;
3687 }
3688
3689 i += off;
3690
3691 cnt2++;
3692 }
3693
3694 time (&now);
3695
3696 if ((now - prev) == 0) continue;
3697
3698 float percent = (float) comp / (float) d.stat.st_size;
3699
3700 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);
3701
3702 time (&prev);
3703 }
3704
3705 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);
3706 if (data.quiet == 0) log_info ("");
3707
3708 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3709
3710 hc_signal (sigHandler_default);
3711
3712 return (cnt);
3713 }
3714
3715 static void *thread_monitor (void *p)
3716 {
3717 uint runtime_check = 0;
3718 uint remove_check = 0;
3719 uint status_check = 0;
3720 uint restore_check = 0;
3721
3722 uint restore_left = data.restore_timer;
3723 uint remove_left = data.remove_timer;
3724 uint status_left = data.status_timer;
3725
3726 #ifdef HAVE_HWMON
3727 uint hwmon_check = 0;
3728
3729 // these variables are mainly used for fan control (AMD only)
3730
3731 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 // temperature controller "loopback" values
3734
3735 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3736 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3737
3738 #ifdef HAVE_ADL
3739 int temp_threshold = 1; // degrees celcius
3740
3741 int fan_speed_min = 15; // in percentage
3742 int fan_speed_max = 100;
3743 #endif // HAVE_ADL
3744
3745 time_t last_temp_check_time;
3746 #endif // HAVE_HWMON
3747
3748 uint sleep_time = 1;
3749
3750 if (data.runtime)
3751 {
3752 runtime_check = 1;
3753 }
3754
3755 if (data.restore_timer)
3756 {
3757 restore_check = 1;
3758 }
3759
3760 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3761 {
3762 remove_check = 1;
3763 }
3764
3765 if (data.status == 1)
3766 {
3767 status_check = 1;
3768 }
3769
3770 #ifdef HAVE_HWMON
3771 if (data.gpu_temp_disable == 0)
3772 {
3773 time (&last_temp_check_time);
3774
3775 hwmon_check = 1;
3776 }
3777 #endif
3778
3779 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3780 {
3781 #ifdef HAVE_HWMON
3782 if (hwmon_check == 0)
3783 #endif
3784 return (p);
3785 }
3786
3787 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3788 {
3789 hc_sleep (sleep_time);
3790
3791 if (data.devices_status != STATUS_RUNNING) continue;
3792
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 1)
3795 {
3796 hc_thread_mutex_lock (mux_adl);
3797
3798 time_t temp_check_time;
3799
3800 time (&temp_check_time);
3801
3802 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3803
3804 if (Ta == 0) Ta = 1;
3805
3806 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3807 {
3808 hc_device_param_t *device_param = &data.devices_param[device_id];
3809
3810 if (device_param->skipped) continue;
3811
3812 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3813
3814 const int temperature = hm_get_temperature_with_device_id (device_id);
3815
3816 if (temperature > (int) data.gpu_temp_abort)
3817 {
3818 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3819
3820 if (data.devices_status != STATUS_QUIT) myabort ();
3821
3822 break;
3823 }
3824
3825 #ifdef HAVE_ADL
3826 const int gpu_temp_retain = data.gpu_temp_retain;
3827
3828 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3829 {
3830 if (data.hm_device[device_id].fan_supported == 1)
3831 {
3832 int temp_cur = temperature;
3833
3834 int temp_diff_new = gpu_temp_retain - temp_cur;
3835
3836 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3837
3838 // calculate Ta value (time difference in seconds between the last check and this check)
3839
3840 last_temp_check_time = temp_check_time;
3841
3842 float Kp = 1.8;
3843 float Ki = 0.005;
3844 float Kd = 6;
3845
3846 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3847
3848 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);
3849
3850 if (abs (fan_diff_required) >= temp_threshold)
3851 {
3852 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3853
3854 int fan_speed_level = fan_speed_cur;
3855
3856 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3857
3858 int fan_speed_new = fan_speed_level - fan_diff_required;
3859
3860 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3861 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3862
3863 if (fan_speed_new != fan_speed_cur)
3864 {
3865 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3866 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3867
3868 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3869 {
3870 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3871
3872 fan_speed_chgd[device_id] = 1;
3873 }
3874
3875 temp_diff_old[device_id] = temp_diff_new;
3876 }
3877 }
3878 }
3879 }
3880 #endif // HAVE_ADL
3881 }
3882
3883 hc_thread_mutex_unlock (mux_adl);
3884 }
3885 #endif // HAVE_HWMON
3886
3887 if (restore_check == 1)
3888 {
3889 restore_left--;
3890
3891 if (restore_left == 0)
3892 {
3893 if (data.restore_disable == 0) cycle_restore ();
3894
3895 restore_left = data.restore_timer;
3896 }
3897 }
3898
3899 if ((runtime_check == 1) && (data.runtime_start > 0))
3900 {
3901 time_t runtime_cur;
3902
3903 time (&runtime_cur);
3904
3905 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3906
3907 if (runtime_left <= 0)
3908 {
3909 if (data.benchmark == 0)
3910 {
3911 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3912 }
3913
3914 if (data.devices_status != STATUS_QUIT) myabort ();
3915 }
3916 }
3917
3918 if (remove_check == 1)
3919 {
3920 remove_left--;
3921
3922 if (remove_left == 0)
3923 {
3924 if (data.digests_saved != data.digests_done)
3925 {
3926 data.digests_saved = data.digests_done;
3927
3928 save_hash ();
3929 }
3930
3931 remove_left = data.remove_timer;
3932 }
3933 }
3934
3935 if (status_check == 1)
3936 {
3937 status_left--;
3938
3939 if (status_left == 0)
3940 {
3941 //hc_thread_mutex_lock (mux_display);
3942
3943 if (data.quiet == 0) clear_prompt ();
3944
3945 if (data.quiet == 0) log_info ("");
3946
3947 status_display ();
3948
3949 if (data.quiet == 0) log_info ("");
3950
3951 //hc_thread_mutex_unlock (mux_display);
3952
3953 status_left = data.status_timer;
3954 }
3955 }
3956 }
3957
3958 #ifdef HAVE_HWMON
3959 myfree (fan_speed_chgd);
3960
3961 myfree (temp_diff_old);
3962 myfree (temp_diff_sum);
3963 #endif
3964
3965 p = NULL;
3966
3967 return (p);
3968 }
3969
3970 static void *thread_outfile_remove (void *p)
3971 {
3972 // some hash-dependent constants
3973 char *outfile_dir = data.outfile_check_directory;
3974 uint dgst_size = data.dgst_size;
3975 uint isSalted = data.isSalted;
3976 uint esalt_size = data.esalt_size;
3977 uint hash_mode = data.hash_mode;
3978
3979 uint outfile_check_timer = data.outfile_check_timer;
3980
3981 char separator = data.separator;
3982
3983 // some hash-dependent functions
3984 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3985 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3986
3987 // buffers
3988 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3989
3990 hash_buf.digest = mymalloc (dgst_size);
3991
3992 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3993
3994 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3995
3996 uint digest_buf[64] = { 0 };
3997
3998 outfile_data_t *out_info = NULL;
3999
4000 char **out_files = NULL;
4001
4002 time_t folder_mtime = 0;
4003
4004 int out_cnt = 0;
4005
4006 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4007
4008 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4009 {
4010 hc_sleep (1);
4011
4012 if (data.devices_status != STATUS_RUNNING) continue;
4013
4014 check_left--;
4015
4016 if (check_left == 0)
4017 {
4018 struct stat outfile_check_stat;
4019
4020 if (stat (outfile_dir, &outfile_check_stat) == 0)
4021 {
4022 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4023
4024 if (is_dir == 1)
4025 {
4026 if (outfile_check_stat.st_mtime > folder_mtime)
4027 {
4028 char **out_files_new = scan_directory (outfile_dir);
4029
4030 int out_cnt_new = count_dictionaries (out_files_new);
4031
4032 outfile_data_t *out_info_new = NULL;
4033
4034 if (out_cnt_new > 0)
4035 {
4036 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4037
4038 for (int i = 0; i < out_cnt_new; i++)
4039 {
4040 out_info_new[i].file_name = out_files_new[i];
4041
4042 // check if there are files that we have seen/checked before (and not changed)
4043
4044 for (int j = 0; j < out_cnt; j++)
4045 {
4046 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4047 {
4048 struct stat outfile_stat;
4049
4050 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4051 {
4052 if (outfile_stat.st_ctime == out_info[j].ctime)
4053 {
4054 out_info_new[i].ctime = out_info[j].ctime;
4055 out_info_new[i].seek = out_info[j].seek;
4056 }
4057 }
4058 }
4059 }
4060 }
4061 }
4062
4063 local_free (out_info);
4064 local_free (out_files);
4065
4066 out_files = out_files_new;
4067 out_cnt = out_cnt_new;
4068 out_info = out_info_new;
4069
4070 folder_mtime = outfile_check_stat.st_mtime;
4071 }
4072
4073 for (int j = 0; j < out_cnt; j++)
4074 {
4075 FILE *fp = fopen (out_info[j].file_name, "rb");
4076
4077 if (fp != NULL)
4078 {
4079 //hc_thread_mutex_lock (mux_display);
4080
4081 #ifdef _POSIX
4082 struct stat outfile_stat;
4083
4084 fstat (fileno (fp), &outfile_stat);
4085 #endif
4086
4087 #ifdef _WIN
4088 struct stat64 outfile_stat;
4089
4090 _fstat64 (fileno (fp), &outfile_stat);
4091 #endif
4092
4093 if (outfile_stat.st_ctime > out_info[j].ctime)
4094 {
4095 out_info[j].ctime = outfile_stat.st_ctime;
4096 out_info[j].seek = 0;
4097 }
4098
4099 fseek (fp, out_info[j].seek, SEEK_SET);
4100
4101 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4102
4103 while (!feof (fp))
4104 {
4105 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4106
4107 if (ptr == NULL) break;
4108
4109 int line_len = strlen (line_buf);
4110
4111 if (line_len <= 0) continue;
4112
4113 int iter = MAX_CUT_TRIES;
4114
4115 for (uint i = line_len - 1; i && iter; i--, line_len--)
4116 {
4117 if (line_buf[i] != separator) continue;
4118
4119 int parser_status = PARSER_OK;
4120
4121 if ((hash_mode != 2500) && (hash_mode != 6800))
4122 {
4123 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4124 }
4125
4126 uint found = 0;
4127
4128 if (parser_status == PARSER_OK)
4129 {
4130 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4131 {
4132 if (data.salts_shown[salt_pos] == 1) continue;
4133
4134 salt_t *salt_buf = &data.salts_buf[salt_pos];
4135
4136 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4137 {
4138 uint idx = salt_buf->digests_offset + digest_pos;
4139
4140 if (data.digests_shown[idx] == 1) continue;
4141
4142 uint cracked = 0;
4143
4144 if (hash_mode == 6800)
4145 {
4146 if (i == salt_buf->salt_len)
4147 {
4148 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4149 }
4150 }
4151 else if (hash_mode == 2500)
4152 {
4153 // BSSID : MAC1 : MAC2 (:plain)
4154 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4155 {
4156 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4157
4158 if (!cracked) continue;
4159
4160 // now compare MAC1 and MAC2 too, since we have this additional info
4161 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4162 char *mac2_pos = mac1_pos + 12 + 1;
4163
4164 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4165 wpa_t *wpa = &wpas[salt_pos];
4166
4167 // compare hex string(s) vs binary MAC address(es)
4168
4169 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4170 {
4171 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4172 {
4173 cracked = 0;
4174
4175 break;
4176 }
4177 }
4178
4179 // early skip ;)
4180 if (!cracked) continue;
4181
4182 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4183 {
4184 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4185 {
4186 cracked = 0;
4187
4188 break;
4189 }
4190 }
4191 }
4192 }
4193 else
4194 {
4195 char *digests_buf_ptr = (char *) data.digests_buf;
4196
4197 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4198
4199 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4200 }
4201
4202 if (cracked == 1)
4203 {
4204 found = 1;
4205
4206 data.digests_shown[idx] = 1;
4207
4208 data.digests_done++;
4209
4210 salt_buf->digests_done++;
4211
4212 if (salt_buf->digests_done == salt_buf->digests_cnt)
4213 {
4214 data.salts_shown[salt_pos] = 1;
4215
4216 data.salts_done++;
4217
4218 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4219 }
4220 }
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225 }
4226
4227 if (found) break;
4228
4229 if (data.devices_status == STATUS_CRACKED) break;
4230
4231 iter--;
4232 }
4233
4234 if (data.devices_status == STATUS_CRACKED) break;
4235 }
4236
4237 myfree (line_buf);
4238
4239 out_info[j].seek = ftell (fp);
4240
4241 //hc_thread_mutex_unlock (mux_display);
4242
4243 fclose (fp);
4244 }
4245 }
4246 }
4247 }
4248
4249 check_left = outfile_check_timer;
4250 }
4251 }
4252
4253 if (esalt_size) local_free (hash_buf.esalt);
4254
4255 if (isSalted) local_free (hash_buf.salt);
4256
4257 local_free (hash_buf.digest);
4258
4259 local_free (out_info);
4260
4261 local_free (out_files);
4262
4263 p = NULL;
4264
4265 return (p);
4266 }
4267
4268 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4269 {
4270 if (device_param->pws_cnt < device_param->kernel_power)
4271 {
4272 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4273
4274 u8 *ptr = (u8 *) pw->i;
4275
4276 memcpy (ptr, pw_buf, pw_len);
4277
4278 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4279
4280 pw->pw_len = pw_len;
4281
4282 device_param->pws_cnt++;
4283 }
4284 else
4285 {
4286 fprintf (stderr, "BUG pw_add()!!\n");
4287
4288 return;
4289 }
4290 }
4291
4292 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4293 {
4294 hc_thread_mutex_lock (mux_dispatcher);
4295
4296 const u64 words_cur = data.words_cur;
4297 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4298
4299 device_param->words_off = words_cur;
4300
4301 const u64 words_left = words_base - words_cur;
4302
4303 if (allow_div)
4304 {
4305 if (data.kernel_power_all > words_left)
4306 {
4307 if (data.kernel_power_div == 0)
4308 {
4309 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4310 }
4311 }
4312
4313 if (data.kernel_power_div)
4314 {
4315 if (device_param->kernel_power == device_param->kernel_power_user)
4316 {
4317 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4318
4319 if (kernel_power_new < device_param->kernel_power)
4320 {
4321 device_param->kernel_power = kernel_power_new;
4322 }
4323 }
4324 }
4325 }
4326
4327 const uint kernel_power = device_param->kernel_power;
4328
4329 uint work = MIN (words_left, kernel_power);
4330
4331 work = MIN (work, max);
4332
4333 data.words_cur += work;
4334
4335 hc_thread_mutex_unlock (mux_dispatcher);
4336
4337 return work;
4338 }
4339
4340 static void *thread_calc_stdin (void *p)
4341 {
4342 hc_device_param_t *device_param = (hc_device_param_t *) p;
4343
4344 if (device_param->skipped) return NULL;
4345
4346 autotune (device_param);
4347
4348 char *buf = (char *) mymalloc (HCBUFSIZ);
4349
4350 const uint attack_kern = data.attack_kern;
4351
4352 const uint kernel_power = device_param->kernel_power;
4353
4354 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4355 {
4356 hc_thread_mutex_lock (mux_dispatcher);
4357
4358 if (feof (stdin) != 0)
4359 {
4360 hc_thread_mutex_unlock (mux_dispatcher);
4361
4362 break;
4363 }
4364
4365 uint words_cur = 0;
4366
4367 while (words_cur < kernel_power)
4368 {
4369 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4370
4371 if (line_buf == NULL) break;
4372
4373 uint line_len = in_superchop (line_buf);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (line_len > PW_MAX)
4397 {
4398 continue;
4399 }
4400
4401 if (attack_kern == ATTACK_KERN_STRAIGHT)
4402 {
4403 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4404 {
4405 hc_thread_mutex_lock (mux_counter);
4406
4407 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4408 {
4409 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4410 }
4411
4412 hc_thread_mutex_unlock (mux_counter);
4413
4414 continue;
4415 }
4416 }
4417 else if (attack_kern == ATTACK_KERN_COMBI)
4418 {
4419 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4420 // since we still need to combine the plains
4421
4422 if (line_len > data.pw_max)
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436
4437 pw_add (device_param, (u8 *) line_buf, line_len);
4438
4439 words_cur++;
4440
4441 if (data.devices_status == STATUS_CRACKED) break;
4442 if (data.devices_status == STATUS_ABORTED) break;
4443 if (data.devices_status == STATUS_QUIT) break;
4444 if (data.devices_status == STATUS_BYPASS) break;
4445 }
4446
4447 hc_thread_mutex_unlock (mux_dispatcher);
4448
4449 if (data.devices_status == STATUS_CRACKED) break;
4450 if (data.devices_status == STATUS_ABORTED) break;
4451 if (data.devices_status == STATUS_QUIT) break;
4452 if (data.devices_status == STATUS_BYPASS) break;
4453
4454 // flush
4455
4456 const uint pws_cnt = device_param->pws_cnt;
4457
4458 if (pws_cnt)
4459 {
4460 run_copy (device_param, pws_cnt);
4461
4462 run_cracker (device_param, pws_cnt);
4463
4464 device_param->pws_cnt = 0;
4465
4466 /*
4467 still required?
4468 if (attack_kern == ATTACK_KERN_STRAIGHT)
4469 {
4470 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4471 }
4472 else if (attack_kern == ATTACK_KERN_COMBI)
4473 {
4474 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4475 }
4476 */
4477 }
4478 }
4479
4480 device_param->kernel_accel = 0;
4481 device_param->kernel_loops = 0;
4482
4483 myfree (buf);
4484
4485 return NULL;
4486 }
4487
4488 static void *thread_calc (void *p)
4489 {
4490 hc_device_param_t *device_param = (hc_device_param_t *) p;
4491
4492 if (device_param->skipped) return NULL;
4493
4494 autotune (device_param);
4495
4496 const uint attack_mode = data.attack_mode;
4497 const uint attack_kern = data.attack_kern;
4498
4499 if (attack_mode == ATTACK_MODE_BF)
4500 {
4501 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4502 {
4503 const uint work = get_work (device_param, -1, true);
4504
4505 if (work == 0) break;
4506
4507 const u64 words_off = device_param->words_off;
4508 const u64 words_fin = words_off + work;
4509
4510 const uint pws_cnt = work;
4511
4512 device_param->pws_cnt = pws_cnt;
4513
4514 if (pws_cnt)
4515 {
4516 run_copy (device_param, pws_cnt);
4517
4518 run_cracker (device_param, pws_cnt);
4519
4520 device_param->pws_cnt = 0;
4521
4522 /*
4523 still required?
4524 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4525 */
4526 }
4527
4528 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4529
4530 if (data.devices_status == STATUS_CRACKED) break;
4531 if (data.devices_status == STATUS_ABORTED) break;
4532 if (data.devices_status == STATUS_QUIT) break;
4533 if (data.devices_status == STATUS_BYPASS) break;
4534
4535 if (data.benchmark == 1) break;
4536
4537 device_param->words_done = words_fin;
4538 }
4539 }
4540 else
4541 {
4542 const uint segment_size = data.segment_size;
4543
4544 char *dictfile = data.dictfile;
4545
4546 if (attack_mode == ATTACK_MODE_COMBI)
4547 {
4548 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4549 {
4550 dictfile = data.dictfile2;
4551 }
4552 }
4553
4554 FILE *fd = fopen (dictfile, "rb");
4555
4556 if (fd == NULL)
4557 {
4558 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4559
4560 return NULL;
4561 }
4562
4563 if (attack_mode == ATTACK_MODE_COMBI)
4564 {
4565 const uint combs_mode = data.combs_mode;
4566
4567 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4568 {
4569 const char *dictfilec = data.dictfile2;
4570
4571 FILE *combs_fp = fopen (dictfilec, "rb");
4572
4573 if (combs_fp == NULL)
4574 {
4575 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4576
4577 fclose (fd);
4578
4579 return NULL;
4580 }
4581
4582 device_param->combs_fp = combs_fp;
4583 }
4584 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4585 {
4586 const char *dictfilec = data.dictfile;
4587
4588 FILE *combs_fp = fopen (dictfilec, "rb");
4589
4590 if (combs_fp == NULL)
4591 {
4592 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4593
4594 fclose (fd);
4595
4596 return NULL;
4597 }
4598
4599 device_param->combs_fp = combs_fp;
4600 }
4601 }
4602
4603 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4604
4605 wl_data->buf = (char *) mymalloc (segment_size);
4606 wl_data->avail = segment_size;
4607 wl_data->incr = segment_size;
4608 wl_data->cnt = 0;
4609 wl_data->pos = 0;
4610
4611 u64 words_cur = 0;
4612
4613 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4614 {
4615 u64 words_off = 0;
4616 u64 words_fin = 0;
4617
4618 bool allow_div = true;
4619
4620 u64 max = -1;
4621
4622 while (max)
4623 {
4624 const uint work = get_work (device_param, max, allow_div);
4625
4626 allow_div = false;
4627
4628 if (work == 0) break;
4629
4630 words_off = device_param->words_off;
4631 words_fin = words_off + work;
4632
4633 char *line_buf;
4634 uint line_len;
4635
4636 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4637
4638 max = 0;
4639
4640 for ( ; words_cur < words_fin; words_cur++)
4641 {
4642 get_next_word (wl_data, fd, &line_buf, &line_len);
4643
4644 line_len = convert_from_hex (line_buf, line_len);
4645
4646 // post-process rule engine
4647
4648 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4649 {
4650 char rule_buf_out[BLOCK_SIZE] = { 0 };
4651
4652 int rule_len_out = -1;
4653
4654 if (line_len < BLOCK_SIZE)
4655 {
4656 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4657 }
4658
4659 if (rule_len_out < 0) continue;
4660
4661 line_buf = rule_buf_out;
4662 line_len = rule_len_out;
4663 }
4664
4665 if (attack_kern == ATTACK_KERN_STRAIGHT)
4666 {
4667 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4668 {
4669 max++;
4670
4671 hc_thread_mutex_lock (mux_counter);
4672
4673 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4674 {
4675 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4676 }
4677
4678 hc_thread_mutex_unlock (mux_counter);
4679
4680 continue;
4681 }
4682 }
4683 else if (attack_kern == ATTACK_KERN_COMBI)
4684 {
4685 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4686 // since we still need to combine the plains
4687
4688 if (line_len > data.pw_max)
4689 {
4690 max++;
4691
4692 hc_thread_mutex_lock (mux_counter);
4693
4694 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4695 {
4696 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4697 }
4698
4699 hc_thread_mutex_unlock (mux_counter);
4700
4701 continue;
4702 }
4703 }
4704
4705 pw_add (device_param, (u8 *) line_buf, line_len);
4706
4707 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4708
4709 if (data.devices_status == STATUS_CRACKED) break;
4710 if (data.devices_status == STATUS_ABORTED) break;
4711 if (data.devices_status == STATUS_QUIT) break;
4712 if (data.devices_status == STATUS_BYPASS) break;
4713 }
4714
4715 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4716
4717 if (data.devices_status == STATUS_CRACKED) break;
4718 if (data.devices_status == STATUS_ABORTED) break;
4719 if (data.devices_status == STATUS_QUIT) break;
4720 if (data.devices_status == STATUS_BYPASS) break;
4721 }
4722
4723 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4724
4725 if (data.devices_status == STATUS_CRACKED) break;
4726 if (data.devices_status == STATUS_ABORTED) break;
4727 if (data.devices_status == STATUS_QUIT) break;
4728 if (data.devices_status == STATUS_BYPASS) break;
4729
4730 //
4731 // flush
4732 //
4733
4734 const uint pws_cnt = device_param->pws_cnt;
4735
4736 if (pws_cnt)
4737 {
4738 run_copy (device_param, pws_cnt);
4739
4740 run_cracker (device_param, pws_cnt);
4741
4742 device_param->pws_cnt = 0;
4743
4744 /*
4745 still required?
4746 if (attack_kern == ATTACK_KERN_STRAIGHT)
4747 {
4748 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4749 }
4750 else if (attack_kern == ATTACK_KERN_COMBI)
4751 {
4752 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4753 }
4754 */
4755 }
4756
4757 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4758
4759 if (data.devices_status == STATUS_CRACKED) break;
4760 if (data.devices_status == STATUS_ABORTED) break;
4761 if (data.devices_status == STATUS_QUIT) break;
4762 if (data.devices_status == STATUS_BYPASS) break;
4763
4764 if (words_fin == 0) break;
4765
4766 device_param->words_done = words_fin;
4767 }
4768
4769 if (attack_mode == ATTACK_MODE_COMBI)
4770 {
4771 fclose (device_param->combs_fp);
4772 }
4773
4774 free (wl_data->buf);
4775 free (wl_data);
4776
4777 fclose (fd);
4778 }
4779
4780 device_param->kernel_accel = 0;
4781 device_param->kernel_loops = 0;
4782
4783 return NULL;
4784 }
4785
4786 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4787 {
4788 if (!device_param)
4789 {
4790 log_error ("ERROR: %s : Invalid argument", __func__);
4791
4792 exit (-1);
4793 }
4794
4795 salt_t *salt_buf = &data.salts_buf[salt_pos];
4796
4797 device_param->kernel_params_buf32[24] = salt_pos;
4798 device_param->kernel_params_buf32[27] = 1;
4799 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4800 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4801 device_param->kernel_params_buf32[30] = 0;
4802 device_param->kernel_params_buf32[31] = 1;
4803
4804 char *dictfile_old = data.dictfile;
4805
4806 const char *weak_hash_check = "weak-hash-check";
4807
4808 data.dictfile = (char *) weak_hash_check;
4809
4810 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4811
4812 data.kernel_rules_buf[0].cmds[0] = 0;
4813
4814 /**
4815 * run the kernel
4816 */
4817
4818 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4819 {
4820 run_kernel (KERN_RUN_1, device_param, 1, false);
4821 }
4822 else
4823 {
4824 run_kernel (KERN_RUN_1, device_param, 1, false);
4825
4826 uint loop_step = 16;
4827
4828 const uint iter = salt_buf->salt_iter;
4829
4830 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4831 {
4832 uint loop_left = iter - loop_pos;
4833
4834 loop_left = MIN (loop_left, loop_step);
4835
4836 device_param->kernel_params_buf32[25] = loop_pos;
4837 device_param->kernel_params_buf32[26] = loop_left;
4838
4839 run_kernel (KERN_RUN_2, device_param, 1, false);
4840 }
4841
4842 run_kernel (KERN_RUN_3, device_param, 1, false);
4843 }
4844
4845 /**
4846 * result
4847 */
4848
4849 check_cracked (device_param, salt_pos);
4850
4851 /**
4852 * cleanup
4853 */
4854
4855 device_param->kernel_params_buf32[24] = 0;
4856 device_param->kernel_params_buf32[25] = 0;
4857 device_param->kernel_params_buf32[26] = 0;
4858 device_param->kernel_params_buf32[27] = 0;
4859 device_param->kernel_params_buf32[28] = 0;
4860 device_param->kernel_params_buf32[29] = 0;
4861 device_param->kernel_params_buf32[30] = 0;
4862 device_param->kernel_params_buf32[31] = 0;
4863
4864 data.dictfile = dictfile_old;
4865
4866 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4867 }
4868
4869 // hlfmt hashcat
4870
4871 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4872 {
4873 if (data.username == 0)
4874 {
4875 *hashbuf_pos = line_buf;
4876 *hashbuf_len = line_len;
4877 }
4878 else
4879 {
4880 char *pos = line_buf;
4881 int len = line_len;
4882
4883 for (int i = 0; i < line_len; i++, pos++, len--)
4884 {
4885 if (line_buf[i] == data.separator)
4886 {
4887 pos++;
4888
4889 len--;
4890
4891 break;
4892 }
4893 }
4894
4895 *hashbuf_pos = pos;
4896 *hashbuf_len = len;
4897 }
4898 }
4899
4900 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4901 {
4902 char *pos = NULL;
4903 int len = 0;
4904
4905 int sep_cnt = 0;
4906
4907 for (int i = 0; i < line_len; i++)
4908 {
4909 if (line_buf[i] == data.separator)
4910 {
4911 sep_cnt++;
4912
4913 continue;
4914 }
4915
4916 if (sep_cnt == 0)
4917 {
4918 if (pos == NULL) pos = line_buf + i;
4919
4920 len++;
4921 }
4922 }
4923
4924 *userbuf_pos = pos;
4925 *userbuf_len = len;
4926 }
4927
4928 // hlfmt pwdump
4929
4930 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4931 {
4932 int sep_cnt = 0;
4933
4934 int sep2_len = 0;
4935 int sep3_len = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 2) sep2_len++;
4947 if (sep_cnt == 3) sep3_len++;
4948 }
4949
4950 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4951
4952 return 0;
4953 }
4954
4955 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4956 {
4957 char *pos = NULL;
4958 int len = 0;
4959
4960 int sep_cnt = 0;
4961
4962 for (int i = 0; i < line_len; i++)
4963 {
4964 if (line_buf[i] == ':')
4965 {
4966 sep_cnt++;
4967
4968 continue;
4969 }
4970
4971 if (data.hash_mode == 1000)
4972 {
4973 if (sep_cnt == 3)
4974 {
4975 if (pos == NULL) pos = line_buf + i;
4976
4977 len++;
4978 }
4979 }
4980 else if (data.hash_mode == 3000)
4981 {
4982 if (sep_cnt == 2)
4983 {
4984 if (pos == NULL) pos = line_buf + i;
4985
4986 len++;
4987 }
4988 }
4989 }
4990
4991 *hashbuf_pos = pos;
4992 *hashbuf_len = len;
4993 }
4994
4995 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4996 {
4997 char *pos = NULL;
4998 int len = 0;
4999
5000 int sep_cnt = 0;
5001
5002 for (int i = 0; i < line_len; i++)
5003 {
5004 if (line_buf[i] == ':')
5005 {
5006 sep_cnt++;
5007
5008 continue;
5009 }
5010
5011 if (sep_cnt == 0)
5012 {
5013 if (pos == NULL) pos = line_buf + i;
5014
5015 len++;
5016 }
5017 }
5018
5019 *userbuf_pos = pos;
5020 *userbuf_len = len;
5021 }
5022
5023 // hlfmt passwd
5024
5025 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5026 {
5027 int sep_cnt = 0;
5028
5029 char sep5_first = 0;
5030 char sep6_first = 0;
5031
5032 for (int i = 0; i < line_len; i++)
5033 {
5034 if (line_buf[i] == ':')
5035 {
5036 sep_cnt++;
5037
5038 continue;
5039 }
5040
5041 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5042 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5043 }
5044
5045 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5046
5047 return 0;
5048 }
5049
5050 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5051 {
5052 char *pos = NULL;
5053 int len = 0;
5054
5055 int sep_cnt = 0;
5056
5057 for (int i = 0; i < line_len; i++)
5058 {
5059 if (line_buf[i] == ':')
5060 {
5061 sep_cnt++;
5062
5063 continue;
5064 }
5065
5066 if (sep_cnt == 1)
5067 {
5068 if (pos == NULL) pos = line_buf + i;
5069
5070 len++;
5071 }
5072 }
5073
5074 *hashbuf_pos = pos;
5075 *hashbuf_len = len;
5076 }
5077
5078 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5079 {
5080 char *pos = NULL;
5081 int len = 0;
5082
5083 int sep_cnt = 0;
5084
5085 for (int i = 0; i < line_len; i++)
5086 {
5087 if (line_buf[i] == ':')
5088 {
5089 sep_cnt++;
5090
5091 continue;
5092 }
5093
5094 if (sep_cnt == 0)
5095 {
5096 if (pos == NULL) pos = line_buf + i;
5097
5098 len++;
5099 }
5100 }
5101
5102 *userbuf_pos = pos;
5103 *userbuf_len = len;
5104 }
5105
5106 // hlfmt shadow
5107
5108 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5109 {
5110 int sep_cnt = 0;
5111
5112 for (int i = 0; i < line_len; i++)
5113 {
5114 if (line_buf[i] == ':') sep_cnt++;
5115 }
5116
5117 if (sep_cnt == 8) return 1;
5118
5119 return 0;
5120 }
5121
5122 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5123 {
5124 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5125 }
5126
5127 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5128 {
5129 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5130 }
5131
5132 // hlfmt main
5133
5134 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5135 {
5136 switch (hashfile_format)
5137 {
5138 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5139 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5141 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5142 }
5143 }
5144
5145 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5146 {
5147 switch (hashfile_format)
5148 {
5149 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5150 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5152 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5153 }
5154 }
5155
5156 char *strhlfmt (const uint hashfile_format)
5157 {
5158 switch (hashfile_format)
5159 {
5160 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5161 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5162 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5163 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5164 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5165 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5166 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5167 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5168 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5169 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5170 }
5171
5172 return ((char *) "Unknown");
5173 }
5174
5175 static uint hlfmt_detect (FILE *fp, uint max_check)
5176 {
5177 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5178
5179 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5180 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5181
5182 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5183
5184 uint num_check = 0;
5185
5186 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5187
5188 while (!feof (fp))
5189 {
5190 int line_len = fgetl (fp, line_buf);
5191
5192 if (line_len == 0) continue;
5193
5194 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5195 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5196 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5197
5198 if (num_check == max_check) break;
5199
5200 num_check++;
5201 }
5202
5203 myfree (line_buf);
5204
5205 uint hashlist_format = HLFMT_HASHCAT;
5206
5207 for (int i = 1; i < HLFMTS_CNT; i++)
5208 {
5209 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5210
5211 hashlist_format = i;
5212 }
5213
5214 free (formats_cnt);
5215
5216 return hashlist_format;
5217 }
5218
5219 /**
5220 * some further helper function
5221 */
5222
5223 // wrapper around mymalloc for ADL
5224
5225 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5226 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5227 {
5228 return mymalloc (iSize);
5229 }
5230 #endif
5231
5232 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)
5233 {
5234 u64 collisions = 0;
5235
5236 const uint dgst_pos0 = data.dgst_pos0;
5237 const uint dgst_pos1 = data.dgst_pos1;
5238 const uint dgst_pos2 = data.dgst_pos2;
5239 const uint dgst_pos3 = data.dgst_pos3;
5240
5241 memset (bitmap_a, 0, bitmap_size);
5242 memset (bitmap_b, 0, bitmap_size);
5243 memset (bitmap_c, 0, bitmap_size);
5244 memset (bitmap_d, 0, bitmap_size);
5245
5246 for (uint i = 0; i < digests_cnt; i++)
5247 {
5248 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5249
5250 uint *digest_ptr = (uint *) digests_buf_ptr;
5251
5252 digests_buf_ptr += dgst_size;
5253
5254 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5255 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5256 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5257 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5258
5259 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5260 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5261 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5262 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5263
5264 if (bitmap_a[idx0] & val0) collisions++;
5265 if (bitmap_b[idx1] & val1) collisions++;
5266 if (bitmap_c[idx2] & val2) collisions++;
5267 if (bitmap_d[idx3] & val3) collisions++;
5268
5269 bitmap_a[idx0] |= val0;
5270 bitmap_b[idx1] |= val1;
5271 bitmap_c[idx2] |= val2;
5272 bitmap_d[idx3] |= val3;
5273
5274 if (collisions >= collisions_max) return 0x7fffffff;
5275 }
5276
5277 return collisions;
5278 }
5279
5280 /**
5281 * main
5282 */
5283
5284 int main (int argc, char **argv)
5285 {
5286 /**
5287 * To help users a bit
5288 */
5289
5290 char *compute = getenv ("COMPUTE");
5291
5292 if (compute)
5293 {
5294 static char display[100];
5295
5296 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5297
5298 putenv (display);
5299 }
5300 else
5301 {
5302 if (getenv ("DISPLAY") == NULL)
5303 putenv ((char *) "DISPLAY=:0");
5304 }
5305
5306 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5307 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5308
5309 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5310 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5311
5312 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5313 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5314
5315 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5316 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5317
5318 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5319 putenv ((char *) "POCL_KERNEL_CACHE=0");
5320
5321 umask (077);
5322
5323 /**
5324 * Real init
5325 */
5326
5327 memset (&data, 0, sizeof (hc_global_data_t));
5328
5329 time_t proc_start;
5330
5331 time (&proc_start);
5332
5333 data.proc_start = proc_start;
5334
5335 int myargc = argc;
5336 char **myargv = argv;
5337
5338 hc_thread_mutex_init (mux_dispatcher);
5339 hc_thread_mutex_init (mux_counter);
5340 hc_thread_mutex_init (mux_display);
5341 hc_thread_mutex_init (mux_adl);
5342
5343 /**
5344 * commandline parameters
5345 */
5346
5347 uint usage = USAGE;
5348 uint version = VERSION;
5349 uint quiet = QUIET;
5350 uint benchmark = BENCHMARK;
5351 uint show = SHOW;
5352 uint left = LEFT;
5353 uint username = USERNAME;
5354 uint remove = REMOVE;
5355 uint remove_timer = REMOVE_TIMER;
5356 u64 skip = SKIP;
5357 u64 limit = LIMIT;
5358 uint keyspace = KEYSPACE;
5359 uint potfile_disable = POTFILE_DISABLE;
5360 char *potfile_path = NULL;
5361 uint debug_mode = DEBUG_MODE;
5362 char *debug_file = NULL;
5363 char *induction_dir = NULL;
5364 char *outfile_check_dir = NULL;
5365 uint force = FORCE;
5366 uint runtime = RUNTIME;
5367 uint hash_mode = HASH_MODE;
5368 uint attack_mode = ATTACK_MODE;
5369 uint markov_disable = MARKOV_DISABLE;
5370 uint markov_classic = MARKOV_CLASSIC;
5371 uint markov_threshold = MARKOV_THRESHOLD;
5372 char *markov_hcstat = NULL;
5373 char *outfile = NULL;
5374 uint outfile_format = OUTFILE_FORMAT;
5375 uint outfile_autohex = OUTFILE_AUTOHEX;
5376 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5377 uint restore = RESTORE;
5378 uint restore_timer = RESTORE_TIMER;
5379 uint restore_disable = RESTORE_DISABLE;
5380 uint status = STATUS;
5381 uint status_timer = STATUS_TIMER;
5382 uint status_automat = STATUS_AUTOMAT;
5383 uint loopback = LOOPBACK;
5384 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5385 char *session = NULL;
5386 uint hex_charset = HEX_CHARSET;
5387 uint hex_salt = HEX_SALT;
5388 uint hex_wordlist = HEX_WORDLIST;
5389 uint rp_gen = RP_GEN;
5390 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5391 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5392 uint rp_gen_seed = RP_GEN_SEED;
5393 char *rule_buf_l = (char *) RULE_BUF_L;
5394 char *rule_buf_r = (char *) RULE_BUF_R;
5395 uint increment = INCREMENT;
5396 uint increment_min = INCREMENT_MIN;
5397 uint increment_max = INCREMENT_MAX;
5398 char *cpu_affinity = NULL;
5399 OCL_PTR *ocl = NULL;
5400 char *opencl_devices = NULL;
5401 char *opencl_platforms = NULL;
5402 char *opencl_device_types = NULL;
5403 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5404 char *truecrypt_keyfiles = NULL;
5405 char *veracrypt_keyfiles = NULL;
5406 uint veracrypt_pim = 0;
5407 uint workload_profile = WORKLOAD_PROFILE;
5408 uint kernel_accel = KERNEL_ACCEL;
5409 uint kernel_loops = KERNEL_LOOPS;
5410 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5411 #ifdef HAVE_HWMON
5412 uint gpu_temp_abort = GPU_TEMP_ABORT;
5413 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5414 #ifdef HAVE_ADL
5415 uint powertune_enable = POWERTUNE_ENABLE;
5416 #endif
5417 #endif
5418 uint logfile_disable = LOGFILE_DISABLE;
5419 uint segment_size = SEGMENT_SIZE;
5420 uint scrypt_tmto = SCRYPT_TMTO;
5421 char separator = SEPARATOR;
5422 uint bitmap_min = BITMAP_MIN;
5423 uint bitmap_max = BITMAP_MAX;
5424 char *custom_charset_1 = NULL;
5425 char *custom_charset_2 = NULL;
5426 char *custom_charset_3 = NULL;
5427 char *custom_charset_4 = NULL;
5428
5429 #define IDX_HELP 'h'
5430 #define IDX_VERSION 'V'
5431 #define IDX_VERSION_LOWER 'v'
5432 #define IDX_QUIET 0xff02
5433 #define IDX_SHOW 0xff03
5434 #define IDX_LEFT 0xff04
5435 #define IDX_REMOVE 0xff05
5436 #define IDX_REMOVE_TIMER 0xff37
5437 #define IDX_SKIP 's'
5438 #define IDX_LIMIT 'l'
5439 #define IDX_KEYSPACE 0xff35
5440 #define IDX_POTFILE_DISABLE 0xff06
5441 #define IDX_POTFILE_PATH 0xffe0
5442 #define IDX_DEBUG_MODE 0xff43
5443 #define IDX_DEBUG_FILE 0xff44
5444 #define IDX_INDUCTION_DIR 0xff46
5445 #define IDX_OUTFILE_CHECK_DIR 0xff47
5446 #define IDX_USERNAME 0xff07
5447 #define IDX_FORCE 0xff08
5448 #define IDX_RUNTIME 0xff09
5449 #define IDX_BENCHMARK 'b'
5450 #define IDX_HASH_MODE 'm'
5451 #define IDX_ATTACK_MODE 'a'
5452 #define IDX_RP_FILE 'r'
5453 #define IDX_RP_GEN 'g'
5454 #define IDX_RP_GEN_FUNC_MIN 0xff10
5455 #define IDX_RP_GEN_FUNC_MAX 0xff11
5456 #define IDX_RP_GEN_SEED 0xff34
5457 #define IDX_RULE_BUF_L 'j'
5458 #define IDX_RULE_BUF_R 'k'
5459 #define IDX_INCREMENT 'i'
5460 #define IDX_INCREMENT_MIN 0xff12
5461 #define IDX_INCREMENT_MAX 0xff13
5462 #define IDX_OUTFILE 'o'
5463 #define IDX_OUTFILE_FORMAT 0xff14
5464 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5465 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5466 #define IDX_RESTORE 0xff15
5467 #define IDX_RESTORE_DISABLE 0xff27
5468 #define IDX_STATUS 0xff17
5469 #define IDX_STATUS_TIMER 0xff18
5470 #define IDX_STATUS_AUTOMAT 0xff50
5471 #define IDX_LOOPBACK 0xff38
5472 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5473 #define IDX_SESSION 0xff19
5474 #define IDX_HEX_CHARSET 0xff20
5475 #define IDX_HEX_SALT 0xff21
5476 #define IDX_HEX_WORDLIST 0xff40
5477 #define IDX_MARKOV_DISABLE 0xff22
5478 #define IDX_MARKOV_CLASSIC 0xff23
5479 #define IDX_MARKOV_THRESHOLD 't'
5480 #define IDX_MARKOV_HCSTAT 0xff24
5481 #define IDX_CPU_AFFINITY 0xff25
5482 #define IDX_OPENCL_DEVICES 'd'
5483 #define IDX_OPENCL_PLATFORMS 0xff72
5484 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5485 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5486 #define IDX_WORKLOAD_PROFILE 'w'
5487 #define IDX_KERNEL_ACCEL 'n'
5488 #define IDX_KERNEL_LOOPS 'u'
5489 #define IDX_GPU_TEMP_DISABLE 0xff29
5490 #define IDX_GPU_TEMP_ABORT 0xff30
5491 #define IDX_GPU_TEMP_RETAIN 0xff31
5492 #define IDX_POWERTUNE_ENABLE 0xff41
5493 #define IDX_LOGFILE_DISABLE 0xff51
5494 #define IDX_TRUECRYPT_KEYFILES 0xff52
5495 #define IDX_VERACRYPT_KEYFILES 0xff53
5496 #define IDX_VERACRYPT_PIM 0xff54
5497 #define IDX_SCRYPT_TMTO 0xff61
5498 #define IDX_SEGMENT_SIZE 'c'
5499 #define IDX_SEPARATOR 'p'
5500 #define IDX_BITMAP_MIN 0xff70
5501 #define IDX_BITMAP_MAX 0xff71
5502 #define IDX_CUSTOM_CHARSET_1 '1'
5503 #define IDX_CUSTOM_CHARSET_2 '2'
5504 #define IDX_CUSTOM_CHARSET_3 '3'
5505 #define IDX_CUSTOM_CHARSET_4 '4'
5506
5507 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5508
5509 struct option long_options[] =
5510 {
5511 {"help", no_argument, 0, IDX_HELP},
5512 {"version", no_argument, 0, IDX_VERSION},
5513 {"quiet", no_argument, 0, IDX_QUIET},
5514 {"show", no_argument, 0, IDX_SHOW},
5515 {"left", no_argument, 0, IDX_LEFT},
5516 {"username", no_argument, 0, IDX_USERNAME},
5517 {"remove", no_argument, 0, IDX_REMOVE},
5518 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5519 {"skip", required_argument, 0, IDX_SKIP},
5520 {"limit", required_argument, 0, IDX_LIMIT},
5521 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5522 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5523 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5524 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5525 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5526 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5527 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5528 {"force", no_argument, 0, IDX_FORCE},
5529 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5530 {"restore", no_argument, 0, IDX_RESTORE},
5531 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5532 {"status", no_argument, 0, IDX_STATUS},
5533 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5534 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5535 {"loopback", no_argument, 0, IDX_LOOPBACK},
5536 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5537 {"session", required_argument, 0, IDX_SESSION},
5538 {"runtime", required_argument, 0, IDX_RUNTIME},
5539 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5540 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5541 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5542 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5543 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5544 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5545 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5546 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5547 {"rules-file", required_argument, 0, IDX_RP_FILE},
5548 {"outfile", required_argument, 0, IDX_OUTFILE},
5549 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5550 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5551 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5552 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5553 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5554 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5555 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5556 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5557 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5558 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5559 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5560 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5561 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5562 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5563 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5564 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5565 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5566 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5567 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5568 #ifdef HAVE_HWMON
5569 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5570 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5571 #ifdef HAVE_ADL
5572 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5573 #endif
5574 #endif // HAVE_HWMON
5575 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5576 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5577 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5578 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5579 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5580 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5581 {"seperator", required_argument, 0, IDX_SEPARATOR},
5582 {"separator", required_argument, 0, IDX_SEPARATOR},
5583 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5584 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5585 {"increment", no_argument, 0, IDX_INCREMENT},
5586 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5587 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5588 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5589 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5590 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5591 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5592 {0, 0, 0, 0}
5593 };
5594
5595 uint rp_files_cnt = 0;
5596
5597 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5598
5599 int option_index = 0;
5600 int c = -1;
5601
5602 optind = 1;
5603 optopt = 0;
5604
5605 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5606 {
5607 switch (c)
5608 {
5609 case IDX_HELP: usage = 1; break;
5610 case IDX_VERSION:
5611 case IDX_VERSION_LOWER: version = 1; break;
5612 case IDX_RESTORE: restore = 1; break;
5613 case IDX_SESSION: session = optarg; break;
5614 case IDX_SHOW: show = 1; break;
5615 case IDX_LEFT: left = 1; break;
5616 case '?': return (-1);
5617 }
5618 }
5619
5620 if (optopt != 0)
5621 {
5622 log_error ("ERROR: Invalid argument specified");
5623
5624 return (-1);
5625 }
5626
5627 /**
5628 * exit functions
5629 */
5630
5631 if (version)
5632 {
5633 log_info ("%s", VERSION_TAG);
5634
5635 return (0);
5636 }
5637
5638 if (usage)
5639 {
5640 usage_big_print (PROGNAME);
5641
5642 return (0);
5643 }
5644
5645 /**
5646 * session needs to be set, always!
5647 */
5648
5649 if (session == NULL) session = (char *) PROGNAME;
5650
5651 /**
5652 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5653 */
5654
5655 char *exec_path = get_exec_path ();
5656
5657 #ifdef LINUX
5658
5659 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5660 char *resolved_exec_path = realpath (exec_path, NULL);
5661
5662 char *install_dir = get_install_dir (resolved_exec_path);
5663 char *profile_dir = NULL;
5664 char *session_dir = NULL;
5665 char *shared_dir = NULL;
5666
5667 if (strcmp (install_dir, resolved_install_folder) == 0)
5668 {
5669 struct passwd *pw = getpwuid (getuid ());
5670
5671 const char *homedir = pw->pw_dir;
5672
5673 profile_dir = get_profile_dir (homedir);
5674 session_dir = get_session_dir (profile_dir);
5675 shared_dir = strdup (SHARED_FOLDER);
5676
5677 mkdir (profile_dir, 0700);
5678 mkdir (session_dir, 0700);
5679 }
5680 else
5681 {
5682 profile_dir = install_dir;
5683 session_dir = install_dir;
5684 shared_dir = install_dir;
5685 }
5686
5687 myfree (resolved_install_folder);
5688 myfree (resolved_exec_path);
5689
5690 #else
5691
5692 char *install_dir = get_install_dir (exec_path);
5693 char *profile_dir = install_dir;
5694 char *session_dir = install_dir;
5695 char *shared_dir = install_dir;
5696
5697 #endif
5698
5699 data.install_dir = install_dir;
5700 data.profile_dir = profile_dir;
5701 data.session_dir = session_dir;
5702 data.shared_dir = shared_dir;
5703
5704 myfree (exec_path);
5705
5706 /**
5707 * kernel cache, we need to make sure folder exist
5708 */
5709
5710 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5711
5712 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5713
5714 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5715
5716 mkdir (kernels_folder, 0700);
5717
5718 myfree (kernels_folder);
5719
5720 /**
5721 * session
5722 */
5723
5724 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5725
5726 data.session = session;
5727
5728 char *eff_restore_file = (char *) mymalloc (session_size);
5729 char *new_restore_file = (char *) mymalloc (session_size);
5730
5731 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5732 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5733
5734 data.eff_restore_file = eff_restore_file;
5735 data.new_restore_file = new_restore_file;
5736
5737 if (((show == 1) || (left == 1)) && (restore == 1))
5738 {
5739 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5740 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5741
5742 return (-1);
5743 }
5744
5745 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5746 if ((show == 1) || (left == 1))
5747 {
5748 restore_disable = 1;
5749
5750 restore = 0;
5751 }
5752
5753 data.restore_disable = restore_disable;
5754
5755 restore_data_t *rd = init_restore (argc, argv);
5756
5757 data.rd = rd;
5758
5759 /**
5760 * restore file
5761 */
5762
5763 if (restore == 1)
5764 {
5765 read_restore (eff_restore_file, rd);
5766
5767 if (rd->version_bin < RESTORE_MIN)
5768 {
5769 log_error ("ERROR: Incompatible restore-file version");
5770
5771 return (-1);
5772 }
5773
5774 myargc = rd->argc;
5775 myargv = rd->argv;
5776
5777 #ifdef _POSIX
5778 rd->pid = getpid ();
5779 #elif _WIN
5780 rd->pid = GetCurrentProcessId ();
5781 #endif
5782 }
5783
5784 uint hash_mode_chgd = 0;
5785 uint runtime_chgd = 0;
5786 uint kernel_loops_chgd = 0;
5787 uint kernel_accel_chgd = 0;
5788 uint attack_mode_chgd = 0;
5789 uint outfile_format_chgd = 0;
5790 uint rp_gen_seed_chgd = 0;
5791 uint remove_timer_chgd = 0;
5792 uint increment_min_chgd = 0;
5793 uint increment_max_chgd = 0;
5794 uint workload_profile_chgd = 0;
5795 uint opencl_vector_width_chgd = 0;
5796
5797 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5798 uint gpu_temp_retain_chgd = 0;
5799 uint gpu_temp_abort_chgd = 0;
5800 #endif
5801
5802 optind = 1;
5803 optopt = 0;
5804 option_index = 0;
5805
5806 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5807 {
5808 switch (c)
5809 {
5810 //case IDX_HELP: usage = 1; break;
5811 //case IDX_VERSION: version = 1; break;
5812 //case IDX_RESTORE: restore = 1; break;
5813 case IDX_QUIET: quiet = 1; break;
5814 //case IDX_SHOW: show = 1; break;
5815 case IDX_SHOW: break;
5816 //case IDX_LEFT: left = 1; break;
5817 case IDX_LEFT: break;
5818 case IDX_USERNAME: username = 1; break;
5819 case IDX_REMOVE: remove = 1; break;
5820 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5821 remove_timer_chgd = 1; break;
5822 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5823 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5824 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5825 case IDX_DEBUG_FILE: debug_file = optarg; break;
5826 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5827 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5828 case IDX_FORCE: force = 1; break;
5829 case IDX_SKIP: skip = atoll (optarg); break;
5830 case IDX_LIMIT: limit = atoll (optarg); break;
5831 case IDX_KEYSPACE: keyspace = 1; break;
5832 case IDX_BENCHMARK: benchmark = 1; break;
5833 case IDX_RESTORE: break;
5834 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5835 case IDX_STATUS: status = 1; break;
5836 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5837 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5838 case IDX_LOOPBACK: loopback = 1; break;
5839 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5840 //case IDX_SESSION: session = optarg; break;
5841 case IDX_SESSION: break;
5842 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5843 hash_mode_chgd = 1; break;
5844 case IDX_RUNTIME: runtime = atoi (optarg);
5845 runtime_chgd = 1; break;
5846 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5847 attack_mode_chgd = 1; break;
5848 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5849 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5850 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5851 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5852 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5853 rp_gen_seed_chgd = 1; break;
5854 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5855 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5856 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5857 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5858 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5859 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5860 case IDX_OUTFILE: outfile = optarg; break;
5861 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5862 outfile_format_chgd = 1; break;
5863 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5864 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5865 case IDX_HEX_CHARSET: hex_charset = 1; break;
5866 case IDX_HEX_SALT: hex_salt = 1; break;
5867 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5868 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5869 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5870 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5871 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5872 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5873 opencl_vector_width_chgd = 1; break;
5874 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5875 workload_profile_chgd = 1; break;
5876 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5877 kernel_accel_chgd = 1; break;
5878 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5879 kernel_loops_chgd = 1; break;
5880 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5881 #ifdef HAVE_HWMON
5882 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_abort_chgd = 1;
5885 #endif
5886 break;
5887 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5888 #ifdef HAVE_ADL
5889 gpu_temp_retain_chgd = 1;
5890 #endif
5891 break;
5892 #ifdef HAVE_ADL
5893 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5894 #endif
5895 #endif // HAVE_HWMON
5896 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5897 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5898 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5899 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5900 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5901 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5902 case IDX_SEPARATOR: separator = optarg[0]; break;
5903 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5904 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5905 case IDX_INCREMENT: increment = 1; break;
5906 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5907 increment_min_chgd = 1; break;
5908 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5909 increment_max_chgd = 1; break;
5910 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5913 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5914
5915 default:
5916 log_error ("ERROR: Invalid argument specified");
5917 return (-1);
5918 }
5919 }
5920
5921 if (optopt != 0)
5922 {
5923 log_error ("ERROR: Invalid argument specified");
5924
5925 return (-1);
5926 }
5927
5928 /**
5929 * Inform user things getting started,
5930 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5931 * - we do not need to check algorithm_pos
5932 */
5933
5934 if (quiet == 0)
5935 {
5936 if (benchmark == 1)
5937 {
5938 if (status_automat == 0)
5939 {
5940 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5941 log_info ("");
5942 }
5943 else
5944 {
5945 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5946 }
5947 }
5948 else if (restore == 1)
5949 {
5950 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5951 log_info ("");
5952 }
5953 else
5954 {
5955 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5956 log_info ("");
5957 }
5958 }
5959
5960 /**
5961 * sanity check
5962 */
5963
5964 if (attack_mode > 7)
5965 {
5966 log_error ("ERROR: Invalid attack-mode specified");
5967
5968 return (-1);
5969 }
5970
5971 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5972 {
5973 log_error ("ERROR: Invalid runtime specified");
5974
5975 return (-1);
5976 }
5977
5978 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5979 {
5980 log_error ("ERROR: Invalid hash-type specified");
5981
5982 return (-1);
5983 }
5984
5985 // renamed hash modes
5986
5987 if (hash_mode_chgd)
5988 {
5989 int n = -1;
5990
5991 switch (hash_mode)
5992 {
5993 case 123: n = 124;
5994 break;
5995 }
5996
5997 if (n >= 0)
5998 {
5999 log_error ("Old -m specified, use -m %d instead", n);
6000
6001 return (-1);
6002 }
6003 }
6004
6005 if (username == 1)
6006 {
6007 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6008 {
6009 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6010
6011 return (-1);
6012 }
6013 }
6014
6015 if (outfile_format > 16)
6016 {
6017 log_error ("ERROR: Invalid outfile-format specified");
6018
6019 return (-1);
6020 }
6021
6022 if (left == 1)
6023 {
6024 if (outfile_format_chgd == 1)
6025 {
6026 if (outfile_format > 1)
6027 {
6028 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6029
6030 return (-1);
6031 }
6032 }
6033 else
6034 {
6035 outfile_format = OUTFILE_FMT_HASH;
6036 }
6037 }
6038
6039 if (show == 1)
6040 {
6041 if (outfile_format_chgd == 1)
6042 {
6043 if ((outfile_format > 7) && (outfile_format < 16))
6044 {
6045 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6046
6047 return (-1);
6048 }
6049 }
6050 }
6051
6052 if (increment_min < INCREMENT_MIN)
6053 {
6054 log_error ("ERROR: Invalid increment-min specified");
6055
6056 return (-1);
6057 }
6058
6059 if (increment_max > INCREMENT_MAX)
6060 {
6061 log_error ("ERROR: Invalid increment-max specified");
6062
6063 return (-1);
6064 }
6065
6066 if (increment_min > increment_max)
6067 {
6068 log_error ("ERROR: Invalid increment-min specified");
6069
6070 return (-1);
6071 }
6072
6073 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6074 {
6075 log_error ("ERROR: increment is not allowed in attack-mode 0");
6076
6077 return (-1);
6078 }
6079
6080 if ((increment == 0) && (increment_min_chgd == 1))
6081 {
6082 log_error ("ERROR: increment-min is only supported together with increment switch");
6083
6084 return (-1);
6085 }
6086
6087 if ((increment == 0) && (increment_max_chgd == 1))
6088 {
6089 log_error ("ERROR: increment-max is only supported together with increment switch");
6090
6091 return (-1);
6092 }
6093
6094 if (rp_files_cnt && rp_gen)
6095 {
6096 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6097
6098 return (-1);
6099 }
6100
6101 if (rp_files_cnt || rp_gen)
6102 {
6103 if (attack_mode != ATTACK_MODE_STRAIGHT)
6104 {
6105 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6106
6107 return (-1);
6108 }
6109 }
6110
6111 if (rp_gen_func_min > rp_gen_func_max)
6112 {
6113 log_error ("ERROR: Invalid rp-gen-func-min specified");
6114
6115 return (-1);
6116 }
6117
6118 if (kernel_accel_chgd == 1)
6119 {
6120 if (force == 0)
6121 {
6122 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6123 log_info ("Please consider using the option -w instead");
6124 log_info ("You can use --force to override this but do not post error reports if you do so");
6125 log_info ("");
6126
6127 return (-1);
6128 }
6129
6130 if (kernel_accel < 1)
6131 {
6132 log_error ("ERROR: Invalid kernel-accel specified");
6133
6134 return (-1);
6135 }
6136
6137 if (kernel_accel > 1024)
6138 {
6139 log_error ("ERROR: Invalid kernel-accel specified");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if (kernel_loops_chgd == 1)
6146 {
6147 if (force == 0)
6148 {
6149 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6150 log_info ("Please consider using the option -w instead");
6151 log_info ("You can use --force to override this but do not post error reports if you do so");
6152 log_info ("");
6153
6154 return (-1);
6155 }
6156
6157 if (kernel_loops < 1)
6158 {
6159 log_error ("ERROR: Invalid kernel-loops specified");
6160
6161 return (-1);
6162 }
6163
6164 if (kernel_loops > 1024)
6165 {
6166 log_error ("ERROR: Invalid kernel-loops specified");
6167
6168 return (-1);
6169 }
6170 }
6171
6172 if ((workload_profile < 1) || (workload_profile > 4))
6173 {
6174 log_error ("ERROR: workload-profile %i not available", workload_profile);
6175
6176 return (-1);
6177 }
6178
6179 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6180 {
6181 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6182
6183 return (-1);
6184 }
6185
6186 if (show == 1 || left == 1)
6187 {
6188 attack_mode = ATTACK_MODE_NONE;
6189
6190 if (remove == 1)
6191 {
6192 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6193
6194 return (-1);
6195 }
6196
6197 if (potfile_disable == 1)
6198 {
6199 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6200
6201 return (-1);
6202 }
6203 }
6204
6205 uint attack_kern = ATTACK_KERN_NONE;
6206
6207 switch (attack_mode)
6208 {
6209 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6210 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6211 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6212 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6213 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6214 }
6215
6216 if (benchmark == 0)
6217 {
6218 if (keyspace == 1)
6219 {
6220 int num_additional_params = 1;
6221
6222 if (attack_kern == ATTACK_KERN_COMBI)
6223 {
6224 num_additional_params = 2;
6225 }
6226
6227 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6228
6229 if (keyspace_wordlist_specified == 0) optind--;
6230 }
6231
6232 if (attack_kern == ATTACK_KERN_NONE)
6233 {
6234 if ((optind + 1) != myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6242 {
6243 if ((optind + 1) > myargc)
6244 {
6245 usage_mini_print (myargv[0]);
6246
6247 return (-1);
6248 }
6249 }
6250 else if (attack_kern == ATTACK_KERN_COMBI)
6251 {
6252 if ((optind + 3) != myargc)
6253 {
6254 usage_mini_print (myargv[0]);
6255
6256 return (-1);
6257 }
6258 }
6259 else if (attack_kern == ATTACK_KERN_BF)
6260 {
6261 if ((optind + 1) > myargc)
6262 {
6263 usage_mini_print (myargv[0]);
6264
6265 return (-1);
6266 }
6267 }
6268 else
6269 {
6270 usage_mini_print (myargv[0]);
6271
6272 return (-1);
6273 }
6274 }
6275 else
6276 {
6277 if (myargv[optind] != 0)
6278 {
6279 log_error ("ERROR: Invalid argument for benchmark mode specified");
6280
6281 return (-1);
6282 }
6283
6284 if (attack_mode_chgd == 1)
6285 {
6286 if (attack_mode != ATTACK_MODE_BF)
6287 {
6288 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6289
6290 return (-1);
6291 }
6292 }
6293 }
6294
6295 if (skip != 0 && limit != 0)
6296 {
6297 limit += skip;
6298 }
6299
6300 if (keyspace == 1)
6301 {
6302 if (show == 1)
6303 {
6304 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6305
6306 return (-1);
6307 }
6308 else if (left == 1)
6309 {
6310 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6311
6312 return (-1);
6313 }
6314
6315 potfile_disable = 1;
6316
6317 restore_disable = 1;
6318
6319 restore = 0;
6320
6321 weak_hash_threshold = 0;
6322
6323 quiet = 1;
6324 }
6325
6326 if (remove_timer_chgd == 1)
6327 {
6328 if (remove == 0)
6329 {
6330 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6331
6332 return (-1);
6333 }
6334
6335 if (remove_timer < 1)
6336 {
6337 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6338
6339 return (-1);
6340 }
6341 }
6342
6343 if (loopback == 1)
6344 {
6345 if (attack_mode == ATTACK_MODE_STRAIGHT)
6346 {
6347 if ((rp_files_cnt == 0) && (rp_gen == 0))
6348 {
6349 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6350
6351 return (-1);
6352 }
6353 }
6354 else
6355 {
6356 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6357
6358 return (-1);
6359 }
6360 }
6361
6362 if (debug_mode > 0)
6363 {
6364 if (attack_mode != ATTACK_MODE_STRAIGHT)
6365 {
6366 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6367
6368 return (-1);
6369 }
6370
6371 if ((rp_files_cnt == 0) && (rp_gen == 0))
6372 {
6373 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (debug_mode > 4)
6380 {
6381 log_error ("ERROR: Invalid debug-mode specified");
6382
6383 return (-1);
6384 }
6385
6386 if (debug_file != NULL)
6387 {
6388 if (debug_mode < 1)
6389 {
6390 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6391
6392 return (-1);
6393 }
6394 }
6395
6396 if (induction_dir != NULL)
6397 {
6398 if (attack_mode == ATTACK_MODE_BF)
6399 {
6400 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6401
6402 return (-1);
6403 }
6404 }
6405
6406 if (attack_mode != ATTACK_MODE_STRAIGHT)
6407 {
6408 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6409 {
6410 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6411
6412 return (-1);
6413 }
6414
6415 weak_hash_threshold = 0;
6416 }
6417
6418 /**
6419 * induction directory
6420 */
6421
6422 char *induction_directory = NULL;
6423
6424 if (attack_mode != ATTACK_MODE_BF)
6425 {
6426 if (induction_dir == NULL)
6427 {
6428 induction_directory = (char *) mymalloc (session_size);
6429
6430 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6431
6432 // create induction folder if it does not already exist
6433
6434 if (keyspace == 0)
6435 {
6436 if (rmdir (induction_directory) == -1)
6437 {
6438 if (errno == ENOENT)
6439 {
6440 // good, we can ignore
6441 }
6442 else if (errno == ENOTEMPTY)
6443 {
6444 char *induction_directory_mv = (char *) mymalloc (session_size);
6445
6446 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6447
6448 if (rename (induction_directory, induction_directory_mv) != 0)
6449 {
6450 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6451
6452 return (-1);
6453 }
6454 }
6455 else
6456 {
6457 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6458
6459 return (-1);
6460 }
6461 }
6462
6463 if (mkdir (induction_directory, 0700) == -1)
6464 {
6465 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6466
6467 return (-1);
6468 }
6469 }
6470 }
6471 else
6472 {
6473 induction_directory = induction_dir;
6474 }
6475 }
6476
6477 data.induction_directory = induction_directory;
6478
6479 /**
6480 * loopback
6481 */
6482
6483 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6484
6485 char *loopback_file = (char *) mymalloc (loopback_size);
6486
6487 /**
6488 * tuning db
6489 */
6490
6491 char tuning_db_file[256] = { 0 };
6492
6493 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6494
6495 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6496
6497 /**
6498 * outfile-check directory
6499 */
6500
6501 char *outfile_check_directory = NULL;
6502
6503 if (outfile_check_dir == NULL)
6504 {
6505 outfile_check_directory = (char *) mymalloc (session_size);
6506
6507 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6508 }
6509 else
6510 {
6511 outfile_check_directory = outfile_check_dir;
6512 }
6513
6514 data.outfile_check_directory = outfile_check_directory;
6515
6516 if (keyspace == 0)
6517 {
6518 struct stat outfile_check_stat;
6519
6520 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6521 {
6522 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6523
6524 if (is_dir == 0)
6525 {
6526 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6527
6528 return (-1);
6529 }
6530 }
6531 else if (outfile_check_dir == NULL)
6532 {
6533 if (mkdir (outfile_check_directory, 0700) == -1)
6534 {
6535 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6536
6537 return (-1);
6538 }
6539 }
6540 }
6541
6542 /**
6543 * special other stuff
6544 */
6545
6546 if (hash_mode == 9710)
6547 {
6548 outfile_format = 5;
6549 outfile_format_chgd = 1;
6550 }
6551
6552 if (hash_mode == 9810)
6553 {
6554 outfile_format = 5;
6555 outfile_format_chgd = 1;
6556 }
6557
6558 if (hash_mode == 10410)
6559 {
6560 outfile_format = 5;
6561 outfile_format_chgd = 1;
6562 }
6563
6564 /**
6565 * store stuff
6566 */
6567
6568 data.hash_mode = hash_mode;
6569 data.restore = restore;
6570 data.restore_timer = restore_timer;
6571 data.restore_disable = restore_disable;
6572 data.status = status;
6573 data.status_timer = status_timer;
6574 data.status_automat = status_automat;
6575 data.loopback = loopback;
6576 data.runtime = runtime;
6577 data.remove = remove;
6578 data.remove_timer = remove_timer;
6579 data.debug_mode = debug_mode;
6580 data.debug_file = debug_file;
6581 data.username = username;
6582 data.quiet = quiet;
6583 data.outfile = outfile;
6584 data.outfile_format = outfile_format;
6585 data.outfile_autohex = outfile_autohex;
6586 data.hex_charset = hex_charset;
6587 data.hex_salt = hex_salt;
6588 data.hex_wordlist = hex_wordlist;
6589 data.separator = separator;
6590 data.rp_files = rp_files;
6591 data.rp_files_cnt = rp_files_cnt;
6592 data.rp_gen = rp_gen;
6593 data.rp_gen_seed = rp_gen_seed;
6594 data.force = force;
6595 data.benchmark = benchmark;
6596 data.skip = skip;
6597 data.limit = limit;
6598 #ifdef HAVE_HWMON
6599 #ifdef HAVE_ADL
6600 data.powertune_enable = powertune_enable;
6601 #endif
6602 #endif
6603 data.logfile_disable = logfile_disable;
6604 data.truecrypt_keyfiles = truecrypt_keyfiles;
6605 data.veracrypt_keyfiles = veracrypt_keyfiles;
6606 data.veracrypt_pim = veracrypt_pim;
6607 data.scrypt_tmto = scrypt_tmto;
6608 data.workload_profile = workload_profile;
6609
6610 /**
6611 * cpu affinity
6612 */
6613
6614 if (cpu_affinity)
6615 {
6616 set_cpu_affinity (cpu_affinity);
6617 }
6618
6619 if (rp_gen_seed_chgd == 0)
6620 {
6621 srand (proc_start);
6622 }
6623 else
6624 {
6625 srand (rp_gen_seed);
6626 }
6627
6628 /**
6629 * logfile init
6630 */
6631
6632 if (logfile_disable == 0)
6633 {
6634 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6635
6636 char *logfile = (char *) mymalloc (logfile_size);
6637
6638 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6639
6640 data.logfile = logfile;
6641
6642 char *topid = logfile_generate_topid ();
6643
6644 data.topid = topid;
6645 }
6646
6647 // logfile_append() checks for logfile_disable internally to make it easier from here
6648
6649 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6650 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6651 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6652 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6653 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6654 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6655 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6656 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6657 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6658 #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));
6659
6660 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6661 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6662 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6663 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6664 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6665 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6666 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6667 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6668
6669 logfile_top_msg ("START");
6670
6671 logfile_top_uint (attack_mode);
6672 logfile_top_uint (attack_kern);
6673 logfile_top_uint (benchmark);
6674 logfile_top_uint (bitmap_min);
6675 logfile_top_uint (bitmap_max);
6676 logfile_top_uint (debug_mode);
6677 logfile_top_uint (force);
6678 logfile_top_uint (kernel_accel);
6679 logfile_top_uint (kernel_loops);
6680 logfile_top_uint (gpu_temp_disable);
6681 #ifdef HAVE_HWMON
6682 logfile_top_uint (gpu_temp_abort);
6683 logfile_top_uint (gpu_temp_retain);
6684 #endif
6685 logfile_top_uint (hash_mode);
6686 logfile_top_uint (hex_charset);
6687 logfile_top_uint (hex_salt);
6688 logfile_top_uint (hex_wordlist);
6689 logfile_top_uint (increment);
6690 logfile_top_uint (increment_max);
6691 logfile_top_uint (increment_min);
6692 logfile_top_uint (keyspace);
6693 logfile_top_uint (left);
6694 logfile_top_uint (logfile_disable);
6695 logfile_top_uint (loopback);
6696 logfile_top_uint (markov_classic);
6697 logfile_top_uint (markov_disable);
6698 logfile_top_uint (markov_threshold);
6699 logfile_top_uint (outfile_autohex);
6700 logfile_top_uint (outfile_check_timer);
6701 logfile_top_uint (outfile_format);
6702 logfile_top_uint (potfile_disable);
6703 logfile_top_string (potfile_path);
6704 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6705 logfile_top_uint (powertune_enable);
6706 #endif
6707 logfile_top_uint (scrypt_tmto);
6708 logfile_top_uint (quiet);
6709 logfile_top_uint (remove);
6710 logfile_top_uint (remove_timer);
6711 logfile_top_uint (restore);
6712 logfile_top_uint (restore_disable);
6713 logfile_top_uint (restore_timer);
6714 logfile_top_uint (rp_gen);
6715 logfile_top_uint (rp_gen_func_max);
6716 logfile_top_uint (rp_gen_func_min);
6717 logfile_top_uint (rp_gen_seed);
6718 logfile_top_uint (runtime);
6719 logfile_top_uint (segment_size);
6720 logfile_top_uint (show);
6721 logfile_top_uint (status);
6722 logfile_top_uint (status_automat);
6723 logfile_top_uint (status_timer);
6724 logfile_top_uint (usage);
6725 logfile_top_uint (username);
6726 logfile_top_uint (version);
6727 logfile_top_uint (weak_hash_threshold);
6728 logfile_top_uint (workload_profile);
6729 logfile_top_uint64 (limit);
6730 logfile_top_uint64 (skip);
6731 logfile_top_char (separator);
6732 logfile_top_string (cpu_affinity);
6733 logfile_top_string (custom_charset_1);
6734 logfile_top_string (custom_charset_2);
6735 logfile_top_string (custom_charset_3);
6736 logfile_top_string (custom_charset_4);
6737 logfile_top_string (debug_file);
6738 logfile_top_string (opencl_devices);
6739 logfile_top_string (opencl_platforms);
6740 logfile_top_string (opencl_device_types);
6741 logfile_top_uint (opencl_vector_width);
6742 logfile_top_string (induction_dir);
6743 logfile_top_string (markov_hcstat);
6744 logfile_top_string (outfile);
6745 logfile_top_string (outfile_check_dir);
6746 logfile_top_string (rule_buf_l);
6747 logfile_top_string (rule_buf_r);
6748 logfile_top_string (session);
6749 logfile_top_string (truecrypt_keyfiles);
6750 logfile_top_string (veracrypt_keyfiles);
6751 logfile_top_uint (veracrypt_pim);
6752
6753 /**
6754 * Init OpenCL library loader
6755 */
6756
6757 if (keyspace == 0)
6758 {
6759 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6760
6761 ocl_init (ocl);
6762
6763 data.ocl = ocl;
6764 }
6765
6766 /**
6767 * OpenCL platform selection
6768 */
6769
6770 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6771
6772 /**
6773 * OpenCL device selection
6774 */
6775
6776 u32 devices_filter = setup_devices_filter (opencl_devices);
6777
6778 /**
6779 * OpenCL device type selection
6780 */
6781
6782 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6783
6784 /**
6785 * benchmark
6786 */
6787
6788 if (benchmark == 1)
6789 {
6790 /**
6791 * disable useless stuff for benchmark
6792 */
6793
6794 status_timer = 0;
6795 restore_timer = 0;
6796 restore_disable = 1;
6797 potfile_disable = 1;
6798 weak_hash_threshold = 0;
6799 gpu_temp_disable = 1;
6800
6801 data.status_timer = status_timer;
6802 data.restore_timer = restore_timer;
6803 data.restore_disable = restore_disable;
6804
6805 /**
6806 * force attack mode to be bruteforce
6807 */
6808
6809 attack_mode = ATTACK_MODE_BF;
6810 attack_kern = ATTACK_KERN_BF;
6811
6812 if (workload_profile_chgd == 0)
6813 {
6814 workload_profile = 3;
6815
6816 data.workload_profile = workload_profile;
6817 }
6818 }
6819
6820 /**
6821 * config
6822 */
6823
6824 uint hash_type = 0;
6825 uint salt_type = 0;
6826 uint attack_exec = 0;
6827 uint opts_type = 0;
6828 uint kern_type = 0;
6829 uint dgst_size = 0;
6830 uint esalt_size = 0;
6831 uint opti_type = 0;
6832 uint dgst_pos0 = -1;
6833 uint dgst_pos1 = -1;
6834 uint dgst_pos2 = -1;
6835 uint dgst_pos3 = -1;
6836
6837 int (*parse_func) (char *, uint, hash_t *);
6838 int (*sort_by_digest) (const void *, const void *);
6839
6840 uint algorithm_pos = 0;
6841 uint algorithm_max = 1;
6842
6843 uint *algorithms = default_benchmark_algorithms;
6844
6845 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6846
6847 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6848 {
6849 /*
6850 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6851 * the following algos are skipped entirely
6852 */
6853
6854 if (algorithm_pos > 0)
6855 {
6856 local_free (rd);
6857
6858 rd = init_restore (argc, argv);
6859
6860 data.rd = rd;
6861 }
6862
6863 /**
6864 * update hash_mode in case of multihash benchmark
6865 */
6866
6867 if (benchmark == 1)
6868 {
6869 if (hash_mode_chgd == 0)
6870 {
6871 hash_mode = algorithms[algorithm_pos];
6872
6873 data.hash_mode = hash_mode;
6874 }
6875
6876 quiet = 1;
6877
6878 data.quiet = quiet;
6879 }
6880
6881 switch (hash_mode)
6882 {
6883 case 0: hash_type = HASH_TYPE_MD5;
6884 salt_type = SALT_TYPE_NONE;
6885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6886 opts_type = OPTS_TYPE_PT_GENERATE_LE
6887 | OPTS_TYPE_PT_ADD80
6888 | OPTS_TYPE_PT_ADDBITS14;
6889 kern_type = KERN_TYPE_MD5;
6890 dgst_size = DGST_SIZE_4_4;
6891 parse_func = md5_parse_hash;
6892 sort_by_digest = sort_by_digest_4_4;
6893 opti_type = OPTI_TYPE_ZERO_BYTE
6894 | OPTI_TYPE_PRECOMPUTE_INIT
6895 | OPTI_TYPE_PRECOMPUTE_MERKLE
6896 | OPTI_TYPE_MEET_IN_MIDDLE
6897 | OPTI_TYPE_EARLY_SKIP
6898 | OPTI_TYPE_NOT_ITERATED
6899 | OPTI_TYPE_NOT_SALTED
6900 | OPTI_TYPE_RAW_HASH;
6901 dgst_pos0 = 0;
6902 dgst_pos1 = 3;
6903 dgst_pos2 = 2;
6904 dgst_pos3 = 1;
6905 break;
6906
6907 case 10: hash_type = HASH_TYPE_MD5;
6908 salt_type = SALT_TYPE_INTERN;
6909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6910 opts_type = OPTS_TYPE_PT_GENERATE_LE
6911 | OPTS_TYPE_ST_ADD80
6912 | OPTS_TYPE_ST_ADDBITS14;
6913 kern_type = KERN_TYPE_MD5_PWSLT;
6914 dgst_size = DGST_SIZE_4_4;
6915 parse_func = md5s_parse_hash;
6916 sort_by_digest = sort_by_digest_4_4;
6917 opti_type = OPTI_TYPE_ZERO_BYTE
6918 | OPTI_TYPE_PRECOMPUTE_INIT
6919 | OPTI_TYPE_PRECOMPUTE_MERKLE
6920 | OPTI_TYPE_MEET_IN_MIDDLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_APPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 0;
6926 dgst_pos1 = 3;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 11: hash_type = HASH_TYPE_MD5;
6932 salt_type = SALT_TYPE_INTERN;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_LE
6935 | OPTS_TYPE_ST_ADD80
6936 | OPTS_TYPE_ST_ADDBITS14;
6937 kern_type = KERN_TYPE_MD5_PWSLT;
6938 dgst_size = DGST_SIZE_4_4;
6939 parse_func = joomla_parse_hash;
6940 sort_by_digest = sort_by_digest_4_4;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_MEET_IN_MIDDLE
6945 | OPTI_TYPE_EARLY_SKIP
6946 | OPTI_TYPE_NOT_ITERATED
6947 | OPTI_TYPE_APPENDED_SALT
6948 | OPTI_TYPE_RAW_HASH;
6949 dgst_pos0 = 0;
6950 dgst_pos1 = 3;
6951 dgst_pos2 = 2;
6952 dgst_pos3 = 1;
6953 break;
6954
6955 case 12: hash_type = HASH_TYPE_MD5;
6956 salt_type = SALT_TYPE_INTERN;
6957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6958 opts_type = OPTS_TYPE_PT_GENERATE_LE
6959 | OPTS_TYPE_ST_ADD80
6960 | OPTS_TYPE_ST_ADDBITS14;
6961 kern_type = KERN_TYPE_MD5_PWSLT;
6962 dgst_size = DGST_SIZE_4_4;
6963 parse_func = postgresql_parse_hash;
6964 sort_by_digest = sort_by_digest_4_4;
6965 opti_type = OPTI_TYPE_ZERO_BYTE
6966 | OPTI_TYPE_PRECOMPUTE_INIT
6967 | OPTI_TYPE_PRECOMPUTE_MERKLE
6968 | OPTI_TYPE_MEET_IN_MIDDLE
6969 | OPTI_TYPE_EARLY_SKIP
6970 | OPTI_TYPE_NOT_ITERATED
6971 | OPTI_TYPE_APPENDED_SALT
6972 | OPTI_TYPE_RAW_HASH;
6973 dgst_pos0 = 0;
6974 dgst_pos1 = 3;
6975 dgst_pos2 = 2;
6976 dgst_pos3 = 1;
6977 break;
6978
6979 case 20: hash_type = HASH_TYPE_MD5;
6980 salt_type = SALT_TYPE_INTERN;
6981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6982 opts_type = OPTS_TYPE_PT_GENERATE_LE
6983 | OPTS_TYPE_PT_ADD80
6984 | OPTS_TYPE_PT_ADDBITS14;
6985 kern_type = KERN_TYPE_MD5_SLTPW;
6986 dgst_size = DGST_SIZE_4_4;
6987 parse_func = md5s_parse_hash;
6988 sort_by_digest = sort_by_digest_4_4;
6989 opti_type = OPTI_TYPE_ZERO_BYTE
6990 | OPTI_TYPE_PRECOMPUTE_INIT
6991 | OPTI_TYPE_PRECOMPUTE_MERKLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_PREPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 0;
6997 dgst_pos1 = 3;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 21: hash_type = HASH_TYPE_MD5;
7003 salt_type = SALT_TYPE_INTERN;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_LE
7006 | OPTS_TYPE_PT_ADD80
7007 | OPTS_TYPE_PT_ADDBITS14;
7008 kern_type = KERN_TYPE_MD5_SLTPW;
7009 dgst_size = DGST_SIZE_4_4;
7010 parse_func = osc_parse_hash;
7011 sort_by_digest = sort_by_digest_4_4;
7012 opti_type = OPTI_TYPE_ZERO_BYTE
7013 | OPTI_TYPE_PRECOMPUTE_INIT
7014 | OPTI_TYPE_PRECOMPUTE_MERKLE
7015 | OPTI_TYPE_EARLY_SKIP
7016 | OPTI_TYPE_NOT_ITERATED
7017 | OPTI_TYPE_PREPENDED_SALT
7018 | OPTI_TYPE_RAW_HASH;
7019 dgst_pos0 = 0;
7020 dgst_pos1 = 3;
7021 dgst_pos2 = 2;
7022 dgst_pos3 = 1;
7023 break;
7024
7025 case 22: hash_type = HASH_TYPE_MD5;
7026 salt_type = SALT_TYPE_EMBEDDED;
7027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7028 opts_type = OPTS_TYPE_PT_GENERATE_LE
7029 | OPTS_TYPE_PT_ADD80
7030 | OPTS_TYPE_PT_ADDBITS14;
7031 kern_type = KERN_TYPE_MD5_SLTPW;
7032 dgst_size = DGST_SIZE_4_4;
7033 parse_func = netscreen_parse_hash;
7034 sort_by_digest = sort_by_digest_4_4;
7035 opti_type = OPTI_TYPE_ZERO_BYTE
7036 | OPTI_TYPE_PRECOMPUTE_INIT
7037 | OPTI_TYPE_PRECOMPUTE_MERKLE
7038 | OPTI_TYPE_EARLY_SKIP
7039 | OPTI_TYPE_NOT_ITERATED
7040 | OPTI_TYPE_PREPENDED_SALT
7041 | OPTI_TYPE_RAW_HASH;
7042 dgst_pos0 = 0;
7043 dgst_pos1 = 3;
7044 dgst_pos2 = 2;
7045 dgst_pos3 = 1;
7046 break;
7047
7048 case 23: hash_type = HASH_TYPE_MD5;
7049 salt_type = SALT_TYPE_EMBEDDED;
7050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7051 opts_type = OPTS_TYPE_PT_GENERATE_LE
7052 | OPTS_TYPE_PT_ADD80
7053 | OPTS_TYPE_PT_ADDBITS14;
7054 kern_type = KERN_TYPE_MD5_SLTPW;
7055 dgst_size = DGST_SIZE_4_4;
7056 parse_func = skype_parse_hash;
7057 sort_by_digest = sort_by_digest_4_4;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_PRECOMPUTE_INIT
7060 | OPTI_TYPE_PRECOMPUTE_MERKLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_PREPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 30: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_PT_UNICODE
7076 | OPTS_TYPE_ST_ADD80
7077 | OPTS_TYPE_ST_ADDBITS14;
7078 kern_type = KERN_TYPE_MD5_PWUSLT;
7079 dgst_size = DGST_SIZE_4_4;
7080 parse_func = md5s_parse_hash;
7081 sort_by_digest = sort_by_digest_4_4;
7082 opti_type = OPTI_TYPE_ZERO_BYTE
7083 | OPTI_TYPE_PRECOMPUTE_INIT
7084 | OPTI_TYPE_PRECOMPUTE_MERKLE
7085 | OPTI_TYPE_MEET_IN_MIDDLE
7086 | OPTI_TYPE_EARLY_SKIP
7087 | OPTI_TYPE_NOT_ITERATED
7088 | OPTI_TYPE_APPENDED_SALT
7089 | OPTI_TYPE_RAW_HASH;
7090 dgst_pos0 = 0;
7091 dgst_pos1 = 3;
7092 dgst_pos2 = 2;
7093 dgst_pos3 = 1;
7094 break;
7095
7096 case 40: hash_type = HASH_TYPE_MD5;
7097 salt_type = SALT_TYPE_INTERN;
7098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7099 opts_type = OPTS_TYPE_PT_GENERATE_LE
7100 | OPTS_TYPE_PT_ADD80
7101 | OPTS_TYPE_PT_ADDBITS14
7102 | OPTS_TYPE_PT_UNICODE;
7103 kern_type = KERN_TYPE_MD5_SLTPWU;
7104 dgst_size = DGST_SIZE_4_4;
7105 parse_func = md5s_parse_hash;
7106 sort_by_digest = sort_by_digest_4_4;
7107 opti_type = OPTI_TYPE_ZERO_BYTE
7108 | OPTI_TYPE_PRECOMPUTE_INIT
7109 | OPTI_TYPE_PRECOMPUTE_MERKLE
7110 | OPTI_TYPE_EARLY_SKIP
7111 | OPTI_TYPE_NOT_ITERATED
7112 | OPTI_TYPE_PREPENDED_SALT
7113 | OPTI_TYPE_RAW_HASH;
7114 dgst_pos0 = 0;
7115 dgst_pos1 = 3;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 50: hash_type = HASH_TYPE_MD5;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_LE
7124 | OPTS_TYPE_ST_ADD80
7125 | OPTS_TYPE_ST_ADDBITS14;
7126 kern_type = KERN_TYPE_HMACMD5_PW;
7127 dgst_size = DGST_SIZE_4_4;
7128 parse_func = hmacmd5_parse_hash;
7129 sort_by_digest = sort_by_digest_4_4;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_NOT_ITERATED;
7132 dgst_pos0 = 0;
7133 dgst_pos1 = 3;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 60: hash_type = HASH_TYPE_MD5;
7139 salt_type = SALT_TYPE_INTERN;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_LE
7142 | OPTS_TYPE_PT_ADD80
7143 | OPTS_TYPE_PT_ADDBITS14;
7144 kern_type = KERN_TYPE_HMACMD5_SLT;
7145 dgst_size = DGST_SIZE_4_4;
7146 parse_func = hmacmd5_parse_hash;
7147 sort_by_digest = sort_by_digest_4_4;
7148 opti_type = OPTI_TYPE_ZERO_BYTE
7149 | OPTI_TYPE_NOT_ITERATED;
7150 dgst_pos0 = 0;
7151 dgst_pos1 = 3;
7152 dgst_pos2 = 2;
7153 dgst_pos3 = 1;
7154 break;
7155
7156 case 100: hash_type = HASH_TYPE_SHA1;
7157 salt_type = SALT_TYPE_NONE;
7158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7159 opts_type = OPTS_TYPE_PT_GENERATE_BE
7160 | OPTS_TYPE_PT_ADD80
7161 | OPTS_TYPE_PT_ADDBITS15;
7162 kern_type = KERN_TYPE_SHA1;
7163 dgst_size = DGST_SIZE_4_5;
7164 parse_func = sha1_parse_hash;
7165 sort_by_digest = sort_by_digest_4_5;
7166 opti_type = OPTI_TYPE_ZERO_BYTE
7167 | OPTI_TYPE_PRECOMPUTE_INIT
7168 | OPTI_TYPE_PRECOMPUTE_MERKLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_NOT_SALTED
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 101: hash_type = HASH_TYPE_SHA1;
7180 salt_type = SALT_TYPE_NONE;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_BE
7183 | OPTS_TYPE_PT_ADD80
7184 | OPTS_TYPE_PT_ADDBITS15;
7185 kern_type = KERN_TYPE_SHA1;
7186 dgst_size = DGST_SIZE_4_5;
7187 parse_func = sha1b64_parse_hash;
7188 sort_by_digest = sort_by_digest_4_5;
7189 opti_type = OPTI_TYPE_ZERO_BYTE
7190 | OPTI_TYPE_PRECOMPUTE_INIT
7191 | OPTI_TYPE_PRECOMPUTE_MERKLE
7192 | OPTI_TYPE_EARLY_SKIP
7193 | OPTI_TYPE_NOT_ITERATED
7194 | OPTI_TYPE_NOT_SALTED
7195 | OPTI_TYPE_RAW_HASH;
7196 dgst_pos0 = 3;
7197 dgst_pos1 = 4;
7198 dgst_pos2 = 2;
7199 dgst_pos3 = 1;
7200 break;
7201
7202 case 110: hash_type = HASH_TYPE_SHA1;
7203 salt_type = SALT_TYPE_INTERN;
7204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7205 opts_type = OPTS_TYPE_PT_GENERATE_BE
7206 | OPTS_TYPE_ST_ADD80
7207 | OPTS_TYPE_ST_ADDBITS15;
7208 kern_type = KERN_TYPE_SHA1_PWSLT;
7209 dgst_size = DGST_SIZE_4_5;
7210 parse_func = sha1s_parse_hash;
7211 sort_by_digest = sort_by_digest_4_5;
7212 opti_type = OPTI_TYPE_ZERO_BYTE
7213 | OPTI_TYPE_PRECOMPUTE_INIT
7214 | OPTI_TYPE_PRECOMPUTE_MERKLE
7215 | OPTI_TYPE_EARLY_SKIP
7216 | OPTI_TYPE_NOT_ITERATED
7217 | OPTI_TYPE_APPENDED_SALT
7218 | OPTI_TYPE_RAW_HASH;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 111: hash_type = HASH_TYPE_SHA1;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_BE
7229 | OPTS_TYPE_ST_ADD80
7230 | OPTS_TYPE_ST_ADDBITS15;
7231 kern_type = KERN_TYPE_SHA1_PWSLT;
7232 dgst_size = DGST_SIZE_4_5;
7233 parse_func = sha1b64s_parse_hash;
7234 sort_by_digest = sort_by_digest_4_5;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_EARLY_SKIP
7239 | OPTI_TYPE_NOT_ITERATED
7240 | OPTI_TYPE_APPENDED_SALT
7241 | OPTI_TYPE_RAW_HASH;
7242 dgst_pos0 = 3;
7243 dgst_pos1 = 4;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 112: hash_type = HASH_TYPE_SHA1;
7249 salt_type = SALT_TYPE_INTERN;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_BE
7252 | OPTS_TYPE_ST_ADD80
7253 | OPTS_TYPE_ST_ADDBITS15
7254 | OPTS_TYPE_ST_HEX;
7255 kern_type = KERN_TYPE_SHA1_PWSLT;
7256 dgst_size = DGST_SIZE_4_5;
7257 parse_func = oracles_parse_hash;
7258 sort_by_digest = sort_by_digest_4_5;
7259 opti_type = OPTI_TYPE_ZERO_BYTE
7260 | OPTI_TYPE_PRECOMPUTE_INIT
7261 | OPTI_TYPE_PRECOMPUTE_MERKLE
7262 | OPTI_TYPE_EARLY_SKIP
7263 | OPTI_TYPE_NOT_ITERATED
7264 | OPTI_TYPE_APPENDED_SALT
7265 | OPTI_TYPE_RAW_HASH;
7266 dgst_pos0 = 3;
7267 dgst_pos1 = 4;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 120: hash_type = HASH_TYPE_SHA1;
7273 salt_type = SALT_TYPE_INTERN;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_BE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS15;
7278 kern_type = KERN_TYPE_SHA1_SLTPW;
7279 dgst_size = DGST_SIZE_4_5;
7280 parse_func = sha1s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_5;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 3;
7290 dgst_pos1 = 4;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 121: hash_type = HASH_TYPE_SHA1;
7296 salt_type = SALT_TYPE_INTERN;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_BE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS15
7301 | OPTS_TYPE_ST_LOWER;
7302 kern_type = KERN_TYPE_SHA1_SLTPW;
7303 dgst_size = DGST_SIZE_4_5;
7304 parse_func = smf_parse_hash;
7305 sort_by_digest = sort_by_digest_4_5;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_EARLY_SKIP
7310 | OPTI_TYPE_NOT_ITERATED
7311 | OPTI_TYPE_PREPENDED_SALT
7312 | OPTI_TYPE_RAW_HASH;
7313 dgst_pos0 = 3;
7314 dgst_pos1 = 4;
7315 dgst_pos2 = 2;
7316 dgst_pos3 = 1;
7317 break;
7318
7319 case 122: hash_type = HASH_TYPE_SHA1;
7320 salt_type = SALT_TYPE_EMBEDDED;
7321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7322 opts_type = OPTS_TYPE_PT_GENERATE_BE
7323 | OPTS_TYPE_PT_ADD80
7324 | OPTS_TYPE_PT_ADDBITS15
7325 | OPTS_TYPE_ST_HEX;
7326 kern_type = KERN_TYPE_SHA1_SLTPW;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = osx1_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_PRECOMPUTE_INIT
7332 | OPTI_TYPE_PRECOMPUTE_MERKLE
7333 | OPTI_TYPE_EARLY_SKIP
7334 | OPTI_TYPE_NOT_ITERATED
7335 | OPTI_TYPE_PREPENDED_SALT
7336 | OPTI_TYPE_RAW_HASH;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 4;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 1;
7341 break;
7342
7343 case 124: hash_type = HASH_TYPE_SHA1;
7344 salt_type = SALT_TYPE_EMBEDDED;
7345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_ADD80
7348 | OPTS_TYPE_PT_ADDBITS15;
7349 kern_type = KERN_TYPE_SHA1_SLTPW;
7350 dgst_size = DGST_SIZE_4_5;
7351 parse_func = djangosha1_parse_hash;
7352 sort_by_digest = sort_by_digest_4_5;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED
7358 | OPTI_TYPE_PREPENDED_SALT
7359 | OPTI_TYPE_RAW_HASH;
7360 dgst_pos0 = 3;
7361 dgst_pos1 = 4;
7362 dgst_pos2 = 2;
7363 dgst_pos3 = 1;
7364 break;
7365
7366 case 125: hash_type = HASH_TYPE_SHA1;
7367 salt_type = SALT_TYPE_EMBEDDED;
7368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7369 opts_type = OPTS_TYPE_PT_GENERATE_BE
7370 | OPTS_TYPE_PT_ADD80
7371 | OPTS_TYPE_PT_ADDBITS15
7372 | OPTS_TYPE_ST_HEX;
7373 kern_type = KERN_TYPE_SHA1_SLTPW;
7374 dgst_size = DGST_SIZE_4_5;
7375 parse_func = arubaos_parse_hash;
7376 sort_by_digest = sort_by_digest_4_5;
7377 opti_type = OPTI_TYPE_ZERO_BYTE
7378 | OPTI_TYPE_PRECOMPUTE_INIT
7379 | OPTI_TYPE_PRECOMPUTE_MERKLE
7380 | OPTI_TYPE_EARLY_SKIP
7381 | OPTI_TYPE_NOT_ITERATED
7382 | OPTI_TYPE_PREPENDED_SALT
7383 | OPTI_TYPE_RAW_HASH;
7384 dgst_pos0 = 3;
7385 dgst_pos1 = 4;
7386 dgst_pos2 = 2;
7387 dgst_pos3 = 1;
7388 break;
7389
7390 case 130: hash_type = HASH_TYPE_SHA1;
7391 salt_type = SALT_TYPE_INTERN;
7392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7393 opts_type = OPTS_TYPE_PT_GENERATE_BE
7394 | OPTS_TYPE_PT_UNICODE
7395 | OPTS_TYPE_ST_ADD80
7396 | OPTS_TYPE_ST_ADDBITS15;
7397 kern_type = KERN_TYPE_SHA1_PWUSLT;
7398 dgst_size = DGST_SIZE_4_5;
7399 parse_func = sha1s_parse_hash;
7400 sort_by_digest = sort_by_digest_4_5;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_APPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 4;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 1;
7412 break;
7413
7414 case 131: hash_type = HASH_TYPE_SHA1;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_PT_UNICODE
7419 | OPTS_TYPE_PT_UPPER
7420 | OPTS_TYPE_ST_ADD80
7421 | OPTS_TYPE_ST_ADDBITS15
7422 | OPTS_TYPE_ST_HEX;
7423 kern_type = KERN_TYPE_SHA1_PWUSLT;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = mssql2000_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_APPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 132: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_EMBEDDED;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_UNICODE
7445 | OPTS_TYPE_ST_ADD80
7446 | OPTS_TYPE_ST_ADDBITS15
7447 | OPTS_TYPE_ST_HEX;
7448 kern_type = KERN_TYPE_SHA1_PWUSLT;
7449 dgst_size = DGST_SIZE_4_5;
7450 parse_func = mssql2005_parse_hash;
7451 sort_by_digest = sort_by_digest_4_5;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_EARLY_SKIP
7456 | OPTI_TYPE_NOT_ITERATED
7457 | OPTI_TYPE_APPENDED_SALT
7458 | OPTI_TYPE_RAW_HASH;
7459 dgst_pos0 = 3;
7460 dgst_pos1 = 4;
7461 dgst_pos2 = 2;
7462 dgst_pos3 = 1;
7463 break;
7464
7465 case 133: hash_type = HASH_TYPE_SHA1;
7466 salt_type = SALT_TYPE_EMBEDDED;
7467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7468 opts_type = OPTS_TYPE_PT_GENERATE_BE
7469 | OPTS_TYPE_PT_UNICODE
7470 | OPTS_TYPE_ST_ADD80
7471 | OPTS_TYPE_ST_ADDBITS15;
7472 kern_type = KERN_TYPE_SHA1_PWUSLT;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = peoplesoft_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_APPENDED_SALT
7482 | OPTI_TYPE_RAW_HASH;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 4;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 1;
7487 break;
7488
7489 case 140: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_INTERN;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS15
7495 | OPTS_TYPE_PT_UNICODE;
7496 kern_type = KERN_TYPE_SHA1_SLTPWU;
7497 dgst_size = DGST_SIZE_4_5;
7498 parse_func = sha1s_parse_hash;
7499 sort_by_digest = sort_by_digest_4_5;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_PREPENDED_SALT
7506 | OPTI_TYPE_RAW_HASH;
7507 dgst_pos0 = 3;
7508 dgst_pos1 = 4;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 141: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_EMBEDDED;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15
7519 | OPTS_TYPE_PT_UNICODE
7520 | OPTS_TYPE_ST_BASE64;
7521 kern_type = KERN_TYPE_SHA1_SLTPWU;
7522 dgst_size = DGST_SIZE_4_5;
7523 parse_func = episerver_parse_hash;
7524 sort_by_digest = sort_by_digest_4_5;
7525 opti_type = OPTI_TYPE_ZERO_BYTE
7526 | OPTI_TYPE_PRECOMPUTE_INIT
7527 | OPTI_TYPE_PRECOMPUTE_MERKLE
7528 | OPTI_TYPE_EARLY_SKIP
7529 | OPTI_TYPE_NOT_ITERATED
7530 | OPTI_TYPE_PREPENDED_SALT
7531 | OPTI_TYPE_RAW_HASH;
7532 dgst_pos0 = 3;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 150: hash_type = HASH_TYPE_SHA1;
7539 salt_type = SALT_TYPE_INTERN;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_BE
7542 | OPTS_TYPE_ST_ADD80
7543 | OPTS_TYPE_ST_ADDBITS15;
7544 kern_type = KERN_TYPE_HMACSHA1_PW;
7545 dgst_size = DGST_SIZE_4_5;
7546 parse_func = hmacsha1_parse_hash;
7547 sort_by_digest = sort_by_digest_4_5;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_NOT_ITERATED;
7550 dgst_pos0 = 3;
7551 dgst_pos1 = 4;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 160: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_INTERN;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_HMACSHA1_SLT;
7563 dgst_size = DGST_SIZE_4_5;
7564 parse_func = hmacsha1_parse_hash;
7565 sort_by_digest = sort_by_digest_4_5;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_NOT_ITERATED;
7568 dgst_pos0 = 3;
7569 dgst_pos1 = 4;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 190: hash_type = HASH_TYPE_SHA1;
7575 salt_type = SALT_TYPE_NONE;
7576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7577 opts_type = OPTS_TYPE_PT_GENERATE_BE
7578 | OPTS_TYPE_PT_ADD80
7579 | OPTS_TYPE_PT_ADDBITS15;
7580 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7581 dgst_size = DGST_SIZE_4_5;
7582 parse_func = sha1linkedin_parse_hash;
7583 sort_by_digest = sort_by_digest_4_5;
7584 opti_type = OPTI_TYPE_ZERO_BYTE
7585 | OPTI_TYPE_PRECOMPUTE_INIT
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_NOT_SALTED;
7589 dgst_pos0 = 0;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 3;
7592 dgst_pos3 = 2;
7593 break;
7594
7595 case 200: hash_type = HASH_TYPE_MYSQL;
7596 salt_type = SALT_TYPE_NONE;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = 0;
7599 kern_type = KERN_TYPE_MYSQL;
7600 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7601 parse_func = mysql323_parse_hash;
7602 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7603 opti_type = OPTI_TYPE_ZERO_BYTE;
7604 dgst_pos0 = 0;
7605 dgst_pos1 = 1;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 3;
7608 break;
7609
7610 case 300: hash_type = HASH_TYPE_SHA1;
7611 salt_type = SALT_TYPE_NONE;
7612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_BE
7614 | OPTS_TYPE_PT_ADD80
7615 | OPTS_TYPE_PT_ADDBITS15;
7616 kern_type = KERN_TYPE_MYSQL41;
7617 dgst_size = DGST_SIZE_4_5;
7618 parse_func = sha1_parse_hash;
7619 sort_by_digest = sort_by_digest_4_5;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_NOT_SALTED;
7626 dgst_pos0 = 3;
7627 dgst_pos1 = 4;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 1;
7630 break;
7631
7632 case 400: hash_type = HASH_TYPE_MD5;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7636 kern_type = KERN_TYPE_PHPASS;
7637 dgst_size = DGST_SIZE_4_4;
7638 parse_func = phpass_parse_hash;
7639 sort_by_digest = sort_by_digest_4_4;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_SLOW_HASH_SIMD;
7642 dgst_pos0 = 0;
7643 dgst_pos1 = 1;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 3;
7646 break;
7647
7648 case 500: hash_type = HASH_TYPE_MD5;
7649 salt_type = SALT_TYPE_EMBEDDED;
7650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7652 kern_type = KERN_TYPE_MD5CRYPT;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = md5crypt_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 1;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 3;
7661 break;
7662
7663 case 501: hash_type = HASH_TYPE_MD5;
7664 salt_type = SALT_TYPE_EMBEDDED;
7665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_LE
7667 | OPTS_TYPE_HASH_COPY;
7668 kern_type = KERN_TYPE_MD5CRYPT;
7669 dgst_size = DGST_SIZE_4_4;
7670 parse_func = juniper_parse_hash;
7671 sort_by_digest = sort_by_digest_4_4;
7672 opti_type = OPTI_TYPE_ZERO_BYTE;
7673 dgst_pos0 = 0;
7674 dgst_pos1 = 1;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 3;
7677 break;
7678
7679 case 900: hash_type = HASH_TYPE_MD4;
7680 salt_type = SALT_TYPE_NONE;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_LE
7683 | OPTS_TYPE_PT_ADD80
7684 | OPTS_TYPE_PT_ADDBITS14;
7685 kern_type = KERN_TYPE_MD4;
7686 dgst_size = DGST_SIZE_4_4;
7687 parse_func = md4_parse_hash;
7688 sort_by_digest = sort_by_digest_4_4;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_MEET_IN_MIDDLE
7693 | OPTI_TYPE_EARLY_SKIP
7694 | OPTI_TYPE_NOT_ITERATED
7695 | OPTI_TYPE_NOT_SALTED
7696 | OPTI_TYPE_RAW_HASH;
7697 dgst_pos0 = 0;
7698 dgst_pos1 = 3;
7699 dgst_pos2 = 2;
7700 dgst_pos3 = 1;
7701 break;
7702
7703 case 1000: hash_type = HASH_TYPE_MD4;
7704 salt_type = SALT_TYPE_NONE;
7705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7706 opts_type = OPTS_TYPE_PT_GENERATE_LE
7707 | OPTS_TYPE_PT_ADD80
7708 | OPTS_TYPE_PT_ADDBITS14
7709 | OPTS_TYPE_PT_UNICODE;
7710 kern_type = KERN_TYPE_MD4_PWU;
7711 dgst_size = DGST_SIZE_4_4;
7712 parse_func = md4_parse_hash;
7713 sort_by_digest = sort_by_digest_4_4;
7714 opti_type = OPTI_TYPE_ZERO_BYTE
7715 | OPTI_TYPE_PRECOMPUTE_INIT
7716 | OPTI_TYPE_PRECOMPUTE_MERKLE
7717 | OPTI_TYPE_MEET_IN_MIDDLE
7718 | OPTI_TYPE_EARLY_SKIP
7719 | OPTI_TYPE_NOT_ITERATED
7720 | OPTI_TYPE_NOT_SALTED
7721 | OPTI_TYPE_RAW_HASH;
7722 dgst_pos0 = 0;
7723 dgst_pos1 = 3;
7724 dgst_pos2 = 2;
7725 dgst_pos3 = 1;
7726 break;
7727
7728 case 1100: hash_type = HASH_TYPE_MD4;
7729 salt_type = SALT_TYPE_INTERN;
7730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7731 opts_type = OPTS_TYPE_PT_GENERATE_LE
7732 | OPTS_TYPE_PT_ADD80
7733 | OPTS_TYPE_PT_ADDBITS14
7734 | OPTS_TYPE_PT_UNICODE
7735 | OPTS_TYPE_ST_ADD80
7736 | OPTS_TYPE_ST_UNICODE
7737 | OPTS_TYPE_ST_LOWER;
7738 kern_type = KERN_TYPE_MD44_PWUSLT;
7739 dgst_size = DGST_SIZE_4_4;
7740 parse_func = dcc_parse_hash;
7741 sort_by_digest = sort_by_digest_4_4;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED;
7747 dgst_pos0 = 0;
7748 dgst_pos1 = 3;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 1;
7751 break;
7752
7753 case 1400: hash_type = HASH_TYPE_SHA256;
7754 salt_type = SALT_TYPE_NONE;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_PT_ADD80
7758 | OPTS_TYPE_PT_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA256;
7760 dgst_size = DGST_SIZE_4_8;
7761 parse_func = sha256_parse_hash;
7762 sort_by_digest = sort_by_digest_4_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_NOT_SALTED
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 7;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 6;
7774 break;
7775
7776 case 1410: hash_type = HASH_TYPE_SHA256;
7777 salt_type = SALT_TYPE_INTERN;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_ST_ADD80
7781 | OPTS_TYPE_ST_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA256_PWSLT;
7783 dgst_size = DGST_SIZE_4_8;
7784 parse_func = sha256s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_8;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_APPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 7;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 6;
7797 break;
7798
7799 case 1420: hash_type = HASH_TYPE_SHA256;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_PT_ADD80
7804 | OPTS_TYPE_PT_ADDBITS15;
7805 kern_type = KERN_TYPE_SHA256_SLTPW;
7806 dgst_size = DGST_SIZE_4_8;
7807 parse_func = sha256s_parse_hash;
7808 sort_by_digest = sort_by_digest_4_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED
7814 | OPTI_TYPE_PREPENDED_SALT
7815 | OPTI_TYPE_RAW_HASH;
7816 dgst_pos0 = 3;
7817 dgst_pos1 = 7;
7818 dgst_pos2 = 2;
7819 dgst_pos3 = 6;
7820 break;
7821
7822 case 1421: hash_type = HASH_TYPE_SHA256;
7823 salt_type = SALT_TYPE_EMBEDDED;
7824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7825 opts_type = OPTS_TYPE_PT_GENERATE_BE
7826 | OPTS_TYPE_PT_ADD80
7827 | OPTS_TYPE_PT_ADDBITS15;
7828 kern_type = KERN_TYPE_SHA256_SLTPW;
7829 dgst_size = DGST_SIZE_4_8;
7830 parse_func = hmailserver_parse_hash;
7831 sort_by_digest = sort_by_digest_4_8;
7832 opti_type = OPTI_TYPE_ZERO_BYTE
7833 | OPTI_TYPE_PRECOMPUTE_INIT
7834 | OPTI_TYPE_PRECOMPUTE_MERKLE
7835 | OPTI_TYPE_EARLY_SKIP
7836 | OPTI_TYPE_NOT_ITERATED
7837 | OPTI_TYPE_PREPENDED_SALT
7838 | OPTI_TYPE_RAW_HASH;
7839 dgst_pos0 = 3;
7840 dgst_pos1 = 7;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 6;
7843 break;
7844
7845 case 1430: hash_type = HASH_TYPE_SHA256;
7846 salt_type = SALT_TYPE_INTERN;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_UNICODE
7850 | OPTS_TYPE_ST_ADD80
7851 | OPTS_TYPE_ST_ADDBITS15;
7852 kern_type = KERN_TYPE_SHA256_PWUSLT;
7853 dgst_size = DGST_SIZE_4_8;
7854 parse_func = sha256s_parse_hash;
7855 sort_by_digest = sort_by_digest_4_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_APPENDED_SALT
7862 | OPTI_TYPE_RAW_HASH;
7863 dgst_pos0 = 3;
7864 dgst_pos1 = 7;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 6;
7867 break;
7868
7869 case 1440: hash_type = HASH_TYPE_SHA256;
7870 salt_type = SALT_TYPE_INTERN;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_BE
7873 | OPTS_TYPE_PT_ADD80
7874 | OPTS_TYPE_PT_ADDBITS15
7875 | OPTS_TYPE_PT_UNICODE;
7876 kern_type = KERN_TYPE_SHA256_SLTPWU;
7877 dgst_size = DGST_SIZE_4_8;
7878 parse_func = sha256s_parse_hash;
7879 sort_by_digest = sort_by_digest_4_8;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_PRECOMPUTE_INIT
7882 | OPTI_TYPE_PRECOMPUTE_MERKLE
7883 | OPTI_TYPE_EARLY_SKIP
7884 | OPTI_TYPE_NOT_ITERATED
7885 | OPTI_TYPE_PREPENDED_SALT
7886 | OPTI_TYPE_RAW_HASH;
7887 dgst_pos0 = 3;
7888 dgst_pos1 = 7;
7889 dgst_pos2 = 2;
7890 dgst_pos3 = 6;
7891 break;
7892
7893 case 1441: hash_type = HASH_TYPE_SHA256;
7894 salt_type = SALT_TYPE_EMBEDDED;
7895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7896 opts_type = OPTS_TYPE_PT_GENERATE_BE
7897 | OPTS_TYPE_PT_ADD80
7898 | OPTS_TYPE_PT_ADDBITS15
7899 | OPTS_TYPE_PT_UNICODE
7900 | OPTS_TYPE_ST_BASE64;
7901 kern_type = KERN_TYPE_SHA256_SLTPWU;
7902 dgst_size = DGST_SIZE_4_8;
7903 parse_func = episerver4_parse_hash;
7904 sort_by_digest = sort_by_digest_4_8;
7905 opti_type = OPTI_TYPE_ZERO_BYTE
7906 | OPTI_TYPE_PRECOMPUTE_INIT
7907 | OPTI_TYPE_PRECOMPUTE_MERKLE
7908 | OPTI_TYPE_EARLY_SKIP
7909 | OPTI_TYPE_NOT_ITERATED
7910 | OPTI_TYPE_PREPENDED_SALT
7911 | OPTI_TYPE_RAW_HASH;
7912 dgst_pos0 = 3;
7913 dgst_pos1 = 7;
7914 dgst_pos2 = 2;
7915 dgst_pos3 = 6;
7916 break;
7917
7918 case 1450: hash_type = HASH_TYPE_SHA256;
7919 salt_type = SALT_TYPE_INTERN;
7920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7921 opts_type = OPTS_TYPE_PT_GENERATE_BE
7922 | OPTS_TYPE_ST_ADD80;
7923 kern_type = KERN_TYPE_HMACSHA256_PW;
7924 dgst_size = DGST_SIZE_4_8;
7925 parse_func = hmacsha256_parse_hash;
7926 sort_by_digest = sort_by_digest_4_8;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_NOT_ITERATED;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 7;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 6;
7933 break;
7934
7935 case 1460: hash_type = HASH_TYPE_SHA256;
7936 salt_type = SALT_TYPE_INTERN;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_ADD80
7940 | OPTS_TYPE_PT_ADDBITS15;
7941 kern_type = KERN_TYPE_HMACSHA256_SLT;
7942 dgst_size = DGST_SIZE_4_8;
7943 parse_func = hmacsha256_parse_hash;
7944 sort_by_digest = sort_by_digest_4_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_NOT_ITERATED;
7947 dgst_pos0 = 3;
7948 dgst_pos1 = 7;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 6;
7951 break;
7952
7953 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7954 salt_type = SALT_TYPE_EMBEDDED;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_LE
7957 | OPTS_TYPE_PT_BITSLICE;
7958 kern_type = KERN_TYPE_DESCRYPT;
7959 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7960 parse_func = descrypt_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7964 dgst_pos0 = 0;
7965 dgst_pos1 = 1;
7966 dgst_pos2 = 2;
7967 dgst_pos3 = 3;
7968 break;
7969
7970 case 1600: hash_type = HASH_TYPE_MD5;
7971 salt_type = SALT_TYPE_EMBEDDED;
7972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7974 kern_type = KERN_TYPE_APR1CRYPT;
7975 dgst_size = DGST_SIZE_4_4;
7976 parse_func = md5apr1_parse_hash;
7977 sort_by_digest = sort_by_digest_4_4;
7978 opti_type = OPTI_TYPE_ZERO_BYTE;
7979 dgst_pos0 = 0;
7980 dgst_pos1 = 1;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 3;
7983 break;
7984
7985 case 1700: hash_type = HASH_TYPE_SHA512;
7986 salt_type = SALT_TYPE_NONE;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_PT_ADD80
7990 | OPTS_TYPE_PT_ADDBITS15;
7991 kern_type = KERN_TYPE_SHA512;
7992 dgst_size = DGST_SIZE_8_8;
7993 parse_func = sha512_parse_hash;
7994 sort_by_digest = sort_by_digest_8_8;
7995 opti_type = OPTI_TYPE_ZERO_BYTE
7996 | OPTI_TYPE_PRECOMPUTE_INIT
7997 | OPTI_TYPE_PRECOMPUTE_MERKLE
7998 | OPTI_TYPE_EARLY_SKIP
7999 | OPTI_TYPE_NOT_ITERATED
8000 | OPTI_TYPE_NOT_SALTED
8001 | OPTI_TYPE_USES_BITS_64
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 14;
8004 dgst_pos1 = 15;
8005 dgst_pos2 = 6;
8006 dgst_pos3 = 7;
8007 break;
8008
8009 case 1710: hash_type = HASH_TYPE_SHA512;
8010 salt_type = SALT_TYPE_INTERN;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_ST_ADD80
8014 | OPTS_TYPE_ST_ADDBITS15;
8015 kern_type = KERN_TYPE_SHA512_PWSLT;
8016 dgst_size = DGST_SIZE_8_8;
8017 parse_func = sha512s_parse_hash;
8018 sort_by_digest = sort_by_digest_8_8;
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_PRECOMPUTE_INIT
8021 | OPTI_TYPE_PRECOMPUTE_MERKLE
8022 | OPTI_TYPE_EARLY_SKIP
8023 | OPTI_TYPE_NOT_ITERATED
8024 | OPTI_TYPE_APPENDED_SALT
8025 | OPTI_TYPE_USES_BITS_64
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 14;
8028 dgst_pos1 = 15;
8029 dgst_pos2 = 6;
8030 dgst_pos3 = 7;
8031 break;
8032
8033 case 1711: hash_type = HASH_TYPE_SHA512;
8034 salt_type = SALT_TYPE_EMBEDDED;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_ST_ADD80
8038 | OPTS_TYPE_ST_ADDBITS15;
8039 kern_type = KERN_TYPE_SHA512_PWSLT;
8040 dgst_size = DGST_SIZE_8_8;
8041 parse_func = sha512b64s_parse_hash;
8042 sort_by_digest = sort_by_digest_8_8;
8043 opti_type = OPTI_TYPE_ZERO_BYTE
8044 | OPTI_TYPE_PRECOMPUTE_INIT
8045 | OPTI_TYPE_PRECOMPUTE_MERKLE
8046 | OPTI_TYPE_EARLY_SKIP
8047 | OPTI_TYPE_NOT_ITERATED
8048 | OPTI_TYPE_APPENDED_SALT
8049 | OPTI_TYPE_USES_BITS_64
8050 | OPTI_TYPE_RAW_HASH;
8051 dgst_pos0 = 14;
8052 dgst_pos1 = 15;
8053 dgst_pos2 = 6;
8054 dgst_pos3 = 7;
8055 break;
8056
8057 case 1720: hash_type = HASH_TYPE_SHA512;
8058 salt_type = SALT_TYPE_INTERN;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_ADD80
8062 | OPTS_TYPE_PT_ADDBITS15;
8063 kern_type = KERN_TYPE_SHA512_SLTPW;
8064 dgst_size = DGST_SIZE_8_8;
8065 parse_func = sha512s_parse_hash;
8066 sort_by_digest = sort_by_digest_8_8;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_INIT
8069 | OPTI_TYPE_PRECOMPUTE_MERKLE
8070 | OPTI_TYPE_EARLY_SKIP
8071 | OPTI_TYPE_NOT_ITERATED
8072 | OPTI_TYPE_PREPENDED_SALT
8073 | OPTI_TYPE_USES_BITS_64
8074 | OPTI_TYPE_RAW_HASH;
8075 dgst_pos0 = 14;
8076 dgst_pos1 = 15;
8077 dgst_pos2 = 6;
8078 dgst_pos3 = 7;
8079 break;
8080
8081 case 1722: hash_type = HASH_TYPE_SHA512;
8082 salt_type = SALT_TYPE_EMBEDDED;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_BE
8085 | OPTS_TYPE_PT_ADD80
8086 | OPTS_TYPE_PT_ADDBITS15
8087 | OPTS_TYPE_ST_HEX;
8088 kern_type = KERN_TYPE_SHA512_SLTPW;
8089 dgst_size = DGST_SIZE_8_8;
8090 parse_func = osx512_parse_hash;
8091 sort_by_digest = sort_by_digest_8_8;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_PRECOMPUTE_INIT
8094 | OPTI_TYPE_PRECOMPUTE_MERKLE
8095 | OPTI_TYPE_EARLY_SKIP
8096 | OPTI_TYPE_NOT_ITERATED
8097 | OPTI_TYPE_PREPENDED_SALT
8098 | OPTI_TYPE_USES_BITS_64
8099 | OPTI_TYPE_RAW_HASH;
8100 dgst_pos0 = 14;
8101 dgst_pos1 = 15;
8102 dgst_pos2 = 6;
8103 dgst_pos3 = 7;
8104 break;
8105
8106 case 1730: hash_type = HASH_TYPE_SHA512;
8107 salt_type = SALT_TYPE_INTERN;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_BE
8110 | OPTS_TYPE_PT_UNICODE
8111 | OPTS_TYPE_ST_ADD80
8112 | OPTS_TYPE_ST_ADDBITS15;
8113 kern_type = KERN_TYPE_SHA512_PWSLTU;
8114 dgst_size = DGST_SIZE_8_8;
8115 parse_func = sha512s_parse_hash;
8116 sort_by_digest = sort_by_digest_8_8;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP
8121 | OPTI_TYPE_NOT_ITERATED
8122 | OPTI_TYPE_APPENDED_SALT
8123 | OPTI_TYPE_USES_BITS_64
8124 | OPTI_TYPE_RAW_HASH;
8125 dgst_pos0 = 14;
8126 dgst_pos1 = 15;
8127 dgst_pos2 = 6;
8128 dgst_pos3 = 7;
8129 break;
8130
8131 case 1731: hash_type = HASH_TYPE_SHA512;
8132 salt_type = SALT_TYPE_EMBEDDED;
8133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_BE
8135 | OPTS_TYPE_PT_UNICODE
8136 | OPTS_TYPE_ST_ADD80
8137 | OPTS_TYPE_ST_ADDBITS15
8138 | OPTS_TYPE_ST_HEX;
8139 kern_type = KERN_TYPE_SHA512_PWSLTU;
8140 dgst_size = DGST_SIZE_8_8;
8141 parse_func = mssql2012_parse_hash;
8142 sort_by_digest = sort_by_digest_8_8;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_APPENDED_SALT
8149 | OPTI_TYPE_USES_BITS_64
8150 | OPTI_TYPE_RAW_HASH;
8151 dgst_pos0 = 14;
8152 dgst_pos1 = 15;
8153 dgst_pos2 = 6;
8154 dgst_pos3 = 7;
8155 break;
8156
8157 case 1740: hash_type = HASH_TYPE_SHA512;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_BE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS15
8163 | OPTS_TYPE_PT_UNICODE;
8164 kern_type = KERN_TYPE_SHA512_SLTPWU;
8165 dgst_size = DGST_SIZE_8_8;
8166 parse_func = sha512s_parse_hash;
8167 sort_by_digest = sort_by_digest_8_8;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_PRECOMPUTE_INIT
8170 | OPTI_TYPE_PRECOMPUTE_MERKLE
8171 | OPTI_TYPE_EARLY_SKIP
8172 | OPTI_TYPE_NOT_ITERATED
8173 | OPTI_TYPE_PREPENDED_SALT
8174 | OPTI_TYPE_USES_BITS_64
8175 | OPTI_TYPE_RAW_HASH;
8176 dgst_pos0 = 14;
8177 dgst_pos1 = 15;
8178 dgst_pos2 = 6;
8179 dgst_pos3 = 7;
8180 break;
8181
8182 case 1750: hash_type = HASH_TYPE_SHA512;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_BE
8186 | OPTS_TYPE_ST_ADD80;
8187 kern_type = KERN_TYPE_HMACSHA512_PW;
8188 dgst_size = DGST_SIZE_8_8;
8189 parse_func = hmacsha512_parse_hash;
8190 sort_by_digest = sort_by_digest_8_8;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_USES_BITS_64
8193 | OPTI_TYPE_NOT_ITERATED;
8194 dgst_pos0 = 14;
8195 dgst_pos1 = 15;
8196 dgst_pos2 = 6;
8197 dgst_pos3 = 7;
8198 break;
8199
8200 case 1760: hash_type = HASH_TYPE_SHA512;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_BE
8204 | OPTS_TYPE_PT_ADD80
8205 | OPTS_TYPE_PT_ADDBITS15;
8206 kern_type = KERN_TYPE_HMACSHA512_SLT;
8207 dgst_size = DGST_SIZE_8_8;
8208 parse_func = hmacsha512_parse_hash;
8209 sort_by_digest = sort_by_digest_8_8;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_USES_BITS_64
8212 | OPTI_TYPE_NOT_ITERATED;
8213 dgst_pos0 = 14;
8214 dgst_pos1 = 15;
8215 dgst_pos2 = 6;
8216 dgst_pos3 = 7;
8217 break;
8218
8219 case 1800: hash_type = HASH_TYPE_SHA512;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8223 kern_type = KERN_TYPE_SHA512CRYPT;
8224 dgst_size = DGST_SIZE_8_8;
8225 parse_func = sha512crypt_parse_hash;
8226 sort_by_digest = sort_by_digest_8_8;
8227 opti_type = OPTI_TYPE_ZERO_BYTE
8228 | OPTI_TYPE_USES_BITS_64;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 1;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 3;
8233 break;
8234
8235 case 2100: hash_type = HASH_TYPE_DCC2;
8236 salt_type = SALT_TYPE_EMBEDDED;
8237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8239 | OPTS_TYPE_ST_LOWER
8240 | OPTS_TYPE_ST_UNICODE;
8241 kern_type = KERN_TYPE_DCC2;
8242 dgst_size = DGST_SIZE_4_4;
8243 parse_func = dcc2_parse_hash;
8244 sort_by_digest = sort_by_digest_4_4;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_SLOW_HASH_SIMD;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 1;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 3;
8251 break;
8252
8253 case 2400: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_NONE;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8257 kern_type = KERN_TYPE_MD5PIX;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5pix_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED
8266 | OPTI_TYPE_NOT_SALTED;
8267 dgst_pos0 = 0;
8268 dgst_pos1 = 3;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 2410: hash_type = HASH_TYPE_MD5;
8274 salt_type = SALT_TYPE_INTERN;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8277 kern_type = KERN_TYPE_MD5ASA;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = md5asa_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP
8285 | OPTI_TYPE_NOT_ITERATED;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2500: hash_type = HASH_TYPE_WPA;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8296 kern_type = KERN_TYPE_WPA;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = wpa_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_SLOW_HASH_SIMD;
8302 dgst_pos0 = 0;
8303 dgst_pos1 = 1;
8304 dgst_pos2 = 2;
8305 dgst_pos3 = 3;
8306 break;
8307
8308 case 2600: hash_type = HASH_TYPE_MD5;
8309 salt_type = SALT_TYPE_VIRTUAL;
8310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8311 opts_type = OPTS_TYPE_PT_GENERATE_LE
8312 | OPTS_TYPE_PT_ADD80
8313 | OPTS_TYPE_PT_ADDBITS14
8314 | OPTS_TYPE_ST_ADD80;
8315 kern_type = KERN_TYPE_MD55_PWSLT1;
8316 dgst_size = DGST_SIZE_4_4;
8317 parse_func = md5md5_parse_hash;
8318 sort_by_digest = sort_by_digest_4_4;
8319 opti_type = OPTI_TYPE_ZERO_BYTE
8320 | OPTI_TYPE_PRECOMPUTE_INIT
8321 | OPTI_TYPE_PRECOMPUTE_MERKLE
8322 | OPTI_TYPE_EARLY_SKIP;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 3;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 1;
8327 break;
8328
8329 case 2611: hash_type = HASH_TYPE_MD5;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS14
8335 | OPTS_TYPE_ST_ADD80;
8336 kern_type = KERN_TYPE_MD55_PWSLT1;
8337 dgst_size = DGST_SIZE_4_4;
8338 parse_func = vb3_parse_hash;
8339 sort_by_digest = sort_by_digest_4_4;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_PRECOMPUTE_MERKLE
8343 | OPTI_TYPE_EARLY_SKIP;
8344 dgst_pos0 = 0;
8345 dgst_pos1 = 3;
8346 dgst_pos2 = 2;
8347 dgst_pos3 = 1;
8348 break;
8349
8350 case 2612: hash_type = HASH_TYPE_MD5;
8351 salt_type = SALT_TYPE_EMBEDDED;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_LE
8354 | OPTS_TYPE_PT_ADD80
8355 | OPTS_TYPE_PT_ADDBITS14
8356 | OPTS_TYPE_ST_ADD80
8357 | OPTS_TYPE_ST_HEX;
8358 kern_type = KERN_TYPE_MD55_PWSLT1;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = phps_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 3;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 1;
8370 break;
8371
8372 case 2711: hash_type = HASH_TYPE_MD5;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_PT_ADD80
8377 | OPTS_TYPE_PT_ADDBITS14
8378 | OPTS_TYPE_ST_ADD80;
8379 kern_type = KERN_TYPE_MD55_PWSLT2;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = vb30_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_EARLY_SKIP;
8386 dgst_pos0 = 0;
8387 dgst_pos1 = 3;
8388 dgst_pos2 = 2;
8389 dgst_pos3 = 1;
8390 break;
8391
8392 case 2811: hash_type = HASH_TYPE_MD5;
8393 salt_type = SALT_TYPE_INTERN;
8394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8395 opts_type = OPTS_TYPE_PT_GENERATE_LE
8396 | OPTS_TYPE_PT_ADD80
8397 | OPTS_TYPE_PT_ADDBITS14;
8398 kern_type = KERN_TYPE_MD55_SLTPW;
8399 dgst_size = DGST_SIZE_4_4;
8400 parse_func = ipb2_parse_hash;
8401 sort_by_digest = sort_by_digest_4_4;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_PRECOMPUTE_INIT
8404 | OPTI_TYPE_EARLY_SKIP;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 3;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 1;
8409 break;
8410
8411 case 3000: hash_type = HASH_TYPE_LM;
8412 salt_type = SALT_TYPE_NONE;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_UPPER
8416 | OPTS_TYPE_PT_BITSLICE;
8417 kern_type = KERN_TYPE_LM;
8418 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8419 parse_func = lm_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 1;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 3;
8427 break;
8428
8429 case 3100: hash_type = HASH_TYPE_ORACLEH;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE
8433 | OPTS_TYPE_PT_UPPER
8434 | OPTS_TYPE_ST_UPPER;
8435 kern_type = KERN_TYPE_ORACLEH;
8436 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8437 parse_func = oracleh_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8439 opti_type = OPTI_TYPE_ZERO_BYTE;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 1;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 3;
8444 break;
8445
8446 case 3200: hash_type = HASH_TYPE_BCRYPT;
8447 salt_type = SALT_TYPE_EMBEDDED;
8448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_LE
8450 | OPTS_TYPE_ST_GENERATE_LE;
8451 kern_type = KERN_TYPE_BCRYPT;
8452 dgst_size = DGST_SIZE_4_6;
8453 parse_func = bcrypt_parse_hash;
8454 sort_by_digest = sort_by_digest_4_6;
8455 opti_type = OPTI_TYPE_ZERO_BYTE;
8456 dgst_pos0 = 0;
8457 dgst_pos1 = 1;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 3;
8460 break;
8461
8462 case 3710: hash_type = HASH_TYPE_MD5;
8463 salt_type = SALT_TYPE_INTERN;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE
8466 | OPTS_TYPE_PT_ADD80
8467 | OPTS_TYPE_PT_ADDBITS14;
8468 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5s_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_PRECOMPUTE_MERKLE
8475 | OPTI_TYPE_EARLY_SKIP;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 3;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482 case 3711: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_PT_ADD80
8487 | OPTS_TYPE_PT_ADDBITS14;
8488 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8489 dgst_size = DGST_SIZE_4_4;
8490 parse_func = mediawiki_b_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4;
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_INIT
8494 | OPTI_TYPE_PRECOMPUTE_MERKLE
8495 | OPTI_TYPE_EARLY_SKIP;
8496 dgst_pos0 = 0;
8497 dgst_pos1 = 3;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 1;
8500 break;
8501
8502 case 3800: hash_type = HASH_TYPE_MD5;
8503 salt_type = SALT_TYPE_INTERN;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE
8506 | OPTS_TYPE_ST_ADDBITS14;
8507 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8508 dgst_size = DGST_SIZE_4_4;
8509 parse_func = md5s_parse_hash;
8510 sort_by_digest = sort_by_digest_4_4;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_RAW_HASH;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 3;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 1;
8521 break;
8522
8523 case 4300: hash_type = HASH_TYPE_MD5;
8524 salt_type = SALT_TYPE_VIRTUAL;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE
8527 | OPTS_TYPE_PT_ADD80
8528 | OPTS_TYPE_PT_ADDBITS14
8529 | OPTS_TYPE_ST_ADD80;
8530 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8531 dgst_size = DGST_SIZE_4_4;
8532 parse_func = md5md5_parse_hash;
8533 sort_by_digest = sort_by_digest_4_4;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_EARLY_SKIP;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544
8545 case 4400: hash_type = HASH_TYPE_MD5;
8546 salt_type = SALT_TYPE_NONE;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_BE
8549 | OPTS_TYPE_PT_ADD80
8550 | OPTS_TYPE_PT_ADDBITS15;
8551 kern_type = KERN_TYPE_MD5_SHA1;
8552 dgst_size = DGST_SIZE_4_4;
8553 parse_func = md5_parse_hash;
8554 sort_by_digest = sort_by_digest_4_4;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_PRECOMPUTE_MERKLE
8558 | OPTI_TYPE_EARLY_SKIP
8559 | OPTI_TYPE_NOT_ITERATED
8560 | OPTI_TYPE_NOT_SALTED
8561 | OPTI_TYPE_RAW_HASH;
8562 dgst_pos0 = 0;
8563 dgst_pos1 = 3;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 1;
8566 break;
8567
8568 case 4500: hash_type = HASH_TYPE_SHA1;
8569 salt_type = SALT_TYPE_NONE;
8570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_BE
8572 | OPTS_TYPE_PT_ADD80
8573 | OPTS_TYPE_PT_ADDBITS15;
8574 kern_type = KERN_TYPE_SHA11;
8575 dgst_size = DGST_SIZE_4_5;
8576 parse_func = sha1_parse_hash;
8577 sort_by_digest = sort_by_digest_4_5;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_SALTED;
8583 dgst_pos0 = 3;
8584 dgst_pos1 = 4;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 1;
8587 break;
8588
8589 case 4700: hash_type = HASH_TYPE_SHA1;
8590 salt_type = SALT_TYPE_NONE;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE
8593 | OPTS_TYPE_PT_ADD80
8594 | OPTS_TYPE_PT_ADDBITS14;
8595 kern_type = KERN_TYPE_SHA1_MD5;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = sha1_parse_hash;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_PRECOMPUTE_INIT
8601 | OPTI_TYPE_PRECOMPUTE_MERKLE
8602 | OPTI_TYPE_EARLY_SKIP
8603 | OPTI_TYPE_NOT_ITERATED
8604 | OPTI_TYPE_NOT_SALTED
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 3;
8607 dgst_pos1 = 4;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 1;
8610 break;
8611
8612 case 4800: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_EMBEDDED;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADDBITS14;
8617 kern_type = KERN_TYPE_MD5_CHAP;
8618 dgst_size = DGST_SIZE_4_4;
8619 parse_func = chap_parse_hash;
8620 sort_by_digest = sort_by_digest_4_4;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_PRECOMPUTE_INIT
8623 | OPTI_TYPE_PRECOMPUTE_MERKLE
8624 | OPTI_TYPE_MEET_IN_MIDDLE
8625 | OPTI_TYPE_EARLY_SKIP
8626 | OPTI_TYPE_NOT_ITERATED
8627 | OPTI_TYPE_RAW_HASH;
8628 dgst_pos0 = 0;
8629 dgst_pos1 = 3;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 4900: hash_type = HASH_TYPE_SHA1;
8635 salt_type = SALT_TYPE_INTERN;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8638 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8639 dgst_size = DGST_SIZE_4_5;
8640 parse_func = sha1s_parse_hash;
8641 sort_by_digest = sort_by_digest_4_5;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_EARLY_SKIP;
8646 dgst_pos0 = 3;
8647 dgst_pos1 = 4;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 5000: hash_type = HASH_TYPE_KECCAK;
8653 salt_type = SALT_TYPE_EMBEDDED;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD01;
8657 kern_type = KERN_TYPE_KECCAK;
8658 dgst_size = DGST_SIZE_8_25;
8659 parse_func = keccak_parse_hash;
8660 sort_by_digest = sort_by_digest_8_25;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_USES_BITS_64
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 2;
8665 dgst_pos1 = 3;
8666 dgst_pos2 = 4;
8667 dgst_pos3 = 5;
8668 break;
8669
8670 case 5100: hash_type = HASH_TYPE_MD5H;
8671 salt_type = SALT_TYPE_NONE;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE
8674 | OPTS_TYPE_PT_ADD80
8675 | OPTS_TYPE_PT_ADDBITS14;
8676 kern_type = KERN_TYPE_MD5H;
8677 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8678 parse_func = md5half_parse_hash;
8679 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8680 opti_type = OPTI_TYPE_ZERO_BYTE
8681 | OPTI_TYPE_RAW_HASH;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 5200: hash_type = HASH_TYPE_SHA256;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8692 kern_type = KERN_TYPE_PSAFE3;
8693 dgst_size = DGST_SIZE_4_8;
8694 parse_func = psafe3_parse_hash;
8695 sort_by_digest = sort_by_digest_4_8;
8696 opti_type = OPTI_TYPE_ZERO_BYTE;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 1;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 3;
8701 break;
8702
8703 case 5300: hash_type = HASH_TYPE_MD5;
8704 salt_type = SALT_TYPE_EMBEDDED;
8705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_LE
8707 | OPTS_TYPE_ST_ADD80;
8708 kern_type = KERN_TYPE_IKEPSK_MD5;
8709 dgst_size = DGST_SIZE_4_4;
8710 parse_func = ikepsk_md5_parse_hash;
8711 sort_by_digest = sort_by_digest_4_4;
8712 opti_type = OPTI_TYPE_ZERO_BYTE;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 3;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719 case 5400: hash_type = HASH_TYPE_SHA1;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_BE
8723 | OPTS_TYPE_ST_ADD80;
8724 kern_type = KERN_TYPE_IKEPSK_SHA1;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = ikepsk_sha1_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 3;
8730 dgst_pos1 = 4;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 1;
8733 break;
8734
8735 case 5500: hash_type = HASH_TYPE_NETNTLM;
8736 salt_type = SALT_TYPE_EMBEDDED;
8737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_LE
8739 | OPTS_TYPE_PT_ADD80
8740 | OPTS_TYPE_PT_ADDBITS14
8741 | OPTS_TYPE_PT_UNICODE
8742 | OPTS_TYPE_ST_HEX;
8743 kern_type = KERN_TYPE_NETNTLMv1;
8744 dgst_size = DGST_SIZE_4_4;
8745 parse_func = netntlmv1_parse_hash;
8746 sort_by_digest = sort_by_digest_4_4;
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 1;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 3;
8753 break;
8754
8755 case 5600: hash_type = HASH_TYPE_MD5;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE
8759 | OPTS_TYPE_PT_ADD80
8760 | OPTS_TYPE_PT_ADDBITS14
8761 | OPTS_TYPE_PT_UNICODE;
8762 kern_type = KERN_TYPE_NETNTLMv2;
8763 dgst_size = DGST_SIZE_4_4;
8764 parse_func = netntlmv2_parse_hash;
8765 sort_by_digest = sort_by_digest_4_4;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 3;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 1;
8771 break;
8772
8773 case 5700: hash_type = HASH_TYPE_SHA256;
8774 salt_type = SALT_TYPE_NONE;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_BE
8777 | OPTS_TYPE_PT_ADD80
8778 | OPTS_TYPE_PT_ADDBITS15;
8779 kern_type = KERN_TYPE_SHA256;
8780 dgst_size = DGST_SIZE_4_8;
8781 parse_func = cisco4_parse_hash;
8782 sort_by_digest = sort_by_digest_4_8;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_PRECOMPUTE_INIT
8785 | OPTI_TYPE_PRECOMPUTE_MERKLE
8786 | OPTI_TYPE_EARLY_SKIP
8787 | OPTI_TYPE_NOT_ITERATED
8788 | OPTI_TYPE_NOT_SALTED
8789 | OPTI_TYPE_RAW_HASH;
8790 dgst_pos0 = 3;
8791 dgst_pos1 = 7;
8792 dgst_pos2 = 2;
8793 dgst_pos3 = 6;
8794 break;
8795
8796 case 5800: hash_type = HASH_TYPE_SHA1;
8797 salt_type = SALT_TYPE_INTERN;
8798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8799 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8800 | OPTS_TYPE_ST_ADD80;
8801 kern_type = KERN_TYPE_ANDROIDPIN;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = androidpin_parse_hash;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8813 salt_type = SALT_TYPE_NONE;
8814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE
8816 | OPTS_TYPE_PT_ADD80;
8817 kern_type = KERN_TYPE_RIPEMD160;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = ripemd160_parse_hash;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8829 salt_type = SALT_TYPE_NONE;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_BE
8832 | OPTS_TYPE_PT_ADD80;
8833 kern_type = KERN_TYPE_WHIRLPOOL;
8834 dgst_size = DGST_SIZE_4_16;
8835 parse_func = whirlpool_parse_hash;
8836 sort_by_digest = sort_by_digest_4_16;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8849 dgst_size = DGST_SIZE_4_5;
8850 parse_func = truecrypt_parse_hash_2k;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8863 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8864 dgst_size = DGST_SIZE_4_5;
8865 parse_func = truecrypt_parse_hash_2k;
8866 sort_by_digest = sort_by_digest_4_5;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8878 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8879 dgst_size = DGST_SIZE_4_5;
8880 parse_func = truecrypt_parse_hash_2k;
8881 sort_by_digest = sort_by_digest_4_5;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 1;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 3;
8887 break;
8888
8889 case 6221: hash_type = HASH_TYPE_SHA512;
8890 salt_type = SALT_TYPE_EMBEDDED;
8891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8893 kern_type = KERN_TYPE_TCSHA512_XTS512;
8894 dgst_size = DGST_SIZE_8_8;
8895 parse_func = truecrypt_parse_hash_1k;
8896 sort_by_digest = sort_by_digest_8_8;
8897 opti_type = OPTI_TYPE_ZERO_BYTE
8898 | OPTI_TYPE_USES_BITS_64;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6222: hash_type = HASH_TYPE_SHA512;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8909 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8910 dgst_size = DGST_SIZE_8_8;
8911 parse_func = truecrypt_parse_hash_1k;
8912 sort_by_digest = sort_by_digest_8_8;
8913 opti_type = OPTI_TYPE_ZERO_BYTE
8914 | OPTI_TYPE_USES_BITS_64;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6223: hash_type = HASH_TYPE_SHA512;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8925 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8926 dgst_size = DGST_SIZE_8_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_8_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE
8930 | OPTI_TYPE_USES_BITS_64;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8957 dgst_size = DGST_SIZE_4_8;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_8;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8972 dgst_size = DGST_SIZE_4_8;
8973 parse_func = truecrypt_parse_hash_1k;
8974 sort_by_digest = sort_by_digest_4_8;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8987 dgst_size = DGST_SIZE_4_5;
8988 parse_func = truecrypt_parse_hash_1k;
8989 sort_by_digest = sort_by_digest_4_5;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_1k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = truecrypt_parse_hash_1k;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6300: hash_type = HASH_TYPE_MD5;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_MD5AIX;
9032 dgst_size = DGST_SIZE_4_4;
9033 parse_func = md5aix_parse_hash;
9034 sort_by_digest = sort_by_digest_4_4;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6400: hash_type = HASH_TYPE_SHA256;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_SHA256AIX;
9047 dgst_size = DGST_SIZE_4_8;
9048 parse_func = sha256aix_parse_hash;
9049 sort_by_digest = sort_by_digest_4_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6500: hash_type = HASH_TYPE_SHA512;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA512AIX;
9062 dgst_size = DGST_SIZE_8_8;
9063 parse_func = sha512aix_parse_hash;
9064 sort_by_digest = sort_by_digest_8_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE
9066 | OPTI_TYPE_USES_BITS_64;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6600: hash_type = HASH_TYPE_AES;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9077 kern_type = KERN_TYPE_AGILEKEY;
9078 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9079 parse_func = agilekey_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 6700: hash_type = HASH_TYPE_SHA1;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9092 kern_type = KERN_TYPE_SHA1AIX;
9093 dgst_size = DGST_SIZE_4_5;
9094 parse_func = sha1aix_parse_hash;
9095 sort_by_digest = sort_by_digest_4_5;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 6800: hash_type = HASH_TYPE_AES;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_LASTPASS;
9108 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9109 parse_func = lastpass_parse_hash;
9110 sort_by_digest = sort_by_digest_4_8;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 6900: hash_type = HASH_TYPE_GOST;
9119 salt_type = SALT_TYPE_NONE;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9122 kern_type = KERN_TYPE_GOST;
9123 dgst_size = DGST_SIZE_4_8;
9124 parse_func = gost_parse_hash;
9125 sort_by_digest = sort_by_digest_4_8;
9126 opti_type = OPTI_TYPE_ZERO_BYTE;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 7100: hash_type = HASH_TYPE_SHA512;
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_PBKDF2_SHA512;
9138 dgst_size = DGST_SIZE_8_16;
9139 parse_func = sha512osx_parse_hash;
9140 sort_by_digest = sort_by_digest_8_16;
9141 opti_type = OPTI_TYPE_ZERO_BYTE
9142 | OPTI_TYPE_USES_BITS_64
9143 | OPTI_TYPE_SLOW_HASH_SIMD;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 7200: hash_type = HASH_TYPE_SHA512;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9154 kern_type = KERN_TYPE_PBKDF2_SHA512;
9155 dgst_size = DGST_SIZE_8_16;
9156 parse_func = sha512grub_parse_hash;
9157 sort_by_digest = sort_by_digest_8_16;
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_USES_BITS_64
9160 | OPTI_TYPE_SLOW_HASH_SIMD;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7300: hash_type = HASH_TYPE_SHA1;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_BE
9171 | OPTS_TYPE_ST_ADD80
9172 | OPTS_TYPE_ST_ADDBITS15;
9173 kern_type = KERN_TYPE_RAKP;
9174 dgst_size = DGST_SIZE_4_5;
9175 parse_func = rakp_parse_hash;
9176 sort_by_digest = sort_by_digest_4_5;
9177 opti_type = OPTI_TYPE_ZERO_BYTE
9178 | OPTI_TYPE_NOT_ITERATED;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 4;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 1;
9183 break;
9184
9185 case 7400: hash_type = HASH_TYPE_SHA256;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9189 kern_type = KERN_TYPE_SHA256CRYPT;
9190 dgst_size = DGST_SIZE_4_8;
9191 parse_func = sha256crypt_parse_hash;
9192 sort_by_digest = sort_by_digest_4_8;
9193 opti_type = OPTI_TYPE_ZERO_BYTE;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 7500: hash_type = HASH_TYPE_KRB5PA;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9204 kern_type = KERN_TYPE_KRB5PA;
9205 dgst_size = DGST_SIZE_4_4;
9206 parse_func = krb5pa_parse_hash;
9207 sort_by_digest = sort_by_digest_4_4;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 7600: hash_type = HASH_TYPE_SHA1;
9217 salt_type = SALT_TYPE_INTERN;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_ADDBITS15;
9222 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9223 dgst_size = DGST_SIZE_4_5;
9224 parse_func = redmine_parse_hash;
9225 sort_by_digest = sort_by_digest_4_5;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_EARLY_SKIP
9229 | OPTI_TYPE_NOT_ITERATED
9230 | OPTI_TYPE_PREPENDED_SALT;
9231 dgst_pos0 = 3;
9232 dgst_pos1 = 4;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 1;
9235 break;
9236
9237 case 7700: hash_type = HASH_TYPE_SAPB;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE
9241 | OPTS_TYPE_PT_UPPER
9242 | OPTS_TYPE_ST_UPPER;
9243 kern_type = KERN_TYPE_SAPB;
9244 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9245 parse_func = sapb_parse_hash;
9246 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9247 opti_type = OPTI_TYPE_ZERO_BYTE
9248 | OPTI_TYPE_PRECOMPUTE_INIT
9249 | OPTI_TYPE_NOT_ITERATED;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 7800: hash_type = HASH_TYPE_SAPG;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_BE
9260 | OPTS_TYPE_ST_ADD80
9261 | OPTS_TYPE_ST_UPPER;
9262 kern_type = KERN_TYPE_SAPG;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = sapg_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE
9267 | OPTI_TYPE_PRECOMPUTE_INIT
9268 | OPTI_TYPE_NOT_ITERATED;
9269 dgst_pos0 = 3;
9270 dgst_pos1 = 4;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 1;
9273 break;
9274
9275 case 7900: hash_type = HASH_TYPE_SHA512;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9279 kern_type = KERN_TYPE_DRUPAL7;
9280 dgst_size = DGST_SIZE_8_8;
9281 parse_func = drupal7_parse_hash;
9282 sort_by_digest = sort_by_digest_8_8;
9283 opti_type = OPTI_TYPE_ZERO_BYTE
9284 | OPTI_TYPE_USES_BITS_64;
9285 dgst_pos0 = 0;
9286 dgst_pos1 = 1;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 3;
9289 break;
9290
9291 case 8000: hash_type = HASH_TYPE_SHA256;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_BE
9295 | OPTS_TYPE_PT_UNICODE
9296 | OPTS_TYPE_ST_ADD80
9297 | OPTS_TYPE_ST_HEX;
9298 kern_type = KERN_TYPE_SYBASEASE;
9299 dgst_size = DGST_SIZE_4_8;
9300 parse_func = sybasease_parse_hash;
9301 sort_by_digest = sort_by_digest_4_8;
9302 opti_type = OPTI_TYPE_ZERO_BYTE
9303 | OPTI_TYPE_PRECOMPUTE_INIT
9304 | OPTI_TYPE_EARLY_SKIP
9305 | OPTI_TYPE_NOT_ITERATED
9306 | OPTI_TYPE_RAW_HASH;
9307 dgst_pos0 = 3;
9308 dgst_pos1 = 7;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 6;
9311 break;
9312
9313 case 8100: hash_type = HASH_TYPE_SHA1;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9317 kern_type = KERN_TYPE_NETSCALER;
9318 dgst_size = DGST_SIZE_4_5;
9319 parse_func = netscaler_parse_hash;
9320 sort_by_digest = sort_by_digest_4_5;
9321 opti_type = OPTI_TYPE_ZERO_BYTE
9322 | OPTI_TYPE_PRECOMPUTE_INIT
9323 | OPTI_TYPE_PRECOMPUTE_MERKLE
9324 | OPTI_TYPE_EARLY_SKIP
9325 | OPTI_TYPE_NOT_ITERATED
9326 | OPTI_TYPE_PREPENDED_SALT
9327 | OPTI_TYPE_RAW_HASH;
9328 dgst_pos0 = 3;
9329 dgst_pos1 = 4;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 1;
9332 break;
9333
9334 case 8200: hash_type = HASH_TYPE_SHA256;
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_CLOUDKEY;
9339 dgst_size = DGST_SIZE_4_8;
9340 parse_func = cloudkey_parse_hash;
9341 sort_by_digest = sort_by_digest_4_8;
9342 opti_type = OPTI_TYPE_ZERO_BYTE;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 8300: hash_type = HASH_TYPE_SHA1;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_BE
9353 | OPTS_TYPE_ST_HEX
9354 | OPTS_TYPE_ST_ADD80;
9355 kern_type = KERN_TYPE_NSEC3;
9356 dgst_size = DGST_SIZE_4_5;
9357 parse_func = nsec3_parse_hash;
9358 sort_by_digest = sort_by_digest_4_5;
9359 opti_type = OPTI_TYPE_ZERO_BYTE;
9360 dgst_pos0 = 3;
9361 dgst_pos1 = 4;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 1;
9364 break;
9365
9366 case 8400: hash_type = HASH_TYPE_SHA1;
9367 salt_type = SALT_TYPE_INTERN;
9368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_BE
9370 | OPTS_TYPE_PT_ADD80
9371 | OPTS_TYPE_PT_ADDBITS15;
9372 kern_type = KERN_TYPE_WBB3;
9373 dgst_size = DGST_SIZE_4_5;
9374 parse_func = wbb3_parse_hash;
9375 sort_by_digest = sort_by_digest_4_5;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_PRECOMPUTE_INIT
9378 | OPTI_TYPE_NOT_ITERATED;
9379 dgst_pos0 = 3;
9380 dgst_pos1 = 4;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 1;
9383 break;
9384
9385 case 8500: hash_type = HASH_TYPE_DESRACF;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE
9389 | OPTS_TYPE_ST_UPPER;
9390 kern_type = KERN_TYPE_RACF;
9391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9392 parse_func = racf_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9396 dgst_pos0 = 0;
9397 dgst_pos1 = 1;
9398 dgst_pos2 = 2;
9399 dgst_pos3 = 3;
9400 break;
9401
9402 case 8600: hash_type = HASH_TYPE_LOTUS5;
9403 salt_type = SALT_TYPE_NONE;
9404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9406 kern_type = KERN_TYPE_LOTUS5;
9407 dgst_size = DGST_SIZE_4_4;
9408 parse_func = lotus5_parse_hash;
9409 sort_by_digest = sort_by_digest_4_4;
9410 opti_type = OPTI_TYPE_EARLY_SKIP
9411 | OPTI_TYPE_NOT_ITERATED
9412 | OPTI_TYPE_NOT_SALTED
9413 | OPTI_TYPE_RAW_HASH;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 8700: hash_type = HASH_TYPE_LOTUS6;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_LOTUS6;
9425 dgst_size = DGST_SIZE_4_4;
9426 parse_func = lotus6_parse_hash;
9427 sort_by_digest = sort_by_digest_4_4;
9428 opti_type = OPTI_TYPE_EARLY_SKIP
9429 | OPTI_TYPE_NOT_ITERATED
9430 | OPTI_TYPE_RAW_HASH;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_ANDROIDFDE;
9442 dgst_size = DGST_SIZE_4_4;
9443 parse_func = androidfde_parse_hash;
9444 sort_by_digest = sort_by_digest_4_4;
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 8900: hash_type = HASH_TYPE_SCRYPT;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9456 kern_type = KERN_TYPE_SCRYPT;
9457 dgst_size = DGST_SIZE_4_8;
9458 parse_func = scrypt_parse_hash;
9459 sort_by_digest = sort_by_digest_4_8;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9000: hash_type = HASH_TYPE_SHA1;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_ST_GENERATE_LE;
9472 kern_type = KERN_TYPE_PSAFE2;
9473 dgst_size = DGST_SIZE_4_5;
9474 parse_func = psafe2_parse_hash;
9475 sort_by_digest = sort_by_digest_4_5;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9100: hash_type = HASH_TYPE_LOTUS8;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9487 kern_type = KERN_TYPE_LOTUS8;
9488 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9489 parse_func = lotus8_parse_hash;
9490 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9491 opti_type = OPTI_TYPE_ZERO_BYTE;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 9200: hash_type = HASH_TYPE_SHA256;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9502 kern_type = KERN_TYPE_PBKDF2_SHA256;
9503 dgst_size = DGST_SIZE_4_32;
9504 parse_func = cisco8_parse_hash;
9505 sort_by_digest = sort_by_digest_4_32;
9506 opti_type = OPTI_TYPE_ZERO_BYTE
9507 | OPTI_TYPE_SLOW_HASH_SIMD;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9300: hash_type = HASH_TYPE_SCRYPT;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9518 kern_type = KERN_TYPE_SCRYPT;
9519 dgst_size = DGST_SIZE_4_8;
9520 parse_func = cisco9_parse_hash;
9521 sort_by_digest = sort_by_digest_4_8;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_OFFICE2007;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = office2007_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9548 kern_type = KERN_TYPE_OFFICE2010;
9549 dgst_size = DGST_SIZE_4_4;
9550 parse_func = office2010_parse_hash;
9551 sort_by_digest = sort_by_digest_4_4;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_OFFICE2013;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = office2013_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 1;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 3;
9572 break;
9573
9574 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_PT_ADD80
9579 | OPTS_TYPE_PT_UNICODE;
9580 kern_type = KERN_TYPE_OLDOFFICE01;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = oldoffice01_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE
9585 | OPTI_TYPE_PRECOMPUTE_INIT
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_PT_ADD80;
9598 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9599 dgst_size = DGST_SIZE_4_4;
9600 parse_func = oldoffice01cm1_parse_hash;
9601 sort_by_digest = sort_by_digest_4_4;
9602 opti_type = OPTI_TYPE_ZERO_BYTE
9603 | OPTI_TYPE_PRECOMPUTE_INIT
9604 | OPTI_TYPE_NOT_ITERATED;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE
9615 | OPTS_TYPE_PT_ADD80
9616 | OPTS_TYPE_PT_UNICODE
9617 | OPTS_TYPE_PT_NEVERCRACK;
9618 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9619 dgst_size = DGST_SIZE_4_4;
9620 parse_func = oldoffice01cm2_parse_hash;
9621 sort_by_digest = sort_by_digest_4_4;
9622 opti_type = OPTI_TYPE_ZERO_BYTE
9623 | OPTI_TYPE_PRECOMPUTE_INIT
9624 | OPTI_TYPE_NOT_ITERATED;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_BE
9635 | OPTS_TYPE_PT_ADD80
9636 | OPTS_TYPE_PT_UNICODE;
9637 kern_type = KERN_TYPE_OLDOFFICE34;
9638 dgst_size = DGST_SIZE_4_4;
9639 parse_func = oldoffice34_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4;
9641 opti_type = OPTI_TYPE_ZERO_BYTE
9642 | OPTI_TYPE_PRECOMPUTE_INIT
9643 | OPTI_TYPE_NOT_ITERATED;
9644 dgst_pos0 = 0;
9645 dgst_pos1 = 1;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 3;
9648 break;
9649
9650 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9653 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9654 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9655 dgst_size = DGST_SIZE_4_4;
9656 parse_func = oldoffice34cm1_parse_hash;
9657 sort_by_digest = sort_by_digest_4_4;
9658 opti_type = OPTI_TYPE_ZERO_BYTE
9659 | OPTI_TYPE_PRECOMPUTE_INIT
9660 | OPTI_TYPE_NOT_ITERATED;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_BE
9671 | OPTS_TYPE_PT_ADD80
9672 | OPTS_TYPE_PT_UNICODE
9673 | OPTS_TYPE_PT_NEVERCRACK;
9674 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9675 dgst_size = DGST_SIZE_4_4;
9676 parse_func = oldoffice34cm2_parse_hash;
9677 sort_by_digest = sort_by_digest_4_4;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_PRECOMPUTE_INIT
9680 | OPTI_TYPE_NOT_ITERATED;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 9900: hash_type = HASH_TYPE_MD5;
9688 salt_type = SALT_TYPE_NONE;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_RADMIN2;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = radmin2_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_PRECOMPUTE_INIT
9697 | OPTI_TYPE_EARLY_SKIP
9698 | OPTI_TYPE_NOT_ITERATED
9699 | OPTI_TYPE_NOT_SALTED;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 3;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 1;
9704 break;
9705
9706 case 10000: hash_type = HASH_TYPE_SHA256;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9710 kern_type = KERN_TYPE_PBKDF2_SHA256;
9711 dgst_size = DGST_SIZE_4_32;
9712 parse_func = djangopbkdf2_parse_hash;
9713 sort_by_digest = sort_by_digest_4_32;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_SLOW_HASH_SIMD;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 10100: hash_type = HASH_TYPE_SIPHASH;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_SIPHASH;
9727 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9728 parse_func = siphash_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED
9732 | OPTI_TYPE_RAW_HASH;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10200: hash_type = HASH_TYPE_MD5;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_ST_ADD80
9744 | OPTS_TYPE_ST_ADDBITS14;
9745 kern_type = KERN_TYPE_HMACMD5_PW;
9746 dgst_size = DGST_SIZE_4_4;
9747 parse_func = crammd5_parse_hash;
9748 sort_by_digest = sort_by_digest_4_4;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 3;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 1;
9755 break;
9756
9757 case 10300: hash_type = HASH_TYPE_SHA1;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9761 kern_type = KERN_TYPE_SAPH_SHA1;
9762 dgst_size = DGST_SIZE_4_5;
9763 parse_func = saph_sha1_parse_hash;
9764 sort_by_digest = sort_by_digest_4_5;
9765 opti_type = OPTI_TYPE_ZERO_BYTE;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 10400: hash_type = HASH_TYPE_PDFU16;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_PDF11;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = pdf11_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_NOT_ITERATED;
9782 dgst_pos0 = 0;
9783 dgst_pos1 = 1;
9784 dgst_pos2 = 2;
9785 dgst_pos3 = 3;
9786 break;
9787
9788 case 10410: hash_type = HASH_TYPE_PDFU16;
9789 salt_type = SALT_TYPE_EMBEDDED;
9790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9792 kern_type = KERN_TYPE_PDF11CM1;
9793 dgst_size = DGST_SIZE_4_4;
9794 parse_func = pdf11cm1_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_NOT_ITERATED;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 1;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 3;
9802 break;
9803
9804 case 10420: hash_type = HASH_TYPE_PDFU16;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9808 kern_type = KERN_TYPE_PDF11CM2;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = pdf11cm2_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 10500: hash_type = HASH_TYPE_PDFU16;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_PDF14;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = pdf14_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_NOT_ITERATED;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 10600: hash_type = HASH_TYPE_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_ST_ADD80
9841 | OPTS_TYPE_ST_ADDBITS15
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_SHA256_PWSLT;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = pdf17l3_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_PRECOMPUTE_MERKLE
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_APPENDED_SALT
9853 | OPTI_TYPE_RAW_HASH;
9854 dgst_pos0 = 3;
9855 dgst_pos1 = 7;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 6;
9858 break;
9859
9860 case 10700: hash_type = HASH_TYPE_PDFU32;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_LE
9864 | OPTS_TYPE_HASH_COPY;
9865 kern_type = KERN_TYPE_PDF17L8;
9866 dgst_size = DGST_SIZE_4_8;
9867 parse_func = pdf17l8_parse_hash;
9868 sort_by_digest = sort_by_digest_4_8;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_NOT_ITERATED;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 10800: hash_type = HASH_TYPE_SHA384;
9878 salt_type = SALT_TYPE_NONE;
9879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_BE
9881 | OPTS_TYPE_PT_ADD80
9882 | OPTS_TYPE_PT_ADDBITS15;
9883 kern_type = KERN_TYPE_SHA384;
9884 dgst_size = DGST_SIZE_8_8;
9885 parse_func = sha384_parse_hash;
9886 sort_by_digest = sort_by_digest_8_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE
9888 | OPTI_TYPE_PRECOMPUTE_INIT
9889 | OPTI_TYPE_PRECOMPUTE_MERKLE
9890 | OPTI_TYPE_EARLY_SKIP
9891 | OPTI_TYPE_NOT_ITERATED
9892 | OPTI_TYPE_NOT_SALTED
9893 | OPTI_TYPE_USES_BITS_64
9894 | OPTI_TYPE_RAW_HASH;
9895 dgst_pos0 = 6;
9896 dgst_pos1 = 7;
9897 dgst_pos2 = 4;
9898 dgst_pos3 = 5;
9899 break;
9900
9901 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9902 salt_type = SALT_TYPE_EMBEDDED;
9903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_ST_BASE64
9906 | OPTS_TYPE_HASH_COPY;
9907 kern_type = KERN_TYPE_PBKDF2_SHA256;
9908 dgst_size = DGST_SIZE_4_32;
9909 parse_func = pbkdf2_sha256_parse_hash;
9910 sort_by_digest = sort_by_digest_4_32;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_SLOW_HASH_SIMD;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 1;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 3;
9917 break;
9918
9919 case 11000: hash_type = HASH_TYPE_MD5;
9920 salt_type = SALT_TYPE_INTERN;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_PT_ADD80;
9924 kern_type = KERN_TYPE_PRESTASHOP;
9925 dgst_size = DGST_SIZE_4_4;
9926 parse_func = prestashop_parse_hash;
9927 sort_by_digest = sort_by_digest_4_4;
9928 opti_type = OPTI_TYPE_ZERO_BYTE
9929 | OPTI_TYPE_PRECOMPUTE_INIT
9930 | OPTI_TYPE_NOT_ITERATED
9931 | OPTI_TYPE_PREPENDED_SALT;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 3;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 11100: hash_type = HASH_TYPE_MD5;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_ST_ADD80;
9943 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9944 dgst_size = DGST_SIZE_4_4;
9945 parse_func = postgresql_auth_parse_hash;
9946 sort_by_digest = sort_by_digest_4_4;
9947 opti_type = OPTI_TYPE_ZERO_BYTE
9948 | OPTI_TYPE_PRECOMPUTE_INIT
9949 | OPTI_TYPE_PRECOMPUTE_MERKLE
9950 | OPTI_TYPE_EARLY_SKIP;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 3;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 11200: hash_type = HASH_TYPE_SHA1;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_BE
9961 | OPTS_TYPE_PT_ADD80
9962 | OPTS_TYPE_ST_HEX;
9963 kern_type = KERN_TYPE_MYSQL_AUTH;
9964 dgst_size = DGST_SIZE_4_5;
9965 parse_func = mysql_auth_parse_hash;
9966 sort_by_digest = sort_by_digest_4_5;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_EARLY_SKIP;
9969 dgst_pos0 = 3;
9970 dgst_pos1 = 4;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 1;
9973 break;
9974
9975 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE
9979 | OPTS_TYPE_ST_HEX
9980 | OPTS_TYPE_ST_ADD80;
9981 kern_type = KERN_TYPE_BITCOIN_WALLET;
9982 dgst_size = DGST_SIZE_4_4;
9983 parse_func = bitcoin_wallet_parse_hash;
9984 sort_by_digest = sort_by_digest_4_4;
9985 opti_type = OPTI_TYPE_ZERO_BYTE;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 11400: hash_type = HASH_TYPE_MD5;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE
9996 | OPTS_TYPE_PT_ADD80
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_SIP_AUTH;
9999 dgst_size = DGST_SIZE_4_4;
10000 parse_func = sip_auth_parse_hash;
10001 sort_by_digest = sort_by_digest_4_4;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 3;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 1;
10007 break;
10008
10009 case 11500: hash_type = HASH_TYPE_CRC32;
10010 salt_type = SALT_TYPE_INTERN;
10011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_ST_GENERATE_LE
10014 | OPTS_TYPE_ST_HEX;
10015 kern_type = KERN_TYPE_CRC32;
10016 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10017 parse_func = crc32_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 11600: hash_type = HASH_TYPE_AES;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_PT_NEVERCRACK;
10031 kern_type = KERN_TYPE_SEVEN_ZIP;
10032 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10033 parse_func = seven_zip_parse_hash;
10034 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10043 salt_type = SALT_TYPE_NONE;
10044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_PT_ADD01;
10047 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10048 dgst_size = DGST_SIZE_4_8;
10049 parse_func = gost2012sbog_256_parse_hash;
10050 sort_by_digest = sort_by_digest_4_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10059 salt_type = SALT_TYPE_NONE;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_PT_ADD01;
10063 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10064 dgst_size = DGST_SIZE_4_16;
10065 parse_func = gost2012sbog_512_parse_hash;
10066 sort_by_digest = sort_by_digest_4_16;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_ST_BASE64
10079 | OPTS_TYPE_HASH_COPY;
10080 kern_type = KERN_TYPE_PBKDF2_MD5;
10081 dgst_size = DGST_SIZE_4_32;
10082 parse_func = pbkdf2_md5_parse_hash;
10083 sort_by_digest = sort_by_digest_4_32;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_SLOW_HASH_SIMD;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE
10096 | OPTS_TYPE_ST_BASE64
10097 | OPTS_TYPE_HASH_COPY;
10098 kern_type = KERN_TYPE_PBKDF2_SHA1;
10099 dgst_size = DGST_SIZE_4_32;
10100 parse_func = pbkdf2_sha1_parse_hash;
10101 sort_by_digest = sort_by_digest_4_32;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_SLOW_HASH_SIMD;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE
10114 | OPTS_TYPE_ST_BASE64
10115 | OPTS_TYPE_HASH_COPY;
10116 kern_type = KERN_TYPE_PBKDF2_SHA512;
10117 dgst_size = DGST_SIZE_8_16;
10118 parse_func = pbkdf2_sha512_parse_hash;
10119 sort_by_digest = sort_by_digest_8_16;
10120 opti_type = OPTI_TYPE_ZERO_BYTE
10121 | OPTI_TYPE_USES_BITS_64
10122 | OPTI_TYPE_SLOW_HASH_SIMD;
10123 dgst_pos0 = 0;
10124 dgst_pos1 = 1;
10125 dgst_pos2 = 2;
10126 dgst_pos3 = 3;
10127 break;
10128
10129 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10130 salt_type = SALT_TYPE_EMBEDDED;
10131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10133 kern_type = KERN_TYPE_ECRYPTFS;
10134 dgst_size = DGST_SIZE_8_8;
10135 parse_func = ecryptfs_parse_hash;
10136 sort_by_digest = sort_by_digest_8_8;
10137 opti_type = OPTI_TYPE_ZERO_BYTE
10138 | OPTI_TYPE_USES_BITS_64;
10139 dgst_pos0 = 0;
10140 dgst_pos1 = 1;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 3;
10143 break;
10144
10145 case 12300: hash_type = HASH_TYPE_ORACLET;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10149 kern_type = KERN_TYPE_ORACLET;
10150 dgst_size = DGST_SIZE_8_16;
10151 parse_func = oraclet_parse_hash;
10152 sort_by_digest = sort_by_digest_8_16;
10153 opti_type = OPTI_TYPE_ZERO_BYTE
10154 | OPTI_TYPE_USES_BITS_64;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10165 kern_type = KERN_TYPE_BSDICRYPT;
10166 dgst_size = DGST_SIZE_4_4;
10167 parse_func = bsdicrypt_parse_hash;
10168 sort_by_digest = sort_by_digest_4_4;
10169 opti_type = OPTI_TYPE_ZERO_BYTE
10170 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12500: hash_type = HASH_TYPE_RAR3HP;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_RAR3;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = rar3hp_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 12600: hash_type = HASH_TYPE_SHA256;
10193 salt_type = SALT_TYPE_INTERN;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_BE
10196 | OPTS_TYPE_PT_ADD80;
10197 kern_type = KERN_TYPE_CF10;
10198 dgst_size = DGST_SIZE_4_8;
10199 parse_func = cf10_parse_hash;
10200 sort_by_digest = sort_by_digest_4_8;
10201 opti_type = OPTI_TYPE_ZERO_BYTE
10202 | OPTI_TYPE_PRECOMPUTE_INIT
10203 | OPTI_TYPE_EARLY_SKIP
10204 | OPTI_TYPE_NOT_ITERATED;
10205 dgst_pos0 = 3;
10206 dgst_pos1 = 7;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 6;
10209 break;
10210
10211 case 12700: hash_type = HASH_TYPE_AES;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE
10215 | OPTS_TYPE_HASH_COPY;
10216 kern_type = KERN_TYPE_MYWALLET;
10217 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10218 parse_func = mywallet_parse_hash;
10219 sort_by_digest = sort_by_digest_4_5;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_MS_DRSR;
10232 dgst_size = DGST_SIZE_4_8;
10233 parse_func = ms_drsr_parse_hash;
10234 sort_by_digest = sort_by_digest_4_8;
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10247 dgst_size = DGST_SIZE_4_8;
10248 parse_func = androidfde_samsung_parse_hash;
10249 sort_by_digest = sort_by_digest_4_8;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10258 salt_type = SALT_TYPE_EMBEDDED;
10259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10261 kern_type = KERN_TYPE_RAR5;
10262 dgst_size = DGST_SIZE_4_4;
10263 parse_func = rar5_parse_hash;
10264 sort_by_digest = sort_by_digest_4_4;
10265 opti_type = OPTI_TYPE_ZERO_BYTE;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 1;
10268 dgst_pos2 = 2;
10269 dgst_pos3 = 3;
10270 break;
10271
10272 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10276 kern_type = KERN_TYPE_KRB5TGS;
10277 dgst_size = DGST_SIZE_4_4;
10278 parse_func = krb5tgs_parse_hash;
10279 sort_by_digest = sort_by_digest_4_4;
10280 opti_type = OPTI_TYPE_ZERO_BYTE
10281 | OPTI_TYPE_NOT_ITERATED;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 case 13200: hash_type = HASH_TYPE_AES;
10289 salt_type = SALT_TYPE_EMBEDDED;
10290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10292 kern_type = KERN_TYPE_AXCRYPT;
10293 dgst_size = DGST_SIZE_4_4;
10294 parse_func = axcrypt_parse_hash;
10295 sort_by_digest = sort_by_digest_4_4;
10296 opti_type = OPTI_TYPE_ZERO_BYTE;
10297 dgst_pos0 = 0;
10298 dgst_pos1 = 1;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 3;
10301 break;
10302
10303 case 13300: hash_type = HASH_TYPE_SHA1;
10304 salt_type = SALT_TYPE_NONE;
10305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_BE
10307 | OPTS_TYPE_PT_ADD80
10308 | OPTS_TYPE_PT_ADDBITS15;
10309 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10310 dgst_size = DGST_SIZE_4_5;
10311 parse_func = sha1axcrypt_parse_hash;
10312 sort_by_digest = sort_by_digest_4_5;
10313 opti_type = OPTI_TYPE_ZERO_BYTE
10314 | OPTI_TYPE_PRECOMPUTE_INIT
10315 | OPTI_TYPE_EARLY_SKIP
10316 | OPTI_TYPE_NOT_ITERATED
10317 | OPTI_TYPE_NOT_SALTED;
10318 dgst_pos0 = 0;
10319 dgst_pos1 = 4;
10320 dgst_pos2 = 3;
10321 dgst_pos3 = 2;
10322 break;
10323
10324 case 13400: hash_type = HASH_TYPE_AES;
10325 salt_type = SALT_TYPE_EMBEDDED;
10326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10328 kern_type = KERN_TYPE_KEEPASS;
10329 dgst_size = DGST_SIZE_4_4;
10330 parse_func = keepass_parse_hash;
10331 sort_by_digest = sort_by_digest_4_4;
10332 opti_type = OPTI_TYPE_ZERO_BYTE;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 13500: hash_type = HASH_TYPE_SHA1;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_BE
10343 | OPTS_TYPE_PT_UNICODE
10344 | OPTS_TYPE_PT_ADD80;
10345 kern_type = KERN_TYPE_PSTOKEN;
10346 dgst_size = DGST_SIZE_4_5;
10347 parse_func = pstoken_parse_hash;
10348 sort_by_digest = sort_by_digest_4_5;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_PRECOMPUTE_INIT
10351 | OPTI_TYPE_EARLY_SKIP
10352 | OPTI_TYPE_NOT_ITERATED
10353 | OPTI_TYPE_PREPENDED_SALT
10354 | OPTI_TYPE_RAW_HASH;
10355 dgst_pos0 = 3;
10356 dgst_pos1 = 4;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 1;
10359 break;
10360
10361 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_ZIP2;
10366 dgst_size = DGST_SIZE_4_4;
10367 parse_func = zip2_parse_hash;
10368 sort_by_digest = sort_by_digest_4_4;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10380 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10381 dgst_size = DGST_SIZE_4_5;
10382 parse_func = veracrypt_parse_hash_655331;
10383 sort_by_digest = sort_by_digest_4_5;
10384 opti_type = OPTI_TYPE_ZERO_BYTE;
10385 dgst_pos0 = 0;
10386 dgst_pos1 = 1;
10387 dgst_pos2 = 2;
10388 dgst_pos3 = 3;
10389 break;
10390
10391 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10395 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10396 dgst_size = DGST_SIZE_4_5;
10397 parse_func = veracrypt_parse_hash_655331;
10398 sort_by_digest = sort_by_digest_4_5;
10399 opti_type = OPTI_TYPE_ZERO_BYTE;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10407 salt_type = SALT_TYPE_EMBEDDED;
10408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10410 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10411 dgst_size = DGST_SIZE_4_5;
10412 parse_func = veracrypt_parse_hash_655331;
10413 sort_by_digest = sort_by_digest_4_5;
10414 opti_type = OPTI_TYPE_ZERO_BYTE;
10415 dgst_pos0 = 0;
10416 dgst_pos1 = 1;
10417 dgst_pos2 = 2;
10418 dgst_pos3 = 3;
10419 break;
10420
10421 case 13721: hash_type = HASH_TYPE_SHA512;
10422 salt_type = SALT_TYPE_EMBEDDED;
10423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10424 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10425 kern_type = KERN_TYPE_TCSHA512_XTS512;
10426 dgst_size = DGST_SIZE_8_8;
10427 parse_func = veracrypt_parse_hash_500000;
10428 sort_by_digest = sort_by_digest_8_8;
10429 opti_type = OPTI_TYPE_ZERO_BYTE
10430 | OPTI_TYPE_USES_BITS_64;
10431 dgst_pos0 = 0;
10432 dgst_pos1 = 1;
10433 dgst_pos2 = 2;
10434 dgst_pos3 = 3;
10435 break;
10436
10437 case 13722: hash_type = HASH_TYPE_SHA512;
10438 salt_type = SALT_TYPE_EMBEDDED;
10439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10440 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10441 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10442 dgst_size = DGST_SIZE_8_8;
10443 parse_func = veracrypt_parse_hash_500000;
10444 sort_by_digest = sort_by_digest_8_8;
10445 opti_type = OPTI_TYPE_ZERO_BYTE
10446 | OPTI_TYPE_USES_BITS_64;
10447 dgst_pos0 = 0;
10448 dgst_pos1 = 1;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 3;
10451 break;
10452
10453 case 13723: hash_type = HASH_TYPE_SHA512;
10454 salt_type = SALT_TYPE_EMBEDDED;
10455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10457 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10458 dgst_size = DGST_SIZE_8_8;
10459 parse_func = veracrypt_parse_hash_500000;
10460 sort_by_digest = sort_by_digest_8_8;
10461 opti_type = OPTI_TYPE_ZERO_BYTE
10462 | OPTI_TYPE_USES_BITS_64;
10463 dgst_pos0 = 0;
10464 dgst_pos1 = 1;
10465 dgst_pos2 = 2;
10466 dgst_pos3 = 3;
10467 break;
10468
10469 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10470 salt_type = SALT_TYPE_EMBEDDED;
10471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10473 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10474 dgst_size = DGST_SIZE_4_8;
10475 parse_func = veracrypt_parse_hash_500000;
10476 sort_by_digest = sort_by_digest_4_8;
10477 opti_type = OPTI_TYPE_ZERO_BYTE;
10478 dgst_pos0 = 0;
10479 dgst_pos1 = 1;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 3;
10482 break;
10483
10484 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10488 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10489 dgst_size = DGST_SIZE_4_8;
10490 parse_func = veracrypt_parse_hash_500000;
10491 sort_by_digest = sort_by_digest_4_8;
10492 opti_type = OPTI_TYPE_ZERO_BYTE;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 1;
10495 dgst_pos2 = 2;
10496 dgst_pos3 = 3;
10497 break;
10498
10499 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10504 dgst_size = DGST_SIZE_4_8;
10505 parse_func = veracrypt_parse_hash_500000;
10506 sort_by_digest = sort_by_digest_4_8;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10518 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10519 dgst_size = DGST_SIZE_4_5;
10520 parse_func = veracrypt_parse_hash_327661;
10521 sort_by_digest = sort_by_digest_4_5;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10534 dgst_size = DGST_SIZE_4_5;
10535 parse_func = veracrypt_parse_hash_327661;
10536 sort_by_digest = sort_by_digest_4_5;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10548 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10549 dgst_size = DGST_SIZE_4_5;
10550 parse_func = veracrypt_parse_hash_327661;
10551 sort_by_digest = sort_by_digest_4_5;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13751: hash_type = HASH_TYPE_SHA256;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10563 kern_type = KERN_TYPE_VCSHA256_XTS512;
10564 dgst_size = DGST_SIZE_4_8;
10565 parse_func = veracrypt_parse_hash_500000;
10566 sort_by_digest = sort_by_digest_4_8;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13752: hash_type = HASH_TYPE_SHA256;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10579 dgst_size = DGST_SIZE_4_8;
10580 parse_func = veracrypt_parse_hash_500000;
10581 sort_by_digest = sort_by_digest_4_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13753: hash_type = HASH_TYPE_SHA256;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10593 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10594 dgst_size = DGST_SIZE_4_8;
10595 parse_func = veracrypt_parse_hash_500000;
10596 sort_by_digest = sort_by_digest_4_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 13761: hash_type = HASH_TYPE_SHA256;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10608 kern_type = KERN_TYPE_VCSHA256_XTS512;
10609 dgst_size = DGST_SIZE_4_8;
10610 parse_func = veracrypt_parse_hash_200000;
10611 sort_by_digest = sort_by_digest_4_8;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13762: hash_type = HASH_TYPE_SHA256;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10623 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_200000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 13763: hash_type = HASH_TYPE_SHA256;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10638 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10639 dgst_size = DGST_SIZE_4_8;
10640 parse_func = veracrypt_parse_hash_200000;
10641 sort_by_digest = sort_by_digest_4_8;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649
10650 default: usage_mini_print (PROGNAME); return (-1);
10651 }
10652
10653 /**
10654 * parser
10655 */
10656
10657 data.parse_func = parse_func;
10658
10659 /**
10660 * misc stuff
10661 */
10662
10663 if (hex_salt)
10664 {
10665 if (salt_type == SALT_TYPE_INTERN)
10666 {
10667 opts_type |= OPTS_TYPE_ST_HEX;
10668 }
10669 else
10670 {
10671 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10672
10673 return (-1);
10674 }
10675 }
10676
10677 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10678 | (salt_type == SALT_TYPE_EXTERN)
10679 | (salt_type == SALT_TYPE_EMBEDDED)
10680 | (salt_type == SALT_TYPE_VIRTUAL));
10681
10682 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10683
10684 data.hash_type = hash_type;
10685 data.attack_mode = attack_mode;
10686 data.attack_kern = attack_kern;
10687 data.attack_exec = attack_exec;
10688 data.kern_type = kern_type;
10689 data.opts_type = opts_type;
10690 data.dgst_size = dgst_size;
10691 data.salt_type = salt_type;
10692 data.isSalted = isSalted;
10693 data.sort_by_digest = sort_by_digest;
10694 data.dgst_pos0 = dgst_pos0;
10695 data.dgst_pos1 = dgst_pos1;
10696 data.dgst_pos2 = dgst_pos2;
10697 data.dgst_pos3 = dgst_pos3;
10698
10699 esalt_size = 0;
10700
10701 switch (hash_mode)
10702 {
10703 case 2500: esalt_size = sizeof (wpa_t); break;
10704 case 5300: esalt_size = sizeof (ikepsk_t); break;
10705 case 5400: esalt_size = sizeof (ikepsk_t); break;
10706 case 5500: esalt_size = sizeof (netntlm_t); break;
10707 case 5600: esalt_size = sizeof (netntlm_t); break;
10708 case 6211: esalt_size = sizeof (tc_t); break;
10709 case 6212: esalt_size = sizeof (tc_t); break;
10710 case 6213: esalt_size = sizeof (tc_t); break;
10711 case 6221: esalt_size = sizeof (tc_t); break;
10712 case 6222: esalt_size = sizeof (tc_t); break;
10713 case 6223: esalt_size = sizeof (tc_t); break;
10714 case 6231: esalt_size = sizeof (tc_t); break;
10715 case 6232: esalt_size = sizeof (tc_t); break;
10716 case 6233: esalt_size = sizeof (tc_t); break;
10717 case 6241: esalt_size = sizeof (tc_t); break;
10718 case 6242: esalt_size = sizeof (tc_t); break;
10719 case 6243: esalt_size = sizeof (tc_t); break;
10720 case 6600: esalt_size = sizeof (agilekey_t); break;
10721 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10722 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10723 case 7300: esalt_size = sizeof (rakp_t); break;
10724 case 7500: esalt_size = sizeof (krb5pa_t); break;
10725 case 8200: esalt_size = sizeof (cloudkey_t); break;
10726 case 8800: esalt_size = sizeof (androidfde_t); break;
10727 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10728 case 9400: esalt_size = sizeof (office2007_t); break;
10729 case 9500: esalt_size = sizeof (office2010_t); break;
10730 case 9600: esalt_size = sizeof (office2013_t); break;
10731 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10732 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10733 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10734 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10735 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10736 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10737 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10738 case 10200: esalt_size = sizeof (cram_md5_t); break;
10739 case 10400: esalt_size = sizeof (pdf_t); break;
10740 case 10410: esalt_size = sizeof (pdf_t); break;
10741 case 10420: esalt_size = sizeof (pdf_t); break;
10742 case 10500: esalt_size = sizeof (pdf_t); break;
10743 case 10600: esalt_size = sizeof (pdf_t); break;
10744 case 10700: esalt_size = sizeof (pdf_t); break;
10745 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10746 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10747 case 11400: esalt_size = sizeof (sip_t); break;
10748 case 11600: esalt_size = sizeof (seven_zip_t); break;
10749 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10750 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10751 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10752 case 13000: esalt_size = sizeof (rar5_t); break;
10753 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10754 case 13400: esalt_size = sizeof (keepass_t); break;
10755 case 13500: esalt_size = sizeof (pstoken_t); break;
10756 case 13600: esalt_size = sizeof (zip2_t); break;
10757 case 13711: esalt_size = sizeof (tc_t); break;
10758 case 13712: esalt_size = sizeof (tc_t); break;
10759 case 13713: esalt_size = sizeof (tc_t); break;
10760 case 13721: esalt_size = sizeof (tc_t); break;
10761 case 13722: esalt_size = sizeof (tc_t); break;
10762 case 13723: esalt_size = sizeof (tc_t); break;
10763 case 13731: esalt_size = sizeof (tc_t); break;
10764 case 13732: esalt_size = sizeof (tc_t); break;
10765 case 13733: esalt_size = sizeof (tc_t); break;
10766 case 13741: esalt_size = sizeof (tc_t); break;
10767 case 13742: esalt_size = sizeof (tc_t); break;
10768 case 13743: esalt_size = sizeof (tc_t); break;
10769 case 13751: esalt_size = sizeof (tc_t); break;
10770 case 13752: esalt_size = sizeof (tc_t); break;
10771 case 13753: esalt_size = sizeof (tc_t); break;
10772 case 13761: esalt_size = sizeof (tc_t); break;
10773 case 13762: esalt_size = sizeof (tc_t); break;
10774 case 13763: esalt_size = sizeof (tc_t); break;
10775 }
10776
10777 data.esalt_size = esalt_size;
10778
10779 /**
10780 * choose dictionary parser
10781 */
10782
10783 if (hash_type == HASH_TYPE_LM)
10784 {
10785 get_next_word_func = get_next_word_lm;
10786 }
10787 else if (opts_type & OPTS_TYPE_PT_UPPER)
10788 {
10789 get_next_word_func = get_next_word_uc;
10790 }
10791 else
10792 {
10793 get_next_word_func = get_next_word_std;
10794 }
10795
10796 /**
10797 * dictstat
10798 */
10799
10800 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10801
10802 #ifdef _POSIX
10803 size_t dictstat_nmemb = 0;
10804 #endif
10805
10806 #ifdef _WIN
10807 uint dictstat_nmemb = 0;
10808 #endif
10809
10810 char dictstat[256] = { 0 };
10811
10812 FILE *dictstat_fp = NULL;
10813
10814 if (keyspace == 0)
10815 {
10816 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10817
10818 dictstat_fp = fopen (dictstat, "rb");
10819
10820 if (dictstat_fp)
10821 {
10822 #ifdef _POSIX
10823 struct stat tmpstat;
10824
10825 fstat (fileno (dictstat_fp), &tmpstat);
10826 #endif
10827
10828 #ifdef _WIN
10829 struct stat64 tmpstat;
10830
10831 _fstat64 (fileno (dictstat_fp), &tmpstat);
10832 #endif
10833
10834 if (tmpstat.st_mtime < COMPTIME)
10835 {
10836 /* with v0.15 the format changed so we have to ensure user is using a good version
10837 since there is no version-header in the dictstat file */
10838
10839 fclose (dictstat_fp);
10840
10841 unlink (dictstat);
10842 }
10843 else
10844 {
10845 while (!feof (dictstat_fp))
10846 {
10847 dictstat_t d;
10848
10849 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10850
10851 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10852
10853 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10854 {
10855 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10856
10857 return -1;
10858 }
10859 }
10860
10861 fclose (dictstat_fp);
10862 }
10863 }
10864 }
10865
10866 /**
10867 * potfile
10868 */
10869
10870 char potfile[256] = { 0 };
10871
10872 if (potfile_path == NULL)
10873 {
10874 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10875 }
10876 else
10877 {
10878 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10879 }
10880
10881 data.pot_fp = NULL;
10882
10883 FILE *out_fp = NULL;
10884 FILE *pot_fp = NULL;
10885
10886 if (show == 1 || left == 1)
10887 {
10888 pot_fp = fopen (potfile, "rb");
10889
10890 if (pot_fp == NULL)
10891 {
10892 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10893
10894 return (-1);
10895 }
10896
10897 if (outfile != NULL)
10898 {
10899 if ((out_fp = fopen (outfile, "ab")) == NULL)
10900 {
10901 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10902
10903 fclose (pot_fp);
10904
10905 return (-1);
10906 }
10907 }
10908 else
10909 {
10910 out_fp = stdout;
10911 }
10912 }
10913 else
10914 {
10915 if (potfile_disable == 0)
10916 {
10917 pot_fp = fopen (potfile, "ab");
10918
10919 if (pot_fp == NULL)
10920 {
10921 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10922
10923 return (-1);
10924 }
10925
10926 data.pot_fp = pot_fp;
10927 }
10928 }
10929
10930 pot_t *pot = NULL;
10931
10932 uint pot_cnt = 0;
10933 uint pot_avail = 0;
10934
10935 if (show == 1 || left == 1)
10936 {
10937 SUPPRESS_OUTPUT = 1;
10938
10939 pot_avail = count_lines (pot_fp);
10940
10941 rewind (pot_fp);
10942
10943 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10944
10945 uint pot_hashes_avail = 0;
10946
10947 uint line_num = 0;
10948
10949 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10950
10951 while (!feof (pot_fp))
10952 {
10953 line_num++;
10954
10955 int line_len = fgetl (pot_fp, line_buf);
10956
10957 if (line_len == 0) continue;
10958
10959 char *plain_buf = line_buf + line_len;
10960
10961 pot_t *pot_ptr = &pot[pot_cnt];
10962
10963 hash_t *hashes_buf = &pot_ptr->hash;
10964
10965 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10966 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10967
10968 if (pot_cnt == pot_hashes_avail)
10969 {
10970 uint pos = 0;
10971
10972 for (pos = 0; pos < INCR_POT; pos++)
10973 {
10974 if ((pot_cnt + pos) >= pot_avail) break;
10975
10976 pot_t *tmp_pot = &pot[pot_cnt + pos];
10977
10978 hash_t *tmp_hash = &tmp_pot->hash;
10979
10980 tmp_hash->digest = mymalloc (dgst_size);
10981
10982 if (isSalted)
10983 {
10984 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10985 }
10986
10987 if (esalt_size)
10988 {
10989 tmp_hash->esalt = mymalloc (esalt_size);
10990 }
10991
10992 pot_hashes_avail++;
10993 }
10994 }
10995
10996 int plain_len = 0;
10997
10998 int parser_status;
10999
11000 int iter = MAX_CUT_TRIES;
11001
11002 do
11003 {
11004 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11005 {
11006 if (line_buf[i] == ':')
11007 {
11008 line_len--;
11009
11010 break;
11011 }
11012 }
11013
11014 if (data.hash_mode != 2500)
11015 {
11016 parser_status = parse_func (line_buf, line_len, hashes_buf);
11017 }
11018 else
11019 {
11020 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11021
11022 if (line_len > max_salt_size)
11023 {
11024 parser_status = PARSER_GLOBAL_LENGTH;
11025 }
11026 else
11027 {
11028 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11029
11030 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11031
11032 hashes_buf->salt->salt_len = line_len;
11033
11034 parser_status = PARSER_OK;
11035 }
11036 }
11037
11038 // if NOT parsed without error, we add the ":" to the plain
11039
11040 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11041 {
11042 plain_len++;
11043 plain_buf--;
11044 }
11045
11046 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11047
11048 if (parser_status < PARSER_GLOBAL_ZERO)
11049 {
11050 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11051
11052 continue;
11053 }
11054
11055 if (plain_len >= 255) continue;
11056
11057 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11058
11059 pot_ptr->plain_len = plain_len;
11060
11061 pot_cnt++;
11062 }
11063
11064 myfree (line_buf);
11065
11066 fclose (pot_fp);
11067
11068 SUPPRESS_OUTPUT = 0;
11069
11070 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11071 }
11072
11073 /**
11074 * word len
11075 */
11076
11077 uint pw_min = PW_MIN;
11078 uint pw_max = PW_MAX;
11079
11080 switch (hash_mode)
11081 {
11082 case 125: if (pw_max > 32) pw_max = 32;
11083 break;
11084 case 400: if (pw_max > 40) pw_max = 40;
11085 break;
11086 case 500: if (pw_max > 16) pw_max = 16;
11087 break;
11088 case 1500: if (pw_max > 8) pw_max = 8;
11089 break;
11090 case 1600: if (pw_max > 16) pw_max = 16;
11091 break;
11092 case 1800: if (pw_max > 16) pw_max = 16;
11093 break;
11094 case 2100: if (pw_max > 16) pw_max = 16;
11095 break;
11096 case 2500: if (pw_min < 8) pw_min = 8;
11097 break;
11098 case 3000: if (pw_max > 7) pw_max = 7;
11099 break;
11100 case 5200: if (pw_max > 24) pw_max = 24;
11101 break;
11102 case 5800: if (pw_max > 16) pw_max = 16;
11103 break;
11104 case 6300: if (pw_max > 16) pw_max = 16;
11105 break;
11106 case 7400: if (pw_max > 16) pw_max = 16;
11107 break;
11108 case 7900: if (pw_max > 48) pw_max = 48;
11109 break;
11110 case 8500: if (pw_max > 8) pw_max = 8;
11111 break;
11112 case 8600: if (pw_max > 16) pw_max = 16;
11113 break;
11114 case 9710: pw_min = 5;
11115 pw_max = 5;
11116 break;
11117 case 9810: pw_min = 5;
11118 pw_max = 5;
11119 break;
11120 case 10410: pw_min = 5;
11121 pw_max = 5;
11122 break;
11123 case 10300: if (pw_max < 3) pw_min = 3;
11124 if (pw_max > 40) pw_max = 40;
11125 break;
11126 case 10500: if (pw_max < 3) pw_min = 3;
11127 if (pw_max > 40) pw_max = 40;
11128 break;
11129 case 10700: if (pw_max > 16) pw_max = 16;
11130 break;
11131 case 11300: if (pw_max > 40) pw_max = 40;
11132 break;
11133 case 11600: if (pw_max > 32) pw_max = 32;
11134 break;
11135 case 12500: if (pw_max > 20) pw_max = 20;
11136 break;
11137 case 12800: if (pw_max > 24) pw_max = 24;
11138 break;
11139 }
11140
11141 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11142 {
11143 switch (attack_kern)
11144 {
11145 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11146 break;
11147 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11148 break;
11149 }
11150 }
11151
11152 /**
11153 * charsets : keep them together for more easy maintainnce
11154 */
11155
11156 cs_t mp_sys[6] = { { { 0 }, 0 } };
11157 cs_t mp_usr[4] = { { { 0 }, 0 } };
11158
11159 mp_setup_sys (mp_sys);
11160
11161 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11162 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11163 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11164 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11165
11166 /**
11167 * load hashes, part I: find input mode, count hashes
11168 */
11169
11170 uint hashlist_mode = 0;
11171 uint hashlist_format = HLFMT_HASHCAT;
11172
11173 uint hashes_avail = 0;
11174
11175 if (benchmark == 0)
11176 {
11177 struct stat f;
11178
11179 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11180
11181 if ((hash_mode == 2500) ||
11182 (hash_mode == 5200) ||
11183 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11184 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11185 (hash_mode == 9000))
11186 {
11187 hashlist_mode = HL_MODE_ARG;
11188
11189 char *hashfile = myargv[optind];
11190
11191 data.hashfile = hashfile;
11192
11193 logfile_top_var_string ("target", hashfile);
11194 }
11195
11196 if (hashlist_mode == HL_MODE_ARG)
11197 {
11198 if (hash_mode == 2500)
11199 {
11200 struct stat st;
11201
11202 if (stat (data.hashfile, &st) == -1)
11203 {
11204 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11205
11206 return (-1);
11207 }
11208
11209 hashes_avail = st.st_size / sizeof (hccap_t);
11210 }
11211 else
11212 {
11213 hashes_avail = 1;
11214 }
11215 }
11216 else if (hashlist_mode == HL_MODE_FILE)
11217 {
11218 char *hashfile = myargv[optind];
11219
11220 data.hashfile = hashfile;
11221
11222 logfile_top_var_string ("target", hashfile);
11223
11224 FILE *fp = NULL;
11225
11226 if ((fp = fopen (hashfile, "rb")) == NULL)
11227 {
11228 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11229
11230 return (-1);
11231 }
11232
11233 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11234
11235 hashes_avail = count_lines (fp);
11236
11237 rewind (fp);
11238
11239 if (hashes_avail == 0)
11240 {
11241 log_error ("ERROR: hashfile is empty or corrupt");
11242
11243 fclose (fp);
11244
11245 return (-1);
11246 }
11247
11248 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11249
11250 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11251 {
11252 log_error ("ERROR: remove not supported in native hashfile-format mode");
11253
11254 fclose (fp);
11255
11256 return (-1);
11257 }
11258
11259 fclose (fp);
11260 }
11261 }
11262 else
11263 {
11264 hashlist_mode = HL_MODE_ARG;
11265
11266 hashes_avail = 1;
11267 }
11268
11269 if (hash_mode == 3000) hashes_avail *= 2;
11270
11271 data.hashlist_mode = hashlist_mode;
11272 data.hashlist_format = hashlist_format;
11273
11274 logfile_top_uint (hashlist_mode);
11275 logfile_top_uint (hashlist_format);
11276
11277 /**
11278 * load hashes, part II: allocate required memory, set pointers
11279 */
11280
11281 hash_t *hashes_buf = NULL;
11282 void *digests_buf = NULL;
11283 salt_t *salts_buf = NULL;
11284 void *esalts_buf = NULL;
11285
11286 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11287
11288 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11289
11290 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11291 {
11292 u32 hash_pos;
11293
11294 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11295 {
11296 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11297
11298 hashes_buf[hash_pos].hash_info = hash_info;
11299
11300 if (username && (remove || show || left))
11301 {
11302 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11303 }
11304
11305 if (benchmark)
11306 {
11307 hash_info->orighash = (char *) mymalloc (256);
11308 }
11309 }
11310 }
11311
11312 if (isSalted)
11313 {
11314 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11315
11316 if (esalt_size)
11317 {
11318 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11319 }
11320 }
11321 else
11322 {
11323 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11324 }
11325
11326 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11327 {
11328 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11329
11330 if (isSalted)
11331 {
11332 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11333
11334 if (esalt_size)
11335 {
11336 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11337 }
11338 }
11339 else
11340 {
11341 hashes_buf[hash_pos].salt = &salts_buf[0];
11342 }
11343 }
11344
11345 /**
11346 * load hashes, part III: parse hashes or generate them if benchmark
11347 */
11348
11349 uint hashes_cnt = 0;
11350
11351 if (benchmark == 0)
11352 {
11353 if (keyspace == 1)
11354 {
11355 // useless to read hash file for keyspace, cheat a little bit w/ optind
11356 }
11357 else if (hashes_avail == 0)
11358 {
11359 }
11360 else if (hashlist_mode == HL_MODE_ARG)
11361 {
11362 char *input_buf = myargv[optind];
11363
11364 uint input_len = strlen (input_buf);
11365
11366 logfile_top_var_string ("target", input_buf);
11367
11368 char *hash_buf = NULL;
11369 int hash_len = 0;
11370
11371 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11372
11373 bool hash_fmt_error = 0;
11374
11375 if (hash_len < 1) hash_fmt_error = 1;
11376 if (hash_buf == NULL) hash_fmt_error = 1;
11377
11378 if (hash_fmt_error)
11379 {
11380 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11381 }
11382 else
11383 {
11384 if (opts_type & OPTS_TYPE_HASH_COPY)
11385 {
11386 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11387
11388 hash_info_tmp->orighash = mystrdup (hash_buf);
11389 }
11390
11391 if (isSalted)
11392 {
11393 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11394 }
11395
11396 int parser_status = PARSER_OK;
11397
11398 if (hash_mode == 2500)
11399 {
11400 if (hash_len == 0)
11401 {
11402 log_error ("ERROR: hccap file not specified");
11403
11404 return (-1);
11405 }
11406
11407 hashlist_mode = HL_MODE_FILE;
11408
11409 data.hashlist_mode = hashlist_mode;
11410
11411 FILE *fp = fopen (hash_buf, "rb");
11412
11413 if (fp == NULL)
11414 {
11415 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11416
11417 return (-1);
11418 }
11419
11420 if (hashes_avail < 1)
11421 {
11422 log_error ("ERROR: hccap file is empty or corrupt");
11423
11424 fclose (fp);
11425
11426 return (-1);
11427 }
11428
11429 uint hccap_size = sizeof (hccap_t);
11430
11431 char *in = (char *) mymalloc (hccap_size);
11432
11433 while (!feof (fp))
11434 {
11435 int n = fread (in, hccap_size, 1, fp);
11436
11437 if (n != 1)
11438 {
11439 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11440
11441 break;
11442 }
11443
11444 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11445
11446 if (parser_status != PARSER_OK)
11447 {
11448 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11449
11450 continue;
11451 }
11452
11453 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11454
11455 if ((show == 1) || (left == 1))
11456 {
11457 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11458
11459 char *salt_ptr = (char *) tmp_salt->salt_buf;
11460
11461 int cur_pos = tmp_salt->salt_len;
11462 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11463
11464 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11465
11466 // do the appending task
11467
11468 snprintf (salt_ptr + cur_pos,
11469 rem_len,
11470 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11471 wpa->orig_mac1[0],
11472 wpa->orig_mac1[1],
11473 wpa->orig_mac1[2],
11474 wpa->orig_mac1[3],
11475 wpa->orig_mac1[4],
11476 wpa->orig_mac1[5],
11477 wpa->orig_mac2[0],
11478 wpa->orig_mac2[1],
11479 wpa->orig_mac2[2],
11480 wpa->orig_mac2[3],
11481 wpa->orig_mac2[4],
11482 wpa->orig_mac2[5]);
11483
11484 // memset () the remaining part of the salt
11485
11486 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11487 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11488
11489 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11490
11491 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11492 }
11493
11494 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);
11495 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);
11496
11497 hashes_cnt++;
11498 }
11499
11500 fclose (fp);
11501
11502 myfree (in);
11503 }
11504 else if (hash_mode == 3000)
11505 {
11506 if (hash_len == 32)
11507 {
11508 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11509
11510 hash_t *lm_hash_left = NULL;
11511
11512 if (parser_status == PARSER_OK)
11513 {
11514 lm_hash_left = &hashes_buf[hashes_cnt];
11515
11516 hashes_cnt++;
11517 }
11518 else
11519 {
11520 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11521 }
11522
11523 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11524
11525 hash_t *lm_hash_right = NULL;
11526
11527 if (parser_status == PARSER_OK)
11528 {
11529 lm_hash_right = &hashes_buf[hashes_cnt];
11530
11531 hashes_cnt++;
11532 }
11533 else
11534 {
11535 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11536 }
11537
11538 // show / left
11539
11540 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11541 {
11542 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);
11543 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);
11544 }
11545 }
11546 else
11547 {
11548 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11549
11550 if (parser_status == PARSER_OK)
11551 {
11552 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11553 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11554 }
11555
11556 if (parser_status == PARSER_OK)
11557 {
11558 hashes_cnt++;
11559 }
11560 else
11561 {
11562 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11563 }
11564 }
11565 }
11566 else
11567 {
11568 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11569
11570 if (parser_status == PARSER_OK)
11571 {
11572 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11573 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11574 }
11575
11576 if (parser_status == PARSER_OK)
11577 {
11578 hashes_cnt++;
11579 }
11580 else
11581 {
11582 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11583 }
11584 }
11585 }
11586 }
11587 else if (hashlist_mode == HL_MODE_FILE)
11588 {
11589 char *hashfile = data.hashfile;
11590
11591 FILE *fp;
11592
11593 if ((fp = fopen (hashfile, "rb")) == NULL)
11594 {
11595 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11596
11597 return (-1);
11598 }
11599
11600 uint line_num = 0;
11601
11602 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11603
11604 while (!feof (fp))
11605 {
11606 line_num++;
11607
11608 int line_len = fgetl (fp, line_buf);
11609
11610 if (line_len == 0) continue;
11611
11612 char *hash_buf = NULL;
11613 int hash_len = 0;
11614
11615 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11616
11617 bool hash_fmt_error = 0;
11618
11619 if (hash_len < 1) hash_fmt_error = 1;
11620 if (hash_buf == NULL) hash_fmt_error = 1;
11621
11622 if (hash_fmt_error)
11623 {
11624 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11625
11626 continue;
11627 }
11628
11629 if (username)
11630 {
11631 char *user_buf = NULL;
11632 int user_len = 0;
11633
11634 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11635
11636 if (remove || show)
11637 {
11638 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11639
11640 *user = (user_t *) mymalloc (sizeof (user_t));
11641
11642 user_t *user_ptr = *user;
11643
11644 if (user_buf != NULL)
11645 {
11646 user_ptr->user_name = mystrdup (user_buf);
11647 }
11648 else
11649 {
11650 user_ptr->user_name = mystrdup ("");
11651 }
11652
11653 user_ptr->user_len = user_len;
11654 }
11655 }
11656
11657 if (opts_type & OPTS_TYPE_HASH_COPY)
11658 {
11659 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11660
11661 hash_info_tmp->orighash = mystrdup (hash_buf);
11662 }
11663
11664 if (isSalted)
11665 {
11666 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11667 }
11668
11669 if (hash_mode == 3000)
11670 {
11671 if (hash_len == 32)
11672 {
11673 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11674
11675 if (parser_status < PARSER_GLOBAL_ZERO)
11676 {
11677 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11678
11679 continue;
11680 }
11681
11682 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11683
11684 hashes_cnt++;
11685
11686 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11687
11688 if (parser_status < PARSER_GLOBAL_ZERO)
11689 {
11690 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11691
11692 continue;
11693 }
11694
11695 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11696
11697 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);
11698
11699 hashes_cnt++;
11700
11701 // show / left
11702
11703 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);
11704 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);
11705 }
11706 else
11707 {
11708 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11709
11710 if (parser_status < PARSER_GLOBAL_ZERO)
11711 {
11712 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11713
11714 continue;
11715 }
11716
11717 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);
11718
11719 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11720 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11721
11722 hashes_cnt++;
11723 }
11724 }
11725 else
11726 {
11727 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11728
11729 if (parser_status < PARSER_GLOBAL_ZERO)
11730 {
11731 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11732
11733 continue;
11734 }
11735
11736 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);
11737
11738 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11739 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11740
11741 hashes_cnt++;
11742 }
11743 }
11744
11745 myfree (line_buf);
11746
11747 fclose (fp);
11748
11749 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11750
11751 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11752 }
11753 }
11754 else
11755 {
11756 if (isSalted)
11757 {
11758 hashes_buf[0].salt->salt_len = 8;
11759
11760 // special salt handling
11761
11762 switch (hash_mode)
11763 {
11764 case 1500: hashes_buf[0].salt->salt_len = 2;
11765 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11766 break;
11767 case 1731: hashes_buf[0].salt->salt_len = 4;
11768 break;
11769 case 2410: hashes_buf[0].salt->salt_len = 4;
11770 break;
11771 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11772 break;
11773 case 3100: hashes_buf[0].salt->salt_len = 1;
11774 break;
11775 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11776 break;
11777 case 5800: hashes_buf[0].salt->salt_len = 16;
11778 break;
11779 case 6800: hashes_buf[0].salt->salt_len = 32;
11780 break;
11781 case 8400: hashes_buf[0].salt->salt_len = 40;
11782 break;
11783 case 8800: hashes_buf[0].salt->salt_len = 16;
11784 break;
11785 case 8900: hashes_buf[0].salt->salt_len = 16;
11786 hashes_buf[0].salt->scrypt_N = 1024;
11787 hashes_buf[0].salt->scrypt_r = 1;
11788 hashes_buf[0].salt->scrypt_p = 1;
11789 break;
11790 case 9100: hashes_buf[0].salt->salt_len = 16;
11791 break;
11792 case 9300: hashes_buf[0].salt->salt_len = 14;
11793 hashes_buf[0].salt->scrypt_N = 16384;
11794 hashes_buf[0].salt->scrypt_r = 1;
11795 hashes_buf[0].salt->scrypt_p = 1;
11796 break;
11797 case 9400: hashes_buf[0].salt->salt_len = 16;
11798 break;
11799 case 9500: hashes_buf[0].salt->salt_len = 16;
11800 break;
11801 case 9600: hashes_buf[0].salt->salt_len = 16;
11802 break;
11803 case 9700: hashes_buf[0].salt->salt_len = 16;
11804 break;
11805 case 9710: hashes_buf[0].salt->salt_len = 16;
11806 break;
11807 case 9720: hashes_buf[0].salt->salt_len = 16;
11808 break;
11809 case 9800: hashes_buf[0].salt->salt_len = 16;
11810 break;
11811 case 9810: hashes_buf[0].salt->salt_len = 16;
11812 break;
11813 case 9820: hashes_buf[0].salt->salt_len = 16;
11814 break;
11815 case 10300: hashes_buf[0].salt->salt_len = 12;
11816 break;
11817 case 11500: hashes_buf[0].salt->salt_len = 4;
11818 break;
11819 case 11600: hashes_buf[0].salt->salt_len = 4;
11820 break;
11821 case 12400: hashes_buf[0].salt->salt_len = 4;
11822 break;
11823 case 12500: hashes_buf[0].salt->salt_len = 8;
11824 break;
11825 case 12600: hashes_buf[0].salt->salt_len = 64;
11826 break;
11827 }
11828
11829 // special esalt handling
11830
11831 switch (hash_mode)
11832 {
11833 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11834 break;
11835 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11836 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11837 break;
11838 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11839 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11840 break;
11841 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11842 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11843 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11844 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11845 break;
11846 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11847 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11848 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11849 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11850 break;
11851 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11852 break;
11853 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11854 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11855 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11856 break;
11857 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11858 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11859 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11860 break;
11861 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11862 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11863 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11864 break;
11865 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11866 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11867 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11868 break;
11869 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11870 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11871 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11872 break;
11873 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11874 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11875 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11876 break;
11877 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11878 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11879 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11880 break;
11881 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11882 break;
11883 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11884 break;
11885 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11886 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11887 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11888 break;
11889 }
11890 }
11891
11892 // set hashfile
11893
11894 switch (hash_mode)
11895 {
11896 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11897 break;
11898 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11899 break;
11900 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11901 break;
11902 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11903 break;
11904 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11905 break;
11906 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11907 break;
11908 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11909 break;
11910 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11911 break;
11912 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11913 break;
11914 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11915 break;
11916 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11917 break;
11918 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11919 break;
11920 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11921 break;
11922 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11923 break;
11924 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11925 break;
11926 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11927 break;
11928 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11929 break;
11930 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11931 break;
11932 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11933 break;
11934 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11935 break;
11936 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11937 break;
11938 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11939 break;
11940 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11941 break;
11942 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11943 break;
11944 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11945 break;
11946 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11947 break;
11948 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11949 break;
11950 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11951 break;
11952 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11953 break;
11954 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11955 break;
11956 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11957 break;
11958 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11959 break;
11960 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11961 break;
11962 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11963 break;
11964 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11965 break;
11966 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11967 break;
11968 }
11969
11970 // set default iterations
11971
11972 switch (hash_mode)
11973 {
11974 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11975 break;
11976 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11977 break;
11978 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11979 break;
11980 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11981 break;
11982 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11983 break;
11984 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11985 break;
11986 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11987 break;
11988 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11989 break;
11990 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11991 break;
11992 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11993 break;
11994 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11995 break;
11996 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11997 break;
11998 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11999 break;
12000 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12001 break;
12002 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12003 break;
12004 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12005 break;
12006 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12007 break;
12008 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12009 break;
12010 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12011 break;
12012 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12013 break;
12014 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12015 break;
12016 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12017 break;
12018 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12019 break;
12020 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12021 break;
12022 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12023 break;
12024 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12025 break;
12026 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12027 break;
12028 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12029 break;
12030 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12031 break;
12032 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12033 break;
12034 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12035 break;
12036 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12037 break;
12038 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12039 break;
12040 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12041 break;
12042 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12043 break;
12044 case 8900: hashes_buf[0].salt->salt_iter = 1;
12045 break;
12046 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12047 break;
12048 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12049 break;
12050 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12051 break;
12052 case 9300: hashes_buf[0].salt->salt_iter = 1;
12053 break;
12054 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12055 break;
12056 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12057 break;
12058 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12059 break;
12060 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12061 break;
12062 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12063 break;
12064 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12065 break;
12066 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12067 break;
12068 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12069 break;
12070 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12071 break;
12072 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12073 break;
12074 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12075 break;
12076 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12077 break;
12078 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12079 break;
12080 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12081 break;
12082 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12083 break;
12084 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12085 break;
12086 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12087 break;
12088 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12089 break;
12090 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12091 break;
12092 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12093 break;
12094 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12095 break;
12096 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12097 break;
12098 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12099 break;
12100 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12101 break;
12102 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12103 break;
12104 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12105 break;
12106 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12107 break;
12108 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12109 break;
12110 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12111 break;
12112 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12113 break;
12114 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12115 break;
12116 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12117 break;
12118 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12119 break;
12120 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12121 break;
12122 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12123 break;
12124 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12125 break;
12126 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12127 break;
12128 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12129 break;
12130 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12131 break;
12132 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12133 break;
12134 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12135 break;
12136 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12137 break;
12138 }
12139
12140 hashes_cnt = 1;
12141 }
12142
12143 if (show == 1 || left == 1)
12144 {
12145 for (uint i = 0; i < pot_cnt; i++)
12146 {
12147 pot_t *pot_ptr = &pot[i];
12148
12149 hash_t *hashes_buf = &pot_ptr->hash;
12150
12151 local_free (hashes_buf->digest);
12152
12153 if (isSalted)
12154 {
12155 local_free (hashes_buf->salt);
12156 }
12157 }
12158
12159 local_free (pot);
12160
12161 if (data.quiet == 0) log_info_nn ("");
12162
12163 return (0);
12164 }
12165
12166 if (keyspace == 0)
12167 {
12168 if (hashes_cnt == 0)
12169 {
12170 log_error ("ERROR: No hashes loaded");
12171
12172 return (-1);
12173 }
12174 }
12175
12176 /**
12177 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12178 */
12179
12180 if (data.outfile != NULL)
12181 {
12182 if (data.hashfile != NULL)
12183 {
12184 #ifdef _POSIX
12185 struct stat tmpstat_outfile;
12186 struct stat tmpstat_hashfile;
12187 #endif
12188
12189 #ifdef _WIN
12190 struct stat64 tmpstat_outfile;
12191 struct stat64 tmpstat_hashfile;
12192 #endif
12193
12194 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12195
12196 if (tmp_outfile_fp)
12197 {
12198 #ifdef _POSIX
12199 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12200 #endif
12201
12202 #ifdef _WIN
12203 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12204 #endif
12205
12206 fclose (tmp_outfile_fp);
12207 }
12208
12209 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12210
12211 if (tmp_hashfile_fp)
12212 {
12213 #ifdef _POSIX
12214 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12215 #endif
12216
12217 #ifdef _WIN
12218 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12219 #endif
12220
12221 fclose (tmp_hashfile_fp);
12222 }
12223
12224 if (tmp_outfile_fp && tmp_outfile_fp)
12225 {
12226 tmpstat_outfile.st_mode = 0;
12227 tmpstat_outfile.st_nlink = 0;
12228 tmpstat_outfile.st_uid = 0;
12229 tmpstat_outfile.st_gid = 0;
12230 tmpstat_outfile.st_rdev = 0;
12231 tmpstat_outfile.st_atime = 0;
12232
12233 tmpstat_hashfile.st_mode = 0;
12234 tmpstat_hashfile.st_nlink = 0;
12235 tmpstat_hashfile.st_uid = 0;
12236 tmpstat_hashfile.st_gid = 0;
12237 tmpstat_hashfile.st_rdev = 0;
12238 tmpstat_hashfile.st_atime = 0;
12239
12240 #ifdef _POSIX
12241 tmpstat_outfile.st_blksize = 0;
12242 tmpstat_outfile.st_blocks = 0;
12243
12244 tmpstat_hashfile.st_blksize = 0;
12245 tmpstat_hashfile.st_blocks = 0;
12246 #endif
12247
12248 #ifdef _POSIX
12249 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12250 {
12251 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12252
12253 return (-1);
12254 }
12255 #endif
12256
12257 #ifdef _WIN
12258 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12259 {
12260 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12261
12262 return (-1);
12263 }
12264 #endif
12265 }
12266 }
12267 }
12268
12269 /**
12270 * Remove duplicates
12271 */
12272
12273 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12274
12275 if (isSalted)
12276 {
12277 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12278 }
12279 else
12280 {
12281 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12282 }
12283
12284 uint hashes_cnt_orig = hashes_cnt;
12285
12286 hashes_cnt = 1;
12287
12288 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12289 {
12290 if (isSalted)
12291 {
12292 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12293 {
12294 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12295 }
12296 }
12297 else
12298 {
12299 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12300 }
12301
12302 if (hashes_pos > hashes_cnt)
12303 {
12304 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12305 }
12306
12307 hashes_cnt++;
12308 }
12309
12310 /**
12311 * Potfile removes
12312 */
12313
12314 uint potfile_remove_cracks = 0;
12315
12316 if (potfile_disable == 0)
12317 {
12318 hash_t hash_buf;
12319
12320 hash_buf.digest = mymalloc (dgst_size);
12321 hash_buf.salt = NULL;
12322 hash_buf.esalt = NULL;
12323 hash_buf.hash_info = NULL;
12324 hash_buf.cracked = 0;
12325
12326 if (isSalted)
12327 {
12328 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12329 }
12330
12331 if (esalt_size)
12332 {
12333 hash_buf.esalt = mymalloc (esalt_size);
12334 }
12335
12336 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12337
12338 // no solution for these special hash types (for instane because they use hashfile in output etc)
12339 if ((hash_mode != 5200) &&
12340 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12341 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12342 (hash_mode != 9000))
12343 {
12344 FILE *fp = fopen (potfile, "rb");
12345
12346 if (fp != NULL)
12347 {
12348 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12349
12350 // to be safe work with a copy (because of line_len loop, i etc)
12351 // moved up here because it's easier to handle continue case
12352 // it's just 64kb
12353
12354 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12355
12356 while (!feof (fp))
12357 {
12358 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12359
12360 if (ptr == NULL) break;
12361
12362 int line_len = strlen (line_buf);
12363
12364 if (line_len == 0) continue;
12365
12366 int iter = MAX_CUT_TRIES;
12367
12368 for (int i = line_len - 1; i && iter; i--, line_len--)
12369 {
12370 if (line_buf[i] != ':') continue;
12371
12372 if (isSalted)
12373 {
12374 memset (hash_buf.salt, 0, sizeof (salt_t));
12375 }
12376
12377 hash_t *found = NULL;
12378
12379 if (hash_mode == 6800)
12380 {
12381 if (i < 64) // 64 = 16 * uint in salt_buf[]
12382 {
12383 // manipulate salt_buf
12384 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12385
12386 hash_buf.salt->salt_len = i;
12387
12388 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12389 }
12390 }
12391 else if (hash_mode == 2500)
12392 {
12393 if (i < 64) // 64 = 16 * uint in salt_buf[]
12394 {
12395 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12396 // manipulate salt_buf
12397
12398 memcpy (line_buf_cpy, line_buf, i);
12399
12400 char *mac2_pos = strrchr (line_buf_cpy, ':');
12401
12402 if (mac2_pos == NULL) continue;
12403
12404 mac2_pos[0] = 0;
12405 mac2_pos++;
12406
12407 if (strlen (mac2_pos) != 12) continue;
12408
12409 char *mac1_pos = strrchr (line_buf_cpy, ':');
12410
12411 if (mac1_pos == NULL) continue;
12412
12413 mac1_pos[0] = 0;
12414 mac1_pos++;
12415
12416 if (strlen (mac1_pos) != 12) continue;
12417
12418 uint essid_length = mac1_pos - line_buf_cpy - 1;
12419
12420 // here we need the ESSID
12421 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12422
12423 hash_buf.salt->salt_len = essid_length;
12424
12425 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12426
12427 if (found)
12428 {
12429 wpa_t *wpa = (wpa_t *) found->esalt;
12430
12431 // compare hex string(s) vs binary MAC address(es)
12432
12433 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12434 {
12435 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12436 {
12437 found = NULL;
12438
12439 break;
12440 }
12441 }
12442
12443 // early skip ;)
12444 if (!found) continue;
12445
12446 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12447 {
12448 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12449 {
12450 found = NULL;
12451
12452 break;
12453 }
12454 }
12455 }
12456 }
12457 }
12458 else
12459 {
12460 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12461
12462 if (parser_status == PARSER_OK)
12463 {
12464 if (isSalted)
12465 {
12466 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12467 }
12468 else
12469 {
12470 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12471 }
12472 }
12473 }
12474
12475 if (found == NULL) continue;
12476
12477 if (!found->cracked) potfile_remove_cracks++;
12478
12479 found->cracked = 1;
12480
12481 if (found) break;
12482
12483 iter--;
12484 }
12485 }
12486
12487 myfree (line_buf_cpy);
12488
12489 myfree (line_buf);
12490
12491 fclose (fp);
12492 }
12493 }
12494
12495 if (esalt_size)
12496 {
12497 local_free (hash_buf.esalt);
12498 }
12499
12500 if (isSalted)
12501 {
12502 local_free (hash_buf.salt);
12503 }
12504
12505 local_free (hash_buf.digest);
12506 }
12507
12508 /**
12509 * Now generate all the buffers required for later
12510 */
12511
12512 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12513
12514 salt_t *salts_buf_new = NULL;
12515 void *esalts_buf_new = NULL;
12516
12517 if (isSalted)
12518 {
12519 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12520
12521 if (esalt_size)
12522 {
12523 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12524 }
12525 }
12526 else
12527 {
12528 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12529 }
12530
12531 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12532
12533 uint digests_cnt = hashes_cnt;
12534 uint digests_done = 0;
12535
12536 size_t size_digests = digests_cnt * dgst_size;
12537 size_t size_shown = digests_cnt * sizeof (uint);
12538
12539 uint *digests_shown = (uint *) mymalloc (size_shown);
12540 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12541
12542 uint salts_cnt = 0;
12543 uint salts_done = 0;
12544
12545 hashinfo_t **hash_info = NULL;
12546
12547 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12548 {
12549 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12550
12551 if (username && (remove || show))
12552 {
12553 uint user_pos;
12554
12555 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12556 {
12557 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12558
12559 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12560 }
12561 }
12562 }
12563
12564 uint *salts_shown = (uint *) mymalloc (size_shown);
12565
12566 salt_t *salt_buf;
12567
12568 {
12569 // copied from inner loop
12570
12571 salt_buf = &salts_buf_new[salts_cnt];
12572
12573 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12574
12575 if (esalt_size)
12576 {
12577 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12578 }
12579
12580 salt_buf->digests_cnt = 0;
12581 salt_buf->digests_done = 0;
12582 salt_buf->digests_offset = 0;
12583
12584 salts_cnt++;
12585 }
12586
12587 if (hashes_buf[0].cracked == 1)
12588 {
12589 digests_shown[0] = 1;
12590
12591 digests_done++;
12592
12593 salt_buf->digests_done++;
12594 }
12595
12596 salt_buf->digests_cnt++;
12597
12598 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12599
12600 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12601 {
12602 hash_info[0] = hashes_buf[0].hash_info;
12603 }
12604
12605 // copy from inner loop
12606
12607 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12608 {
12609 if (isSalted)
12610 {
12611 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12612 {
12613 salt_buf = &salts_buf_new[salts_cnt];
12614
12615 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12616
12617 if (esalt_size)
12618 {
12619 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12620 }
12621
12622 salt_buf->digests_cnt = 0;
12623 salt_buf->digests_done = 0;
12624 salt_buf->digests_offset = hashes_pos;
12625
12626 salts_cnt++;
12627 }
12628 }
12629
12630 if (hashes_buf[hashes_pos].cracked == 1)
12631 {
12632 digests_shown[hashes_pos] = 1;
12633
12634 digests_done++;
12635
12636 salt_buf->digests_done++;
12637 }
12638
12639 salt_buf->digests_cnt++;
12640
12641 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12642
12643 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12644 {
12645 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12646 }
12647 }
12648
12649 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12650 {
12651 salt_t *salt_buf = &salts_buf_new[salt_pos];
12652
12653 if (salt_buf->digests_done == salt_buf->digests_cnt)
12654 {
12655 salts_shown[salt_pos] = 1;
12656
12657 salts_done++;
12658 }
12659
12660 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12661 }
12662
12663 local_free (digests_buf);
12664 local_free (salts_buf);
12665 local_free (esalts_buf);
12666
12667 digests_buf = digests_buf_new;
12668 salts_buf = salts_buf_new;
12669 esalts_buf = esalts_buf_new;
12670
12671 local_free (hashes_buf);
12672
12673 /**
12674 * special modification not set from parser
12675 */
12676
12677 switch (hash_mode)
12678 {
12679 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12680 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12681 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12682 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12683 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12684 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12685 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12686 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12687 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12688 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12689 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12690 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12691 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12692 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12693 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12694 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12695 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12696 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12697 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12698 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12699 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12700 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12701 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12702 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12703 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12704 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12705 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12706 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12707 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12708 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12709 }
12710
12711 if (truecrypt_keyfiles)
12712 {
12713 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12714
12715 char *keyfiles = strdup (truecrypt_keyfiles);
12716
12717 char *keyfile = strtok (keyfiles, ",");
12718
12719 do
12720 {
12721 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12722
12723 } while ((keyfile = strtok (NULL, ",")) != NULL);
12724
12725 free (keyfiles);
12726 }
12727
12728 if (veracrypt_keyfiles)
12729 {
12730 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12731
12732 char *keyfiles = strdup (veracrypt_keyfiles);
12733
12734 char *keyfile = strtok (keyfiles, ",");
12735
12736 do
12737 {
12738 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12739
12740 } while ((keyfile = strtok (NULL, ",")) != NULL);
12741
12742 free (keyfiles);
12743 }
12744
12745 data.digests_cnt = digests_cnt;
12746 data.digests_done = digests_done;
12747 data.digests_buf = digests_buf;
12748 data.digests_shown = digests_shown;
12749 data.digests_shown_tmp = digests_shown_tmp;
12750
12751 data.salts_cnt = salts_cnt;
12752 data.salts_done = salts_done;
12753 data.salts_buf = salts_buf;
12754 data.salts_shown = salts_shown;
12755
12756 data.esalts_buf = esalts_buf;
12757 data.hash_info = hash_info;
12758
12759 /**
12760 * Automatic Optimizers
12761 */
12762
12763 if (salts_cnt == 1)
12764 opti_type |= OPTI_TYPE_SINGLE_SALT;
12765
12766 if (digests_cnt == 1)
12767 opti_type |= OPTI_TYPE_SINGLE_HASH;
12768
12769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12770 opti_type |= OPTI_TYPE_NOT_ITERATED;
12771
12772 if (attack_mode == ATTACK_MODE_BF)
12773 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12774
12775 data.opti_type = opti_type;
12776
12777 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12778 {
12779 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12780 {
12781 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12782 {
12783 if (opts_type & OPTS_TYPE_ST_ADD80)
12784 {
12785 opts_type &= ~OPTS_TYPE_ST_ADD80;
12786 opts_type |= OPTS_TYPE_PT_ADD80;
12787 }
12788
12789 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12790 {
12791 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12792 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12793 }
12794
12795 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12796 {
12797 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12798 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12799 }
12800 }
12801 }
12802 }
12803
12804 /**
12805 * Some algorithm, like descrypt, can benefit from JIT compilation
12806 */
12807
12808 int force_jit_compilation = -1;
12809
12810 if (hash_mode == 8900)
12811 {
12812 force_jit_compilation = 8900;
12813 }
12814 else if (hash_mode == 9300)
12815 {
12816 force_jit_compilation = 8900;
12817 }
12818 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12819 {
12820 force_jit_compilation = 1500;
12821 }
12822
12823 /**
12824 * generate bitmap tables
12825 */
12826
12827 const uint bitmap_shift1 = 5;
12828 const uint bitmap_shift2 = 13;
12829
12830 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12831
12832 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12833 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12834 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12835 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12836 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12837 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12838 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12839 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12840
12841 uint bitmap_bits;
12842 uint bitmap_nums;
12843 uint bitmap_mask;
12844 uint bitmap_size;
12845
12846 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12847 {
12848 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12849
12850 bitmap_nums = 1 << bitmap_bits;
12851
12852 bitmap_mask = bitmap_nums - 1;
12853
12854 bitmap_size = bitmap_nums * sizeof (uint);
12855
12856 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12857
12858 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;
12859 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;
12860
12861 break;
12862 }
12863
12864 bitmap_nums = 1 << bitmap_bits;
12865
12866 bitmap_mask = bitmap_nums - 1;
12867
12868 bitmap_size = bitmap_nums * sizeof (uint);
12869
12870 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);
12871 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);
12872
12873 /**
12874 * prepare quick rule
12875 */
12876
12877 data.rule_buf_l = rule_buf_l;
12878 data.rule_buf_r = rule_buf_r;
12879
12880 int rule_len_l = (int) strlen (rule_buf_l);
12881 int rule_len_r = (int) strlen (rule_buf_r);
12882
12883 data.rule_len_l = rule_len_l;
12884 data.rule_len_r = rule_len_r;
12885
12886 /**
12887 * load rules
12888 */
12889
12890 uint *all_kernel_rules_cnt = NULL;
12891
12892 kernel_rule_t **all_kernel_rules_buf = NULL;
12893
12894 if (rp_files_cnt)
12895 {
12896 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12897
12898 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12899 }
12900
12901 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12902
12903 int rule_len = 0;
12904
12905 for (uint i = 0; i < rp_files_cnt; i++)
12906 {
12907 uint kernel_rules_avail = 0;
12908
12909 uint kernel_rules_cnt = 0;
12910
12911 kernel_rule_t *kernel_rules_buf = NULL;
12912
12913 char *rp_file = rp_files[i];
12914
12915 char in[BLOCK_SIZE] = { 0 };
12916 char out[BLOCK_SIZE] = { 0 };
12917
12918 FILE *fp = NULL;
12919
12920 uint rule_line = 0;
12921
12922 if ((fp = fopen (rp_file, "rb")) == NULL)
12923 {
12924 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12925
12926 return (-1);
12927 }
12928
12929 while (!feof (fp))
12930 {
12931 memset (rule_buf, 0, HCBUFSIZ);
12932
12933 rule_len = fgetl (fp, rule_buf);
12934
12935 rule_line++;
12936
12937 if (rule_len == 0) continue;
12938
12939 if (rule_buf[0] == '#') continue;
12940
12941 if (kernel_rules_avail == kernel_rules_cnt)
12942 {
12943 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12944
12945 kernel_rules_avail += INCR_RULES;
12946 }
12947
12948 memset (in, 0, BLOCK_SIZE);
12949 memset (out, 0, BLOCK_SIZE);
12950
12951 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12952
12953 if (result == -1)
12954 {
12955 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12956
12957 continue;
12958 }
12959
12960 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12961 {
12962 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12963
12964 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12965
12966 continue;
12967 }
12968
12969 /* its so slow
12970 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12971 {
12972 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12973
12974 continue;
12975 }
12976 */
12977
12978 kernel_rules_cnt++;
12979 }
12980
12981 fclose (fp);
12982
12983 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12984
12985 all_kernel_rules_buf[i] = kernel_rules_buf;
12986 }
12987
12988 /**
12989 * merge rules or automatic rule generator
12990 */
12991
12992 uint kernel_rules_cnt = 0;
12993
12994 kernel_rule_t *kernel_rules_buf = NULL;
12995
12996 if (attack_mode == ATTACK_MODE_STRAIGHT)
12997 {
12998 if (rp_files_cnt)
12999 {
13000 kernel_rules_cnt = 1;
13001
13002 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13003
13004 repeats[0] = kernel_rules_cnt;
13005
13006 for (uint i = 0; i < rp_files_cnt; i++)
13007 {
13008 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13009
13010 repeats[i + 1] = kernel_rules_cnt;
13011 }
13012
13013 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13014
13015 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13016
13017 for (uint i = 0; i < kernel_rules_cnt; i++)
13018 {
13019 uint out_pos = 0;
13020
13021 kernel_rule_t *out = &kernel_rules_buf[i];
13022
13023 for (uint j = 0; j < rp_files_cnt; j++)
13024 {
13025 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13026 uint in_pos;
13027
13028 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13029
13030 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13031 {
13032 if (out_pos == RULES_MAX - 1)
13033 {
13034 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13035
13036 break;
13037 }
13038
13039 out->cmds[out_pos] = in->cmds[in_pos];
13040 }
13041 }
13042 }
13043
13044 local_free (repeats);
13045 }
13046 else if (rp_gen)
13047 {
13048 uint kernel_rules_avail = 0;
13049
13050 while (kernel_rules_cnt < rp_gen)
13051 {
13052 if (kernel_rules_avail == kernel_rules_cnt)
13053 {
13054 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13055
13056 kernel_rules_avail += INCR_RULES;
13057 }
13058
13059 memset (rule_buf, 0, HCBUFSIZ);
13060
13061 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13062
13063 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13064
13065 kernel_rules_cnt++;
13066 }
13067 }
13068 }
13069
13070 myfree (rule_buf);
13071
13072 /**
13073 * generate NOP rules
13074 */
13075
13076 if (kernel_rules_cnt == 0)
13077 {
13078 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13079
13080 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13081
13082 kernel_rules_cnt++;
13083 }
13084
13085 data.kernel_rules_cnt = kernel_rules_cnt;
13086 data.kernel_rules_buf = kernel_rules_buf;
13087
13088 /**
13089 * OpenCL platforms: detect
13090 */
13091
13092 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13093 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13094
13095 cl_uint platforms_cnt = 0;
13096 cl_uint platform_devices_cnt = 0;
13097
13098 if (keyspace == 0)
13099 {
13100 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13101
13102 if (platforms_cnt == 0)
13103 {
13104 log_info ("");
13105 log_info ("ATTENTION! No OpenCL compatible platform found");
13106 log_info ("");
13107 log_info ("You're probably missing the OpenCL runtime installation");
13108 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13109 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13110 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13111 log_info ("");
13112
13113 return (-1);
13114 }
13115
13116 if (opencl_platforms_filter != (uint) -1)
13117 {
13118 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13119
13120 if (opencl_platforms_filter > platform_cnt_mask)
13121 {
13122 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13123
13124 return (-1);
13125 }
13126 }
13127 }
13128
13129 /**
13130 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13131 */
13132
13133 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13134 {
13135 cl_platform_id platform = platforms[platform_id];
13136
13137 char platform_vendor[INFOSZ] = { 0 };
13138
13139 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13140
13141 #ifdef HAVE_HWMON
13142 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13143 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13144 {
13145 // make sure that we do not directly control the fan for NVidia
13146
13147 gpu_temp_retain = 0;
13148
13149 data.gpu_temp_retain = gpu_temp_retain;
13150 }
13151 #endif // HAVE_NVML || HAVE_NVAPI
13152 #endif
13153 }
13154
13155 /**
13156 * OpenCL device types:
13157 * 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.
13158 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13159 */
13160
13161 if (opencl_device_types == NULL)
13162 {
13163 cl_device_type device_types_all = 0;
13164
13165 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13166 {
13167 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13168
13169 cl_platform_id platform = platforms[platform_id];
13170
13171 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13172
13173 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13174 {
13175 cl_device_id device = platform_devices[platform_devices_id];
13176
13177 cl_device_type device_type;
13178
13179 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13180
13181 device_types_all |= device_type;
13182 }
13183 }
13184
13185 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13186 {
13187 device_types_filter |= CL_DEVICE_TYPE_CPU;
13188 }
13189 }
13190
13191 /**
13192 * OpenCL devices: simply push all devices from all platforms into the same device array
13193 */
13194
13195 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13196
13197 data.devices_param = devices_param;
13198
13199 uint devices_cnt = 0;
13200
13201 uint devices_active = 0;
13202
13203 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13204 {
13205 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13206
13207 cl_platform_id platform = platforms[platform_id];
13208
13209 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13210
13211 char platform_vendor[INFOSZ] = { 0 };
13212
13213 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13214
13215 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13216 // this causes trouble with vendor id based macros
13217 // we'll assign generic to those without special optimization available
13218
13219 cl_uint platform_vendor_id = 0;
13220
13221 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13222 {
13223 platform_vendor_id = VENDOR_ID_AMD;
13224 }
13225 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13226 {
13227 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13228 }
13229 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13230 {
13231 platform_vendor_id = VENDOR_ID_APPLE;
13232 }
13233 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13234 {
13235 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13236 }
13237 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13238 {
13239 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13240 }
13241 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13242 {
13243 platform_vendor_id = VENDOR_ID_MESA;
13244 }
13245 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13246 {
13247 platform_vendor_id = VENDOR_ID_NV;
13248 }
13249 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13250 {
13251 platform_vendor_id = VENDOR_ID_POCL;
13252 }
13253 else
13254 {
13255 platform_vendor_id = VENDOR_ID_GENERIC;
13256 }
13257
13258 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13259 {
13260 size_t param_value_size = 0;
13261
13262 const uint device_id = devices_cnt;
13263
13264 hc_device_param_t *device_param = &data.devices_param[device_id];
13265
13266 device_param->platform_vendor_id = platform_vendor_id;
13267
13268 device_param->device = platform_devices[platform_devices_id];
13269
13270 device_param->device_id = device_id;
13271
13272 device_param->platform_devices_id = platform_devices_id;
13273
13274 // device_type
13275
13276 cl_device_type device_type;
13277
13278 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13279
13280 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13281
13282 device_param->device_type = device_type;
13283
13284 // device_name
13285
13286 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13287
13288 char *device_name = (char *) mymalloc (param_value_size);
13289
13290 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13291
13292 device_param->device_name = device_name;
13293
13294 // device_vendor
13295
13296 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13297
13298 char *device_vendor = (char *) mymalloc (param_value_size);
13299
13300 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13301
13302 device_param->device_vendor = device_vendor;
13303
13304 cl_uint device_vendor_id = 0;
13305
13306 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13307 {
13308 device_vendor_id = VENDOR_ID_AMD;
13309 }
13310 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13311 {
13312 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13313 }
13314 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13315 {
13316 device_vendor_id = VENDOR_ID_APPLE;
13317 }
13318 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13319 {
13320 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13321 }
13322 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13323 {
13324 device_vendor_id = VENDOR_ID_INTEL_SDK;
13325 }
13326 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13327 {
13328 device_vendor_id = VENDOR_ID_MESA;
13329 }
13330 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13331 {
13332 device_vendor_id = VENDOR_ID_NV;
13333 }
13334 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13335 {
13336 device_vendor_id = VENDOR_ID_POCL;
13337 }
13338 else
13339 {
13340 device_vendor_id = VENDOR_ID_GENERIC;
13341 }
13342
13343 device_param->device_vendor_id = device_vendor_id;
13344
13345 // tuning db
13346
13347 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13348
13349 // device_version
13350
13351 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13352
13353 char *device_version = (char *) mymalloc (param_value_size);
13354
13355 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13356
13357 device_param->device_version = device_version;
13358
13359 // device_opencl_version
13360
13361 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13362
13363 char *device_opencl_version = (char *) mymalloc (param_value_size);
13364
13365 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13366
13367 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13368
13369 myfree (device_opencl_version);
13370
13371 // vector_width
13372
13373 cl_uint vector_width;
13374
13375 if (opencl_vector_width_chgd == 0)
13376 {
13377 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13378 {
13379 if (opti_type & OPTI_TYPE_USES_BITS_64)
13380 {
13381 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13382 }
13383 else
13384 {
13385 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13386 }
13387 }
13388 else
13389 {
13390 vector_width = (cl_uint) tuningdb_entry->vector_width;
13391 }
13392 }
13393 else
13394 {
13395 vector_width = opencl_vector_width;
13396 }
13397
13398 if (vector_width > 16) vector_width = 16;
13399
13400 device_param->vector_width = vector_width;
13401
13402 // max_compute_units
13403
13404 cl_uint device_processors;
13405
13406 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13407
13408 device_param->device_processors = device_processors;
13409
13410 // device_maxmem_alloc
13411 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13412
13413 cl_ulong device_maxmem_alloc;
13414
13415 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13416
13417 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13418
13419 // device_global_mem
13420
13421 cl_ulong device_global_mem;
13422
13423 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13424
13425 device_param->device_global_mem = device_global_mem;
13426
13427 // max_work_group_size
13428
13429 size_t device_maxworkgroup_size;
13430
13431 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13432
13433 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13434
13435 // max_clock_frequency
13436
13437 cl_uint device_maxclock_frequency;
13438
13439 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13440
13441 device_param->device_maxclock_frequency = device_maxclock_frequency;
13442
13443 // device_endian_little
13444
13445 cl_bool device_endian_little;
13446
13447 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13448
13449 if (device_endian_little == CL_FALSE)
13450 {
13451 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13452
13453 device_param->skipped = 1;
13454 }
13455
13456 // device_available
13457
13458 cl_bool device_available;
13459
13460 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13461
13462 if (device_available == CL_FALSE)
13463 {
13464 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13465
13466 device_param->skipped = 1;
13467 }
13468
13469 // device_compiler_available
13470
13471 cl_bool device_compiler_available;
13472
13473 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13474
13475 if (device_compiler_available == CL_FALSE)
13476 {
13477 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13478
13479 device_param->skipped = 1;
13480 }
13481
13482 // device_execution_capabilities
13483
13484 cl_device_exec_capabilities device_execution_capabilities;
13485
13486 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13487
13488 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13489 {
13490 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13491
13492 device_param->skipped = 1;
13493 }
13494
13495 // device_extensions
13496
13497 size_t device_extensions_size;
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13500
13501 char *device_extensions = mymalloc (device_extensions_size + 1);
13502
13503 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13504
13505 if (strstr (device_extensions, "base_atomics") == 0)
13506 {
13507 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13508
13509 device_param->skipped = 1;
13510 }
13511
13512 if (strstr (device_extensions, "byte_addressable_store") == 0)
13513 {
13514 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13515
13516 device_param->skipped = 1;
13517 }
13518
13519 myfree (device_extensions);
13520
13521 // device_local_mem_size
13522
13523 cl_ulong device_local_mem_size;
13524
13525 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13526
13527 if (device_local_mem_size < 32768)
13528 {
13529 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13530
13531 device_param->skipped = 1;
13532 }
13533
13534 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13535 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13536 // This results in both utilizing it for 50%
13537 // However, Intel has much better SIMD control over their own hardware
13538 // It makes sense to give them full control over their own hardware
13539
13540 if (device_type & CL_DEVICE_TYPE_CPU)
13541 {
13542 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13543 {
13544 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13545
13546 device_param->skipped = 1;
13547 }
13548 }
13549
13550 // skipped
13551
13552 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13553 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13554
13555 // driver_version
13556
13557 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13558
13559 char *driver_version = (char *) mymalloc (param_value_size);
13560
13561 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13562
13563 device_param->driver_version = driver_version;
13564
13565 // device_name_chksum
13566
13567 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13568
13569 #if __x86_64__
13570 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);
13571 #else
13572 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);
13573 #endif
13574
13575 uint device_name_digest[4] = { 0 };
13576
13577 md5_64 ((uint *) device_name_chksum, device_name_digest);
13578
13579 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13580
13581 device_param->device_name_chksum = device_name_chksum;
13582
13583 // device_processor_cores
13584
13585 if (device_type & CL_DEVICE_TYPE_CPU)
13586 {
13587 cl_uint device_processor_cores = 1;
13588
13589 device_param->device_processor_cores = device_processor_cores;
13590 }
13591
13592 if (device_type & CL_DEVICE_TYPE_GPU)
13593 {
13594 if (device_vendor_id == VENDOR_ID_AMD)
13595 {
13596 cl_uint device_processor_cores = 0;
13597
13598 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13599
13600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13601
13602 device_param->device_processor_cores = device_processor_cores;
13603 }
13604 else if (device_vendor_id == VENDOR_ID_NV)
13605 {
13606 cl_uint kernel_exec_timeout = 0;
13607
13608 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13609
13610 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13611
13612 device_param->kernel_exec_timeout = kernel_exec_timeout;
13613
13614 cl_uint device_processor_cores = 0;
13615
13616 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13617
13618 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13619
13620 device_param->device_processor_cores = device_processor_cores;
13621
13622 cl_uint sm_minor = 0;
13623 cl_uint sm_major = 0;
13624
13625 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13626 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13627
13628 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13629 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13630
13631 device_param->sm_minor = sm_minor;
13632 device_param->sm_major = sm_major;
13633 }
13634 else
13635 {
13636 cl_uint device_processor_cores = 1;
13637
13638 device_param->device_processor_cores = device_processor_cores;
13639 }
13640 }
13641
13642 // display results
13643
13644 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13645 {
13646 if (status_automat == 0)
13647 {
13648 if (device_param->skipped == 0)
13649 {
13650 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13651 device_id + 1,
13652 device_name,
13653 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13654 (unsigned int) (device_global_mem / 1024 / 1024),
13655 (unsigned int) (device_maxclock_frequency),
13656 (unsigned int) device_processors);
13657 }
13658 else
13659 {
13660 log_info ("Device #%u: %s, skipped",
13661 device_id + 1,
13662 device_name);
13663 }
13664 }
13665 }
13666
13667 // common driver check
13668
13669 if (device_param->skipped == 0)
13670 {
13671 if (device_type & CL_DEVICE_TYPE_GPU)
13672 {
13673 if (platform_vendor_id == VENDOR_ID_AMD)
13674 {
13675 int catalyst_check = (force == 1) ? 0 : 1;
13676
13677 int catalyst_warn = 0;
13678
13679 int catalyst_broken = 0;
13680
13681 if (catalyst_check == 1)
13682 {
13683 catalyst_warn = 1;
13684
13685 // v14.9 and higher
13686 if (atoi (device_param->driver_version) >= 1573)
13687 {
13688 catalyst_warn = 0;
13689 }
13690
13691 catalyst_check = 0;
13692 }
13693
13694 if (catalyst_broken == 1)
13695 {
13696 log_info ("");
13697 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13698 log_info ("It will pass over cracked hashes and does not report them as cracked");
13699 log_info ("You are STRONGLY encouraged not to use it");
13700 log_info ("You can use --force to override this but do not post error reports if you do so");
13701 log_info ("");
13702
13703 return (-1);
13704 }
13705
13706 if (catalyst_warn == 1)
13707 {
13708 log_info ("");
13709 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13710 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13711 log_info ("See hashcat's homepage for official supported catalyst drivers");
13712 #ifdef _WIN
13713 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13714 #endif
13715 log_info ("You can use --force to override this but do not post error reports if you do so");
13716 log_info ("");
13717
13718 return (-1);
13719 }
13720 }
13721 else if (platform_vendor_id == VENDOR_ID_NV)
13722 {
13723 if (device_param->kernel_exec_timeout != 0)
13724 {
13725 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);
13726 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13727 }
13728 }
13729 }
13730
13731 /* turns out pocl still creates segfaults (because of llvm)
13732 if (device_type & CL_DEVICE_TYPE_CPU)
13733 {
13734 if (platform_vendor_id == VENDOR_ID_AMD)
13735 {
13736 if (force == 0)
13737 {
13738 log_info ("");
13739 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13740 log_info ("You are STRONGLY encouraged not to use it");
13741 log_info ("You can use --force to override this but do not post error reports if you do so");
13742 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13743 log_info ("");
13744
13745 return (-1);
13746 }
13747 }
13748 }
13749 */
13750
13751 /**
13752 * kernel accel and loops tuning db adjustment
13753 */
13754
13755 device_param->kernel_accel_min = 1;
13756 device_param->kernel_accel_max = 1024;
13757
13758 device_param->kernel_loops_min = 1;
13759 device_param->kernel_loops_max = 1024;
13760
13761 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13762
13763 if (tuningdb_entry)
13764 {
13765 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13766 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13767
13768 if (_kernel_accel)
13769 {
13770 device_param->kernel_accel_min = _kernel_accel;
13771 device_param->kernel_accel_max = _kernel_accel;
13772 }
13773
13774 if (_kernel_loops)
13775 {
13776 if (workload_profile == 1)
13777 {
13778 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13779 }
13780 else if (workload_profile == 2)
13781 {
13782 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13783 }
13784
13785 device_param->kernel_loops_min = _kernel_loops;
13786 device_param->kernel_loops_max = _kernel_loops;
13787 }
13788 }
13789
13790 // commandline parameters overwrite tuningdb entries
13791
13792 if (kernel_accel)
13793 {
13794 device_param->kernel_accel_min = kernel_accel;
13795 device_param->kernel_accel_max = kernel_accel;
13796 }
13797
13798 if (kernel_loops)
13799 {
13800 device_param->kernel_loops_min = kernel_loops;
13801 device_param->kernel_loops_max = kernel_loops;
13802 }
13803
13804 /**
13805 * activate device
13806 */
13807
13808 devices_active++;
13809 }
13810
13811 // next please
13812
13813 devices_cnt++;
13814 }
13815 }
13816
13817 if (keyspace == 0 && devices_active == 0)
13818 {
13819 log_error ("ERROR: No devices found/left");
13820
13821 return (-1);
13822 }
13823
13824 // 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)
13825
13826 if (devices_filter != (uint) -1)
13827 {
13828 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13829
13830 if (devices_filter > devices_cnt_mask)
13831 {
13832 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13833
13834 return (-1);
13835 }
13836 }
13837
13838 data.devices_cnt = devices_cnt;
13839
13840 data.devices_active = devices_active;
13841
13842 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13843 {
13844 if (status_automat == 0)
13845 {
13846 log_info ("");
13847 }
13848 }
13849
13850 /**
13851 * HM devices: init
13852 */
13853
13854 #ifdef HAVE_HWMON
13855 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13856 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13857 #endif
13858
13859 #ifdef HAVE_ADL
13860 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13861 #endif
13862
13863 if (gpu_temp_disable == 0)
13864 {
13865 #if defined(WIN) && defined(HAVE_NVAPI)
13866 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13867
13868 if (nvapi_init (nvapi) == 0)
13869 data.hm_nv = nvapi;
13870
13871 if (data.hm_nv)
13872 {
13873 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13874 {
13875 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13876
13877 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13878
13879 int tmp_out = 0;
13880
13881 for (int i = 0; i < tmp_in; i++)
13882 {
13883 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13884 }
13885
13886 for (int i = 0; i < tmp_out; i++)
13887 {
13888 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13889
13890 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13891
13892 if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13893 }
13894 }
13895 }
13896 #endif // WIN && HAVE_NVAPI
13897
13898 #if defined(LINUX) && defined(HAVE_NVML)
13899 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13900
13901 if (nvml_init (nvml) == 0)
13902 data.hm_nv = nvml;
13903
13904 if (data.hm_nv)
13905 {
13906 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13907 {
13908 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13909
13910 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13911
13912 int tmp_out = 0;
13913
13914 for (int i = 0; i < tmp_in; i++)
13915 {
13916 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13917 }
13918
13919 for (int i = 0; i < tmp_out; i++)
13920 {
13921 unsigned int speed;
13922
13923 if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1;
13924 }
13925 }
13926 }
13927 #endif // LINUX && HAVE_NVML
13928
13929 data.hm_amd = NULL;
13930
13931 #ifdef HAVE_ADL
13932 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13933
13934 if (adl_init (adl) == 0)
13935 data.hm_amd = adl;
13936
13937 if (data.hm_amd)
13938 {
13939 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13940 {
13941 // total number of adapters
13942
13943 int hm_adapters_num;
13944
13945 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13946
13947 // adapter info
13948
13949 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13950
13951 if (lpAdapterInfo == NULL) return (-1);
13952
13953 // get a list (of ids of) valid/usable adapters
13954
13955 int num_adl_adapters = 0;
13956
13957 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13958
13959 if (num_adl_adapters > 0)
13960 {
13961 hc_thread_mutex_lock (mux_adl);
13962
13963 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13964
13965 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13966
13967 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13968 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13969
13970 hc_thread_mutex_unlock (mux_adl);
13971 }
13972
13973 myfree (valid_adl_device_list);
13974 myfree (lpAdapterInfo);
13975 }
13976 }
13977 #endif // HAVE_ADL
13978
13979 if (data.hm_amd == NULL && data.hm_nv == NULL)
13980 {
13981 gpu_temp_disable = 1;
13982 }
13983 }
13984
13985 /**
13986 * OpenCL devices: allocate buffer for device specific information
13987 */
13988
13989 #ifdef HAVE_HWMON
13990 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13991
13992 #ifdef HAVE_ADL
13993 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13994
13995 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13996 #endif // ADL
13997 #endif
13998
13999 /**
14000 * enable custom signal handler(s)
14001 */
14002
14003 if (benchmark == 0)
14004 {
14005 hc_signal (sigHandler_default);
14006 }
14007 else
14008 {
14009 hc_signal (sigHandler_benchmark);
14010 }
14011
14012 /**
14013 * User-defined GPU temp handling
14014 */
14015
14016 #ifdef HAVE_HWMON
14017 if (gpu_temp_disable == 1)
14018 {
14019 gpu_temp_abort = 0;
14020 gpu_temp_retain = 0;
14021 }
14022
14023 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14024 {
14025 if (gpu_temp_abort < gpu_temp_retain)
14026 {
14027 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14028
14029 return (-1);
14030 }
14031 }
14032
14033 data.gpu_temp_disable = gpu_temp_disable;
14034 data.gpu_temp_abort = gpu_temp_abort;
14035 data.gpu_temp_retain = gpu_temp_retain;
14036 #endif
14037
14038 /**
14039 * inform the user
14040 */
14041
14042 if (data.quiet == 0)
14043 {
14044 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14045
14046 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);
14047
14048 if (attack_mode == ATTACK_MODE_STRAIGHT)
14049 {
14050 log_info ("Rules: %u", kernel_rules_cnt);
14051 }
14052
14053 if (opti_type)
14054 {
14055 log_info ("Applicable Optimizers:");
14056
14057 for (uint i = 0; i < 32; i++)
14058 {
14059 const uint opti_bit = 1u << i;
14060
14061 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14062 }
14063 }
14064
14065 /**
14066 * Watchdog and Temperature balance
14067 */
14068
14069 #ifdef HAVE_HWMON
14070 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14071 {
14072 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14073 }
14074
14075 if (gpu_temp_abort == 0)
14076 {
14077 log_info ("Watchdog: Temperature abort trigger disabled");
14078 }
14079 else
14080 {
14081 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14082 }
14083
14084 if (gpu_temp_retain == 0)
14085 {
14086 log_info ("Watchdog: Temperature retain trigger disabled");
14087 }
14088 else
14089 {
14090 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14091 }
14092
14093 if (data.quiet == 0) log_info ("");
14094 #endif
14095 }
14096
14097 /**
14098 * HM devices: copy
14099 */
14100
14101 if (gpu_temp_disable == 0)
14102 {
14103 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14104 {
14105 hc_device_param_t *device_param = &data.devices_param[device_id];
14106
14107 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14108
14109 if (device_param->skipped) continue;
14110
14111 const uint platform_devices_id = device_param->platform_devices_id;
14112
14113 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14114 if (device_param->device_vendor_id == VENDOR_ID_NV)
14115 {
14116 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14117 }
14118 #endif
14119
14120 #ifdef HAVE_ADL
14121 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14122 {
14123 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14124 }
14125 #endif
14126 }
14127 }
14128
14129 /*
14130 * Temporary fix:
14131 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14132 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14133 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14134 * Driver / ADL bug?
14135 */
14136
14137 #ifdef HAVE_ADL
14138 if (powertune_enable == 1)
14139 {
14140 hc_thread_mutex_lock (mux_adl);
14141
14142 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14143 {
14144 hc_device_param_t *device_param = &data.devices_param[device_id];
14145
14146 if (device_param->skipped) continue;
14147
14148 if (data.hm_device[device_id].od_version == 6)
14149 {
14150 // set powertune value only
14151
14152 int powertune_supported = 0;
14153
14154 int ADL_rc = 0;
14155
14156 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14157 {
14158 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14159
14160 return (-1);
14161 }
14162
14163 if (powertune_supported != 0)
14164 {
14165 // powertune set
14166 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14167
14168 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14169 {
14170 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14171
14172 return (-1);
14173 }
14174
14175 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14176 {
14177 log_error ("ERROR: Failed to set new ADL PowerControl values");
14178
14179 return (-1);
14180 }
14181 }
14182 }
14183 }
14184
14185 hc_thread_mutex_unlock (mux_adl);
14186 }
14187 #endif // HAVE_ADK
14188 #endif // HAVE_HWMON
14189
14190 #ifdef DEBUG
14191 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14192 #endif
14193
14194 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14195
14196 uint kernel_power_all = 0;
14197
14198 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14199 {
14200 /**
14201 * host buffer
14202 */
14203
14204 hc_device_param_t *device_param = &data.devices_param[device_id];
14205
14206 if (device_param->skipped) continue;
14207
14208 /**
14209 * device properties
14210 */
14211
14212 const char *device_name_chksum = device_param->device_name_chksum;
14213 const u32 device_processors = device_param->device_processors;
14214 const u32 device_processor_cores = device_param->device_processor_cores;
14215
14216 /**
14217 * create context for each device
14218 */
14219
14220 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14221
14222 /**
14223 * create command-queue
14224 */
14225
14226 // not supported with NV
14227 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14228
14229 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14230
14231 /**
14232 * kernel threads: some algorithms need a fixed kernel-threads count
14233 * because of shared memory usage or bitslice
14234 * there needs to be some upper limit, otherwise there's too much overhead
14235 */
14236
14237 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14238
14239 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14240 {
14241 kernel_threads = KERNEL_THREADS_MAX_CPU;
14242 }
14243
14244 if (hash_mode == 1500) kernel_threads = 64; // DES
14245 if (hash_mode == 3000) kernel_threads = 64; // DES
14246 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14247 if (hash_mode == 7500) kernel_threads = 64; // RC4
14248 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14249 if (hash_mode == 9700) kernel_threads = 64; // RC4
14250 if (hash_mode == 9710) kernel_threads = 64; // RC4
14251 if (hash_mode == 9800) kernel_threads = 64; // RC4
14252 if (hash_mode == 9810) kernel_threads = 64; // RC4
14253 if (hash_mode == 10400) kernel_threads = 64; // RC4
14254 if (hash_mode == 10410) kernel_threads = 64; // RC4
14255 if (hash_mode == 10500) kernel_threads = 64; // RC4
14256 if (hash_mode == 13100) kernel_threads = 64; // RC4
14257
14258 /**
14259 * create input buffers on device : calculate size of fixed memory buffers
14260 */
14261
14262 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14263 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14264
14265 device_param->size_root_css = size_root_css;
14266 device_param->size_markov_css = size_markov_css;
14267
14268 size_t size_results = sizeof (uint);
14269
14270 device_param->size_results = size_results;
14271
14272 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14273 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14274
14275 size_t size_plains = digests_cnt * sizeof (plain_t);
14276 size_t size_salts = salts_cnt * sizeof (salt_t);
14277 size_t size_esalts = salts_cnt * esalt_size;
14278
14279 device_param->size_plains = size_plains;
14280 device_param->size_digests = size_digests;
14281 device_param->size_shown = size_shown;
14282 device_param->size_salts = size_salts;
14283
14284 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14285 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14286 size_t size_tm = 32 * sizeof (bs_word_t);
14287
14288 // scryptV stuff
14289
14290 size_t size_scryptV = 1;
14291
14292 if ((hash_mode == 8900) || (hash_mode == 9300))
14293 {
14294 uint tmto_start = 0;
14295 uint tmto_stop = 10;
14296
14297 if (scrypt_tmto)
14298 {
14299 tmto_start = scrypt_tmto;
14300 }
14301 else
14302 {
14303 // in case the user did not specify the tmto manually
14304 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14305 // but set the lower end only in case the user has a device with too less memory
14306
14307 if (hash_mode == 8900)
14308 {
14309 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14310 {
14311 tmto_start = 1;
14312 }
14313 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14314 {
14315 tmto_start = 2;
14316 }
14317 }
14318 else if (hash_mode == 9300)
14319 {
14320 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14321 {
14322 tmto_start = 2;
14323 }
14324 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14325 {
14326 tmto_start = 2;
14327 }
14328 }
14329 }
14330
14331 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14332 {
14333 // TODO: in theory the following calculation needs to be done per salt, not global
14334 // we assume all hashes have the same scrypt settings
14335
14336 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14337
14338 size_scryptV /= 1 << tmto;
14339
14340 size_scryptV *= device_processors * device_processor_cores;
14341
14342 if (size_scryptV > device_param->device_maxmem_alloc)
14343 {
14344 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14345
14346 continue;
14347 }
14348
14349 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14350 {
14351 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14352 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14353 }
14354
14355 break;
14356 }
14357
14358 if (data.salts_buf[0].scrypt_phy == 0)
14359 {
14360 log_error ("ERROR: can't allocate enough device memory");
14361
14362 return -1;
14363 }
14364
14365 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14366 }
14367
14368 /**
14369 * some algorithms need a fixed kernel-loops count
14370 */
14371
14372 if (hash_mode == 1500)
14373 {
14374 const u32 kernel_loops_fixed = 1024;
14375
14376 device_param->kernel_loops_min = kernel_loops_fixed;
14377 device_param->kernel_loops_max = kernel_loops_fixed;
14378 }
14379
14380 if (hash_mode == 3000)
14381 {
14382 const u32 kernel_loops_fixed = 1024;
14383
14384 device_param->kernel_loops_min = kernel_loops_fixed;
14385 device_param->kernel_loops_max = kernel_loops_fixed;
14386 }
14387
14388 if (hash_mode == 8900)
14389 {
14390 const u32 kernel_loops_fixed = 1;
14391
14392 device_param->kernel_loops_min = kernel_loops_fixed;
14393 device_param->kernel_loops_max = kernel_loops_fixed;
14394 }
14395
14396 if (hash_mode == 9300)
14397 {
14398 const u32 kernel_loops_fixed = 1;
14399
14400 device_param->kernel_loops_min = kernel_loops_fixed;
14401 device_param->kernel_loops_max = kernel_loops_fixed;
14402 }
14403
14404 if (hash_mode == 12500)
14405 {
14406 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14407
14408 device_param->kernel_loops_min = kernel_loops_fixed;
14409 device_param->kernel_loops_max = kernel_loops_fixed;
14410 }
14411
14412 /**
14413 * some algorithms have a maximum kernel-loops count
14414 */
14415
14416 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14417 {
14418 u32 innerloop_cnt = 0;
14419
14420 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14421 {
14422 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14423 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14424 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14425 }
14426 else
14427 {
14428 innerloop_cnt = data.salts_buf[0].salt_iter;
14429 }
14430
14431 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14432 (innerloop_cnt <= device_param->kernel_loops_max))
14433 {
14434 device_param->kernel_loops_max = innerloop_cnt;
14435 }
14436 }
14437
14438 u32 kernel_accel_min = device_param->kernel_accel_min;
14439 u32 kernel_accel_max = device_param->kernel_accel_max;
14440
14441 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14442
14443 size_t size_pws = 4;
14444 size_t size_tmps = 4;
14445 size_t size_hooks = 4;
14446
14447 while (kernel_accel_max >= kernel_accel_min)
14448 {
14449 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14450
14451 // size_pws
14452
14453 size_pws = kernel_power_max * sizeof (pw_t);
14454
14455 // size_tmps
14456
14457 switch (hash_mode)
14458 {
14459 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14460 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14461 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14462 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14463 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14464 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14465 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14466 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14467 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14468 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14469 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14470 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14471 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14472 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14473 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14474 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14475 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14476 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14477 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14478 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14479 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14480 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14481 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14482 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14483 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14484 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14485 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14486 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14487 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14488 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14489 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14490 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14491 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14492 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14493 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14494 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14495 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14496 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14497 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14498 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14499 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14500 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14501 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14502 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14503 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14504 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14505 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14506 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14507 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14508 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14509 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14510 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14511 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14512 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14513 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14514 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14515 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14516 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14517 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14518 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14519 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14520 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14521 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14522 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14523 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14524 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14525 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14526 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14527 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14528 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14529 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14530 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14531 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14532 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14533 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14534 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14535 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14536 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14537 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14538 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14539 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14540 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14541 };
14542
14543 // size_hooks
14544
14545 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14546 {
14547 // none yet
14548 }
14549
14550 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14551 // if not, decrease amplifier and try again
14552
14553 int skip = 0;
14554
14555 const u64 size_total
14556 = bitmap_size
14557 + bitmap_size
14558 + bitmap_size
14559 + bitmap_size
14560 + bitmap_size
14561 + bitmap_size
14562 + bitmap_size
14563 + bitmap_size
14564 + size_bfs
14565 + size_combs
14566 + size_digests
14567 + size_esalts
14568 + size_hooks
14569 + size_markov_css
14570 + size_plains
14571 + size_pws
14572 + size_pws // not a bug
14573 + size_results
14574 + size_root_css
14575 + size_rules
14576 + size_rules_c
14577 + size_salts
14578 + size_scryptV
14579 + size_shown
14580 + size_tm
14581 + size_tmps;
14582
14583 // Don't ask me, ask AMD!
14584
14585 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14586 if (size_total > device_param->device_global_mem) skip = 1;
14587
14588 if (skip == 1)
14589 {
14590 kernel_accel_max--;
14591
14592 continue;
14593 }
14594
14595 break;
14596 }
14597
14598 /*
14599 if (kernel_accel_max == 0)
14600 {
14601 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14602
14603 return -1;
14604 }
14605 */
14606
14607 device_param->kernel_accel_min = kernel_accel_min;
14608 device_param->kernel_accel_max = kernel_accel_max;
14609
14610 /*
14611 if (kernel_accel_max < kernel_accel)
14612 {
14613 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14614
14615 device_param->kernel_accel = kernel_accel_max;
14616 }
14617 */
14618
14619 device_param->size_bfs = size_bfs;
14620 device_param->size_combs = size_combs;
14621 device_param->size_rules = size_rules;
14622 device_param->size_rules_c = size_rules_c;
14623 device_param->size_pws = size_pws;
14624 device_param->size_tmps = size_tmps;
14625 device_param->size_hooks = size_hooks;
14626
14627 // do not confuse kernel_accel_max with kernel_accel here
14628
14629 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14630
14631 device_param->kernel_threads = kernel_threads;
14632 device_param->kernel_power_user = kernel_power;
14633
14634 kernel_power_all += kernel_power;
14635
14636 /**
14637 * default building options
14638 */
14639
14640 char build_opts[1024] = { 0 };
14641
14642 // we don't have sm_* on vendors not NV but it doesn't matter
14643
14644 #if _WIN
14645 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);
14646 #else
14647 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);
14648 #endif
14649
14650 char build_opts_new[1024] = { 0 };
14651
14652 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);
14653
14654 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14655
14656 /*
14657 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14658 {
14659 // we do vectorizing much better than the auto-vectorizer
14660
14661 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14662
14663 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14664 }
14665 */
14666
14667 #ifdef DEBUG
14668 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14669 #endif
14670
14671 /**
14672 * main kernel
14673 */
14674
14675 {
14676 /**
14677 * kernel source filename
14678 */
14679
14680 char source_file[256] = { 0 };
14681
14682 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14683
14684 struct stat sst;
14685
14686 if (stat (source_file, &sst) == -1)
14687 {
14688 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14689
14690 return -1;
14691 }
14692
14693 /**
14694 * kernel cached filename
14695 */
14696
14697 char cached_file[256] = { 0 };
14698
14699 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14700
14701 int cached = 1;
14702
14703 struct stat cst;
14704
14705 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14706 {
14707 cached = 0;
14708 }
14709
14710 /**
14711 * kernel compile or load
14712 */
14713
14714 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14715
14716 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14717
14718 if (force_jit_compilation == -1)
14719 {
14720 if (cached == 0)
14721 {
14722 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14723
14724 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14725
14726 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14727
14728 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14729
14730 #ifdef DEBUG
14731 size_t build_log_size = 0;
14732
14733 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14734
14735 if (build_log_size > 1)
14736 {
14737 char *build_log = (char *) malloc (build_log_size + 1);
14738
14739 memset (build_log, 0, build_log_size + 1);
14740
14741 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14742
14743 puts (build_log);
14744
14745 free (build_log);
14746 }
14747 #endif
14748
14749 if (rc != 0)
14750 {
14751 device_param->skipped = true;
14752
14753 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14754
14755 continue;
14756 }
14757
14758 size_t binary_size;
14759
14760 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14761
14762 u8 *binary = (u8 *) mymalloc (binary_size);
14763
14764 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14765
14766 writeProgramBin (cached_file, binary, binary_size);
14767
14768 local_free (binary);
14769 }
14770 else
14771 {
14772 #ifdef DEBUG
14773 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14774 #endif
14775
14776 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14777
14778 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14779
14780 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14781 }
14782 }
14783 else
14784 {
14785 #ifdef DEBUG
14786 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14787 #endif
14788
14789 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14790
14791 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14792
14793 char build_opts_update[1024] = { 0 };
14794
14795 if (force_jit_compilation == 1500)
14796 {
14797 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14798 }
14799 else if (force_jit_compilation == 8900)
14800 {
14801 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);
14802 }
14803 else
14804 {
14805 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14806 }
14807
14808 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14809
14810 #ifdef DEBUG
14811 size_t build_log_size = 0;
14812
14813 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14814
14815 if (build_log_size > 1)
14816 {
14817 char *build_log = (char *) malloc (build_log_size + 1);
14818
14819 memset (build_log, 0, build_log_size + 1);
14820
14821 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14822
14823 puts (build_log);
14824
14825 free (build_log);
14826 }
14827 #endif
14828
14829 if (rc != 0)
14830 {
14831 device_param->skipped = true;
14832
14833 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14834 }
14835 }
14836
14837 local_free (kernel_lengths);
14838 local_free (kernel_sources[0]);
14839 local_free (kernel_sources);
14840 }
14841
14842 /**
14843 * word generator kernel
14844 */
14845
14846 if (attack_mode != ATTACK_MODE_STRAIGHT)
14847 {
14848 /**
14849 * kernel mp source filename
14850 */
14851
14852 char source_file[256] = { 0 };
14853
14854 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14855
14856 struct stat sst;
14857
14858 if (stat (source_file, &sst) == -1)
14859 {
14860 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14861
14862 return -1;
14863 }
14864
14865 /**
14866 * kernel mp cached filename
14867 */
14868
14869 char cached_file[256] = { 0 };
14870
14871 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14872
14873 int cached = 1;
14874
14875 struct stat cst;
14876
14877 if (stat (cached_file, &cst) == -1)
14878 {
14879 cached = 0;
14880 }
14881
14882 /**
14883 * kernel compile or load
14884 */
14885
14886 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14887
14888 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14889
14890 if (cached == 0)
14891 {
14892 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14893 if (quiet == 0) log_info ("");
14894
14895 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14896
14897 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14898
14899 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14900
14901 if (rc != 0)
14902 {
14903 device_param->skipped = true;
14904
14905 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14906
14907 continue;
14908 }
14909
14910 size_t binary_size;
14911
14912 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14913
14914 u8 *binary = (u8 *) mymalloc (binary_size);
14915
14916 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14917
14918 writeProgramBin (cached_file, binary, binary_size);
14919
14920 local_free (binary);
14921 }
14922 else
14923 {
14924 #ifdef DEBUG
14925 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14926 #endif
14927
14928 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14929
14930 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14931
14932 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14933 }
14934
14935 local_free (kernel_lengths);
14936 local_free (kernel_sources[0]);
14937 local_free (kernel_sources);
14938 }
14939
14940 /**
14941 * amplifier kernel
14942 */
14943
14944 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14945 {
14946
14947 }
14948 else
14949 {
14950 /**
14951 * kernel amp source filename
14952 */
14953
14954 char source_file[256] = { 0 };
14955
14956 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14957
14958 struct stat sst;
14959
14960 if (stat (source_file, &sst) == -1)
14961 {
14962 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14963
14964 return -1;
14965 }
14966
14967 /**
14968 * kernel amp cached filename
14969 */
14970
14971 char cached_file[256] = { 0 };
14972
14973 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14974
14975 int cached = 1;
14976
14977 struct stat cst;
14978
14979 if (stat (cached_file, &cst) == -1)
14980 {
14981 cached = 0;
14982 }
14983
14984 /**
14985 * kernel compile or load
14986 */
14987
14988 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14989
14990 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14991
14992 if (cached == 0)
14993 {
14994 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14995 if (quiet == 0) log_info ("");
14996
14997 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14998
14999 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15000
15001 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15002
15003 if (rc != 0)
15004 {
15005 device_param->skipped = true;
15006
15007 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15008
15009 continue;
15010 }
15011
15012 size_t binary_size;
15013
15014 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15015
15016 u8 *binary = (u8 *) mymalloc (binary_size);
15017
15018 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15019
15020 writeProgramBin (cached_file, binary, binary_size);
15021
15022 local_free (binary);
15023 }
15024 else
15025 {
15026 #ifdef DEBUG
15027 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15028 #endif
15029
15030 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15031
15032 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15033
15034 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15035 }
15036
15037 local_free (kernel_lengths);
15038 local_free (kernel_sources[0]);
15039 local_free (kernel_sources);
15040 }
15041
15042 // some algorithm collide too fast, make that impossible
15043
15044 if (benchmark == 1)
15045 {
15046 ((uint *) digests_buf)[0] = -1;
15047 ((uint *) digests_buf)[1] = -1;
15048 ((uint *) digests_buf)[2] = -1;
15049 ((uint *) digests_buf)[3] = -1;
15050 }
15051
15052 /**
15053 * global buffers
15054 */
15055
15056 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15057 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15058 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15059 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15060 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15061 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15062 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15063 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15064 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15065 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15066 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15067 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15068 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15069 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15070 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15071 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15072 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15073 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15074
15075 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);
15076 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);
15077 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);
15078 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);
15079 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);
15080 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);
15081 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);
15082 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);
15083 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15084 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15085 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15086
15087 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15088 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15089 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15090 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15091 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15092 run_kernel_bzero (device_param, device_param->d_result, size_results);
15093
15094 /**
15095 * special buffers
15096 */
15097
15098 if (attack_kern == ATTACK_KERN_STRAIGHT)
15099 {
15100 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15101 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15102
15103 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15104
15105 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15106 }
15107 else if (attack_kern == ATTACK_KERN_COMBI)
15108 {
15109 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15110 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15111 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15112 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15113
15114 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15115 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15116 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15117 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15118 }
15119 else if (attack_kern == ATTACK_KERN_BF)
15120 {
15121 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15122 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15123 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15124 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15125 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15126
15127 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15128 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15129 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15130 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15131 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15132 }
15133
15134 if (size_esalts)
15135 {
15136 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15137
15138 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15139 }
15140
15141 /**
15142 * main host data
15143 */
15144
15145 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15146
15147 device_param->pws_buf = pws_buf;
15148
15149 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15150
15151 device_param->combs_buf = combs_buf;
15152
15153 void *hooks_buf = mymalloc (size_hooks);
15154
15155 device_param->hooks_buf = hooks_buf;
15156
15157 /**
15158 * kernel args
15159 */
15160
15161 device_param->kernel_params_buf32[21] = bitmap_mask;
15162 device_param->kernel_params_buf32[22] = bitmap_shift1;
15163 device_param->kernel_params_buf32[23] = bitmap_shift2;
15164 device_param->kernel_params_buf32[24] = 0; // salt_pos
15165 device_param->kernel_params_buf32[25] = 0; // loop_pos
15166 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15167 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15168 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15169 device_param->kernel_params_buf32[29] = 0; // digests_offset
15170 device_param->kernel_params_buf32[30] = 0; // combs_mode
15171 device_param->kernel_params_buf32[31] = 0; // gid_max
15172
15173 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15174 ? &device_param->d_pws_buf
15175 : &device_param->d_pws_amp_buf;
15176 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15177 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15178 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15179 device_param->kernel_params[ 4] = &device_param->d_tmps;
15180 device_param->kernel_params[ 5] = &device_param->d_hooks;
15181 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15182 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15183 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15184 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15185 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15186 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15187 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15188 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15189 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15190 device_param->kernel_params[15] = &device_param->d_digests_buf;
15191 device_param->kernel_params[16] = &device_param->d_digests_shown;
15192 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15193 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15194 device_param->kernel_params[19] = &device_param->d_result;
15195 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15196 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15197 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15198 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15199 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15200 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15201 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15202 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15203 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15204 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15205 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15206 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15207
15208 device_param->kernel_params_mp_buf64[3] = 0;
15209 device_param->kernel_params_mp_buf32[4] = 0;
15210 device_param->kernel_params_mp_buf32[5] = 0;
15211 device_param->kernel_params_mp_buf32[6] = 0;
15212 device_param->kernel_params_mp_buf32[7] = 0;
15213 device_param->kernel_params_mp_buf32[8] = 0;
15214
15215 device_param->kernel_params_mp[0] = NULL;
15216 device_param->kernel_params_mp[1] = NULL;
15217 device_param->kernel_params_mp[2] = NULL;
15218 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15219 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15220 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15221 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15222 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15223 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15224
15225 device_param->kernel_params_mp_l_buf64[3] = 0;
15226 device_param->kernel_params_mp_l_buf32[4] = 0;
15227 device_param->kernel_params_mp_l_buf32[5] = 0;
15228 device_param->kernel_params_mp_l_buf32[6] = 0;
15229 device_param->kernel_params_mp_l_buf32[7] = 0;
15230 device_param->kernel_params_mp_l_buf32[8] = 0;
15231 device_param->kernel_params_mp_l_buf32[9] = 0;
15232
15233 device_param->kernel_params_mp_l[0] = NULL;
15234 device_param->kernel_params_mp_l[1] = NULL;
15235 device_param->kernel_params_mp_l[2] = NULL;
15236 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15237 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15238 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15239 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15240 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15241 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15242 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15243
15244 device_param->kernel_params_mp_r_buf64[3] = 0;
15245 device_param->kernel_params_mp_r_buf32[4] = 0;
15246 device_param->kernel_params_mp_r_buf32[5] = 0;
15247 device_param->kernel_params_mp_r_buf32[6] = 0;
15248 device_param->kernel_params_mp_r_buf32[7] = 0;
15249 device_param->kernel_params_mp_r_buf32[8] = 0;
15250
15251 device_param->kernel_params_mp_r[0] = NULL;
15252 device_param->kernel_params_mp_r[1] = NULL;
15253 device_param->kernel_params_mp_r[2] = NULL;
15254 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15255 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15256 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15257 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15258 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15259 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15260
15261 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15262 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15263
15264 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15265 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15266 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15267 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15268 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15269 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15270 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15271
15272 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15273 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15274
15275 /**
15276 * kernel name
15277 */
15278
15279 size_t kernel_wgs_tmp;
15280
15281 char kernel_name[64] = { 0 };
15282
15283 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15284 {
15285 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15286 {
15287 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15288
15289 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15290
15291 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15292
15293 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15294
15295 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15296
15297 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15298 }
15299 else
15300 {
15301 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15302
15303 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15304
15305 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15306
15307 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15308
15309 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15310
15311 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15312 }
15313
15314 if (data.attack_mode == ATTACK_MODE_BF)
15315 {
15316 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15317 {
15318 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15319
15320 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15321
15322 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);
15323 }
15324 }
15325 }
15326 else
15327 {
15328 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15329
15330 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15331
15332 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15333
15334 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15335
15336 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15337
15338 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15339
15340 if (opts_type & OPTS_TYPE_HOOK12)
15341 {
15342 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15343
15344 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15345
15346 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);
15347 }
15348
15349 if (opts_type & OPTS_TYPE_HOOK23)
15350 {
15351 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15352
15353 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15354
15355 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);
15356 }
15357 }
15358
15359 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);
15360 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);
15361 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);
15362
15363 for (uint i = 0; i <= 20; i++)
15364 {
15365 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15366 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15367 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15368
15369 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15370 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15371 }
15372
15373 for (uint i = 21; i <= 31; i++)
15374 {
15375 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15376 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15377 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15378
15379 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15380 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15381 }
15382
15383 if (attack_mode == ATTACK_MODE_BF)
15384 {
15385 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15386 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15387
15388 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);
15389 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);
15390
15391 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15392 {
15393 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15394 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15395 }
15396 }
15397 else if (attack_mode == ATTACK_MODE_HYBRID1)
15398 {
15399 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15400
15401 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);
15402 }
15403 else if (attack_mode == ATTACK_MODE_HYBRID2)
15404 {
15405 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15406
15407 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);
15408 }
15409
15410 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15411 {
15412 // nothing to do
15413 }
15414 else
15415 {
15416 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15417
15418 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);
15419 }
15420
15421 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15422 {
15423 // nothing to do
15424 }
15425 else
15426 {
15427 for (uint i = 0; i < 5; i++)
15428 {
15429 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15430 }
15431
15432 for (uint i = 5; i < 7; i++)
15433 {
15434 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15435 }
15436 }
15437
15438 // maybe this has been updated by clGetKernelWorkGroupInfo()
15439 // value can only be decreased, so we don't need to reallocate buffers
15440
15441 device_param->kernel_threads = kernel_threads;
15442
15443 /**
15444 * Store initial fanspeed if gpu_temp_retain is enabled
15445 */
15446
15447 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15448 int gpu_temp_retain_set = 0;
15449
15450 if (gpu_temp_disable == 0)
15451 {
15452 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15453 {
15454 hc_thread_mutex_lock (mux_adl);
15455
15456 if (data.hm_device[device_id].fan_supported == 1)
15457 {
15458 if (gpu_temp_retain_chgd == 0)
15459 {
15460 uint cur_temp = 0;
15461 uint default_temp = 0;
15462
15463 int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp);
15464
15465 if (ADL_rc == ADL_OK)
15466 {
15467 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15468
15469 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15470
15471 // special case with multi gpu setups: always use minimum retain
15472
15473 if (gpu_temp_retain_set == 0)
15474 {
15475 gpu_temp_retain = gpu_temp_retain_target;
15476 gpu_temp_retain_set = 1;
15477 }
15478 else
15479 {
15480 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15481 }
15482
15483 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15484 }
15485 }
15486
15487 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15488
15489 temp_retain_fanspeed_value[device_id] = fan_speed;
15490
15491 if (fan_speed == -1)
15492 {
15493 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15494
15495 temp_retain_fanspeed_value[device_id] = 0;
15496 }
15497 }
15498
15499 hc_thread_mutex_unlock (mux_adl);
15500 }
15501 }
15502
15503 /**
15504 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15505 */
15506
15507 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15508 {
15509 hc_thread_mutex_lock (mux_adl);
15510
15511 if (data.hm_device[device_id].od_version == 6)
15512 {
15513 int ADL_rc;
15514
15515 // check powertune capabilities first, if not available then skip device
15516
15517 int powertune_supported = 0;
15518
15519 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15520 {
15521 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15522
15523 return (-1);
15524 }
15525
15526 if (powertune_supported != 0)
15527 {
15528 // powercontrol settings
15529
15530 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15531
15532 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15533 {
15534 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15535 }
15536
15537 if (ADL_rc != ADL_OK)
15538 {
15539 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15540
15541 return (-1);
15542 }
15543
15544 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15545 {
15546 log_error ("ERROR: Failed to set new ADL PowerControl values");
15547
15548 return (-1);
15549 }
15550
15551 // clocks
15552
15553 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15554
15555 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15556
15557 if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK)
15558 {
15559 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15560
15561 return (-1);
15562 }
15563
15564 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15565
15566 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15567
15568 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15569 {
15570 log_error ("ERROR: Failed to get ADL device capabilities");
15571
15572 return (-1);
15573 }
15574
15575 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15576 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15577
15578 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15579 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15580
15581 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15582 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15583
15584 // warning if profile has too low max values
15585
15586 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15587 {
15588 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15589 }
15590
15591 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15592 {
15593 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15594 }
15595
15596 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15597
15598 performance_state->iNumberOfPerformanceLevels = 2;
15599
15600 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15601 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15602 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15603 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15604
15605 if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
15606 {
15607 log_info ("ERROR: Failed to set ADL performance state");
15608
15609 return (-1);
15610 }
15611
15612 local_free (performance_state);
15613 }
15614 }
15615
15616 hc_thread_mutex_unlock (mux_adl);
15617 }
15618 #endif // HAVE_HWMON && HAVE_ADL
15619 }
15620
15621 data.kernel_power_all = kernel_power_all;
15622
15623 if (data.quiet == 0) log_info_nn ("");
15624
15625 /**
15626 * In benchmark-mode, inform user which algorithm is checked
15627 */
15628
15629 if (benchmark == 1)
15630 {
15631 if (status_automat == 0)
15632 {
15633 quiet = 0;
15634
15635 data.quiet = quiet;
15636
15637 char *hash_type = strhashtype (data.hash_mode); // not a bug
15638
15639 log_info ("Hashtype: %s", hash_type);
15640 log_info ("");
15641 }
15642 }
15643
15644 /**
15645 * keep track of the progress
15646 */
15647
15648 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15649 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15650 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15651
15652 /**
15653 * open filehandles
15654 */
15655
15656 #if _WIN
15657 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15658 {
15659 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15660
15661 return (-1);
15662 }
15663
15664 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15665 {
15666 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15667
15668 return (-1);
15669 }
15670
15671 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15672 {
15673 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15674
15675 return (-1);
15676 }
15677 #endif
15678
15679 /**
15680 * dictionary pad
15681 */
15682
15683 segment_size *= (1024 * 1024);
15684
15685 data.segment_size = segment_size;
15686
15687 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15688
15689 wl_data->buf = (char *) mymalloc (segment_size);
15690 wl_data->avail = segment_size;
15691 wl_data->incr = segment_size;
15692 wl_data->cnt = 0;
15693 wl_data->pos = 0;
15694
15695 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15696
15697 data.wordlist_mode = wordlist_mode;
15698
15699 cs_t *css_buf = NULL;
15700 uint css_cnt = 0;
15701 uint dictcnt = 0;
15702 uint maskcnt = 1;
15703 char **masks = NULL;
15704 char **dictfiles = NULL;
15705
15706 uint mask_from_file = 0;
15707
15708 if (attack_mode == ATTACK_MODE_STRAIGHT)
15709 {
15710 if (wordlist_mode == WL_MODE_FILE)
15711 {
15712 int wls_left = myargc - (optind + 1);
15713
15714 for (int i = 0; i < wls_left; i++)
15715 {
15716 char *l0_filename = myargv[optind + 1 + i];
15717
15718 struct stat l0_stat;
15719
15720 if (stat (l0_filename, &l0_stat) == -1)
15721 {
15722 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15723
15724 return (-1);
15725 }
15726
15727 uint is_dir = S_ISDIR (l0_stat.st_mode);
15728
15729 if (is_dir == 0)
15730 {
15731 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15732
15733 dictcnt++;
15734
15735 dictfiles[dictcnt - 1] = l0_filename;
15736 }
15737 else
15738 {
15739 // do not allow --keyspace w/ a directory
15740
15741 if (keyspace == 1)
15742 {
15743 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15744
15745 return (-1);
15746 }
15747
15748 char **dictionary_files = NULL;
15749
15750 dictionary_files = scan_directory (l0_filename);
15751
15752 if (dictionary_files != NULL)
15753 {
15754 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15755
15756 for (int d = 0; dictionary_files[d] != NULL; d++)
15757 {
15758 char *l1_filename = dictionary_files[d];
15759
15760 struct stat l1_stat;
15761
15762 if (stat (l1_filename, &l1_stat) == -1)
15763 {
15764 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15765
15766 return (-1);
15767 }
15768
15769 if (S_ISREG (l1_stat.st_mode))
15770 {
15771 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15772
15773 dictcnt++;
15774
15775 dictfiles[dictcnt - 1] = strdup (l1_filename);
15776 }
15777 }
15778 }
15779
15780 local_free (dictionary_files);
15781 }
15782 }
15783
15784 if (dictcnt < 1)
15785 {
15786 log_error ("ERROR: No usable dictionary file found.");
15787
15788 return (-1);
15789 }
15790 }
15791 else if (wordlist_mode == WL_MODE_STDIN)
15792 {
15793 dictcnt = 1;
15794 }
15795 }
15796 else if (attack_mode == ATTACK_MODE_COMBI)
15797 {
15798 // display
15799
15800 char *dictfile1 = myargv[optind + 1 + 0];
15801 char *dictfile2 = myargv[optind + 1 + 1];
15802
15803 // find the bigger dictionary and use as base
15804
15805 FILE *fp1 = NULL;
15806 FILE *fp2 = NULL;
15807
15808 struct stat tmp_stat;
15809
15810 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15811 {
15812 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15813
15814 return (-1);
15815 }
15816
15817 if (stat (dictfile1, &tmp_stat) == -1)
15818 {
15819 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15820
15821 fclose (fp1);
15822
15823 return (-1);
15824 }
15825
15826 if (S_ISDIR (tmp_stat.st_mode))
15827 {
15828 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15829
15830 fclose (fp1);
15831
15832 return (-1);
15833 }
15834
15835 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15836 {
15837 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15838
15839 fclose (fp1);
15840
15841 return (-1);
15842 }
15843
15844 if (stat (dictfile2, &tmp_stat) == -1)
15845 {
15846 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15847
15848 fclose (fp1);
15849 fclose (fp2);
15850
15851 return (-1);
15852 }
15853
15854 if (S_ISDIR (tmp_stat.st_mode))
15855 {
15856 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15857
15858 fclose (fp1);
15859 fclose (fp2);
15860
15861 return (-1);
15862 }
15863
15864 data.combs_cnt = 1;
15865
15866 data.quiet = 1;
15867
15868 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15869
15870 data.quiet = quiet;
15871
15872 if (words1_cnt == 0)
15873 {
15874 log_error ("ERROR: %s: empty file", dictfile1);
15875
15876 fclose (fp1);
15877 fclose (fp2);
15878
15879 return (-1);
15880 }
15881
15882 data.combs_cnt = 1;
15883
15884 data.quiet = 1;
15885
15886 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15887
15888 data.quiet = quiet;
15889
15890 if (words2_cnt == 0)
15891 {
15892 log_error ("ERROR: %s: empty file", dictfile2);
15893
15894 fclose (fp1);
15895 fclose (fp2);
15896
15897 return (-1);
15898 }
15899
15900 fclose (fp1);
15901 fclose (fp2);
15902
15903 data.dictfile = dictfile1;
15904 data.dictfile2 = dictfile2;
15905
15906 if (words1_cnt >= words2_cnt)
15907 {
15908 data.combs_cnt = words2_cnt;
15909 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15910
15911 dictfiles = &data.dictfile;
15912
15913 dictcnt = 1;
15914 }
15915 else
15916 {
15917 data.combs_cnt = words1_cnt;
15918 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15919
15920 dictfiles = &data.dictfile2;
15921
15922 dictcnt = 1;
15923
15924 // we also have to switch wordlist related rules!
15925
15926 char *tmpc = data.rule_buf_l;
15927
15928 data.rule_buf_l = data.rule_buf_r;
15929 data.rule_buf_r = tmpc;
15930
15931 int tmpi = data.rule_len_l;
15932
15933 data.rule_len_l = data.rule_len_r;
15934 data.rule_len_r = tmpi;
15935 }
15936 }
15937 else if (attack_mode == ATTACK_MODE_BF)
15938 {
15939 char *mask = NULL;
15940
15941 maskcnt = 0;
15942
15943 if (benchmark == 0)
15944 {
15945 mask = myargv[optind + 1];
15946
15947 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15948
15949 if ((optind + 2) <= myargc)
15950 {
15951 struct stat file_stat;
15952
15953 if (stat (mask, &file_stat) == -1)
15954 {
15955 maskcnt = 1;
15956
15957 masks[maskcnt - 1] = mystrdup (mask);
15958 }
15959 else
15960 {
15961 int wls_left = myargc - (optind + 1);
15962
15963 uint masks_avail = INCR_MASKS;
15964
15965 for (int i = 0; i < wls_left; i++)
15966 {
15967 if (i != 0)
15968 {
15969 mask = myargv[optind + 1 + i];
15970
15971 if (stat (mask, &file_stat) == -1)
15972 {
15973 log_error ("ERROR: %s: %s", mask, strerror (errno));
15974
15975 return (-1);
15976 }
15977 }
15978
15979 uint is_file = S_ISREG (file_stat.st_mode);
15980
15981 if (is_file == 1)
15982 {
15983 FILE *mask_fp;
15984
15985 if ((mask_fp = fopen (mask, "r")) == NULL)
15986 {
15987 log_error ("ERROR: %s: %s", mask, strerror (errno));
15988
15989 return (-1);
15990 }
15991
15992 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15993
15994 while (!feof (mask_fp))
15995 {
15996 memset (line_buf, 0, HCBUFSIZ);
15997
15998 int line_len = fgetl (mask_fp, line_buf);
15999
16000 if (line_len == 0) continue;
16001
16002 if (line_buf[0] == '#') continue;
16003
16004 if (masks_avail == maskcnt)
16005 {
16006 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16007
16008 masks_avail += INCR_MASKS;
16009 }
16010
16011 masks[maskcnt] = mystrdup (line_buf);
16012
16013 maskcnt++;
16014 }
16015
16016 myfree (line_buf);
16017
16018 fclose (mask_fp);
16019 }
16020 else
16021 {
16022 log_error ("ERROR: %s: unsupported file-type", mask);
16023
16024 return (-1);
16025 }
16026 }
16027
16028 mask_from_file = 1;
16029 }
16030 }
16031 else
16032 {
16033 custom_charset_1 = (char *) "?l?d?u";
16034 custom_charset_2 = (char *) "?l?d";
16035 custom_charset_3 = (char *) "?l?d*!$@_";
16036
16037 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16038 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16039 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16040
16041 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16042
16043 wordlist_mode = WL_MODE_MASK;
16044
16045 data.wordlist_mode = wordlist_mode;
16046
16047 increment = 1;
16048
16049 maskcnt = 1;
16050 }
16051 }
16052 else
16053 {
16054 /**
16055 * generate full masks and charsets
16056 */
16057
16058 masks = (char **) mymalloc (sizeof (char *));
16059
16060 switch (hash_mode)
16061 {
16062 case 1731: pw_min = 5;
16063 pw_max = 5;
16064 mask = mystrdup ("?b?b?b?b?b");
16065 break;
16066 case 12500: pw_min = 5;
16067 pw_max = 5;
16068 mask = mystrdup ("?b?b?b?b?b");
16069 break;
16070 default: pw_min = 7;
16071 pw_max = 7;
16072 mask = mystrdup ("?b?b?b?b?b?b?b");
16073 break;
16074 }
16075
16076 maskcnt = 1;
16077
16078 masks[maskcnt - 1] = mystrdup (mask);
16079
16080 wordlist_mode = WL_MODE_MASK;
16081
16082 data.wordlist_mode = wordlist_mode;
16083
16084 increment = 1;
16085 }
16086
16087 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16088
16089 if (increment)
16090 {
16091 if (increment_min > pw_min) pw_min = increment_min;
16092
16093 if (increment_max < pw_max) pw_max = increment_max;
16094 }
16095 }
16096 else if (attack_mode == ATTACK_MODE_HYBRID1)
16097 {
16098 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16099
16100 // display
16101
16102 char *mask = myargv[myargc - 1];
16103
16104 maskcnt = 0;
16105
16106 masks = (char **) mymalloc (1 * sizeof (char *));
16107
16108 // mod
16109
16110 struct stat file_stat;
16111
16112 if (stat (mask, &file_stat) == -1)
16113 {
16114 maskcnt = 1;
16115
16116 masks[maskcnt - 1] = mystrdup (mask);
16117 }
16118 else
16119 {
16120 uint is_file = S_ISREG (file_stat.st_mode);
16121
16122 if (is_file == 1)
16123 {
16124 FILE *mask_fp;
16125
16126 if ((mask_fp = fopen (mask, "r")) == NULL)
16127 {
16128 log_error ("ERROR: %s: %s", mask, strerror (errno));
16129
16130 return (-1);
16131 }
16132
16133 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16134
16135 uint masks_avail = 1;
16136
16137 while (!feof (mask_fp))
16138 {
16139 memset (line_buf, 0, HCBUFSIZ);
16140
16141 int line_len = fgetl (mask_fp, line_buf);
16142
16143 if (line_len == 0) continue;
16144
16145 if (line_buf[0] == '#') continue;
16146
16147 if (masks_avail == maskcnt)
16148 {
16149 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16150
16151 masks_avail += INCR_MASKS;
16152 }
16153
16154 masks[maskcnt] = mystrdup (line_buf);
16155
16156 maskcnt++;
16157 }
16158
16159 myfree (line_buf);
16160
16161 fclose (mask_fp);
16162
16163 mask_from_file = 1;
16164 }
16165 else
16166 {
16167 maskcnt = 1;
16168
16169 masks[maskcnt - 1] = mystrdup (mask);
16170 }
16171 }
16172
16173 // base
16174
16175 int wls_left = myargc - (optind + 2);
16176
16177 for (int i = 0; i < wls_left; i++)
16178 {
16179 char *filename = myargv[optind + 1 + i];
16180
16181 struct stat file_stat;
16182
16183 if (stat (filename, &file_stat) == -1)
16184 {
16185 log_error ("ERROR: %s: %s", filename, strerror (errno));
16186
16187 return (-1);
16188 }
16189
16190 uint is_dir = S_ISDIR (file_stat.st_mode);
16191
16192 if (is_dir == 0)
16193 {
16194 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16195
16196 dictcnt++;
16197
16198 dictfiles[dictcnt - 1] = filename;
16199 }
16200 else
16201 {
16202 // do not allow --keyspace w/ a directory
16203
16204 if (keyspace == 1)
16205 {
16206 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16207
16208 return (-1);
16209 }
16210
16211 char **dictionary_files = NULL;
16212
16213 dictionary_files = scan_directory (filename);
16214
16215 if (dictionary_files != NULL)
16216 {
16217 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16218
16219 for (int d = 0; dictionary_files[d] != NULL; d++)
16220 {
16221 char *l1_filename = dictionary_files[d];
16222
16223 struct stat l1_stat;
16224
16225 if (stat (l1_filename, &l1_stat) == -1)
16226 {
16227 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16228
16229 return (-1);
16230 }
16231
16232 if (S_ISREG (l1_stat.st_mode))
16233 {
16234 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16235
16236 dictcnt++;
16237
16238 dictfiles[dictcnt - 1] = strdup (l1_filename);
16239 }
16240 }
16241 }
16242
16243 local_free (dictionary_files);
16244 }
16245 }
16246
16247 if (dictcnt < 1)
16248 {
16249 log_error ("ERROR: No usable dictionary file found.");
16250
16251 return (-1);
16252 }
16253
16254 if (increment)
16255 {
16256 maskcnt = 0;
16257
16258 uint mask_min = increment_min; // we can't reject smaller masks here
16259 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16260
16261 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16262 {
16263 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16264
16265 if (cur_mask == NULL) break;
16266
16267 masks[maskcnt] = cur_mask;
16268
16269 maskcnt++;
16270
16271 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16272 }
16273 }
16274 }
16275 else if (attack_mode == ATTACK_MODE_HYBRID2)
16276 {
16277 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16278
16279 // display
16280
16281 char *mask = myargv[optind + 1 + 0];
16282
16283 maskcnt = 0;
16284
16285 masks = (char **) mymalloc (1 * sizeof (char *));
16286
16287 // mod
16288
16289 struct stat file_stat;
16290
16291 if (stat (mask, &file_stat) == -1)
16292 {
16293 maskcnt = 1;
16294
16295 masks[maskcnt - 1] = mystrdup (mask);
16296 }
16297 else
16298 {
16299 uint is_file = S_ISREG (file_stat.st_mode);
16300
16301 if (is_file == 1)
16302 {
16303 FILE *mask_fp;
16304
16305 if ((mask_fp = fopen (mask, "r")) == NULL)
16306 {
16307 log_error ("ERROR: %s: %s", mask, strerror (errno));
16308
16309 return (-1);
16310 }
16311
16312 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16313
16314 uint masks_avail = 1;
16315
16316 while (!feof (mask_fp))
16317 {
16318 memset (line_buf, 0, HCBUFSIZ);
16319
16320 int line_len = fgetl (mask_fp, line_buf);
16321
16322 if (line_len == 0) continue;
16323
16324 if (line_buf[0] == '#') continue;
16325
16326 if (masks_avail == maskcnt)
16327 {
16328 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16329
16330 masks_avail += INCR_MASKS;
16331 }
16332
16333 masks[maskcnt] = mystrdup (line_buf);
16334
16335 maskcnt++;
16336 }
16337
16338 myfree (line_buf);
16339
16340 fclose (mask_fp);
16341
16342 mask_from_file = 1;
16343 }
16344 else
16345 {
16346 maskcnt = 1;
16347
16348 masks[maskcnt - 1] = mystrdup (mask);
16349 }
16350 }
16351
16352 // base
16353
16354 int wls_left = myargc - (optind + 2);
16355
16356 for (int i = 0; i < wls_left; i++)
16357 {
16358 char *filename = myargv[optind + 2 + i];
16359
16360 struct stat file_stat;
16361
16362 if (stat (filename, &file_stat) == -1)
16363 {
16364 log_error ("ERROR: %s: %s", filename, strerror (errno));
16365
16366 return (-1);
16367 }
16368
16369 uint is_dir = S_ISDIR (file_stat.st_mode);
16370
16371 if (is_dir == 0)
16372 {
16373 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16374
16375 dictcnt++;
16376
16377 dictfiles[dictcnt - 1] = filename;
16378 }
16379 else
16380 {
16381 // do not allow --keyspace w/ a directory
16382
16383 if (keyspace == 1)
16384 {
16385 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16386
16387 return (-1);
16388 }
16389
16390 char **dictionary_files = NULL;
16391
16392 dictionary_files = scan_directory (filename);
16393
16394 if (dictionary_files != NULL)
16395 {
16396 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16397
16398 for (int d = 0; dictionary_files[d] != NULL; d++)
16399 {
16400 char *l1_filename = dictionary_files[d];
16401
16402 struct stat l1_stat;
16403
16404 if (stat (l1_filename, &l1_stat) == -1)
16405 {
16406 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16407
16408 return (-1);
16409 }
16410
16411 if (S_ISREG (l1_stat.st_mode))
16412 {
16413 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16414
16415 dictcnt++;
16416
16417 dictfiles[dictcnt - 1] = strdup (l1_filename);
16418 }
16419 }
16420 }
16421
16422 local_free (dictionary_files);
16423 }
16424 }
16425
16426 if (dictcnt < 1)
16427 {
16428 log_error ("ERROR: No usable dictionary file found.");
16429
16430 return (-1);
16431 }
16432
16433 if (increment)
16434 {
16435 maskcnt = 0;
16436
16437 uint mask_min = increment_min; // we can't reject smaller masks here
16438 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16439
16440 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16441 {
16442 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16443
16444 if (cur_mask == NULL) break;
16445
16446 masks[maskcnt] = cur_mask;
16447
16448 maskcnt++;
16449
16450 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16451 }
16452 }
16453 }
16454
16455 data.pw_min = pw_min;
16456 data.pw_max = pw_max;
16457
16458 /**
16459 * weak hash check
16460 */
16461
16462 if (weak_hash_threshold >= salts_cnt)
16463 {
16464 hc_device_param_t *device_param = NULL;
16465
16466 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16467 {
16468 device_param = &data.devices_param[device_id];
16469
16470 if (device_param->skipped) continue;
16471
16472 break;
16473 }
16474
16475 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16476
16477 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16478 {
16479 weak_hash_check (device_param, salt_pos);
16480 }
16481
16482 // Display hack, guarantee that there is at least one \r before real start
16483
16484 //if (data.quiet == 0) log_info ("");
16485 }
16486
16487 /**
16488 * status and monitor threads
16489 */
16490
16491 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16492
16493 hc_thread_t i_thread = 0;
16494
16495 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16496 {
16497 hc_thread_create (i_thread, thread_keypress, &benchmark);
16498 }
16499
16500 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16501
16502 uint ni_threads_cnt = 0;
16503
16504 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16505
16506 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16507
16508 ni_threads_cnt++;
16509
16510 /**
16511 * Outfile remove
16512 */
16513
16514 if (keyspace == 0)
16515 {
16516 if (outfile_check_timer != 0)
16517 {
16518 if (data.outfile_check_directory != NULL)
16519 {
16520 if ((hash_mode != 5200) &&
16521 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16522 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16523 (hash_mode != 9000))
16524 {
16525 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16526
16527 ni_threads_cnt++;
16528 }
16529 else
16530 {
16531 outfile_check_timer = 0;
16532 }
16533 }
16534 else
16535 {
16536 outfile_check_timer = 0;
16537 }
16538 }
16539 }
16540
16541 /**
16542 * Inform the user if we got some hashes remove because of the pot file remove feature
16543 */
16544
16545 if (data.quiet == 0)
16546 {
16547 if (potfile_remove_cracks > 0)
16548 {
16549 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16550 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16551 }
16552 }
16553
16554 data.outfile_check_timer = outfile_check_timer;
16555
16556 /**
16557 * main loop
16558 */
16559
16560 char **induction_dictionaries = NULL;
16561
16562 int induction_dictionaries_cnt = 0;
16563
16564 hcstat_table_t *root_table_buf = NULL;
16565 hcstat_table_t *markov_table_buf = NULL;
16566
16567 uint initial_restore_done = 0;
16568
16569 data.maskcnt = maskcnt;
16570
16571 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16572 {
16573 if (data.devices_status == STATUS_CRACKED) break;
16574
16575 data.devices_status = STATUS_INIT;
16576
16577 if (maskpos > rd->maskpos)
16578 {
16579 rd->dictpos = 0;
16580 }
16581
16582 rd->maskpos = maskpos;
16583 data.maskpos = maskpos;
16584
16585 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16586 {
16587 char *mask = masks[maskpos];
16588
16589 if (mask_from_file == 1)
16590 {
16591 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16592
16593 char *str_ptr;
16594 uint str_pos;
16595
16596 uint mask_offset = 0;
16597
16598 uint separator_cnt;
16599
16600 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16601 {
16602 str_ptr = strstr (mask + mask_offset, ",");
16603
16604 if (str_ptr == NULL) break;
16605
16606 str_pos = str_ptr - mask;
16607
16608 // escaped separator, i.e. "\,"
16609
16610 if (str_pos > 0)
16611 {
16612 if (mask[str_pos - 1] == '\\')
16613 {
16614 separator_cnt --;
16615
16616 mask_offset = str_pos + 1;
16617
16618 continue;
16619 }
16620 }
16621
16622 // reset the offset
16623
16624 mask_offset = 0;
16625
16626 mask[str_pos] = '\0';
16627
16628 switch (separator_cnt)
16629 {
16630 case 0:
16631 mp_reset_usr (mp_usr, 0);
16632
16633 custom_charset_1 = mask;
16634 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16635 break;
16636
16637 case 1:
16638 mp_reset_usr (mp_usr, 1);
16639
16640 custom_charset_2 = mask;
16641 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16642 break;
16643
16644 case 2:
16645 mp_reset_usr (mp_usr, 2);
16646
16647 custom_charset_3 = mask;
16648 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16649 break;
16650
16651 case 3:
16652 mp_reset_usr (mp_usr, 3);
16653
16654 custom_charset_4 = mask;
16655 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16656 break;
16657 }
16658
16659 mask = mask + str_pos + 1;
16660 }
16661 }
16662
16663 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16664 {
16665 if (maskpos > 0)
16666 {
16667 local_free (css_buf);
16668 local_free (data.root_css_buf);
16669 local_free (data.markov_css_buf);
16670
16671 local_free (masks[maskpos - 1]);
16672 }
16673
16674 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16675
16676 data.mask = mask;
16677 data.css_cnt = css_cnt;
16678 data.css_buf = css_buf;
16679
16680 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16681
16682 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16683
16684 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16685 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16686
16687 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16688
16689 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16690
16691 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16692 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16693
16694 data.root_css_buf = root_css_buf;
16695 data.markov_css_buf = markov_css_buf;
16696
16697 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16698
16699 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16700
16701 local_free (root_table_buf);
16702 local_free (markov_table_buf);
16703
16704 // args
16705
16706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16707 {
16708 hc_device_param_t *device_param = &data.devices_param[device_id];
16709
16710 if (device_param->skipped) continue;
16711
16712 device_param->kernel_params_mp[0] = &device_param->d_combs;
16713 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16714 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16715
16716 device_param->kernel_params_mp_buf64[3] = 0;
16717 device_param->kernel_params_mp_buf32[4] = css_cnt;
16718 device_param->kernel_params_mp_buf32[5] = 0;
16719 device_param->kernel_params_mp_buf32[6] = 0;
16720 device_param->kernel_params_mp_buf32[7] = 0;
16721
16722 if (attack_mode == ATTACK_MODE_HYBRID1)
16723 {
16724 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16725 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16726 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16727 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16728 }
16729 else if (attack_mode == ATTACK_MODE_HYBRID2)
16730 {
16731 device_param->kernel_params_mp_buf32[5] = 0;
16732 device_param->kernel_params_mp_buf32[6] = 0;
16733 device_param->kernel_params_mp_buf32[7] = 0;
16734 }
16735
16736 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]);
16737 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]);
16738 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]);
16739
16740 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);
16741 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);
16742 }
16743 }
16744 else if (attack_mode == ATTACK_MODE_BF)
16745 {
16746 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16747
16748 if (increment)
16749 {
16750 for (uint i = 0; i < dictcnt; i++)
16751 {
16752 local_free (dictfiles[i]);
16753 }
16754
16755 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16756 {
16757 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16758
16759 if (l1_filename == NULL) break;
16760
16761 dictcnt++;
16762
16763 dictfiles[dictcnt - 1] = l1_filename;
16764 }
16765 }
16766 else
16767 {
16768 dictcnt++;
16769
16770 dictfiles[dictcnt - 1] = mask;
16771 }
16772
16773 if (dictcnt == 0)
16774 {
16775 log_error ("ERROR: Mask is too small");
16776
16777 return (-1);
16778 }
16779 }
16780 }
16781
16782 free (induction_dictionaries);
16783
16784 // induction_dictionaries_cnt = 0; // implied
16785
16786 if (attack_mode != ATTACK_MODE_BF)
16787 {
16788 if (keyspace == 0)
16789 {
16790 induction_dictionaries = scan_directory (induction_directory);
16791
16792 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16793 }
16794 }
16795
16796 if (induction_dictionaries_cnt)
16797 {
16798 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16799 }
16800
16801 /**
16802 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16803 */
16804 if (keyspace == 1)
16805 {
16806 if ((maskcnt > 1) || (dictcnt > 1))
16807 {
16808 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16809
16810 return (-1);
16811 }
16812 }
16813
16814 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16815 {
16816 char *subid = logfile_generate_subid ();
16817
16818 data.subid = subid;
16819
16820 logfile_sub_msg ("START");
16821
16822 data.devices_status = STATUS_INIT;
16823
16824 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16825 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16826 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16827
16828 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16829
16830 data.cpt_pos = 0;
16831
16832 data.cpt_start = time (NULL);
16833
16834 data.cpt_total = 0;
16835
16836 if (data.restore == 0)
16837 {
16838 rd->words_cur = skip;
16839
16840 skip = 0;
16841
16842 data.skip = 0;
16843 }
16844
16845 data.ms_paused = 0;
16846
16847 data.words_cur = rd->words_cur;
16848
16849 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16850 {
16851 hc_device_param_t *device_param = &data.devices_param[device_id];
16852
16853 if (device_param->skipped) continue;
16854
16855 device_param->speed_pos = 0;
16856
16857 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16858 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16859
16860 device_param->exec_pos = 0;
16861
16862 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16863
16864 device_param->kernel_power = device_param->kernel_power_user;
16865
16866 device_param->outerloop_pos = 0;
16867 device_param->outerloop_left = 0;
16868 device_param->innerloop_pos = 0;
16869 device_param->innerloop_left = 0;
16870
16871 // some more resets:
16872
16873 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16874
16875 device_param->pws_cnt = 0;
16876
16877 device_param->words_off = 0;
16878 device_param->words_done = 0;
16879 }
16880
16881 data.kernel_power_div = 0;
16882
16883 // figure out some workload
16884
16885 if (attack_mode == ATTACK_MODE_STRAIGHT)
16886 {
16887 if (data.wordlist_mode == WL_MODE_FILE)
16888 {
16889 char *dictfile = NULL;
16890
16891 if (induction_dictionaries_cnt)
16892 {
16893 dictfile = induction_dictionaries[0];
16894 }
16895 else
16896 {
16897 dictfile = dictfiles[dictpos];
16898 }
16899
16900 data.dictfile = dictfile;
16901
16902 logfile_sub_string (dictfile);
16903
16904 for (uint i = 0; i < rp_files_cnt; i++)
16905 {
16906 logfile_sub_var_string ("rulefile", rp_files[i]);
16907 }
16908
16909 FILE *fd2 = fopen (dictfile, "rb");
16910
16911 if (fd2 == NULL)
16912 {
16913 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16914
16915 return (-1);
16916 }
16917
16918 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16919
16920 fclose (fd2);
16921
16922 if (data.words_cnt == 0)
16923 {
16924 if (data.devices_status == STATUS_CRACKED) break;
16925 if (data.devices_status == STATUS_ABORTED) break;
16926
16927 dictpos++;
16928
16929 continue;
16930 }
16931 }
16932 }
16933 else if (attack_mode == ATTACK_MODE_COMBI)
16934 {
16935 char *dictfile = data.dictfile;
16936 char *dictfile2 = data.dictfile2;
16937
16938 logfile_sub_string (dictfile);
16939 logfile_sub_string (dictfile2);
16940
16941 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16942 {
16943 FILE *fd2 = fopen (dictfile, "rb");
16944
16945 if (fd2 == NULL)
16946 {
16947 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16948
16949 return (-1);
16950 }
16951
16952 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16953
16954 fclose (fd2);
16955 }
16956 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16957 {
16958 FILE *fd2 = fopen (dictfile2, "rb");
16959
16960 if (fd2 == NULL)
16961 {
16962 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16963
16964 return (-1);
16965 }
16966
16967 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16968
16969 fclose (fd2);
16970 }
16971
16972 if (data.words_cnt == 0)
16973 {
16974 if (data.devices_status == STATUS_CRACKED) break;
16975 if (data.devices_status == STATUS_ABORTED) break;
16976
16977 dictpos++;
16978
16979 continue;
16980 }
16981 }
16982 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16983 {
16984 char *dictfile = NULL;
16985
16986 if (induction_dictionaries_cnt)
16987 {
16988 dictfile = induction_dictionaries[0];
16989 }
16990 else
16991 {
16992 dictfile = dictfiles[dictpos];
16993 }
16994
16995 data.dictfile = dictfile;
16996
16997 char *mask = data.mask;
16998
16999 logfile_sub_string (dictfile);
17000 logfile_sub_string (mask);
17001
17002 FILE *fd2 = fopen (dictfile, "rb");
17003
17004 if (fd2 == NULL)
17005 {
17006 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17007
17008 return (-1);
17009 }
17010
17011 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17012
17013 fclose (fd2);
17014
17015 if (data.words_cnt == 0)
17016 {
17017 if (data.devices_status == STATUS_CRACKED) break;
17018 if (data.devices_status == STATUS_ABORTED) break;
17019
17020 dictpos++;
17021
17022 continue;
17023 }
17024 }
17025 else if (attack_mode == ATTACK_MODE_BF)
17026 {
17027 local_free (css_buf);
17028 local_free (data.root_css_buf);
17029 local_free (data.markov_css_buf);
17030
17031 char *mask = dictfiles[dictpos];
17032
17033 logfile_sub_string (mask);
17034
17035 // base
17036
17037 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17038
17039 if (opts_type & OPTS_TYPE_PT_UNICODE)
17040 {
17041 uint css_cnt_unicode = css_cnt * 2;
17042
17043 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17044
17045 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17046 {
17047 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17048
17049 css_buf_unicode[j + 1].cs_buf[0] = 0;
17050 css_buf_unicode[j + 1].cs_len = 1;
17051 }
17052
17053 free (css_buf);
17054
17055 css_buf = css_buf_unicode;
17056 css_cnt = css_cnt_unicode;
17057 }
17058
17059 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17060
17061 uint mask_min = pw_min;
17062 uint mask_max = pw_max;
17063
17064 if (opts_type & OPTS_TYPE_PT_UNICODE)
17065 {
17066 mask_min *= 2;
17067 mask_max *= 2;
17068 }
17069
17070 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17071 {
17072 if (css_cnt < mask_min)
17073 {
17074 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17075 }
17076
17077 if (css_cnt > mask_max)
17078 {
17079 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17080 }
17081
17082 // skip to next mask
17083
17084 dictpos++;
17085
17086 rd->dictpos = dictpos;
17087
17088 logfile_sub_msg ("STOP");
17089
17090 continue;
17091 }
17092
17093 uint save_css_cnt = css_cnt;
17094
17095 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17096 {
17097 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17098 {
17099 uint salt_len = (uint) data.salts_buf[0].salt_len;
17100 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17101
17102 uint css_cnt_salt = css_cnt + salt_len;
17103
17104 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17105
17106 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17107
17108 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17109 {
17110 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17111 css_buf_salt[j].cs_len = 1;
17112 }
17113
17114 free (css_buf);
17115
17116 css_buf = css_buf_salt;
17117 css_cnt = css_cnt_salt;
17118 }
17119 }
17120
17121 data.mask = mask;
17122 data.css_cnt = css_cnt;
17123 data.css_buf = css_buf;
17124
17125 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17126
17127 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17128
17129 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17130
17131 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17132 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17133
17134 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17135
17136 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17137
17138 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17139 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17140
17141 data.root_css_buf = root_css_buf;
17142 data.markov_css_buf = markov_css_buf;
17143
17144 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17145
17146 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17147
17148 local_free (root_table_buf);
17149 local_free (markov_table_buf);
17150
17151 // copy + args
17152
17153 uint css_cnt_l = css_cnt;
17154 uint css_cnt_r;
17155
17156 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17157 {
17158 if (save_css_cnt < 6)
17159 {
17160 css_cnt_r = 1;
17161 }
17162 else if (save_css_cnt == 6)
17163 {
17164 css_cnt_r = 2;
17165 }
17166 else
17167 {
17168 if (opts_type & OPTS_TYPE_PT_UNICODE)
17169 {
17170 if (save_css_cnt == 8 || save_css_cnt == 10)
17171 {
17172 css_cnt_r = 2;
17173 }
17174 else
17175 {
17176 css_cnt_r = 4;
17177 }
17178 }
17179 else
17180 {
17181 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17182 {
17183 css_cnt_r = 3;
17184 }
17185 else
17186 {
17187 css_cnt_r = 4;
17188 }
17189 }
17190 }
17191 }
17192 else
17193 {
17194 css_cnt_r = 1;
17195
17196 /* unfinished code?
17197 int sum = css_buf[css_cnt_r - 1].cs_len;
17198
17199 for (uint i = 1; i < 4 && i < css_cnt; i++)
17200 {
17201 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17202
17203 css_cnt_r++;
17204
17205 sum *= css_buf[css_cnt_r - 1].cs_len;
17206 }
17207 */
17208 }
17209
17210 css_cnt_l -= css_cnt_r;
17211
17212 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17213
17214 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17215 {
17216 hc_device_param_t *device_param = &data.devices_param[device_id];
17217
17218 if (device_param->skipped) continue;
17219
17220 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17221 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17222 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17223
17224 device_param->kernel_params_mp_l_buf64[3] = 0;
17225 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17226 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17227 device_param->kernel_params_mp_l_buf32[6] = 0;
17228 device_param->kernel_params_mp_l_buf32[7] = 0;
17229 device_param->kernel_params_mp_l_buf32[8] = 0;
17230
17231 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17232 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17233 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17234 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17235
17236 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17237 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17238 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17239
17240 device_param->kernel_params_mp_r_buf64[3] = 0;
17241 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17242 device_param->kernel_params_mp_r_buf32[5] = 0;
17243 device_param->kernel_params_mp_r_buf32[6] = 0;
17244 device_param->kernel_params_mp_r_buf32[7] = 0;
17245
17246 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]);
17247 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]);
17248 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]);
17249
17250 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]);
17251 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]);
17252 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]);
17253
17254 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);
17255 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);
17256 }
17257 }
17258
17259 u64 words_base = data.words_cnt;
17260
17261 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17262 {
17263 if (data.kernel_rules_cnt)
17264 {
17265 words_base /= data.kernel_rules_cnt;
17266 }
17267 }
17268 else if (data.attack_kern == ATTACK_KERN_COMBI)
17269 {
17270 if (data.combs_cnt)
17271 {
17272 words_base /= data.combs_cnt;
17273 }
17274 }
17275 else if (data.attack_kern == ATTACK_KERN_BF)
17276 {
17277 if (data.bfs_cnt)
17278 {
17279 words_base /= data.bfs_cnt;
17280 }
17281 }
17282
17283 data.words_base = words_base;
17284
17285 if (keyspace == 1)
17286 {
17287 log_info ("%llu", (unsigned long long int) words_base);
17288
17289 return (0);
17290 }
17291
17292 if (data.words_cur > data.words_base)
17293 {
17294 log_error ("ERROR: restore value greater keyspace");
17295
17296 return (-1);
17297 }
17298
17299 if (data.words_cur)
17300 {
17301 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17302 {
17303 for (uint i = 0; i < data.salts_cnt; i++)
17304 {
17305 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17306 }
17307 }
17308 else if (data.attack_kern == ATTACK_KERN_COMBI)
17309 {
17310 for (uint i = 0; i < data.salts_cnt; i++)
17311 {
17312 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17313 }
17314 }
17315 else if (data.attack_kern == ATTACK_KERN_BF)
17316 {
17317 for (uint i = 0; i < data.salts_cnt; i++)
17318 {
17319 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17320 }
17321 }
17322 }
17323
17324 /*
17325 * Inform user about possible slow speeds
17326 */
17327
17328 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17329 {
17330 if (data.words_base < kernel_power_all)
17331 {
17332 if (quiet == 0)
17333 {
17334 log_info ("ATTENTION!");
17335 log_info (" The wordlist or mask you are using is too small.");
17336 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17337 log_info (" The cracking speed will drop.");
17338 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17339 log_info ("");
17340 }
17341 }
17342 }
17343
17344 /*
17345 * Update loopback file
17346 */
17347
17348 if (loopback == 1)
17349 {
17350 time_t now;
17351
17352 time (&now);
17353
17354 uint random_num = get_random_num (0, 9999);
17355
17356 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17357
17358 data.loopback_file = loopback_file;
17359 }
17360
17361 /*
17362 * Update dictionary statistic
17363 */
17364
17365 if (keyspace == 0)
17366 {
17367 dictstat_fp = fopen (dictstat, "wb");
17368
17369 if (dictstat_fp)
17370 {
17371 lock_file (dictstat_fp);
17372
17373 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17374
17375 fclose (dictstat_fp);
17376 }
17377 }
17378
17379 data.devices_status = STATUS_RUNNING;
17380
17381 if (initial_restore_done == 0)
17382 {
17383 if (data.restore_disable == 0) cycle_restore ();
17384
17385 initial_restore_done = 1;
17386 }
17387
17388 hc_timer_set (&data.timer_running);
17389
17390 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17391 {
17392 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17393 {
17394 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17395 if (quiet == 0) fflush (stdout);
17396 }
17397 }
17398 else if (wordlist_mode == WL_MODE_STDIN)
17399 {
17400 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17401 if (data.quiet == 0) log_info ("");
17402 }
17403
17404 time_t runtime_start;
17405
17406 time (&runtime_start);
17407
17408 data.runtime_start = runtime_start;
17409
17410 /**
17411 * create cracker threads
17412 */
17413
17414 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17415
17416 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17417 {
17418 hc_device_param_t *device_param = &devices_param[device_id];
17419
17420 if (wordlist_mode == WL_MODE_STDIN)
17421 {
17422 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17423 }
17424 else
17425 {
17426 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17427 }
17428 }
17429
17430 // wait for crack threads to exit
17431
17432 hc_thread_wait (data.devices_cnt, c_threads);
17433
17434 local_free (c_threads);
17435
17436 data.restore = 0;
17437
17438 // finalize task
17439
17440 logfile_sub_var_uint ("status-after-work", data.devices_status);
17441
17442 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17443
17444 if (data.devices_status == STATUS_CRACKED) break;
17445 if (data.devices_status == STATUS_ABORTED) break;
17446
17447 if (data.devices_status == STATUS_BYPASS)
17448 {
17449 data.devices_status = STATUS_RUNNING;
17450 }
17451
17452 if (induction_dictionaries_cnt)
17453 {
17454 unlink (induction_dictionaries[0]);
17455 }
17456
17457 free (induction_dictionaries);
17458
17459 if (attack_mode != ATTACK_MODE_BF)
17460 {
17461 induction_dictionaries = scan_directory (induction_directory);
17462
17463 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17464 }
17465
17466 if (benchmark == 0)
17467 {
17468 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17469 {
17470 if (quiet == 0) clear_prompt ();
17471
17472 if (quiet == 0) log_info ("");
17473
17474 if (status == 1)
17475 {
17476 status_display ();
17477 }
17478 else
17479 {
17480 if (quiet == 0) status_display ();
17481 }
17482
17483 if (quiet == 0) log_info ("");
17484 }
17485 }
17486
17487 if (attack_mode == ATTACK_MODE_BF)
17488 {
17489 dictpos++;
17490
17491 rd->dictpos = dictpos;
17492 }
17493 else
17494 {
17495 if (induction_dictionaries_cnt)
17496 {
17497 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17498 }
17499 else
17500 {
17501 dictpos++;
17502
17503 rd->dictpos = dictpos;
17504 }
17505 }
17506
17507 time_t runtime_stop;
17508
17509 time (&runtime_stop);
17510
17511 data.runtime_stop = runtime_stop;
17512
17513 logfile_sub_uint (runtime_start);
17514 logfile_sub_uint (runtime_stop);
17515
17516 logfile_sub_msg ("STOP");
17517
17518 global_free (subid);
17519 }
17520
17521 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17522
17523 if (data.devices_status == STATUS_CRACKED) break;
17524 if (data.devices_status == STATUS_ABORTED) break;
17525 if (data.devices_status == STATUS_QUIT) break;
17526
17527 if (data.devices_status == STATUS_BYPASS)
17528 {
17529 data.devices_status = STATUS_RUNNING;
17530 }
17531 }
17532
17533 // 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
17534
17535 if (attack_mode == ATTACK_MODE_STRAIGHT)
17536 {
17537 if (data.wordlist_mode == WL_MODE_FILE)
17538 {
17539 if (data.dictfile == NULL)
17540 {
17541 if (dictfiles != NULL)
17542 {
17543 data.dictfile = dictfiles[0];
17544
17545 hc_timer_set (&data.timer_running);
17546 }
17547 }
17548 }
17549 }
17550 // NOTE: combi is okay because it is already set beforehand
17551 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17552 {
17553 if (data.dictfile == NULL)
17554 {
17555 if (dictfiles != NULL)
17556 {
17557 hc_timer_set (&data.timer_running);
17558
17559 data.dictfile = dictfiles[0];
17560 }
17561 }
17562 }
17563 else if (attack_mode == ATTACK_MODE_BF)
17564 {
17565 if (data.mask == NULL)
17566 {
17567 hc_timer_set (&data.timer_running);
17568
17569 data.mask = masks[0];
17570 }
17571 }
17572
17573 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17574 {
17575 data.devices_status = STATUS_EXHAUSTED;
17576 }
17577
17578 // if cracked / aborted remove last induction dictionary
17579
17580 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17581 {
17582 struct stat induct_stat;
17583
17584 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17585 {
17586 unlink (induction_dictionaries[file_pos]);
17587 }
17588 }
17589
17590 // wait for non-interactive threads
17591
17592 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17593 {
17594 hc_thread_wait (1, &ni_threads[thread_idx]);
17595 }
17596
17597 local_free (ni_threads);
17598
17599 // wait for interactive threads
17600
17601 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17602 {
17603 hc_thread_wait (1, &i_thread);
17604 }
17605
17606 // we dont need restore file anymore
17607 if (data.restore_disable == 0)
17608 {
17609 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17610 {
17611 unlink (eff_restore_file);
17612 unlink (new_restore_file);
17613 }
17614 else
17615 {
17616 cycle_restore ();
17617 }
17618 }
17619
17620 // finally save left hashes
17621
17622 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17623 {
17624 save_hash ();
17625 }
17626
17627 /**
17628 * Clean up
17629 */
17630
17631 if (benchmark == 1)
17632 {
17633 status_benchmark ();
17634
17635 if (status_automat == 0)
17636 {
17637 log_info ("");
17638 }
17639 }
17640 else
17641 {
17642 if (quiet == 0) clear_prompt ();
17643
17644 if (quiet == 0) log_info ("");
17645
17646 if (status == 1)
17647 {
17648 status_display ();
17649 }
17650 else
17651 {
17652 if (quiet == 0) status_display ();
17653 }
17654
17655 if (quiet == 0) log_info ("");
17656 }
17657
17658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17659 {
17660 hc_device_param_t *device_param = &data.devices_param[device_id];
17661
17662 if (device_param->skipped) continue;
17663
17664 local_free (device_param->combs_buf);
17665
17666 local_free (device_param->hooks_buf);
17667
17668 local_free (device_param->device_name);
17669
17670 local_free (device_param->device_name_chksum);
17671
17672 local_free (device_param->device_version);
17673
17674 local_free (device_param->driver_version);
17675
17676 if (device_param->pws_buf) myfree (device_param->pws_buf);
17677 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17678 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17679 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17680 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17681 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17682 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17683 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17684 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17685 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17686 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17687 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17688 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17689 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17690 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17691 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17692 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17693 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17694 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17695 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17696 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17697 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17698 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17699 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17700 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17701 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17702 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17703 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17704 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17705
17706 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17707 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17708 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17709 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17710 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17711 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17712 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17713 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17714 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17715 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17716
17717 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17718 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17719 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17720
17721 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17722 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17723 }
17724
17725 // reset default fan speed
17726
17727 #ifdef HAVE_HWMON
17728 if (gpu_temp_disable == 0)
17729 {
17730 #ifdef HAVE_ADL
17731 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17732 {
17733 hc_thread_mutex_lock (mux_adl);
17734
17735 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17736 {
17737 hc_device_param_t *device_param = &data.devices_param[device_id];
17738
17739 if (device_param->skipped) continue;
17740
17741 if (data.hm_device[device_id].fan_supported == 1)
17742 {
17743 int fanspeed = temp_retain_fanspeed_value[device_id];
17744
17745 if (fanspeed == -1) continue;
17746
17747 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17748
17749 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17750 }
17751 }
17752
17753 hc_thread_mutex_unlock (mux_adl);
17754 }
17755 #endif // HAVE_ADL
17756 }
17757
17758 #ifdef HAVE_ADL
17759 // reset power tuning
17760
17761 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17762 {
17763 hc_thread_mutex_lock (mux_adl);
17764
17765 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17766 {
17767 hc_device_param_t *device_param = &data.devices_param[device_id];
17768
17769 if (device_param->skipped) continue;
17770
17771 if (data.hm_device[device_id].od_version == 6)
17772 {
17773 // check powertune capabilities first, if not available then skip device
17774
17775 int powertune_supported = 0;
17776
17777 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17778 {
17779 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17780
17781 return (-1);
17782 }
17783
17784 if (powertune_supported != 0)
17785 {
17786 // powercontrol settings
17787
17788 if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK)
17789 {
17790 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17791
17792 return (-1);
17793 }
17794
17795 // clocks
17796
17797 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17798
17799 performance_state->iNumberOfPerformanceLevels = 2;
17800
17801 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17802 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17803 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17804 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17805
17806 if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK)
17807 {
17808 log_info ("ERROR: Failed to restore ADL performance state");
17809
17810 return (-1);
17811 }
17812
17813 local_free (performance_state);
17814 }
17815 }
17816 }
17817
17818 hc_thread_mutex_unlock (mux_adl);
17819 }
17820 #endif // HAVE_ADL
17821
17822 if (gpu_temp_disable == 0)
17823 {
17824 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17825 if (data.hm_nv)
17826 {
17827 #if defined(LINUX) && defined(HAVE_NVML)
17828
17829 hm_NVML_nvmlShutdown (data.hm_nv);
17830
17831 nvml_close (data.hm_nv);
17832
17833 #elif defined(WIN) && (HAVE_NVAPI)
17834
17835 hm_NvAPI_Unload (data.hm_nv);
17836
17837 nvapi_close (data.hm_nv);
17838
17839 #endif
17840
17841 data.hm_nv = NULL;
17842 }
17843 #endif
17844
17845 #ifdef HAVE_ADL
17846 if (data.hm_amd)
17847 {
17848 hm_ADL_Main_Control_Destroy (data.hm_amd);
17849
17850 adl_close (data.hm_amd);
17851 data.hm_amd = NULL;
17852 }
17853 #endif
17854 }
17855 #endif // HAVE_HWMON
17856
17857 // free memory
17858
17859 local_free (masks);
17860
17861 local_free (dictstat_base);
17862
17863 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17864 {
17865 pot_t *pot_ptr = &pot[pot_pos];
17866
17867 hash_t *hash = &pot_ptr->hash;
17868
17869 local_free (hash->digest);
17870
17871 if (isSalted)
17872 {
17873 local_free (hash->salt);
17874 }
17875 }
17876
17877 local_free (pot);
17878
17879 local_free (all_kernel_rules_cnt);
17880 local_free (all_kernel_rules_buf);
17881
17882 local_free (wl_data->buf);
17883 local_free (wl_data);
17884
17885 local_free (bitmap_s1_a);
17886 local_free (bitmap_s1_b);
17887 local_free (bitmap_s1_c);
17888 local_free (bitmap_s1_d);
17889 local_free (bitmap_s2_a);
17890 local_free (bitmap_s2_b);
17891 local_free (bitmap_s2_c);
17892 local_free (bitmap_s2_d);
17893
17894 #ifdef HAVE_HWMON
17895 local_free (temp_retain_fanspeed_value);
17896 #ifdef HAVE_ADL
17897 local_free (od_clock_mem_status);
17898 local_free (od_power_control_status);
17899 #endif // ADL
17900 #endif
17901
17902 global_free (devices_param);
17903
17904 global_free (kernel_rules_buf);
17905
17906 global_free (root_css_buf);
17907 global_free (markov_css_buf);
17908
17909 global_free (digests_buf);
17910 global_free (digests_shown);
17911 global_free (digests_shown_tmp);
17912
17913 global_free (salts_buf);
17914 global_free (salts_shown);
17915
17916 global_free (esalts_buf);
17917
17918 global_free (words_progress_done);
17919 global_free (words_progress_rejected);
17920 global_free (words_progress_restored);
17921
17922 if (pot_fp) fclose (pot_fp);
17923
17924 if (data.devices_status == STATUS_QUIT) break;
17925 }
17926
17927 // destroy others mutex
17928
17929 hc_thread_mutex_delete (mux_dispatcher);
17930 hc_thread_mutex_delete (mux_counter);
17931 hc_thread_mutex_delete (mux_display);
17932 hc_thread_mutex_delete (mux_adl);
17933
17934 // free memory
17935
17936 local_free (eff_restore_file);
17937 local_free (new_restore_file);
17938
17939 local_free (rd);
17940
17941 // tuning db
17942
17943 tuning_db_destroy (tuning_db);
17944
17945 // loopback
17946
17947 local_free (loopback_file);
17948
17949 if (loopback == 1) unlink (loopback_file);
17950
17951 // induction directory
17952
17953 if (induction_dir == NULL)
17954 {
17955 if (attack_mode != ATTACK_MODE_BF)
17956 {
17957 if (rmdir (induction_directory) == -1)
17958 {
17959 if (errno == ENOENT)
17960 {
17961 // good, we can ignore
17962 }
17963 else if (errno == ENOTEMPTY)
17964 {
17965 // good, we can ignore
17966 }
17967 else
17968 {
17969 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17970
17971 return (-1);
17972 }
17973 }
17974
17975 local_free (induction_directory);
17976 }
17977 }
17978
17979 // outfile-check directory
17980
17981 if (outfile_check_dir == NULL)
17982 {
17983 if (rmdir (outfile_check_directory) == -1)
17984 {
17985 if (errno == ENOENT)
17986 {
17987 // good, we can ignore
17988 }
17989 else if (errno == ENOTEMPTY)
17990 {
17991 // good, we can ignore
17992 }
17993 else
17994 {
17995 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17996
17997 return (-1);
17998 }
17999 }
18000
18001 local_free (outfile_check_directory);
18002 }
18003
18004 time_t proc_stop;
18005
18006 time (&proc_stop);
18007
18008 logfile_top_uint (proc_start);
18009 logfile_top_uint (proc_stop);
18010
18011 logfile_top_msg ("STOP");
18012
18013 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18014 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18015
18016 if (data.ocl) ocl_close (data.ocl);
18017
18018 if (data.devices_status == STATUS_ABORTED) return 2;
18019 if (data.devices_status == STATUS_QUIT) return 2;
18020 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18021 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18022 if (data.devices_status == STATUS_CRACKED) return 0;
18023
18024 return -1;
18025 }
Hashcat additions to support pwdhash