projects / hashcat.git / blob
? search:


45f54967bdf902772775e1380dd096c8cdcd8490
[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->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->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->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 * Detect if the user has both an Intel and and AMD OpenCL runtime and not filtered any of them
13193 * In this case mark it for later use
13194 */
13195
13196 int has_intel = 0;
13197 int has_amd = 0;
13198
13199 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13200 {
13201 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13202
13203 cl_platform_id platform = platforms[platform_id];
13204
13205 char platform_vendor[INFOSZ] = { 0 };
13206
13207 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13208
13209 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13210 {
13211 has_intel = 1;
13212 }
13213 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13214 {
13215 has_amd = 1;
13216 }
13217 }
13218
13219 /**
13220 * OpenCL devices: simply push all devices from all platforms into the same device array
13221 */
13222
13223 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13224
13225 data.devices_param = devices_param;
13226
13227 uint devices_cnt = 0;
13228
13229 uint devices_active = 0;
13230
13231 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13232 {
13233 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13234
13235 cl_platform_id platform = platforms[platform_id];
13236
13237 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13238
13239 char platform_vendor[INFOSZ] = { 0 };
13240
13241 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13242
13243 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13244 // this causes trouble with vendor id based macros
13245 // we'll assign generic to those without special optimization available
13246
13247 cl_uint vendor_id = 0;
13248
13249 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13250 {
13251 vendor_id = VENDOR_ID_AMD;
13252 }
13253 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13254 {
13255 vendor_id = VENDOR_ID_APPLE;
13256 }
13257 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13258 {
13259 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13260 }
13261 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13262 {
13263 vendor_id = VENDOR_ID_INTEL_SDK;
13264 }
13265 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13266 {
13267 vendor_id = VENDOR_ID_MESA;
13268 }
13269 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13270 {
13271 vendor_id = VENDOR_ID_NV;
13272 }
13273 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13274 {
13275 vendor_id = VENDOR_ID_POCL;
13276 }
13277 else
13278 {
13279 vendor_id = VENDOR_ID_GENERIC;
13280 }
13281
13282 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13283 {
13284 size_t param_value_size = 0;
13285
13286 const uint device_id = devices_cnt;
13287
13288 hc_device_param_t *device_param = &data.devices_param[device_id];
13289
13290 device_param->vendor_id = vendor_id;
13291
13292 device_param->device = platform_devices[platform_devices_id];
13293
13294 device_param->device_id = device_id;
13295
13296 device_param->platform_devices_id = platform_devices_id;
13297
13298 // device_type
13299
13300 cl_device_type device_type;
13301
13302 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13303
13304 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13305
13306 device_param->device_type = device_type;
13307
13308 // device_name
13309
13310 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13311
13312 char *device_name = (char *) mymalloc (param_value_size);
13313
13314 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13315
13316 device_param->device_name = device_name;
13317
13318 // tuning db
13319
13320 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13321
13322 // device_version
13323
13324 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13325
13326 char *device_version = (char *) mymalloc (param_value_size);
13327
13328 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13329
13330 device_param->device_version = device_version;
13331
13332 // device_opencl_version
13333
13334 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13335
13336 char *device_opencl_version = (char *) mymalloc (param_value_size);
13337
13338 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13339
13340 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13341
13342 myfree (device_opencl_version);
13343
13344 // vector_width
13345
13346 cl_uint vector_width;
13347
13348 if (opencl_vector_width_chgd == 0)
13349 {
13350 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13351 {
13352 if (opti_type & OPTI_TYPE_USES_BITS_64)
13353 {
13354 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13355 }
13356 else
13357 {
13358 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13359 }
13360 }
13361 else
13362 {
13363 vector_width = (cl_uint) tuningdb_entry->vector_width;
13364 }
13365 }
13366 else
13367 {
13368 vector_width = opencl_vector_width;
13369 }
13370
13371 if (vector_width > 16) vector_width = 16;
13372
13373 device_param->vector_width = vector_width;
13374
13375 // max_compute_units
13376
13377 cl_uint device_processors;
13378
13379 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13380
13381 device_param->device_processors = device_processors;
13382
13383 // device_maxmem_alloc
13384 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13385
13386 cl_ulong device_maxmem_alloc;
13387
13388 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13389
13390 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13391
13392 // device_global_mem
13393
13394 cl_ulong device_global_mem;
13395
13396 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13397
13398 device_param->device_global_mem = device_global_mem;
13399
13400 // max_work_group_size
13401
13402 size_t device_maxworkgroup_size;
13403
13404 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13405
13406 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13407
13408 // max_clock_frequency
13409
13410 cl_uint device_maxclock_frequency;
13411
13412 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13413
13414 device_param->device_maxclock_frequency = device_maxclock_frequency;
13415
13416 // device_endian_little
13417
13418 cl_bool device_endian_little;
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13421
13422 if (device_endian_little == CL_FALSE)
13423 {
13424 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13425
13426 device_param->skipped = 1;
13427 }
13428
13429 // device_available
13430
13431 cl_bool device_available;
13432
13433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13434
13435 if (device_available == CL_FALSE)
13436 {
13437 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13438
13439 device_param->skipped = 1;
13440 }
13441
13442 // device_compiler_available
13443
13444 cl_bool device_compiler_available;
13445
13446 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13447
13448 if (device_compiler_available == CL_FALSE)
13449 {
13450 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13451
13452 device_param->skipped = 1;
13453 }
13454
13455 // device_execution_capabilities
13456
13457 cl_device_exec_capabilities device_execution_capabilities;
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13460
13461 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13462 {
13463 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13464
13465 device_param->skipped = 1;
13466 }
13467
13468 // device_extensions
13469
13470 size_t device_extensions_size;
13471
13472 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13473
13474 char *device_extensions = mymalloc (device_extensions_size + 1);
13475
13476 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13477
13478 if (strstr (device_extensions, "base_atomics") == 0)
13479 {
13480 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13481
13482 device_param->skipped = 1;
13483 }
13484
13485 if (strstr (device_extensions, "byte_addressable_store") == 0)
13486 {
13487 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13488
13489 device_param->skipped = 1;
13490 }
13491
13492 myfree (device_extensions);
13493
13494 // device_local_mem_size
13495
13496 cl_ulong device_local_mem_size;
13497
13498 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13499
13500 if (device_local_mem_size < 32768)
13501 {
13502 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13503
13504 device_param->skipped = 1;
13505 }
13506
13507 // if we have both intel and amd opencl runtime we want they share the same cpu
13508 // so both virtual cpu share the same resources and run at 50%
13509 // however, intel has better control over their own hardware so it makes sense
13510 // to give them full control over their own hardware
13511
13512 if (device_type & CL_DEVICE_TYPE_CPU)
13513 {
13514 if ((has_intel == 1) && (has_amd == 1) && (vendor_id == VENDOR_ID_AMD))
13515 {
13516 if (data.quiet == 0) log_info ("Device #%u: WARNING: Not its native platform vendor", device_id + 1);
13517
13518 device_param->skipped = 1;
13519 }
13520 }
13521
13522 // skipped
13523
13524 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13525 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13526
13527 // driver_version
13528
13529 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13530
13531 char *driver_version = (char *) mymalloc (param_value_size);
13532
13533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13534
13535 device_param->driver_version = driver_version;
13536
13537 // device_name_chksum
13538
13539 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13540
13541 #if __x86_64__
13542 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13543 #else
13544 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13545 #endif
13546
13547 uint device_name_digest[4] = { 0 };
13548
13549 md5_64 ((uint *) device_name_chksum, device_name_digest);
13550
13551 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13552
13553 device_param->device_name_chksum = device_name_chksum;
13554
13555 // device_processor_cores
13556
13557 if (device_type & CL_DEVICE_TYPE_CPU)
13558 {
13559 cl_uint device_processor_cores = 1;
13560
13561 device_param->device_processor_cores = device_processor_cores;
13562 }
13563
13564 if (device_type & CL_DEVICE_TYPE_GPU)
13565 {
13566 if (vendor_id == VENDOR_ID_AMD)
13567 {
13568 cl_uint device_processor_cores = 0;
13569
13570 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13571
13572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13573
13574 device_param->device_processor_cores = device_processor_cores;
13575 }
13576 else if (vendor_id == VENDOR_ID_NV)
13577 {
13578 cl_uint kernel_exec_timeout = 0;
13579
13580 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13581
13582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13583
13584 device_param->kernel_exec_timeout = kernel_exec_timeout;
13585
13586 cl_uint device_processor_cores = 0;
13587
13588 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13589
13590 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13591
13592 device_param->device_processor_cores = device_processor_cores;
13593
13594 cl_uint sm_minor = 0;
13595 cl_uint sm_major = 0;
13596
13597 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13598 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13599
13600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13601 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13602
13603 device_param->sm_minor = sm_minor;
13604 device_param->sm_major = sm_major;
13605 }
13606 else
13607 {
13608 cl_uint device_processor_cores = 1;
13609
13610 device_param->device_processor_cores = device_processor_cores;
13611 }
13612 }
13613
13614 // display results
13615
13616 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13617 {
13618 if (status_automat == 0)
13619 {
13620 if (device_param->skipped == 0)
13621 {
13622 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13623 device_id + 1,
13624 device_name,
13625 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13626 (unsigned int) (device_global_mem / 1024 / 1024),
13627 (unsigned int) (device_maxclock_frequency),
13628 (unsigned int) device_processors);
13629 }
13630 else
13631 {
13632 log_info ("Device #%u: %s, skipped",
13633 device_id + 1,
13634 device_name);
13635 }
13636 }
13637 }
13638
13639 // common driver check
13640
13641 if (device_param->skipped == 0)
13642 {
13643 if (device_type & CL_DEVICE_TYPE_GPU)
13644 {
13645 if (vendor_id == VENDOR_ID_AMD)
13646 {
13647 int catalyst_check = (force == 1) ? 0 : 1;
13648
13649 int catalyst_warn = 0;
13650
13651 int catalyst_broken = 0;
13652
13653 if (catalyst_check == 1)
13654 {
13655 catalyst_warn = 1;
13656
13657 // v14.9 and higher
13658 if (atoi (device_param->driver_version) >= 1573)
13659 {
13660 catalyst_warn = 0;
13661 }
13662
13663 catalyst_check = 0;
13664 }
13665
13666 if (catalyst_broken == 1)
13667 {
13668 log_info ("");
13669 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13670 log_info ("It will pass over cracked hashes and does not report them as cracked");
13671 log_info ("You are STRONGLY encouraged not to use it");
13672 log_info ("You can use --force to override this but do not post error reports if you do so");
13673 log_info ("");
13674
13675 return (-1);
13676 }
13677
13678 if (catalyst_warn == 1)
13679 {
13680 log_info ("");
13681 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13682 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13683 log_info ("See hashcat's homepage for official supported catalyst drivers");
13684 #ifdef _WIN
13685 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13686 #endif
13687 log_info ("You can use --force to override this but do not post error reports if you do so");
13688 log_info ("");
13689
13690 return (-1);
13691 }
13692 }
13693 else if (vendor_id == VENDOR_ID_NV)
13694 {
13695 if (device_param->kernel_exec_timeout != 0)
13696 {
13697 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);
13698 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13699 }
13700 }
13701 }
13702
13703 /* turns out pocl still creates segfaults (because of llvm)
13704 if (device_type & CL_DEVICE_TYPE_CPU)
13705 {
13706 if (vendor_id == VENDOR_ID_AMD)
13707 {
13708 if (force == 0)
13709 {
13710 log_info ("");
13711 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13712 log_info ("You are STRONGLY encouraged not to use it");
13713 log_info ("You can use --force to override this but do not post error reports if you do so");
13714 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13715 log_info ("");
13716
13717 return (-1);
13718 }
13719 }
13720 }
13721 */
13722
13723 /**
13724 * kernel accel and loops tuning db adjustment
13725 */
13726
13727 device_param->kernel_accel_min = 1;
13728 device_param->kernel_accel_max = 1024;
13729
13730 device_param->kernel_loops_min = 1;
13731 device_param->kernel_loops_max = 1024;
13732
13733 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13734
13735 if (tuningdb_entry)
13736 {
13737 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13738 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13739
13740 if (_kernel_accel)
13741 {
13742 device_param->kernel_accel_min = _kernel_accel;
13743 device_param->kernel_accel_max = _kernel_accel;
13744 }
13745
13746 if (_kernel_loops)
13747 {
13748 if (workload_profile == 1)
13749 {
13750 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13751 }
13752 else if (workload_profile == 2)
13753 {
13754 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13755 }
13756
13757 device_param->kernel_loops_min = _kernel_loops;
13758 device_param->kernel_loops_max = _kernel_loops;
13759 }
13760 }
13761
13762 // commandline parameters overwrite tuningdb entries
13763
13764 if (kernel_accel)
13765 {
13766 device_param->kernel_accel_min = kernel_accel;
13767 device_param->kernel_accel_max = kernel_accel;
13768 }
13769
13770 if (kernel_loops)
13771 {
13772 device_param->kernel_loops_min = kernel_loops;
13773 device_param->kernel_loops_max = kernel_loops;
13774 }
13775
13776 /**
13777 * activate device
13778 */
13779
13780 devices_active++;
13781 }
13782
13783 // next please
13784
13785 devices_cnt++;
13786 }
13787 }
13788
13789 if (keyspace == 0 && devices_active == 0)
13790 {
13791 log_error ("ERROR: No devices found/left");
13792
13793 return (-1);
13794 }
13795
13796 // 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)
13797
13798 if (devices_filter != (uint) -1)
13799 {
13800 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13801
13802 if (devices_filter > devices_cnt_mask)
13803 {
13804 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13805
13806 return (-1);
13807 }
13808 }
13809
13810 data.devices_cnt = devices_cnt;
13811
13812 data.devices_active = devices_active;
13813
13814 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13815 {
13816 if (status_automat == 0)
13817 {
13818 log_info ("");
13819 }
13820 }
13821
13822 /**
13823 * HM devices: init
13824 */
13825
13826 #ifdef HAVE_HWMON
13827 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13828 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13829 #endif
13830
13831 #ifdef HAVE_ADL
13832 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13833 #endif
13834
13835 if (gpu_temp_disable == 0)
13836 {
13837 #if defined(WIN) && defined(HAVE_NVAPI)
13838 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13839
13840 if (nvapi_init (nvapi) == 0)
13841 data.hm_nv = nvapi;
13842
13843 if (data.hm_nv)
13844 {
13845 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13846 {
13847 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13848
13849 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13850
13851 int tmp_out = 0;
13852
13853 for (int i = 0; i < tmp_in; i++)
13854 {
13855 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13856 }
13857
13858 for (int i = 0; i < tmp_out; i++)
13859 {
13860 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13861
13862 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13863
13864 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;
13865 }
13866 }
13867 }
13868 #endif // WIN && HAVE_NVAPI
13869
13870 #if defined(LINUX) && defined(HAVE_NVML)
13871 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13872
13873 if (nvml_init (nvml) == 0)
13874 data.hm_nv = nvml;
13875
13876 if (data.hm_nv)
13877 {
13878 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13879 {
13880 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13881
13882 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13883
13884 int tmp_out = 0;
13885
13886 for (int i = 0; i < tmp_in; i++)
13887 {
13888 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13889 }
13890
13891 for (int i = 0; i < tmp_out; i++)
13892 {
13893 unsigned int speed;
13894
13895 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;
13896 }
13897 }
13898 }
13899 #endif // LINUX && HAVE_NVML
13900
13901 data.hm_amd = NULL;
13902
13903 #ifdef HAVE_ADL
13904 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13905
13906 if (adl_init (adl) == 0)
13907 data.hm_amd = adl;
13908
13909 if (data.hm_amd)
13910 {
13911 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13912 {
13913 // total number of adapters
13914
13915 int hm_adapters_num;
13916
13917 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13918
13919 // adapter info
13920
13921 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13922
13923 if (lpAdapterInfo == NULL) return (-1);
13924
13925 // get a list (of ids of) valid/usable adapters
13926
13927 int num_adl_adapters = 0;
13928
13929 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13930
13931 if (num_adl_adapters > 0)
13932 {
13933 hc_thread_mutex_lock (mux_adl);
13934
13935 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13936
13937 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13938
13939 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13940 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13941
13942 hc_thread_mutex_unlock (mux_adl);
13943 }
13944
13945 myfree (valid_adl_device_list);
13946 myfree (lpAdapterInfo);
13947 }
13948 }
13949 #endif // HAVE_ADL
13950
13951 if (data.hm_amd == NULL && data.hm_nv == NULL)
13952 {
13953 gpu_temp_disable = 1;
13954 }
13955 }
13956
13957 /**
13958 * OpenCL devices: allocate buffer for device specific information
13959 */
13960
13961 #ifdef HAVE_HWMON
13962 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13963
13964 #ifdef HAVE_ADL
13965 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13966
13967 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13968 #endif // ADL
13969 #endif
13970
13971 /**
13972 * enable custom signal handler(s)
13973 */
13974
13975 if (benchmark == 0)
13976 {
13977 hc_signal (sigHandler_default);
13978 }
13979 else
13980 {
13981 hc_signal (sigHandler_benchmark);
13982 }
13983
13984 /**
13985 * User-defined GPU temp handling
13986 */
13987
13988 #ifdef HAVE_HWMON
13989 if (gpu_temp_disable == 1)
13990 {
13991 gpu_temp_abort = 0;
13992 gpu_temp_retain = 0;
13993 }
13994
13995 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13996 {
13997 if (gpu_temp_abort < gpu_temp_retain)
13998 {
13999 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14000
14001 return (-1);
14002 }
14003 }
14004
14005 data.gpu_temp_disable = gpu_temp_disable;
14006 data.gpu_temp_abort = gpu_temp_abort;
14007 data.gpu_temp_retain = gpu_temp_retain;
14008 #endif
14009
14010 /**
14011 * inform the user
14012 */
14013
14014 if (data.quiet == 0)
14015 {
14016 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14017
14018 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);
14019
14020 if (attack_mode == ATTACK_MODE_STRAIGHT)
14021 {
14022 log_info ("Rules: %u", kernel_rules_cnt);
14023 }
14024
14025 if (opti_type)
14026 {
14027 log_info ("Applicable Optimizers:");
14028
14029 for (uint i = 0; i < 32; i++)
14030 {
14031 const uint opti_bit = 1u << i;
14032
14033 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14034 }
14035 }
14036
14037 /**
14038 * Watchdog and Temperature balance
14039 */
14040
14041 #ifdef HAVE_HWMON
14042 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14043 {
14044 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14045 }
14046
14047 if (gpu_temp_abort == 0)
14048 {
14049 log_info ("Watchdog: Temperature abort trigger disabled");
14050 }
14051 else
14052 {
14053 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14054 }
14055
14056 if (gpu_temp_retain == 0)
14057 {
14058 log_info ("Watchdog: Temperature retain trigger disabled");
14059 }
14060 else
14061 {
14062 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14063 }
14064
14065 if (data.quiet == 0) log_info ("");
14066 #endif
14067 }
14068
14069 /**
14070 * HM devices: copy
14071 */
14072
14073 if (gpu_temp_disable == 0)
14074 {
14075 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14076 {
14077 hc_device_param_t *device_param = &data.devices_param[device_id];
14078
14079 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14080
14081 if (device_param->skipped) continue;
14082
14083 const uint platform_devices_id = device_param->platform_devices_id;
14084
14085 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14086 if (device_param->vendor_id == VENDOR_ID_NV)
14087 {
14088 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14089 }
14090 #endif
14091
14092 #ifdef HAVE_ADL
14093 if (device_param->vendor_id == VENDOR_ID_AMD)
14094 {
14095 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14096 }
14097 #endif
14098 }
14099 }
14100
14101 /*
14102 * Temporary fix:
14103 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14104 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14105 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14106 * Driver / ADL bug?
14107 */
14108
14109 #ifdef HAVE_ADL
14110 if (powertune_enable == 1)
14111 {
14112 hc_thread_mutex_lock (mux_adl);
14113
14114 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14115 {
14116 hc_device_param_t *device_param = &data.devices_param[device_id];
14117
14118 if (device_param->skipped) continue;
14119
14120 if (data.hm_device[device_id].od_version == 6)
14121 {
14122 // set powertune value only
14123
14124 int powertune_supported = 0;
14125
14126 int ADL_rc = 0;
14127
14128 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14129 {
14130 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14131
14132 return (-1);
14133 }
14134
14135 if (powertune_supported != 0)
14136 {
14137 // powertune set
14138 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14139
14140 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14141 {
14142 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14143
14144 return (-1);
14145 }
14146
14147 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14148 {
14149 log_error ("ERROR: Failed to set new ADL PowerControl values");
14150
14151 return (-1);
14152 }
14153 }
14154 }
14155 }
14156
14157 hc_thread_mutex_unlock (mux_adl);
14158 }
14159 #endif // HAVE_ADK
14160 #endif // HAVE_HWMON
14161
14162 #ifdef DEBUG
14163 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14164 #endif
14165
14166 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14167
14168 uint kernel_power_all = 0;
14169
14170 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14171 {
14172 /**
14173 * host buffer
14174 */
14175
14176 hc_device_param_t *device_param = &data.devices_param[device_id];
14177
14178 if (device_param->skipped) continue;
14179
14180 /**
14181 * device properties
14182 */
14183
14184 const char *device_name_chksum = device_param->device_name_chksum;
14185 const u32 device_processors = device_param->device_processors;
14186 const u32 device_processor_cores = device_param->device_processor_cores;
14187
14188 /**
14189 * create context for each device
14190 */
14191
14192 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14193
14194 /**
14195 * create command-queue
14196 */
14197
14198 // not supported with NV
14199 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14200
14201 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14202
14203 /**
14204 * kernel threads: some algorithms need a fixed kernel-threads count
14205 * because of shared memory usage or bitslice
14206 * there needs to be some upper limit, otherwise there's too much overhead
14207 */
14208
14209 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14210
14211 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14212 {
14213 kernel_threads = KERNEL_THREADS_MAX_CPU;
14214 }
14215
14216 if (hash_mode == 1500) kernel_threads = 64; // DES
14217 if (hash_mode == 3000) kernel_threads = 64; // DES
14218 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14219 if (hash_mode == 7500) kernel_threads = 64; // RC4
14220 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14221 if (hash_mode == 9700) kernel_threads = 64; // RC4
14222 if (hash_mode == 9710) kernel_threads = 64; // RC4
14223 if (hash_mode == 9800) kernel_threads = 64; // RC4
14224 if (hash_mode == 9810) kernel_threads = 64; // RC4
14225 if (hash_mode == 10400) kernel_threads = 64; // RC4
14226 if (hash_mode == 10410) kernel_threads = 64; // RC4
14227 if (hash_mode == 10500) kernel_threads = 64; // RC4
14228 if (hash_mode == 13100) kernel_threads = 64; // RC4
14229
14230 /**
14231 * create input buffers on device : calculate size of fixed memory buffers
14232 */
14233
14234 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14235 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14236
14237 device_param->size_root_css = size_root_css;
14238 device_param->size_markov_css = size_markov_css;
14239
14240 size_t size_results = sizeof (uint);
14241
14242 device_param->size_results = size_results;
14243
14244 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14245 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14246
14247 size_t size_plains = digests_cnt * sizeof (plain_t);
14248 size_t size_salts = salts_cnt * sizeof (salt_t);
14249 size_t size_esalts = salts_cnt * esalt_size;
14250
14251 device_param->size_plains = size_plains;
14252 device_param->size_digests = size_digests;
14253 device_param->size_shown = size_shown;
14254 device_param->size_salts = size_salts;
14255
14256 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14257 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14258 size_t size_tm = 32 * sizeof (bs_word_t);
14259
14260 // scryptV stuff
14261
14262 size_t size_scryptV = 1;
14263
14264 if ((hash_mode == 8900) || (hash_mode == 9300))
14265 {
14266 uint tmto_start = 0;
14267 uint tmto_stop = 10;
14268
14269 if (scrypt_tmto)
14270 {
14271 tmto_start = scrypt_tmto;
14272 }
14273 else
14274 {
14275 // in case the user did not specify the tmto manually
14276 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14277 // but set the lower end only in case the user has a device with too less memory
14278
14279 if (hash_mode == 8900)
14280 {
14281 if (device_param->vendor_id == VENDOR_ID_AMD)
14282 {
14283 tmto_start = 1;
14284 }
14285 else if (device_param->vendor_id == VENDOR_ID_NV)
14286 {
14287 tmto_start = 2;
14288 }
14289 }
14290 else if (hash_mode == 9300)
14291 {
14292 if (device_param->vendor_id == VENDOR_ID_AMD)
14293 {
14294 tmto_start = 2;
14295 }
14296 else if (device_param->vendor_id == VENDOR_ID_NV)
14297 {
14298 tmto_start = 2;
14299 }
14300 }
14301 }
14302
14303 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14304 {
14305 // TODO: in theory the following calculation needs to be done per salt, not global
14306 // we assume all hashes have the same scrypt settings
14307
14308 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14309
14310 size_scryptV /= 1 << tmto;
14311
14312 size_scryptV *= device_processors * device_processor_cores;
14313
14314 if (size_scryptV > device_param->device_maxmem_alloc)
14315 {
14316 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14317
14318 continue;
14319 }
14320
14321 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14322 {
14323 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14324 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14325 }
14326
14327 break;
14328 }
14329
14330 if (data.salts_buf[0].scrypt_phy == 0)
14331 {
14332 log_error ("ERROR: can't allocate enough device memory");
14333
14334 return -1;
14335 }
14336
14337 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14338 }
14339
14340 /**
14341 * some algorithms need a fixed kernel-loops count
14342 */
14343
14344 if (hash_mode == 1500)
14345 {
14346 const u32 kernel_loops_fixed = 1024;
14347
14348 device_param->kernel_loops_min = kernel_loops_fixed;
14349 device_param->kernel_loops_max = kernel_loops_fixed;
14350 }
14351
14352 if (hash_mode == 3000)
14353 {
14354 const u32 kernel_loops_fixed = 1024;
14355
14356 device_param->kernel_loops_min = kernel_loops_fixed;
14357 device_param->kernel_loops_max = kernel_loops_fixed;
14358 }
14359
14360 if (hash_mode == 8900)
14361 {
14362 const u32 kernel_loops_fixed = 1;
14363
14364 device_param->kernel_loops_min = kernel_loops_fixed;
14365 device_param->kernel_loops_max = kernel_loops_fixed;
14366 }
14367
14368 if (hash_mode == 9300)
14369 {
14370 const u32 kernel_loops_fixed = 1;
14371
14372 device_param->kernel_loops_min = kernel_loops_fixed;
14373 device_param->kernel_loops_max = kernel_loops_fixed;
14374 }
14375
14376 if (hash_mode == 12500)
14377 {
14378 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14379
14380 device_param->kernel_loops_min = kernel_loops_fixed;
14381 device_param->kernel_loops_max = kernel_loops_fixed;
14382 }
14383
14384 /**
14385 * some algorithms have a maximum kernel-loops count
14386 */
14387
14388 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14389 {
14390 u32 innerloop_cnt = 0;
14391
14392 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14393 {
14394 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14395 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14396 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14397 }
14398 else
14399 {
14400 innerloop_cnt = data.salts_buf[0].salt_iter;
14401 }
14402
14403 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14404 (innerloop_cnt <= device_param->kernel_loops_max))
14405 {
14406 device_param->kernel_loops_max = innerloop_cnt;
14407 }
14408 }
14409
14410 u32 kernel_accel_min = device_param->kernel_accel_min;
14411 u32 kernel_accel_max = device_param->kernel_accel_max;
14412
14413 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14414
14415 size_t size_pws = 4;
14416 size_t size_tmps = 4;
14417 size_t size_hooks = 4;
14418
14419 while (kernel_accel_max >= kernel_accel_min)
14420 {
14421 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14422
14423 // size_pws
14424
14425 size_pws = kernel_power_max * sizeof (pw_t);
14426
14427 // size_tmps
14428
14429 switch (hash_mode)
14430 {
14431 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14432 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14433 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14434 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14435 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14436 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14437 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14438 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14439 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14440 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14441 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14442 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14443 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14444 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14445 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14446 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14447 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14448 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14452 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14453 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14454 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14455 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14456 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14457 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14458 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14459 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14460 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14461 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14462 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14463 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14464 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14465 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14466 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14467 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14468 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14469 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14470 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14471 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14472 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14473 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14474 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14475 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14476 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14477 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14478 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14479 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14480 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14481 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14482 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14483 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14484 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14485 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14486 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14487 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14488 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14489 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14490 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14491 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14492 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14493 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14494 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14495 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14496 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14497 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14498 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14499 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14500 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14501 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14502 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14503 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14504 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14505 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14506 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14507 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14508 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14509 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14510 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14511 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14512 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14513 };
14514
14515 // size_hooks
14516
14517 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14518 {
14519 // none yet
14520 }
14521
14522 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14523 // if not, decrease amplifier and try again
14524
14525 int skip = 0;
14526
14527 const u64 size_total
14528 = bitmap_size
14529 + bitmap_size
14530 + bitmap_size
14531 + bitmap_size
14532 + bitmap_size
14533 + bitmap_size
14534 + bitmap_size
14535 + bitmap_size
14536 + size_bfs
14537 + size_combs
14538 + size_digests
14539 + size_esalts
14540 + size_hooks
14541 + size_markov_css
14542 + size_plains
14543 + size_pws
14544 + size_pws // not a bug
14545 + size_results
14546 + size_root_css
14547 + size_rules
14548 + size_rules_c
14549 + size_salts
14550 + size_scryptV
14551 + size_shown
14552 + size_tm
14553 + size_tmps;
14554
14555 // Don't ask me, ask AMD!
14556
14557 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14558 if (size_total > device_param->device_global_mem) skip = 1;
14559
14560 if (skip == 1)
14561 {
14562 kernel_accel_max--;
14563
14564 continue;
14565 }
14566
14567 break;
14568 }
14569
14570 /*
14571 if (kernel_accel_max == 0)
14572 {
14573 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14574
14575 return -1;
14576 }
14577 */
14578
14579 device_param->kernel_accel_min = kernel_accel_min;
14580 device_param->kernel_accel_max = kernel_accel_max;
14581
14582 /*
14583 if (kernel_accel_max < kernel_accel)
14584 {
14585 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14586
14587 device_param->kernel_accel = kernel_accel_max;
14588 }
14589 */
14590
14591 device_param->size_bfs = size_bfs;
14592 device_param->size_combs = size_combs;
14593 device_param->size_rules = size_rules;
14594 device_param->size_rules_c = size_rules_c;
14595 device_param->size_pws = size_pws;
14596 device_param->size_tmps = size_tmps;
14597 device_param->size_hooks = size_hooks;
14598
14599 // do not confuse kernel_accel_max with kernel_accel here
14600
14601 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14602
14603 device_param->kernel_threads = kernel_threads;
14604 device_param->kernel_power_user = kernel_power;
14605
14606 kernel_power_all += kernel_power;
14607
14608 /**
14609 * default building options
14610 */
14611
14612 char build_opts[1024] = { 0 };
14613
14614 // we don't have sm_* on vendors not NV but it doesn't matter
14615
14616 #if _WIN
14617 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);
14618 #else
14619 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);
14620 #endif
14621
14622 char build_opts_new[1024] = { 0 };
14623
14624 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->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14625
14626 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14627
14628
14629 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14630 {
14631 // we do vectorizing much better than the auto-vectorizer
14632
14633 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14634
14635 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14636 }
14637
14638 #ifdef DEBUG
14639 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14640 #endif
14641
14642 /**
14643 * main kernel
14644 */
14645
14646 {
14647 /**
14648 * kernel source filename
14649 */
14650
14651 char source_file[256] = { 0 };
14652
14653 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14654
14655 struct stat sst;
14656
14657 if (stat (source_file, &sst) == -1)
14658 {
14659 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14660
14661 return -1;
14662 }
14663
14664 /**
14665 * kernel cached filename
14666 */
14667
14668 char cached_file[256] = { 0 };
14669
14670 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14671
14672 int cached = 1;
14673
14674 struct stat cst;
14675
14676 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14677 {
14678 cached = 0;
14679 }
14680
14681 /**
14682 * kernel compile or load
14683 */
14684
14685 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14686
14687 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14688
14689 if (force_jit_compilation == -1)
14690 {
14691 if (cached == 0)
14692 {
14693 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14694
14695 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14696
14697 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14698
14699 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14700
14701 #ifdef DEBUG
14702 size_t build_log_size = 0;
14703
14704 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14705
14706 if (build_log_size > 1)
14707 {
14708 char *build_log = (char *) malloc (build_log_size + 1);
14709
14710 memset (build_log, 0, build_log_size + 1);
14711
14712 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14713
14714 puts (build_log);
14715
14716 free (build_log);
14717 }
14718 #endif
14719
14720 if (rc != 0)
14721 {
14722 device_param->skipped = true;
14723
14724 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14725
14726 continue;
14727 }
14728
14729 size_t binary_size;
14730
14731 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14732
14733 u8 *binary = (u8 *) mymalloc (binary_size);
14734
14735 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14736
14737 writeProgramBin (cached_file, binary, binary_size);
14738
14739 local_free (binary);
14740 }
14741 else
14742 {
14743 #ifdef DEBUG
14744 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14745 #endif
14746
14747 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14748
14749 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14750
14751 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14752 }
14753 }
14754 else
14755 {
14756 #ifdef DEBUG
14757 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14758 #endif
14759
14760 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14761
14762 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14763
14764 char build_opts_update[1024] = { 0 };
14765
14766 if (force_jit_compilation == 1500)
14767 {
14768 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14769 }
14770 else if (force_jit_compilation == 8900)
14771 {
14772 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);
14773 }
14774 else
14775 {
14776 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14777 }
14778
14779 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14780
14781 #ifdef DEBUG
14782 size_t build_log_size = 0;
14783
14784 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14785
14786 if (build_log_size > 1)
14787 {
14788 char *build_log = (char *) malloc (build_log_size + 1);
14789
14790 memset (build_log, 0, build_log_size + 1);
14791
14792 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14793
14794 puts (build_log);
14795
14796 free (build_log);
14797 }
14798 #endif
14799
14800 if (rc != 0)
14801 {
14802 device_param->skipped = true;
14803
14804 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14805 }
14806 }
14807
14808 local_free (kernel_lengths);
14809 local_free (kernel_sources[0]);
14810 local_free (kernel_sources);
14811 }
14812
14813 /**
14814 * word generator kernel
14815 */
14816
14817 if (attack_mode != ATTACK_MODE_STRAIGHT)
14818 {
14819 /**
14820 * kernel mp source filename
14821 */
14822
14823 char source_file[256] = { 0 };
14824
14825 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14826
14827 struct stat sst;
14828
14829 if (stat (source_file, &sst) == -1)
14830 {
14831 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14832
14833 return -1;
14834 }
14835
14836 /**
14837 * kernel mp cached filename
14838 */
14839
14840 char cached_file[256] = { 0 };
14841
14842 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14843
14844 int cached = 1;
14845
14846 struct stat cst;
14847
14848 if (stat (cached_file, &cst) == -1)
14849 {
14850 cached = 0;
14851 }
14852
14853 /**
14854 * kernel compile or load
14855 */
14856
14857 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14858
14859 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14860
14861 if (cached == 0)
14862 {
14863 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14864 if (quiet == 0) log_info ("");
14865
14866 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14867
14868 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14869
14870 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14871
14872 if (rc != 0)
14873 {
14874 device_param->skipped = true;
14875
14876 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14877
14878 continue;
14879 }
14880
14881 size_t binary_size;
14882
14883 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14884
14885 u8 *binary = (u8 *) mymalloc (binary_size);
14886
14887 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14888
14889 writeProgramBin (cached_file, binary, binary_size);
14890
14891 local_free (binary);
14892 }
14893 else
14894 {
14895 #ifdef DEBUG
14896 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14897 #endif
14898
14899 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14900
14901 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14902
14903 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14904 }
14905
14906 local_free (kernel_lengths);
14907 local_free (kernel_sources[0]);
14908 local_free (kernel_sources);
14909 }
14910
14911 /**
14912 * amplifier kernel
14913 */
14914
14915 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14916 {
14917
14918 }
14919 else
14920 {
14921 /**
14922 * kernel amp source filename
14923 */
14924
14925 char source_file[256] = { 0 };
14926
14927 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14928
14929 struct stat sst;
14930
14931 if (stat (source_file, &sst) == -1)
14932 {
14933 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14934
14935 return -1;
14936 }
14937
14938 /**
14939 * kernel amp cached filename
14940 */
14941
14942 char cached_file[256] = { 0 };
14943
14944 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14945
14946 int cached = 1;
14947
14948 struct stat cst;
14949
14950 if (stat (cached_file, &cst) == -1)
14951 {
14952 cached = 0;
14953 }
14954
14955 /**
14956 * kernel compile or load
14957 */
14958
14959 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14960
14961 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14962
14963 if (cached == 0)
14964 {
14965 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14966 if (quiet == 0) log_info ("");
14967
14968 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14969
14970 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14971
14972 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14973
14974 if (rc != 0)
14975 {
14976 device_param->skipped = true;
14977
14978 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14979
14980 continue;
14981 }
14982
14983 size_t binary_size;
14984
14985 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14986
14987 u8 *binary = (u8 *) mymalloc (binary_size);
14988
14989 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14990
14991 writeProgramBin (cached_file, binary, binary_size);
14992
14993 local_free (binary);
14994 }
14995 else
14996 {
14997 #ifdef DEBUG
14998 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14999 #endif
15000
15001 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15002
15003 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15004
15005 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15006 }
15007
15008 local_free (kernel_lengths);
15009 local_free (kernel_sources[0]);
15010 local_free (kernel_sources);
15011 }
15012
15013 // some algorithm collide too fast, make that impossible
15014
15015 if (benchmark == 1)
15016 {
15017 ((uint *) digests_buf)[0] = -1;
15018 ((uint *) digests_buf)[1] = -1;
15019 ((uint *) digests_buf)[2] = -1;
15020 ((uint *) digests_buf)[3] = -1;
15021 }
15022
15023 /**
15024 * global buffers
15025 */
15026
15027 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15028 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15029 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15030 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15031 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15032 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15033 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15034 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15035 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15036 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15037 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15038 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15039 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15040 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15041 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15042 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15043 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15044 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15045
15046 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);
15047 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);
15048 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);
15049 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);
15050 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);
15051 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);
15052 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);
15053 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);
15054 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15055 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15056 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15057
15058 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15059 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15060 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15061 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15062 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15063 run_kernel_bzero (device_param, device_param->d_result, size_results);
15064
15065 /**
15066 * special buffers
15067 */
15068
15069 if (attack_kern == ATTACK_KERN_STRAIGHT)
15070 {
15071 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15072 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15073
15074 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15075
15076 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15077 }
15078 else if (attack_kern == ATTACK_KERN_COMBI)
15079 {
15080 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15081 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15082 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15083 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15084
15085 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15086 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15087 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15088 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15089 }
15090 else if (attack_kern == ATTACK_KERN_BF)
15091 {
15092 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15093 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15094 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15095 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15096 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15097
15098 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15099 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15100 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15101 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15102 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15103 }
15104
15105 if (size_esalts)
15106 {
15107 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15108
15109 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15110 }
15111
15112 /**
15113 * main host data
15114 */
15115
15116 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15117
15118 device_param->pws_buf = pws_buf;
15119
15120 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15121
15122 device_param->combs_buf = combs_buf;
15123
15124 void *hooks_buf = mymalloc (size_hooks);
15125
15126 device_param->hooks_buf = hooks_buf;
15127
15128 /**
15129 * kernel args
15130 */
15131
15132 device_param->kernel_params_buf32[21] = bitmap_mask;
15133 device_param->kernel_params_buf32[22] = bitmap_shift1;
15134 device_param->kernel_params_buf32[23] = bitmap_shift2;
15135 device_param->kernel_params_buf32[24] = 0; // salt_pos
15136 device_param->kernel_params_buf32[25] = 0; // loop_pos
15137 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15138 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15139 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15140 device_param->kernel_params_buf32[29] = 0; // digests_offset
15141 device_param->kernel_params_buf32[30] = 0; // combs_mode
15142 device_param->kernel_params_buf32[31] = 0; // gid_max
15143
15144 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15145 ? &device_param->d_pws_buf
15146 : &device_param->d_pws_amp_buf;
15147 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15148 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15149 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15150 device_param->kernel_params[ 4] = &device_param->d_tmps;
15151 device_param->kernel_params[ 5] = &device_param->d_hooks;
15152 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15153 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15154 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15155 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15156 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15157 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15158 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15159 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15160 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15161 device_param->kernel_params[15] = &device_param->d_digests_buf;
15162 device_param->kernel_params[16] = &device_param->d_digests_shown;
15163 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15164 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15165 device_param->kernel_params[19] = &device_param->d_result;
15166 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15167 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15168 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15169 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15170 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15171 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15172 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15173 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15174 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15175 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15176 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15177 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15178
15179 device_param->kernel_params_mp_buf64[3] = 0;
15180 device_param->kernel_params_mp_buf32[4] = 0;
15181 device_param->kernel_params_mp_buf32[5] = 0;
15182 device_param->kernel_params_mp_buf32[6] = 0;
15183 device_param->kernel_params_mp_buf32[7] = 0;
15184 device_param->kernel_params_mp_buf32[8] = 0;
15185
15186 device_param->kernel_params_mp[0] = NULL;
15187 device_param->kernel_params_mp[1] = NULL;
15188 device_param->kernel_params_mp[2] = NULL;
15189 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15190 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15191 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15192 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15193 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15194 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15195
15196 device_param->kernel_params_mp_l_buf64[3] = 0;
15197 device_param->kernel_params_mp_l_buf32[4] = 0;
15198 device_param->kernel_params_mp_l_buf32[5] = 0;
15199 device_param->kernel_params_mp_l_buf32[6] = 0;
15200 device_param->kernel_params_mp_l_buf32[7] = 0;
15201 device_param->kernel_params_mp_l_buf32[8] = 0;
15202 device_param->kernel_params_mp_l_buf32[9] = 0;
15203
15204 device_param->kernel_params_mp_l[0] = NULL;
15205 device_param->kernel_params_mp_l[1] = NULL;
15206 device_param->kernel_params_mp_l[2] = NULL;
15207 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15208 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15209 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15210 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15211 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15212 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15213 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15214
15215 device_param->kernel_params_mp_r_buf64[3] = 0;
15216 device_param->kernel_params_mp_r_buf32[4] = 0;
15217 device_param->kernel_params_mp_r_buf32[5] = 0;
15218 device_param->kernel_params_mp_r_buf32[6] = 0;
15219 device_param->kernel_params_mp_r_buf32[7] = 0;
15220 device_param->kernel_params_mp_r_buf32[8] = 0;
15221
15222 device_param->kernel_params_mp_r[0] = NULL;
15223 device_param->kernel_params_mp_r[1] = NULL;
15224 device_param->kernel_params_mp_r[2] = NULL;
15225 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15226 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15227 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15228 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15229 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15230 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15231
15232 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15233 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15234
15235 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15236 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15237 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15238 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15239 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15240 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15241 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15242
15243 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15244 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15245
15246 /**
15247 * kernel name
15248 */
15249
15250 size_t kernel_wgs_tmp;
15251
15252 char kernel_name[64] = { 0 };
15253
15254 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15255 {
15256 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15257 {
15258 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15259
15260 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15261
15262 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15263
15264 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15265
15266 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15267
15268 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15269 }
15270 else
15271 {
15272 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15273
15274 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15275
15276 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15277
15278 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15279
15280 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15281
15282 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15283 }
15284
15285 if (data.attack_mode == ATTACK_MODE_BF)
15286 {
15287 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15288 {
15289 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15290
15291 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15292
15293 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);
15294 }
15295 }
15296 }
15297 else
15298 {
15299 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15300
15301 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15302
15303 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15304
15305 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15306
15307 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15308
15309 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15310
15311 if (opts_type & OPTS_TYPE_HOOK12)
15312 {
15313 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15314
15315 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15316
15317 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);
15318 }
15319
15320 if (opts_type & OPTS_TYPE_HOOK23)
15321 {
15322 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15323
15324 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15325
15326 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);
15327 }
15328 }
15329
15330 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);
15331 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);
15332 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);
15333
15334 for (uint i = 0; i <= 20; i++)
15335 {
15336 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15337 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15338 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15339
15340 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15341 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15342 }
15343
15344 for (uint i = 21; i <= 31; i++)
15345 {
15346 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15347 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15348 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15349
15350 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15351 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15352 }
15353
15354 if (attack_mode == ATTACK_MODE_BF)
15355 {
15356 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15357 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15358
15359 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);
15360 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);
15361
15362 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15363 {
15364 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15365 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15366 }
15367 }
15368 else if (attack_mode == ATTACK_MODE_HYBRID1)
15369 {
15370 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15371
15372 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);
15373 }
15374 else if (attack_mode == ATTACK_MODE_HYBRID2)
15375 {
15376 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15377
15378 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);
15379 }
15380
15381 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15382 {
15383 // nothing to do
15384 }
15385 else
15386 {
15387 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15388
15389 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);
15390 }
15391
15392 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15393 {
15394 // nothing to do
15395 }
15396 else
15397 {
15398 for (uint i = 0; i < 5; i++)
15399 {
15400 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15401 }
15402
15403 for (uint i = 5; i < 7; i++)
15404 {
15405 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15406 }
15407 }
15408
15409 // maybe this has been updated by clGetKernelWorkGroupInfo()
15410 // value can only be decreased, so we don't need to reallocate buffers
15411
15412 device_param->kernel_threads = kernel_threads;
15413
15414 /**
15415 * Store initial fanspeed if gpu_temp_retain is enabled
15416 */
15417
15418 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15419 int gpu_temp_retain_set = 0;
15420
15421 if (gpu_temp_disable == 0)
15422 {
15423 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15424 {
15425 hc_thread_mutex_lock (mux_adl);
15426
15427 if (data.hm_device[device_id].fan_supported == 1)
15428 {
15429 if (gpu_temp_retain_chgd == 0)
15430 {
15431 uint cur_temp = 0;
15432 uint default_temp = 0;
15433
15434 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);
15435
15436 if (ADL_rc == ADL_OK)
15437 {
15438 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15439
15440 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15441
15442 // special case with multi gpu setups: always use minimum retain
15443
15444 if (gpu_temp_retain_set == 0)
15445 {
15446 gpu_temp_retain = gpu_temp_retain_target;
15447 gpu_temp_retain_set = 1;
15448 }
15449 else
15450 {
15451 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15452 }
15453
15454 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15455 }
15456 }
15457
15458 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15459
15460 temp_retain_fanspeed_value[device_id] = fan_speed;
15461
15462 if (fan_speed == -1)
15463 {
15464 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15465
15466 temp_retain_fanspeed_value[device_id] = 0;
15467 }
15468 }
15469
15470 hc_thread_mutex_unlock (mux_adl);
15471 }
15472 }
15473
15474 /**
15475 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15476 */
15477
15478 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15479 {
15480 hc_thread_mutex_lock (mux_adl);
15481
15482 if (data.hm_device[device_id].od_version == 6)
15483 {
15484 int ADL_rc;
15485
15486 // check powertune capabilities first, if not available then skip device
15487
15488 int powertune_supported = 0;
15489
15490 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15491 {
15492 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15493
15494 return (-1);
15495 }
15496
15497 if (powertune_supported != 0)
15498 {
15499 // powercontrol settings
15500
15501 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15502
15503 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15504 {
15505 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15506 }
15507
15508 if (ADL_rc != ADL_OK)
15509 {
15510 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15511
15512 return (-1);
15513 }
15514
15515 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15516 {
15517 log_error ("ERROR: Failed to set new ADL PowerControl values");
15518
15519 return (-1);
15520 }
15521
15522 // clocks
15523
15524 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15525
15526 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15527
15528 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)
15529 {
15530 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15531
15532 return (-1);
15533 }
15534
15535 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15536
15537 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15538
15539 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15540 {
15541 log_error ("ERROR: Failed to get ADL device capabilities");
15542
15543 return (-1);
15544 }
15545
15546 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15547 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15548
15549 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15550 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15551
15552 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15553 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15554
15555 // warning if profile has too low max values
15556
15557 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15558 {
15559 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15560 }
15561
15562 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15563 {
15564 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15565 }
15566
15567 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15568
15569 performance_state->iNumberOfPerformanceLevels = 2;
15570
15571 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15572 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15573 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15574 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15575
15576 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)
15577 {
15578 log_info ("ERROR: Failed to set ADL performance state");
15579
15580 return (-1);
15581 }
15582
15583 local_free (performance_state);
15584 }
15585 }
15586
15587 hc_thread_mutex_unlock (mux_adl);
15588 }
15589 #endif // HAVE_HWMON && HAVE_ADL
15590 }
15591
15592 data.kernel_power_all = kernel_power_all;
15593
15594 if (data.quiet == 0) log_info_nn ("");
15595
15596 /**
15597 * In benchmark-mode, inform user which algorithm is checked
15598 */
15599
15600 if (benchmark == 1)
15601 {
15602 if (status_automat == 0)
15603 {
15604 quiet = 0;
15605
15606 data.quiet = quiet;
15607
15608 char *hash_type = strhashtype (data.hash_mode); // not a bug
15609
15610 log_info ("Hashtype: %s", hash_type);
15611 log_info ("");
15612 }
15613 }
15614
15615 /**
15616 * keep track of the progress
15617 */
15618
15619 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15620 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15621 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15622
15623 /**
15624 * open filehandles
15625 */
15626
15627 #if _WIN
15628 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15629 {
15630 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15631
15632 return (-1);
15633 }
15634
15635 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15636 {
15637 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15638
15639 return (-1);
15640 }
15641
15642 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15643 {
15644 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15645
15646 return (-1);
15647 }
15648 #endif
15649
15650 /**
15651 * dictionary pad
15652 */
15653
15654 segment_size *= (1024 * 1024);
15655
15656 data.segment_size = segment_size;
15657
15658 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15659
15660 wl_data->buf = (char *) mymalloc (segment_size);
15661 wl_data->avail = segment_size;
15662 wl_data->incr = segment_size;
15663 wl_data->cnt = 0;
15664 wl_data->pos = 0;
15665
15666 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15667
15668 data.wordlist_mode = wordlist_mode;
15669
15670 cs_t *css_buf = NULL;
15671 uint css_cnt = 0;
15672 uint dictcnt = 0;
15673 uint maskcnt = 1;
15674 char **masks = NULL;
15675 char **dictfiles = NULL;
15676
15677 uint mask_from_file = 0;
15678
15679 if (attack_mode == ATTACK_MODE_STRAIGHT)
15680 {
15681 if (wordlist_mode == WL_MODE_FILE)
15682 {
15683 int wls_left = myargc - (optind + 1);
15684
15685 for (int i = 0; i < wls_left; i++)
15686 {
15687 char *l0_filename = myargv[optind + 1 + i];
15688
15689 struct stat l0_stat;
15690
15691 if (stat (l0_filename, &l0_stat) == -1)
15692 {
15693 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15694
15695 return (-1);
15696 }
15697
15698 uint is_dir = S_ISDIR (l0_stat.st_mode);
15699
15700 if (is_dir == 0)
15701 {
15702 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15703
15704 dictcnt++;
15705
15706 dictfiles[dictcnt - 1] = l0_filename;
15707 }
15708 else
15709 {
15710 // do not allow --keyspace w/ a directory
15711
15712 if (keyspace == 1)
15713 {
15714 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15715
15716 return (-1);
15717 }
15718
15719 char **dictionary_files = NULL;
15720
15721 dictionary_files = scan_directory (l0_filename);
15722
15723 if (dictionary_files != NULL)
15724 {
15725 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15726
15727 for (int d = 0; dictionary_files[d] != NULL; d++)
15728 {
15729 char *l1_filename = dictionary_files[d];
15730
15731 struct stat l1_stat;
15732
15733 if (stat (l1_filename, &l1_stat) == -1)
15734 {
15735 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15736
15737 return (-1);
15738 }
15739
15740 if (S_ISREG (l1_stat.st_mode))
15741 {
15742 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15743
15744 dictcnt++;
15745
15746 dictfiles[dictcnt - 1] = strdup (l1_filename);
15747 }
15748 }
15749 }
15750
15751 local_free (dictionary_files);
15752 }
15753 }
15754
15755 if (dictcnt < 1)
15756 {
15757 log_error ("ERROR: No usable dictionary file found.");
15758
15759 return (-1);
15760 }
15761 }
15762 else if (wordlist_mode == WL_MODE_STDIN)
15763 {
15764 dictcnt = 1;
15765 }
15766 }
15767 else if (attack_mode == ATTACK_MODE_COMBI)
15768 {
15769 // display
15770
15771 char *dictfile1 = myargv[optind + 1 + 0];
15772 char *dictfile2 = myargv[optind + 1 + 1];
15773
15774 // find the bigger dictionary and use as base
15775
15776 FILE *fp1 = NULL;
15777 FILE *fp2 = NULL;
15778
15779 struct stat tmp_stat;
15780
15781 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15782 {
15783 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15784
15785 return (-1);
15786 }
15787
15788 if (stat (dictfile1, &tmp_stat) == -1)
15789 {
15790 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15791
15792 fclose (fp1);
15793
15794 return (-1);
15795 }
15796
15797 if (S_ISDIR (tmp_stat.st_mode))
15798 {
15799 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15800
15801 fclose (fp1);
15802
15803 return (-1);
15804 }
15805
15806 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15807 {
15808 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15809
15810 fclose (fp1);
15811
15812 return (-1);
15813 }
15814
15815 if (stat (dictfile2, &tmp_stat) == -1)
15816 {
15817 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15818
15819 fclose (fp1);
15820 fclose (fp2);
15821
15822 return (-1);
15823 }
15824
15825 if (S_ISDIR (tmp_stat.st_mode))
15826 {
15827 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15828
15829 fclose (fp1);
15830 fclose (fp2);
15831
15832 return (-1);
15833 }
15834
15835 data.combs_cnt = 1;
15836
15837 data.quiet = 1;
15838
15839 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15840
15841 data.quiet = quiet;
15842
15843 if (words1_cnt == 0)
15844 {
15845 log_error ("ERROR: %s: empty file", dictfile1);
15846
15847 fclose (fp1);
15848 fclose (fp2);
15849
15850 return (-1);
15851 }
15852
15853 data.combs_cnt = 1;
15854
15855 data.quiet = 1;
15856
15857 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15858
15859 data.quiet = quiet;
15860
15861 if (words2_cnt == 0)
15862 {
15863 log_error ("ERROR: %s: empty file", dictfile2);
15864
15865 fclose (fp1);
15866 fclose (fp2);
15867
15868 return (-1);
15869 }
15870
15871 fclose (fp1);
15872 fclose (fp2);
15873
15874 data.dictfile = dictfile1;
15875 data.dictfile2 = dictfile2;
15876
15877 if (words1_cnt >= words2_cnt)
15878 {
15879 data.combs_cnt = words2_cnt;
15880 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15881
15882 dictfiles = &data.dictfile;
15883
15884 dictcnt = 1;
15885 }
15886 else
15887 {
15888 data.combs_cnt = words1_cnt;
15889 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15890
15891 dictfiles = &data.dictfile2;
15892
15893 dictcnt = 1;
15894
15895 // we also have to switch wordlist related rules!
15896
15897 char *tmpc = data.rule_buf_l;
15898
15899 data.rule_buf_l = data.rule_buf_r;
15900 data.rule_buf_r = tmpc;
15901
15902 int tmpi = data.rule_len_l;
15903
15904 data.rule_len_l = data.rule_len_r;
15905 data.rule_len_r = tmpi;
15906 }
15907 }
15908 else if (attack_mode == ATTACK_MODE_BF)
15909 {
15910 char *mask = NULL;
15911
15912 maskcnt = 0;
15913
15914 if (benchmark == 0)
15915 {
15916 mask = myargv[optind + 1];
15917
15918 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15919
15920 if ((optind + 2) <= myargc)
15921 {
15922 struct stat file_stat;
15923
15924 if (stat (mask, &file_stat) == -1)
15925 {
15926 maskcnt = 1;
15927
15928 masks[maskcnt - 1] = mystrdup (mask);
15929 }
15930 else
15931 {
15932 int wls_left = myargc - (optind + 1);
15933
15934 uint masks_avail = INCR_MASKS;
15935
15936 for (int i = 0; i < wls_left; i++)
15937 {
15938 if (i != 0)
15939 {
15940 mask = myargv[optind + 1 + i];
15941
15942 if (stat (mask, &file_stat) == -1)
15943 {
15944 log_error ("ERROR: %s: %s", mask, strerror (errno));
15945
15946 return (-1);
15947 }
15948 }
15949
15950 uint is_file = S_ISREG (file_stat.st_mode);
15951
15952 if (is_file == 1)
15953 {
15954 FILE *mask_fp;
15955
15956 if ((mask_fp = fopen (mask, "r")) == NULL)
15957 {
15958 log_error ("ERROR: %s: %s", mask, strerror (errno));
15959
15960 return (-1);
15961 }
15962
15963 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15964
15965 while (!feof (mask_fp))
15966 {
15967 memset (line_buf, 0, HCBUFSIZ);
15968
15969 int line_len = fgetl (mask_fp, line_buf);
15970
15971 if (line_len == 0) continue;
15972
15973 if (line_buf[0] == '#') continue;
15974
15975 if (masks_avail == maskcnt)
15976 {
15977 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15978
15979 masks_avail += INCR_MASKS;
15980 }
15981
15982 masks[maskcnt] = mystrdup (line_buf);
15983
15984 maskcnt++;
15985 }
15986
15987 myfree (line_buf);
15988
15989 fclose (mask_fp);
15990 }
15991 else
15992 {
15993 log_error ("ERROR: %s: unsupported file-type", mask);
15994
15995 return (-1);
15996 }
15997 }
15998
15999 mask_from_file = 1;
16000 }
16001 }
16002 else
16003 {
16004 custom_charset_1 = (char *) "?l?d?u";
16005 custom_charset_2 = (char *) "?l?d";
16006 custom_charset_3 = (char *) "?l?d*!$@_";
16007
16008 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16009 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16010 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16011
16012 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16013
16014 wordlist_mode = WL_MODE_MASK;
16015
16016 data.wordlist_mode = wordlist_mode;
16017
16018 increment = 1;
16019
16020 maskcnt = 1;
16021 }
16022 }
16023 else
16024 {
16025 /**
16026 * generate full masks and charsets
16027 */
16028
16029 masks = (char **) mymalloc (sizeof (char *));
16030
16031 switch (hash_mode)
16032 {
16033 case 1731: pw_min = 5;
16034 pw_max = 5;
16035 mask = mystrdup ("?b?b?b?b?b");
16036 break;
16037 case 12500: pw_min = 5;
16038 pw_max = 5;
16039 mask = mystrdup ("?b?b?b?b?b");
16040 break;
16041 default: pw_min = 7;
16042 pw_max = 7;
16043 mask = mystrdup ("?b?b?b?b?b?b?b");
16044 break;
16045 }
16046
16047 maskcnt = 1;
16048
16049 masks[maskcnt - 1] = mystrdup (mask);
16050
16051 wordlist_mode = WL_MODE_MASK;
16052
16053 data.wordlist_mode = wordlist_mode;
16054
16055 increment = 1;
16056 }
16057
16058 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16059
16060 if (increment)
16061 {
16062 if (increment_min > pw_min) pw_min = increment_min;
16063
16064 if (increment_max < pw_max) pw_max = increment_max;
16065 }
16066 }
16067 else if (attack_mode == ATTACK_MODE_HYBRID1)
16068 {
16069 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16070
16071 // display
16072
16073 char *mask = myargv[myargc - 1];
16074
16075 maskcnt = 0;
16076
16077 masks = (char **) mymalloc (1 * sizeof (char *));
16078
16079 // mod
16080
16081 struct stat file_stat;
16082
16083 if (stat (mask, &file_stat) == -1)
16084 {
16085 maskcnt = 1;
16086
16087 masks[maskcnt - 1] = mystrdup (mask);
16088 }
16089 else
16090 {
16091 uint is_file = S_ISREG (file_stat.st_mode);
16092
16093 if (is_file == 1)
16094 {
16095 FILE *mask_fp;
16096
16097 if ((mask_fp = fopen (mask, "r")) == NULL)
16098 {
16099 log_error ("ERROR: %s: %s", mask, strerror (errno));
16100
16101 return (-1);
16102 }
16103
16104 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16105
16106 uint masks_avail = 1;
16107
16108 while (!feof (mask_fp))
16109 {
16110 memset (line_buf, 0, HCBUFSIZ);
16111
16112 int line_len = fgetl (mask_fp, line_buf);
16113
16114 if (line_len == 0) continue;
16115
16116 if (line_buf[0] == '#') continue;
16117
16118 if (masks_avail == maskcnt)
16119 {
16120 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16121
16122 masks_avail += INCR_MASKS;
16123 }
16124
16125 masks[maskcnt] = mystrdup (line_buf);
16126
16127 maskcnt++;
16128 }
16129
16130 myfree (line_buf);
16131
16132 fclose (mask_fp);
16133
16134 mask_from_file = 1;
16135 }
16136 else
16137 {
16138 maskcnt = 1;
16139
16140 masks[maskcnt - 1] = mystrdup (mask);
16141 }
16142 }
16143
16144 // base
16145
16146 int wls_left = myargc - (optind + 2);
16147
16148 for (int i = 0; i < wls_left; i++)
16149 {
16150 char *filename = myargv[optind + 1 + i];
16151
16152 struct stat file_stat;
16153
16154 if (stat (filename, &file_stat) == -1)
16155 {
16156 log_error ("ERROR: %s: %s", filename, strerror (errno));
16157
16158 return (-1);
16159 }
16160
16161 uint is_dir = S_ISDIR (file_stat.st_mode);
16162
16163 if (is_dir == 0)
16164 {
16165 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16166
16167 dictcnt++;
16168
16169 dictfiles[dictcnt - 1] = filename;
16170 }
16171 else
16172 {
16173 // do not allow --keyspace w/ a directory
16174
16175 if (keyspace == 1)
16176 {
16177 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16178
16179 return (-1);
16180 }
16181
16182 char **dictionary_files = NULL;
16183
16184 dictionary_files = scan_directory (filename);
16185
16186 if (dictionary_files != NULL)
16187 {
16188 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16189
16190 for (int d = 0; dictionary_files[d] != NULL; d++)
16191 {
16192 char *l1_filename = dictionary_files[d];
16193
16194 struct stat l1_stat;
16195
16196 if (stat (l1_filename, &l1_stat) == -1)
16197 {
16198 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16199
16200 return (-1);
16201 }
16202
16203 if (S_ISREG (l1_stat.st_mode))
16204 {
16205 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16206
16207 dictcnt++;
16208
16209 dictfiles[dictcnt - 1] = strdup (l1_filename);
16210 }
16211 }
16212 }
16213
16214 local_free (dictionary_files);
16215 }
16216 }
16217
16218 if (dictcnt < 1)
16219 {
16220 log_error ("ERROR: No usable dictionary file found.");
16221
16222 return (-1);
16223 }
16224
16225 if (increment)
16226 {
16227 maskcnt = 0;
16228
16229 uint mask_min = increment_min; // we can't reject smaller masks here
16230 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16231
16232 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16233 {
16234 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16235
16236 if (cur_mask == NULL) break;
16237
16238 masks[maskcnt] = cur_mask;
16239
16240 maskcnt++;
16241
16242 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16243 }
16244 }
16245 }
16246 else if (attack_mode == ATTACK_MODE_HYBRID2)
16247 {
16248 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16249
16250 // display
16251
16252 char *mask = myargv[optind + 1 + 0];
16253
16254 maskcnt = 0;
16255
16256 masks = (char **) mymalloc (1 * sizeof (char *));
16257
16258 // mod
16259
16260 struct stat file_stat;
16261
16262 if (stat (mask, &file_stat) == -1)
16263 {
16264 maskcnt = 1;
16265
16266 masks[maskcnt - 1] = mystrdup (mask);
16267 }
16268 else
16269 {
16270 uint is_file = S_ISREG (file_stat.st_mode);
16271
16272 if (is_file == 1)
16273 {
16274 FILE *mask_fp;
16275
16276 if ((mask_fp = fopen (mask, "r")) == NULL)
16277 {
16278 log_error ("ERROR: %s: %s", mask, strerror (errno));
16279
16280 return (-1);
16281 }
16282
16283 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16284
16285 uint masks_avail = 1;
16286
16287 while (!feof (mask_fp))
16288 {
16289 memset (line_buf, 0, HCBUFSIZ);
16290
16291 int line_len = fgetl (mask_fp, line_buf);
16292
16293 if (line_len == 0) continue;
16294
16295 if (line_buf[0] == '#') continue;
16296
16297 if (masks_avail == maskcnt)
16298 {
16299 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16300
16301 masks_avail += INCR_MASKS;
16302 }
16303
16304 masks[maskcnt] = mystrdup (line_buf);
16305
16306 maskcnt++;
16307 }
16308
16309 myfree (line_buf);
16310
16311 fclose (mask_fp);
16312
16313 mask_from_file = 1;
16314 }
16315 else
16316 {
16317 maskcnt = 1;
16318
16319 masks[maskcnt - 1] = mystrdup (mask);
16320 }
16321 }
16322
16323 // base
16324
16325 int wls_left = myargc - (optind + 2);
16326
16327 for (int i = 0; i < wls_left; i++)
16328 {
16329 char *filename = myargv[optind + 2 + i];
16330
16331 struct stat file_stat;
16332
16333 if (stat (filename, &file_stat) == -1)
16334 {
16335 log_error ("ERROR: %s: %s", filename, strerror (errno));
16336
16337 return (-1);
16338 }
16339
16340 uint is_dir = S_ISDIR (file_stat.st_mode);
16341
16342 if (is_dir == 0)
16343 {
16344 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16345
16346 dictcnt++;
16347
16348 dictfiles[dictcnt - 1] = filename;
16349 }
16350 else
16351 {
16352 // do not allow --keyspace w/ a directory
16353
16354 if (keyspace == 1)
16355 {
16356 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16357
16358 return (-1);
16359 }
16360
16361 char **dictionary_files = NULL;
16362
16363 dictionary_files = scan_directory (filename);
16364
16365 if (dictionary_files != NULL)
16366 {
16367 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16368
16369 for (int d = 0; dictionary_files[d] != NULL; d++)
16370 {
16371 char *l1_filename = dictionary_files[d];
16372
16373 struct stat l1_stat;
16374
16375 if (stat (l1_filename, &l1_stat) == -1)
16376 {
16377 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16378
16379 return (-1);
16380 }
16381
16382 if (S_ISREG (l1_stat.st_mode))
16383 {
16384 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16385
16386 dictcnt++;
16387
16388 dictfiles[dictcnt - 1] = strdup (l1_filename);
16389 }
16390 }
16391 }
16392
16393 local_free (dictionary_files);
16394 }
16395 }
16396
16397 if (dictcnt < 1)
16398 {
16399 log_error ("ERROR: No usable dictionary file found.");
16400
16401 return (-1);
16402 }
16403
16404 if (increment)
16405 {
16406 maskcnt = 0;
16407
16408 uint mask_min = increment_min; // we can't reject smaller masks here
16409 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16410
16411 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16412 {
16413 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16414
16415 if (cur_mask == NULL) break;
16416
16417 masks[maskcnt] = cur_mask;
16418
16419 maskcnt++;
16420
16421 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16422 }
16423 }
16424 }
16425
16426 data.pw_min = pw_min;
16427 data.pw_max = pw_max;
16428
16429 /**
16430 * weak hash check
16431 */
16432
16433 if (weak_hash_threshold >= salts_cnt)
16434 {
16435 hc_device_param_t *device_param = NULL;
16436
16437 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16438 {
16439 device_param = &data.devices_param[device_id];
16440
16441 if (device_param->skipped) continue;
16442
16443 break;
16444 }
16445
16446 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16447
16448 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16449 {
16450 weak_hash_check (device_param, salt_pos);
16451 }
16452
16453 // Display hack, guarantee that there is at least one \r before real start
16454
16455 //if (data.quiet == 0) log_info ("");
16456 }
16457
16458 /**
16459 * status and monitor threads
16460 */
16461
16462 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16463
16464 hc_thread_t i_thread = 0;
16465
16466 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16467 {
16468 hc_thread_create (i_thread, thread_keypress, &benchmark);
16469 }
16470
16471 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16472
16473 uint ni_threads_cnt = 0;
16474
16475 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16476
16477 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16478
16479 ni_threads_cnt++;
16480
16481 /**
16482 * Outfile remove
16483 */
16484
16485 if (keyspace == 0)
16486 {
16487 if (outfile_check_timer != 0)
16488 {
16489 if (data.outfile_check_directory != NULL)
16490 {
16491 if ((hash_mode != 5200) &&
16492 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16493 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16494 (hash_mode != 9000))
16495 {
16496 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16497
16498 ni_threads_cnt++;
16499 }
16500 else
16501 {
16502 outfile_check_timer = 0;
16503 }
16504 }
16505 else
16506 {
16507 outfile_check_timer = 0;
16508 }
16509 }
16510 }
16511
16512 /**
16513 * Inform the user if we got some hashes remove because of the pot file remove feature
16514 */
16515
16516 if (data.quiet == 0)
16517 {
16518 if (potfile_remove_cracks > 0)
16519 {
16520 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16521 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16522 }
16523 }
16524
16525 data.outfile_check_timer = outfile_check_timer;
16526
16527 /**
16528 * main loop
16529 */
16530
16531 char **induction_dictionaries = NULL;
16532
16533 int induction_dictionaries_cnt = 0;
16534
16535 hcstat_table_t *root_table_buf = NULL;
16536 hcstat_table_t *markov_table_buf = NULL;
16537
16538 uint initial_restore_done = 0;
16539
16540 data.maskcnt = maskcnt;
16541
16542 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16543 {
16544 if (data.devices_status == STATUS_CRACKED) break;
16545
16546 data.devices_status = STATUS_INIT;
16547
16548 if (maskpos > rd->maskpos)
16549 {
16550 rd->dictpos = 0;
16551 }
16552
16553 rd->maskpos = maskpos;
16554 data.maskpos = maskpos;
16555
16556 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16557 {
16558 char *mask = masks[maskpos];
16559
16560 if (mask_from_file == 1)
16561 {
16562 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16563
16564 char *str_ptr;
16565 uint str_pos;
16566
16567 uint mask_offset = 0;
16568
16569 uint separator_cnt;
16570
16571 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16572 {
16573 str_ptr = strstr (mask + mask_offset, ",");
16574
16575 if (str_ptr == NULL) break;
16576
16577 str_pos = str_ptr - mask;
16578
16579 // escaped separator, i.e. "\,"
16580
16581 if (str_pos > 0)
16582 {
16583 if (mask[str_pos - 1] == '\\')
16584 {
16585 separator_cnt --;
16586
16587 mask_offset = str_pos + 1;
16588
16589 continue;
16590 }
16591 }
16592
16593 // reset the offset
16594
16595 mask_offset = 0;
16596
16597 mask[str_pos] = '\0';
16598
16599 switch (separator_cnt)
16600 {
16601 case 0:
16602 mp_reset_usr (mp_usr, 0);
16603
16604 custom_charset_1 = mask;
16605 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16606 break;
16607
16608 case 1:
16609 mp_reset_usr (mp_usr, 1);
16610
16611 custom_charset_2 = mask;
16612 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16613 break;
16614
16615 case 2:
16616 mp_reset_usr (mp_usr, 2);
16617
16618 custom_charset_3 = mask;
16619 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16620 break;
16621
16622 case 3:
16623 mp_reset_usr (mp_usr, 3);
16624
16625 custom_charset_4 = mask;
16626 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16627 break;
16628 }
16629
16630 mask = mask + str_pos + 1;
16631 }
16632 }
16633
16634 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16635 {
16636 if (maskpos > 0)
16637 {
16638 local_free (css_buf);
16639 local_free (data.root_css_buf);
16640 local_free (data.markov_css_buf);
16641
16642 local_free (masks[maskpos - 1]);
16643 }
16644
16645 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16646
16647 data.mask = mask;
16648 data.css_cnt = css_cnt;
16649 data.css_buf = css_buf;
16650
16651 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16652
16653 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16654
16655 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16656 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16657
16658 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16659
16660 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16661
16662 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16663 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16664
16665 data.root_css_buf = root_css_buf;
16666 data.markov_css_buf = markov_css_buf;
16667
16668 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16669
16670 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16671
16672 local_free (root_table_buf);
16673 local_free (markov_table_buf);
16674
16675 // args
16676
16677 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16678 {
16679 hc_device_param_t *device_param = &data.devices_param[device_id];
16680
16681 if (device_param->skipped) continue;
16682
16683 device_param->kernel_params_mp[0] = &device_param->d_combs;
16684 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16685 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16686
16687 device_param->kernel_params_mp_buf64[3] = 0;
16688 device_param->kernel_params_mp_buf32[4] = css_cnt;
16689 device_param->kernel_params_mp_buf32[5] = 0;
16690 device_param->kernel_params_mp_buf32[6] = 0;
16691 device_param->kernel_params_mp_buf32[7] = 0;
16692
16693 if (attack_mode == ATTACK_MODE_HYBRID1)
16694 {
16695 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16696 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16697 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16698 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16699 }
16700 else if (attack_mode == ATTACK_MODE_HYBRID2)
16701 {
16702 device_param->kernel_params_mp_buf32[5] = 0;
16703 device_param->kernel_params_mp_buf32[6] = 0;
16704 device_param->kernel_params_mp_buf32[7] = 0;
16705 }
16706
16707 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]);
16708 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]);
16709 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]);
16710
16711 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);
16712 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);
16713 }
16714 }
16715 else if (attack_mode == ATTACK_MODE_BF)
16716 {
16717 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16718
16719 if (increment)
16720 {
16721 for (uint i = 0; i < dictcnt; i++)
16722 {
16723 local_free (dictfiles[i]);
16724 }
16725
16726 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16727 {
16728 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16729
16730 if (l1_filename == NULL) break;
16731
16732 dictcnt++;
16733
16734 dictfiles[dictcnt - 1] = l1_filename;
16735 }
16736 }
16737 else
16738 {
16739 dictcnt++;
16740
16741 dictfiles[dictcnt - 1] = mask;
16742 }
16743
16744 if (dictcnt == 0)
16745 {
16746 log_error ("ERROR: Mask is too small");
16747
16748 return (-1);
16749 }
16750 }
16751 }
16752
16753 free (induction_dictionaries);
16754
16755 // induction_dictionaries_cnt = 0; // implied
16756
16757 if (attack_mode != ATTACK_MODE_BF)
16758 {
16759 if (keyspace == 0)
16760 {
16761 induction_dictionaries = scan_directory (induction_directory);
16762
16763 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16764 }
16765 }
16766
16767 if (induction_dictionaries_cnt)
16768 {
16769 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16770 }
16771
16772 /**
16773 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16774 */
16775 if (keyspace == 1)
16776 {
16777 if ((maskcnt > 1) || (dictcnt > 1))
16778 {
16779 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16780
16781 return (-1);
16782 }
16783 }
16784
16785 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16786 {
16787 char *subid = logfile_generate_subid ();
16788
16789 data.subid = subid;
16790
16791 logfile_sub_msg ("START");
16792
16793 data.devices_status = STATUS_INIT;
16794
16795 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16796 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16797 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16798
16799 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16800
16801 data.cpt_pos = 0;
16802
16803 data.cpt_start = time (NULL);
16804
16805 data.cpt_total = 0;
16806
16807 if (data.restore == 0)
16808 {
16809 rd->words_cur = skip;
16810
16811 skip = 0;
16812
16813 data.skip = 0;
16814 }
16815
16816 data.ms_paused = 0;
16817
16818 data.words_cur = rd->words_cur;
16819
16820 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16821 {
16822 hc_device_param_t *device_param = &data.devices_param[device_id];
16823
16824 if (device_param->skipped) continue;
16825
16826 device_param->speed_pos = 0;
16827
16828 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16829 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16830
16831 device_param->exec_pos = 0;
16832
16833 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16834
16835 device_param->kernel_power = device_param->kernel_power_user;
16836
16837 device_param->outerloop_pos = 0;
16838 device_param->outerloop_left = 0;
16839 device_param->innerloop_pos = 0;
16840 device_param->innerloop_left = 0;
16841
16842 // some more resets:
16843
16844 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16845
16846 device_param->pws_cnt = 0;
16847
16848 device_param->words_off = 0;
16849 device_param->words_done = 0;
16850 }
16851
16852 data.kernel_power_div = 0;
16853
16854 // figure out some workload
16855
16856 if (attack_mode == ATTACK_MODE_STRAIGHT)
16857 {
16858 if (data.wordlist_mode == WL_MODE_FILE)
16859 {
16860 char *dictfile = NULL;
16861
16862 if (induction_dictionaries_cnt)
16863 {
16864 dictfile = induction_dictionaries[0];
16865 }
16866 else
16867 {
16868 dictfile = dictfiles[dictpos];
16869 }
16870
16871 data.dictfile = dictfile;
16872
16873 logfile_sub_string (dictfile);
16874
16875 for (uint i = 0; i < rp_files_cnt; i++)
16876 {
16877 logfile_sub_var_string ("rulefile", rp_files[i]);
16878 }
16879
16880 FILE *fd2 = fopen (dictfile, "rb");
16881
16882 if (fd2 == NULL)
16883 {
16884 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16885
16886 return (-1);
16887 }
16888
16889 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16890
16891 fclose (fd2);
16892
16893 if (data.words_cnt == 0)
16894 {
16895 if (data.devices_status == STATUS_CRACKED) break;
16896 if (data.devices_status == STATUS_ABORTED) break;
16897
16898 dictpos++;
16899
16900 continue;
16901 }
16902 }
16903 }
16904 else if (attack_mode == ATTACK_MODE_COMBI)
16905 {
16906 char *dictfile = data.dictfile;
16907 char *dictfile2 = data.dictfile2;
16908
16909 logfile_sub_string (dictfile);
16910 logfile_sub_string (dictfile2);
16911
16912 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16913 {
16914 FILE *fd2 = fopen (dictfile, "rb");
16915
16916 if (fd2 == NULL)
16917 {
16918 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16919
16920 return (-1);
16921 }
16922
16923 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16924
16925 fclose (fd2);
16926 }
16927 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16928 {
16929 FILE *fd2 = fopen (dictfile2, "rb");
16930
16931 if (fd2 == NULL)
16932 {
16933 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16934
16935 return (-1);
16936 }
16937
16938 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16939
16940 fclose (fd2);
16941 }
16942
16943 if (data.words_cnt == 0)
16944 {
16945 if (data.devices_status == STATUS_CRACKED) break;
16946 if (data.devices_status == STATUS_ABORTED) break;
16947
16948 dictpos++;
16949
16950 continue;
16951 }
16952 }
16953 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16954 {
16955 char *dictfile = NULL;
16956
16957 if (induction_dictionaries_cnt)
16958 {
16959 dictfile = induction_dictionaries[0];
16960 }
16961 else
16962 {
16963 dictfile = dictfiles[dictpos];
16964 }
16965
16966 data.dictfile = dictfile;
16967
16968 char *mask = data.mask;
16969
16970 logfile_sub_string (dictfile);
16971 logfile_sub_string (mask);
16972
16973 FILE *fd2 = fopen (dictfile, "rb");
16974
16975 if (fd2 == NULL)
16976 {
16977 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16978
16979 return (-1);
16980 }
16981
16982 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16983
16984 fclose (fd2);
16985
16986 if (data.words_cnt == 0)
16987 {
16988 if (data.devices_status == STATUS_CRACKED) break;
16989 if (data.devices_status == STATUS_ABORTED) break;
16990
16991 dictpos++;
16992
16993 continue;
16994 }
16995 }
16996 else if (attack_mode == ATTACK_MODE_BF)
16997 {
16998 local_free (css_buf);
16999 local_free (data.root_css_buf);
17000 local_free (data.markov_css_buf);
17001
17002 char *mask = dictfiles[dictpos];
17003
17004 logfile_sub_string (mask);
17005
17006 // base
17007
17008 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17009
17010 if (opts_type & OPTS_TYPE_PT_UNICODE)
17011 {
17012 uint css_cnt_unicode = css_cnt * 2;
17013
17014 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17015
17016 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17017 {
17018 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17019
17020 css_buf_unicode[j + 1].cs_buf[0] = 0;
17021 css_buf_unicode[j + 1].cs_len = 1;
17022 }
17023
17024 free (css_buf);
17025
17026 css_buf = css_buf_unicode;
17027 css_cnt = css_cnt_unicode;
17028 }
17029
17030 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17031
17032 uint mask_min = pw_min;
17033 uint mask_max = pw_max;
17034
17035 if (opts_type & OPTS_TYPE_PT_UNICODE)
17036 {
17037 mask_min *= 2;
17038 mask_max *= 2;
17039 }
17040
17041 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17042 {
17043 if (css_cnt < mask_min)
17044 {
17045 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17046 }
17047
17048 if (css_cnt > mask_max)
17049 {
17050 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17051 }
17052
17053 // skip to next mask
17054
17055 dictpos++;
17056
17057 rd->dictpos = dictpos;
17058
17059 logfile_sub_msg ("STOP");
17060
17061 continue;
17062 }
17063
17064 uint save_css_cnt = css_cnt;
17065
17066 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17067 {
17068 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17069 {
17070 uint salt_len = (uint) data.salts_buf[0].salt_len;
17071 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17072
17073 uint css_cnt_salt = css_cnt + salt_len;
17074
17075 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17076
17077 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17078
17079 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17080 {
17081 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17082 css_buf_salt[j].cs_len = 1;
17083 }
17084
17085 free (css_buf);
17086
17087 css_buf = css_buf_salt;
17088 css_cnt = css_cnt_salt;
17089 }
17090 }
17091
17092 data.mask = mask;
17093 data.css_cnt = css_cnt;
17094 data.css_buf = css_buf;
17095
17096 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17097
17098 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17099
17100 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17101
17102 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17103 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17104
17105 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17106
17107 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17108
17109 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17110 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17111
17112 data.root_css_buf = root_css_buf;
17113 data.markov_css_buf = markov_css_buf;
17114
17115 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17116
17117 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17118
17119 local_free (root_table_buf);
17120 local_free (markov_table_buf);
17121
17122 // copy + args
17123
17124 uint css_cnt_l = css_cnt;
17125 uint css_cnt_r;
17126
17127 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17128 {
17129 if (save_css_cnt < 6)
17130 {
17131 css_cnt_r = 1;
17132 }
17133 else if (save_css_cnt == 6)
17134 {
17135 css_cnt_r = 2;
17136 }
17137 else
17138 {
17139 if (opts_type & OPTS_TYPE_PT_UNICODE)
17140 {
17141 if (save_css_cnt == 8 || save_css_cnt == 10)
17142 {
17143 css_cnt_r = 2;
17144 }
17145 else
17146 {
17147 css_cnt_r = 4;
17148 }
17149 }
17150 else
17151 {
17152 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17153 {
17154 css_cnt_r = 3;
17155 }
17156 else
17157 {
17158 css_cnt_r = 4;
17159 }
17160 }
17161 }
17162 }
17163 else
17164 {
17165 css_cnt_r = 1;
17166
17167 /* unfinished code?
17168 int sum = css_buf[css_cnt_r - 1].cs_len;
17169
17170 for (uint i = 1; i < 4 && i < css_cnt; i++)
17171 {
17172 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17173
17174 css_cnt_r++;
17175
17176 sum *= css_buf[css_cnt_r - 1].cs_len;
17177 }
17178 */
17179 }
17180
17181 css_cnt_l -= css_cnt_r;
17182
17183 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17184
17185 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17186 {
17187 hc_device_param_t *device_param = &data.devices_param[device_id];
17188
17189 if (device_param->skipped) continue;
17190
17191 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17192 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17193 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17194
17195 device_param->kernel_params_mp_l_buf64[3] = 0;
17196 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17197 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17198 device_param->kernel_params_mp_l_buf32[6] = 0;
17199 device_param->kernel_params_mp_l_buf32[7] = 0;
17200 device_param->kernel_params_mp_l_buf32[8] = 0;
17201
17202 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17203 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17204 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17205 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17206
17207 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17208 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17209 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17210
17211 device_param->kernel_params_mp_r_buf64[3] = 0;
17212 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17213 device_param->kernel_params_mp_r_buf32[5] = 0;
17214 device_param->kernel_params_mp_r_buf32[6] = 0;
17215 device_param->kernel_params_mp_r_buf32[7] = 0;
17216
17217 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]);
17218 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]);
17219 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]);
17220
17221 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]);
17222 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]);
17223 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]);
17224
17225 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);
17226 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);
17227 }
17228 }
17229
17230 u64 words_base = data.words_cnt;
17231
17232 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17233 {
17234 if (data.kernel_rules_cnt)
17235 {
17236 words_base /= data.kernel_rules_cnt;
17237 }
17238 }
17239 else if (data.attack_kern == ATTACK_KERN_COMBI)
17240 {
17241 if (data.combs_cnt)
17242 {
17243 words_base /= data.combs_cnt;
17244 }
17245 }
17246 else if (data.attack_kern == ATTACK_KERN_BF)
17247 {
17248 if (data.bfs_cnt)
17249 {
17250 words_base /= data.bfs_cnt;
17251 }
17252 }
17253
17254 data.words_base = words_base;
17255
17256 if (keyspace == 1)
17257 {
17258 log_info ("%llu", (unsigned long long int) words_base);
17259
17260 return (0);
17261 }
17262
17263 if (data.words_cur > data.words_base)
17264 {
17265 log_error ("ERROR: restore value greater keyspace");
17266
17267 return (-1);
17268 }
17269
17270 if (data.words_cur)
17271 {
17272 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17273 {
17274 for (uint i = 0; i < data.salts_cnt; i++)
17275 {
17276 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17277 }
17278 }
17279 else if (data.attack_kern == ATTACK_KERN_COMBI)
17280 {
17281 for (uint i = 0; i < data.salts_cnt; i++)
17282 {
17283 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17284 }
17285 }
17286 else if (data.attack_kern == ATTACK_KERN_BF)
17287 {
17288 for (uint i = 0; i < data.salts_cnt; i++)
17289 {
17290 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17291 }
17292 }
17293 }
17294
17295 /*
17296 * Inform user about possible slow speeds
17297 */
17298
17299 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17300 {
17301 if (data.words_base < kernel_power_all)
17302 {
17303 if (quiet == 0)
17304 {
17305 log_info ("ATTENTION!");
17306 log_info (" The wordlist or mask you are using is too small.");
17307 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17308 log_info (" The cracking speed will drop.");
17309 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17310 log_info ("");
17311 }
17312 }
17313 }
17314
17315 /*
17316 * Update loopback file
17317 */
17318
17319 if (loopback == 1)
17320 {
17321 time_t now;
17322
17323 time (&now);
17324
17325 uint random_num = get_random_num (0, 9999);
17326
17327 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17328
17329 data.loopback_file = loopback_file;
17330 }
17331
17332 /*
17333 * Update dictionary statistic
17334 */
17335
17336 if (keyspace == 0)
17337 {
17338 dictstat_fp = fopen (dictstat, "wb");
17339
17340 if (dictstat_fp)
17341 {
17342 lock_file (dictstat_fp);
17343
17344 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17345
17346 fclose (dictstat_fp);
17347 }
17348 }
17349
17350 data.devices_status = STATUS_RUNNING;
17351
17352 if (initial_restore_done == 0)
17353 {
17354 if (data.restore_disable == 0) cycle_restore ();
17355
17356 initial_restore_done = 1;
17357 }
17358
17359 hc_timer_set (&data.timer_running);
17360
17361 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17362 {
17363 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17364 {
17365 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17366 if (quiet == 0) fflush (stdout);
17367 }
17368 }
17369 else if (wordlist_mode == WL_MODE_STDIN)
17370 {
17371 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17372 if (data.quiet == 0) log_info ("");
17373 }
17374
17375 time_t runtime_start;
17376
17377 time (&runtime_start);
17378
17379 data.runtime_start = runtime_start;
17380
17381 /**
17382 * create cracker threads
17383 */
17384
17385 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17386
17387 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17388 {
17389 hc_device_param_t *device_param = &devices_param[device_id];
17390
17391 if (wordlist_mode == WL_MODE_STDIN)
17392 {
17393 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17394 }
17395 else
17396 {
17397 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17398 }
17399 }
17400
17401 // wait for crack threads to exit
17402
17403 hc_thread_wait (data.devices_cnt, c_threads);
17404
17405 local_free (c_threads);
17406
17407 data.restore = 0;
17408
17409 // finalize task
17410
17411 logfile_sub_var_uint ("status-after-work", data.devices_status);
17412
17413 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17414
17415 if (data.devices_status == STATUS_CRACKED) break;
17416 if (data.devices_status == STATUS_ABORTED) break;
17417
17418 if (data.devices_status == STATUS_BYPASS)
17419 {
17420 data.devices_status = STATUS_RUNNING;
17421 }
17422
17423 if (induction_dictionaries_cnt)
17424 {
17425 unlink (induction_dictionaries[0]);
17426 }
17427
17428 free (induction_dictionaries);
17429
17430 if (attack_mode != ATTACK_MODE_BF)
17431 {
17432 induction_dictionaries = scan_directory (induction_directory);
17433
17434 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17435 }
17436
17437 if (benchmark == 0)
17438 {
17439 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17440 {
17441 if (quiet == 0) clear_prompt ();
17442
17443 if (quiet == 0) log_info ("");
17444
17445 if (status == 1)
17446 {
17447 status_display ();
17448 }
17449 else
17450 {
17451 if (quiet == 0) status_display ();
17452 }
17453
17454 if (quiet == 0) log_info ("");
17455 }
17456 }
17457
17458 if (attack_mode == ATTACK_MODE_BF)
17459 {
17460 dictpos++;
17461
17462 rd->dictpos = dictpos;
17463 }
17464 else
17465 {
17466 if (induction_dictionaries_cnt)
17467 {
17468 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17469 }
17470 else
17471 {
17472 dictpos++;
17473
17474 rd->dictpos = dictpos;
17475 }
17476 }
17477
17478 time_t runtime_stop;
17479
17480 time (&runtime_stop);
17481
17482 data.runtime_stop = runtime_stop;
17483
17484 logfile_sub_uint (runtime_start);
17485 logfile_sub_uint (runtime_stop);
17486
17487 logfile_sub_msg ("STOP");
17488
17489 global_free (subid);
17490 }
17491
17492 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17493
17494 if (data.devices_status == STATUS_CRACKED) break;
17495 if (data.devices_status == STATUS_ABORTED) break;
17496 if (data.devices_status == STATUS_QUIT) break;
17497
17498 if (data.devices_status == STATUS_BYPASS)
17499 {
17500 data.devices_status = STATUS_RUNNING;
17501 }
17502 }
17503
17504 // 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
17505
17506 if (attack_mode == ATTACK_MODE_STRAIGHT)
17507 {
17508 if (data.wordlist_mode == WL_MODE_FILE)
17509 {
17510 if (data.dictfile == NULL)
17511 {
17512 if (dictfiles != NULL)
17513 {
17514 data.dictfile = dictfiles[0];
17515
17516 hc_timer_set (&data.timer_running);
17517 }
17518 }
17519 }
17520 }
17521 // NOTE: combi is okay because it is already set beforehand
17522 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17523 {
17524 if (data.dictfile == NULL)
17525 {
17526 if (dictfiles != NULL)
17527 {
17528 hc_timer_set (&data.timer_running);
17529
17530 data.dictfile = dictfiles[0];
17531 }
17532 }
17533 }
17534 else if (attack_mode == ATTACK_MODE_BF)
17535 {
17536 if (data.mask == NULL)
17537 {
17538 hc_timer_set (&data.timer_running);
17539
17540 data.mask = masks[0];
17541 }
17542 }
17543
17544 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17545 {
17546 data.devices_status = STATUS_EXHAUSTED;
17547 }
17548
17549 // if cracked / aborted remove last induction dictionary
17550
17551 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17552 {
17553 struct stat induct_stat;
17554
17555 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17556 {
17557 unlink (induction_dictionaries[file_pos]);
17558 }
17559 }
17560
17561 // wait for non-interactive threads
17562
17563 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17564 {
17565 hc_thread_wait (1, &ni_threads[thread_idx]);
17566 }
17567
17568 local_free (ni_threads);
17569
17570 // wait for interactive threads
17571
17572 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17573 {
17574 hc_thread_wait (1, &i_thread);
17575 }
17576
17577 // we dont need restore file anymore
17578 if (data.restore_disable == 0)
17579 {
17580 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17581 {
17582 unlink (eff_restore_file);
17583 unlink (new_restore_file);
17584 }
17585 else
17586 {
17587 cycle_restore ();
17588 }
17589 }
17590
17591 // finally save left hashes
17592
17593 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17594 {
17595 save_hash ();
17596 }
17597
17598 /**
17599 * Clean up
17600 */
17601
17602 if (benchmark == 1)
17603 {
17604 status_benchmark ();
17605
17606 if (status_automat == 0)
17607 {
17608 log_info ("");
17609 }
17610 }
17611 else
17612 {
17613 if (quiet == 0) clear_prompt ();
17614
17615 if (quiet == 0) log_info ("");
17616
17617 if (status == 1)
17618 {
17619 status_display ();
17620 }
17621 else
17622 {
17623 if (quiet == 0) status_display ();
17624 }
17625
17626 if (quiet == 0) log_info ("");
17627 }
17628
17629 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17630 {
17631 hc_device_param_t *device_param = &data.devices_param[device_id];
17632
17633 if (device_param->skipped) continue;
17634
17635 local_free (device_param->combs_buf);
17636
17637 local_free (device_param->hooks_buf);
17638
17639 local_free (device_param->device_name);
17640
17641 local_free (device_param->device_name_chksum);
17642
17643 local_free (device_param->device_version);
17644
17645 local_free (device_param->driver_version);
17646
17647 if (device_param->pws_buf) myfree (device_param->pws_buf);
17648 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17649 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17650 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17651 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17652 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17653 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17654 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17655 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17656 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17657 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17658 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17659 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17660 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17661 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17662 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17663 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17664 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17665 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17666 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17667 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17668 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17669 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17670 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17671 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17672 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17673 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17674 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17675 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17676
17677 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17678 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17679 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17680 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17681 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17682 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17683 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17684 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17685 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17686 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17687
17688 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17689 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17690 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17691
17692 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17693 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17694 }
17695
17696 // reset default fan speed
17697
17698 #ifdef HAVE_HWMON
17699 if (gpu_temp_disable == 0)
17700 {
17701 #ifdef HAVE_ADL
17702 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17703 {
17704 hc_thread_mutex_lock (mux_adl);
17705
17706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17707 {
17708 hc_device_param_t *device_param = &data.devices_param[device_id];
17709
17710 if (device_param->skipped) continue;
17711
17712 if (data.hm_device[device_id].fan_supported == 1)
17713 {
17714 int fanspeed = temp_retain_fanspeed_value[device_id];
17715
17716 if (fanspeed == -1) continue;
17717
17718 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17719
17720 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17721 }
17722 }
17723
17724 hc_thread_mutex_unlock (mux_adl);
17725 }
17726 #endif // HAVE_ADL
17727 }
17728
17729 #ifdef HAVE_ADL
17730 // reset power tuning
17731
17732 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17733 {
17734 hc_thread_mutex_lock (mux_adl);
17735
17736 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17737 {
17738 hc_device_param_t *device_param = &data.devices_param[device_id];
17739
17740 if (device_param->skipped) continue;
17741
17742 if (data.hm_device[device_id].od_version == 6)
17743 {
17744 // check powertune capabilities first, if not available then skip device
17745
17746 int powertune_supported = 0;
17747
17748 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17749 {
17750 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17751
17752 return (-1);
17753 }
17754
17755 if (powertune_supported != 0)
17756 {
17757 // powercontrol settings
17758
17759 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)
17760 {
17761 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17762
17763 return (-1);
17764 }
17765
17766 // clocks
17767
17768 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17769
17770 performance_state->iNumberOfPerformanceLevels = 2;
17771
17772 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17773 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17774 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17775 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17776
17777 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)
17778 {
17779 log_info ("ERROR: Failed to restore ADL performance state");
17780
17781 return (-1);
17782 }
17783
17784 local_free (performance_state);
17785 }
17786 }
17787 }
17788
17789 hc_thread_mutex_unlock (mux_adl);
17790 }
17791 #endif // HAVE_ADL
17792
17793 if (gpu_temp_disable == 0)
17794 {
17795 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17796 if (data.hm_nv)
17797 {
17798 #if defined(LINUX) && defined(HAVE_NVML)
17799
17800 hm_NVML_nvmlShutdown (data.hm_nv);
17801
17802 nvml_close (data.hm_nv);
17803
17804 #elif defined(WIN) && (HAVE_NVAPI)
17805
17806 hm_NvAPI_Unload (data.hm_nv);
17807
17808 nvapi_close (data.hm_nv);
17809
17810 #endif
17811
17812 data.hm_nv = NULL;
17813 }
17814 #endif
17815
17816 #ifdef HAVE_ADL
17817 if (data.hm_amd)
17818 {
17819 hm_ADL_Main_Control_Destroy (data.hm_amd);
17820
17821 adl_close (data.hm_amd);
17822 data.hm_amd = NULL;
17823 }
17824 #endif
17825 }
17826 #endif // HAVE_HWMON
17827
17828 // free memory
17829
17830 local_free (masks);
17831
17832 local_free (dictstat_base);
17833
17834 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17835 {
17836 pot_t *pot_ptr = &pot[pot_pos];
17837
17838 hash_t *hash = &pot_ptr->hash;
17839
17840 local_free (hash->digest);
17841
17842 if (isSalted)
17843 {
17844 local_free (hash->salt);
17845 }
17846 }
17847
17848 local_free (pot);
17849
17850 local_free (all_kernel_rules_cnt);
17851 local_free (all_kernel_rules_buf);
17852
17853 local_free (wl_data->buf);
17854 local_free (wl_data);
17855
17856 local_free (bitmap_s1_a);
17857 local_free (bitmap_s1_b);
17858 local_free (bitmap_s1_c);
17859 local_free (bitmap_s1_d);
17860 local_free (bitmap_s2_a);
17861 local_free (bitmap_s2_b);
17862 local_free (bitmap_s2_c);
17863 local_free (bitmap_s2_d);
17864
17865 #ifdef HAVE_HWMON
17866 local_free (temp_retain_fanspeed_value);
17867 #ifdef HAVE_ADL
17868 local_free (od_clock_mem_status);
17869 local_free (od_power_control_status);
17870 #endif // ADL
17871 #endif
17872
17873 global_free (devices_param);
17874
17875 global_free (kernel_rules_buf);
17876
17877 global_free (root_css_buf);
17878 global_free (markov_css_buf);
17879
17880 global_free (digests_buf);
17881 global_free (digests_shown);
17882 global_free (digests_shown_tmp);
17883
17884 global_free (salts_buf);
17885 global_free (salts_shown);
17886
17887 global_free (esalts_buf);
17888
17889 global_free (words_progress_done);
17890 global_free (words_progress_rejected);
17891 global_free (words_progress_restored);
17892
17893 if (pot_fp) fclose (pot_fp);
17894
17895 if (data.devices_status == STATUS_QUIT) break;
17896 }
17897
17898 // destroy others mutex
17899
17900 hc_thread_mutex_delete (mux_dispatcher);
17901 hc_thread_mutex_delete (mux_counter);
17902 hc_thread_mutex_delete (mux_display);
17903 hc_thread_mutex_delete (mux_adl);
17904
17905 // free memory
17906
17907 local_free (eff_restore_file);
17908 local_free (new_restore_file);
17909
17910 local_free (rd);
17911
17912 // tuning db
17913
17914 tuning_db_destroy (tuning_db);
17915
17916 // loopback
17917
17918 local_free (loopback_file);
17919
17920 if (loopback == 1) unlink (loopback_file);
17921
17922 // induction directory
17923
17924 if (induction_dir == NULL)
17925 {
17926 if (attack_mode != ATTACK_MODE_BF)
17927 {
17928 if (rmdir (induction_directory) == -1)
17929 {
17930 if (errno == ENOENT)
17931 {
17932 // good, we can ignore
17933 }
17934 else if (errno == ENOTEMPTY)
17935 {
17936 // good, we can ignore
17937 }
17938 else
17939 {
17940 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17941
17942 return (-1);
17943 }
17944 }
17945
17946 local_free (induction_directory);
17947 }
17948 }
17949
17950 // outfile-check directory
17951
17952 if (outfile_check_dir == NULL)
17953 {
17954 if (rmdir (outfile_check_directory) == -1)
17955 {
17956 if (errno == ENOENT)
17957 {
17958 // good, we can ignore
17959 }
17960 else if (errno == ENOTEMPTY)
17961 {
17962 // good, we can ignore
17963 }
17964 else
17965 {
17966 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17967
17968 return (-1);
17969 }
17970 }
17971
17972 local_free (outfile_check_directory);
17973 }
17974
17975 time_t proc_stop;
17976
17977 time (&proc_stop);
17978
17979 logfile_top_uint (proc_start);
17980 logfile_top_uint (proc_stop);
17981
17982 logfile_top_msg ("STOP");
17983
17984 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17985 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17986
17987 if (data.ocl) ocl_close (data.ocl);
17988
17989 if (data.devices_status == STATUS_ABORTED) return 2;
17990 if (data.devices_status == STATUS_QUIT) return 2;
17991 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17992 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17993 if (data.devices_status == STATUS_CRACKED) return 0;
17994
17995 return -1;
17996 }
Hashcat additions to support pwdhash