projects / hashcat.git / blob
? search:


e84991d899d8f542be969640a046fdbfafaa8f05
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->device_vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->device_vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2613 {
2614 int rc = -1;
2615
2616 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2617 {
2618 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2619
2620 const cl_uchar zero = 0;
2621
2622 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2623 }
2624
2625 if (rc != 0)
2626 {
2627 // NOTE: clEnqueueFillBuffer () always fails with -59
2628 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2629 // How's that possible, OpenCL 1.2 support is advertised??
2630 // We need to workaround...
2631
2632 #define FILLSZ 0x100000
2633
2634 char *tmp = (char *) mymalloc (FILLSZ);
2635
2636 for (size_t i = 0; i < size; i += FILLSZ)
2637 {
2638 const size_t left = size - i;
2639
2640 const size_t fillsz = MIN (FILLSZ, left);
2641
2642 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2643 }
2644
2645 myfree (tmp);
2646 }
2647 }
2648
2649 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2650 {
2651 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2652 {
2653 if (attack_mode == ATTACK_MODE_BF)
2654 {
2655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2656 {
2657 const uint size_tm = 32 * sizeof (bs_word_t);
2658
2659 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2660
2661 run_kernel_tm (device_param);
2662
2663 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2664 }
2665 }
2666
2667 if (highest_pw_len < 16)
2668 {
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2670 }
2671 else if (highest_pw_len < 32)
2672 {
2673 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2674 }
2675 else
2676 {
2677 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2678 }
2679 }
2680 else
2681 {
2682 run_kernel_amp (device_param, pws_cnt);
2683
2684 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2685
2686 if (opts_type & OPTS_TYPE_HOOK12)
2687 {
2688 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2689 }
2690
2691 uint iter = salt_buf->salt_iter;
2692
2693 uint loop_step = device_param->kernel_loops;
2694
2695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2696 {
2697 uint loop_left = iter - loop_pos;
2698
2699 loop_left = MIN (loop_left, loop_step);
2700
2701 device_param->kernel_params_buf32[25] = loop_pos;
2702 device_param->kernel_params_buf32[26] = loop_left;
2703
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705
2706 if (data.devices_status == STATUS_CRACKED) break;
2707 if (data.devices_status == STATUS_ABORTED) break;
2708 if (data.devices_status == STATUS_QUIT) break;
2709
2710 /**
2711 * speed
2712 */
2713
2714 const float iter_part = (float) (loop_pos + loop_left) / iter;
2715
2716 const u64 perf_sum_all = pws_cnt * iter_part;
2717
2718 double speed_ms;
2719
2720 hc_timer_get (device_param->timer_speed, speed_ms);
2721
2722 const u32 speed_pos = device_param->speed_pos;
2723
2724 device_param->speed_cnt[speed_pos] = perf_sum_all;
2725
2726 device_param->speed_ms[speed_pos] = speed_ms;
2727
2728 if (data.benchmark == 1)
2729 {
2730 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2731 }
2732 }
2733
2734 if (opts_type & OPTS_TYPE_HOOK23)
2735 {
2736 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2737
2738 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2739
2740 // do something with data
2741
2742 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2743 }
2744
2745 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2746 }
2747 }
2748
2749 static int run_rule_engine (const int rule_len, const char *rule_buf)
2750 {
2751 if (rule_len == 0)
2752 {
2753 return 0;
2754 }
2755 else if (rule_len == 1)
2756 {
2757 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2758 }
2759
2760 return 1;
2761 }
2762
2763 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2764 {
2765 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2766 {
2767 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_COMBI)
2770 {
2771 if (data.attack_mode == ATTACK_MODE_COMBI)
2772 {
2773 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2774 {
2775 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2776 {
2777 for (u32 i = 0; i < pws_cnt; i++)
2778 {
2779 const u32 pw_len = device_param->pws_buf[i].pw_len;
2780
2781 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2782
2783 ptr[pw_len] = 0x01;
2784 }
2785 }
2786 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2787 {
2788 for (u32 i = 0; i < pws_cnt; i++)
2789 {
2790 const u32 pw_len = device_param->pws_buf[i].pw_len;
2791
2792 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2793
2794 ptr[pw_len] = 0x80;
2795 }
2796 }
2797 }
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x01;
2810 }
2811 }
2812 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x80;
2821 }
2822 }
2823 }
2824
2825 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2826 }
2827 else if (data.attack_kern == ATTACK_KERN_BF)
2828 {
2829 const u64 off = device_param->words_off;
2830
2831 device_param->kernel_params_mp_l_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2834 }
2835 }
2836
2837 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2838 {
2839 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2840
2841 device_param->kernel_params_buf32[25] = 0;
2842 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2843 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2844
2845 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2846 {
2847 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2848 }
2849 else
2850 {
2851 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2852 }
2853
2854 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2855
2856 return exec_ms_prev;
2857 }
2858
2859 static void autotune (hc_device_param_t *device_param)
2860 {
2861 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2862
2863 const u32 kernel_accel_min = device_param->kernel_accel_min;
2864 const u32 kernel_accel_max = device_param->kernel_accel_max;
2865
2866 const u32 kernel_loops_min = device_param->kernel_loops_min;
2867 const u32 kernel_loops_max = device_param->kernel_loops_max;
2868
2869 u32 kernel_accel = kernel_accel_min;
2870 u32 kernel_loops = kernel_loops_min;
2871
2872 // in this case the user specified a fixed -u and -n on the commandline
2873 // no way to tune anything
2874 // but we need to run a few caching rounds
2875
2876 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2877 {
2878 try_run (device_param, kernel_accel, kernel_loops);
2879 try_run (device_param, kernel_accel, kernel_loops);
2880 try_run (device_param, kernel_accel, kernel_loops);
2881 try_run (device_param, kernel_accel, kernel_loops);
2882
2883 device_param->kernel_accel = kernel_accel;
2884 device_param->kernel_loops = kernel_loops;
2885
2886 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2887
2888 device_param->kernel_power = kernel_power;
2889
2890 return;
2891 }
2892
2893 // from here it's clear we are allowed to autotune
2894 // so let's init some fake words
2895
2896 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].i[0] = i;
2901 device_param->pws_buf[i].i[1] = 0x01234567;
2902 device_param->pws_buf[i].pw_len = 7;
2903 }
2904
2905 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2906
2907 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2908 {
2909 run_kernel_amp (device_param, kernel_power_max);
2910 }
2911
2912 #define VERIFIER_CNT 1
2913
2914 // first find out highest kernel-loops that stays below target_ms
2915
2916 if (kernel_loops_min < kernel_loops_max)
2917 {
2918 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2919 {
2920 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2921
2922 for (int i = 0; i < VERIFIER_CNT; i++)
2923 {
2924 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2925
2926 exec_ms = MIN (exec_ms, exec_ms_v);
2927 }
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931 }
2932
2933 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2934
2935 #define STEPS_CNT 10
2936
2937 if (kernel_accel_min < kernel_accel_max)
2938 {
2939 for (int i = 0; i < STEPS_CNT; i++)
2940 {
2941 const u32 kernel_accel_try = 1 << i;
2942
2943 if (kernel_accel_try < kernel_accel_min) continue;
2944 if (kernel_accel_try > kernel_accel_max) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms > target_ms) break;
2956
2957 kernel_accel = kernel_accel_try;
2958 }
2959 }
2960
2961 // at this point we want to know the actual runtime for the following reason:
2962 // we need a reference for the balancing loop following up, and this
2963 // the balancing loop can have an effect that the creates a new opportunity, for example:
2964 // if the target is 95 ms and the current runtime is 48ms the above loop
2965 // stopped the execution because the previous exec_ms was > 95ms
2966 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2967 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2968
2969 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2970
2971 for (int i = 0; i < VERIFIER_CNT; i++)
2972 {
2973 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2974
2975 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2976 }
2977
2978 u32 diff = kernel_loops - kernel_accel;
2979
2980 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2981 {
2982 u32 kernel_accel_orig = kernel_accel;
2983 u32 kernel_loops_orig = kernel_loops;
2984
2985 for (u32 f = 1; f < 1024; f++)
2986 {
2987 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
2988 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
2989
2990 if (kernel_accel_try > kernel_accel_max) break;
2991 if (kernel_loops_try < kernel_loops_min) break;
2992
2993 u32 diff_new = kernel_loops_try - kernel_accel_try;
2994
2995 if (diff_new > diff) break;
2996
2997 diff_new = diff;
2998
2999 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3000
3001 for (int i = 0; i < VERIFIER_CNT; i++)
3002 {
3003 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3004
3005 exec_ms = MIN (exec_ms, exec_ms_v);
3006 }
3007
3008 if (exec_ms < exec_ms_pre_final)
3009 {
3010 exec_ms_pre_final = exec_ms;
3011
3012 kernel_accel = kernel_accel_try;
3013 kernel_loops = kernel_loops_try;
3014 }
3015 }
3016 }
3017
3018 const double exec_left = target_ms / exec_ms_pre_final;
3019
3020 const double accel_left = kernel_accel_max / kernel_accel;
3021
3022 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3023
3024 if (exec_accel_min >= 1.0)
3025 {
3026 // this is safe to not overflow kernel_accel_max because of accel_left
3027
3028 kernel_accel = (double) kernel_accel * exec_accel_min;
3029 }
3030
3031 // reset them fake words
3032
3033 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3034
3035 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3036 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3037
3038 // reset timer
3039
3040 device_param->exec_pos = 0;
3041
3042 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3043
3044 // store
3045
3046 device_param->kernel_accel = kernel_accel;
3047 device_param->kernel_loops = kernel_loops;
3048
3049 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3050
3051 device_param->kernel_power = kernel_power;
3052
3053 #ifdef DEBUG
3054
3055 if (data.quiet == 0)
3056 {
3057 clear_prompt ();
3058
3059 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3060 "Device #%u: autotuned kernel-loops to %u\n",
3061 device_param->device_id + 1, kernel_accel,
3062 device_param->device_id + 1, kernel_loops);
3063
3064 fprintf (stdout, "%s", PROMPT);
3065
3066 fflush (stdout);
3067 }
3068
3069 #endif
3070 }
3071
3072 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3073 {
3074 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3075
3076 // init speed timer
3077
3078 uint speed_pos = device_param->speed_pos;
3079
3080 #ifdef _POSIX
3081 if (device_param->timer_speed.tv_sec == 0)
3082 {
3083 hc_timer_set (&device_param->timer_speed);
3084 }
3085 #endif
3086
3087 #ifdef _WIN
3088 if (device_param->timer_speed.QuadPart == 0)
3089 {
3090 hc_timer_set (&device_param->timer_speed);
3091 }
3092 #endif
3093
3094 // find higest password length, this is for optimization stuff
3095
3096 uint highest_pw_len = 0;
3097
3098 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3099 {
3100 }
3101 else if (data.attack_kern == ATTACK_KERN_COMBI)
3102 {
3103 }
3104 else if (data.attack_kern == ATTACK_KERN_BF)
3105 {
3106 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3107 + device_param->kernel_params_mp_l_buf32[5];
3108 }
3109
3110 // iteration type
3111
3112 uint innerloop_step = 0;
3113 uint innerloop_cnt = 0;
3114
3115 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3116 else innerloop_step = 1;
3117
3118 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3119 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3120 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3121
3122 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3123
3124 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3125 {
3126 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3127
3128 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3129
3130 if (data.devices_status == STATUS_CRACKED) break;
3131 if (data.devices_status == STATUS_ABORTED) break;
3132 if (data.devices_status == STATUS_QUIT) break;
3133 if (data.devices_status == STATUS_BYPASS) break;
3134
3135 salt_t *salt_buf = &data.salts_buf[salt_pos];
3136
3137 device_param->kernel_params_buf32[24] = salt_pos;
3138 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3139 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3140
3141 FILE *combs_fp = device_param->combs_fp;
3142
3143 if (data.attack_mode == ATTACK_MODE_COMBI)
3144 {
3145 rewind (combs_fp);
3146 }
3147
3148 // innerloops
3149
3150 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3151 {
3152 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3153
3154 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3155
3156 if (data.devices_status == STATUS_CRACKED) break;
3157 if (data.devices_status == STATUS_ABORTED) break;
3158 if (data.devices_status == STATUS_QUIT) break;
3159 if (data.devices_status == STATUS_BYPASS) break;
3160
3161 uint innerloop_left = innerloop_cnt - innerloop_pos;
3162
3163 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3164
3165 device_param->innerloop_pos = innerloop_pos;
3166 device_param->innerloop_left = innerloop_left;
3167
3168 device_param->kernel_params_buf32[27] = innerloop_left;
3169
3170 // i think we can get rid of this
3171 if (innerloop_left == 0)
3172 {
3173 puts ("bug, how should this happen????\n");
3174
3175 continue;
3176 }
3177
3178 if (data.salts_shown[salt_pos] == 1)
3179 {
3180 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3181
3182 continue;
3183 }
3184
3185 // initialize amplifiers
3186
3187 if (data.attack_mode == ATTACK_MODE_COMBI)
3188 {
3189 uint i = 0;
3190
3191 while (i < innerloop_left)
3192 {
3193 if (feof (combs_fp)) break;
3194
3195 int line_len = fgetl (combs_fp, line_buf);
3196
3197 if (line_len >= PW_MAX1) continue;
3198
3199 line_len = convert_from_hex (line_buf, line_len);
3200
3201 char *line_buf_new = line_buf;
3202
3203 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3204 {
3205 char rule_buf_out[BLOCK_SIZE] = { 0 };
3206
3207 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3208
3209 if (rule_len_out < 0)
3210 {
3211 data.words_progress_rejected[salt_pos] += pws_cnt;
3212
3213 continue;
3214 }
3215
3216 line_len = rule_len_out;
3217
3218 line_buf_new = rule_buf_out;
3219 }
3220
3221 line_len = MIN (line_len, PW_DICTMAX);
3222
3223 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3224
3225 memcpy (ptr, line_buf_new, line_len);
3226
3227 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3228
3229 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3230 {
3231 uppercase (ptr, line_len);
3232 }
3233
3234 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3235 {
3236 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3237 {
3238 ptr[line_len] = 0x80;
3239 }
3240
3241 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3242 {
3243 ptr[line_len] = 0x01;
3244 }
3245 }
3246
3247 device_param->combs_buf[i].pw_len = line_len;
3248
3249 i++;
3250 }
3251
3252 for (uint j = i; j < innerloop_left; j++)
3253 {
3254 device_param->combs_buf[j].i[0] = 0;
3255 device_param->combs_buf[j].i[1] = 0;
3256 device_param->combs_buf[j].i[2] = 0;
3257 device_param->combs_buf[j].i[3] = 0;
3258 device_param->combs_buf[j].i[4] = 0;
3259 device_param->combs_buf[j].i[5] = 0;
3260 device_param->combs_buf[j].i[6] = 0;
3261 device_param->combs_buf[j].i[7] = 0;
3262
3263 device_param->combs_buf[j].pw_len = 0;
3264 }
3265
3266 innerloop_left = i;
3267 }
3268 else if (data.attack_mode == ATTACK_MODE_BF)
3269 {
3270 u64 off = innerloop_pos;
3271
3272 device_param->kernel_params_mp_r_buf64[3] = off;
3273
3274 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3275 }
3276 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3277 {
3278 u64 off = innerloop_pos;
3279
3280 device_param->kernel_params_mp_buf64[3] = off;
3281
3282 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3285 {
3286 u64 off = innerloop_pos;
3287
3288 device_param->kernel_params_mp_buf64[3] = off;
3289
3290 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3291 }
3292
3293 // copy amplifiers
3294
3295 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3296 {
3297 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3298 }
3299 else if (data.attack_mode == ATTACK_MODE_COMBI)
3300 {
3301 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3302 }
3303 else if (data.attack_mode == ATTACK_MODE_BF)
3304 {
3305 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3306 }
3307 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3308 {
3309 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3310 }
3311 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3312 {
3313 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3314 }
3315
3316 if (data.benchmark == 1)
3317 {
3318 hc_timer_set (&device_param->timer_speed);
3319 }
3320
3321 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3322
3323 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3324
3325 if (data.devices_status == STATUS_CRACKED) break;
3326 if (data.devices_status == STATUS_ABORTED) break;
3327 if (data.devices_status == STATUS_QUIT) break;
3328
3329 /**
3330 * result
3331 */
3332
3333 check_cracked (device_param, salt_pos);
3334
3335 /**
3336 * progress
3337 */
3338
3339 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3340
3341 hc_thread_mutex_lock (mux_counter);
3342
3343 data.words_progress_done[salt_pos] += perf_sum_all;
3344
3345 hc_thread_mutex_unlock (mux_counter);
3346
3347 /**
3348 * speed
3349 */
3350
3351 double speed_ms;
3352
3353 hc_timer_get (device_param->timer_speed, speed_ms);
3354
3355 hc_timer_set (&device_param->timer_speed);
3356
3357 // current speed
3358
3359 //hc_thread_mutex_lock (mux_display);
3360
3361 device_param->speed_cnt[speed_pos] = perf_sum_all;
3362
3363 device_param->speed_ms[speed_pos] = speed_ms;
3364
3365 //hc_thread_mutex_unlock (mux_display);
3366
3367 speed_pos++;
3368
3369 if (speed_pos == SPEED_CACHE)
3370 {
3371 speed_pos = 0;
3372 }
3373
3374 /**
3375 * benchmark
3376 */
3377
3378 if (data.benchmark == 1) break;
3379 }
3380 }
3381
3382 device_param->speed_pos = speed_pos;
3383
3384 myfree (line_buf);
3385 }
3386
3387 static void load_segment (wl_data_t *wl_data, FILE *fd)
3388 {
3389 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3390
3391 wl_data->pos = 0;
3392
3393 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3394
3395 wl_data->buf[wl_data->cnt] = 0;
3396
3397 if (wl_data->cnt == 0) return;
3398
3399 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3400
3401 while (!feof (fd))
3402 {
3403 if (wl_data->cnt == wl_data->avail)
3404 {
3405 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3406
3407 wl_data->avail += wl_data->incr;
3408 }
3409
3410 const int c = fgetc (fd);
3411
3412 if (c == EOF) break;
3413
3414 wl_data->buf[wl_data->cnt] = (char) c;
3415
3416 wl_data->cnt++;
3417
3418 if (c == '\n') break;
3419 }
3420
3421 // ensure stream ends with a newline
3422
3423 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3424 {
3425 wl_data->cnt++;
3426
3427 wl_data->buf[wl_data->cnt - 1] = '\n';
3428 }
3429
3430 return;
3431 }
3432
3433 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3434 {
3435 char *ptr = buf;
3436
3437 for (u32 i = 0; i < sz; i++, ptr++)
3438 {
3439 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3440
3441 if (i == 7)
3442 {
3443 *off = i;
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 if (*ptr != '\n') continue;
3450
3451 *off = i + 1;
3452
3453 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3454
3455 *len = i;
3456
3457 return;
3458 }
3459
3460 *off = sz;
3461 *len = sz;
3462 }
3463
3464 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3465 {
3466 char *ptr = buf;
3467
3468 for (u32 i = 0; i < sz; i++, ptr++)
3469 {
3470 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3471
3472 if (*ptr != '\n') continue;
3473
3474 *off = i + 1;
3475
3476 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3477
3478 *len = i;
3479
3480 return;
3481 }
3482
3483 *off = sz;
3484 *len = sz;
3485 }
3486
3487 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3488 {
3489 char *ptr = buf;
3490
3491 for (u32 i = 0; i < sz; i++, ptr++)
3492 {
3493 if (*ptr != '\n') continue;
3494
3495 *off = i + 1;
3496
3497 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3498
3499 *len = i;
3500
3501 return;
3502 }
3503
3504 *off = sz;
3505 *len = sz;
3506 }
3507
3508 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3509 {
3510 while (wl_data->pos < wl_data->cnt)
3511 {
3512 uint off;
3513 uint len;
3514
3515 char *ptr = wl_data->buf + wl_data->pos;
3516
3517 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3518
3519 wl_data->pos += off;
3520
3521 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3522 {
3523 char rule_buf_out[BLOCK_SIZE] = { 0 };
3524
3525 int rule_len_out = -1;
3526
3527 if (len < BLOCK_SIZE)
3528 {
3529 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3530 }
3531
3532 if (rule_len_out < 0)
3533 {
3534 continue;
3535 }
3536
3537 if (rule_len_out > PW_MAX)
3538 {
3539 continue;
3540 }
3541 }
3542 else
3543 {
3544 if (len > PW_MAX)
3545 {
3546 continue;
3547 }
3548 }
3549
3550 *out_buf = ptr;
3551 *out_len = len;
3552
3553 return;
3554 }
3555
3556 if (feof (fd))
3557 {
3558 fprintf (stderr, "BUG feof()!!\n");
3559
3560 return;
3561 }
3562
3563 load_segment (wl_data, fd);
3564
3565 get_next_word (wl_data, fd, out_buf, out_len);
3566 }
3567
3568 #ifdef _POSIX
3569 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3570 #endif
3571
3572 #ifdef _WIN
3573 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3574 #endif
3575 {
3576 hc_signal (NULL);
3577
3578 dictstat_t d;
3579
3580 d.cnt = 0;
3581
3582 #ifdef _POSIX
3583 fstat (fileno (fd), &d.stat);
3584 #endif
3585
3586 #ifdef _WIN
3587 _fstat64 (fileno (fd), &d.stat);
3588 #endif
3589
3590 d.stat.st_mode = 0;
3591 d.stat.st_nlink = 0;
3592 d.stat.st_uid = 0;
3593 d.stat.st_gid = 0;
3594 d.stat.st_rdev = 0;
3595 d.stat.st_atime = 0;
3596
3597 #ifdef _POSIX
3598 d.stat.st_blksize = 0;
3599 d.stat.st_blocks = 0;
3600 #endif
3601
3602 if (d.stat.st_size == 0) return 0;
3603
3604 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3605
3606 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3607 {
3608 if (d_cache)
3609 {
3610 u64 cnt = d_cache->cnt;
3611
3612 u64 keyspace = cnt;
3613
3614 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3615 {
3616 keyspace *= data.kernel_rules_cnt;
3617 }
3618 else if (data.attack_kern == ATTACK_KERN_COMBI)
3619 {
3620 keyspace *= data.combs_cnt;
3621 }
3622
3623 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3624 if (data.quiet == 0) log_info ("");
3625
3626 hc_signal (sigHandler_default);
3627
3628 return (keyspace);
3629 }
3630 }
3631
3632 time_t now = 0;
3633 time_t prev = 0;
3634
3635 u64 comp = 0;
3636 u64 cnt = 0;
3637 u64 cnt2 = 0;
3638
3639 while (!feof (fd))
3640 {
3641 load_segment (wl_data, fd);
3642
3643 comp += wl_data->cnt;
3644
3645 u32 i = 0;
3646
3647 while (i < wl_data->cnt)
3648 {
3649 u32 len;
3650 u32 off;
3651
3652 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3653
3654 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3655 {
3656 char rule_buf_out[BLOCK_SIZE] = { 0 };
3657
3658 int rule_len_out = -1;
3659
3660 if (len < BLOCK_SIZE)
3661 {
3662 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3663 }
3664
3665 if (rule_len_out < 0)
3666 {
3667 len = PW_MAX1;
3668 }
3669 else
3670 {
3671 len = rule_len_out;
3672 }
3673 }
3674
3675 if (len < PW_MAX1)
3676 {
3677 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3678 {
3679 cnt += data.kernel_rules_cnt;
3680 }
3681 else if (data.attack_kern == ATTACK_KERN_COMBI)
3682 {
3683 cnt += data.combs_cnt;
3684 }
3685
3686 d.cnt++;
3687 }
3688
3689 i += off;
3690
3691 cnt2++;
3692 }
3693
3694 time (&now);
3695
3696 if ((now - prev) == 0) continue;
3697
3698 float percent = (float) comp / (float) d.stat.st_size;
3699
3700 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3701
3702 time (&prev);
3703 }
3704
3705 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3706 if (data.quiet == 0) log_info ("");
3707
3708 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3709
3710 hc_signal (sigHandler_default);
3711
3712 return (cnt);
3713 }
3714
3715 static void *thread_monitor (void *p)
3716 {
3717 uint runtime_check = 0;
3718 uint remove_check = 0;
3719 uint status_check = 0;
3720 uint restore_check = 0;
3721
3722 uint restore_left = data.restore_timer;
3723 uint remove_left = data.remove_timer;
3724 uint status_left = data.status_timer;
3725
3726 #ifdef HAVE_HWMON
3727 uint hwmon_check = 0;
3728
3729 // these variables are mainly used for fan control (AMD only)
3730
3731 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 // temperature controller "loopback" values
3734
3735 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3736 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3737
3738 #ifdef HAVE_ADL
3739 int temp_threshold = 1; // degrees celcius
3740
3741 int fan_speed_min = 15; // in percentage
3742 int fan_speed_max = 100;
3743 #endif // HAVE_ADL
3744
3745 time_t last_temp_check_time;
3746 #endif // HAVE_HWMON
3747
3748 uint sleep_time = 1;
3749
3750 if (data.runtime)
3751 {
3752 runtime_check = 1;
3753 }
3754
3755 if (data.restore_timer)
3756 {
3757 restore_check = 1;
3758 }
3759
3760 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3761 {
3762 remove_check = 1;
3763 }
3764
3765 if (data.status == 1)
3766 {
3767 status_check = 1;
3768 }
3769
3770 #ifdef HAVE_HWMON
3771 if (data.gpu_temp_disable == 0)
3772 {
3773 time (&last_temp_check_time);
3774
3775 hwmon_check = 1;
3776 }
3777 #endif
3778
3779 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3780 {
3781 #ifdef HAVE_HWMON
3782 if (hwmon_check == 0)
3783 #endif
3784 return (p);
3785 }
3786
3787 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3788 {
3789 hc_sleep (sleep_time);
3790
3791 if (data.devices_status != STATUS_RUNNING) continue;
3792
3793 #ifdef HAVE_HWMON
3794 if (hwmon_check == 1)
3795 {
3796 hc_thread_mutex_lock (mux_adl);
3797
3798 time_t temp_check_time;
3799
3800 time (&temp_check_time);
3801
3802 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3803
3804 if (Ta == 0) Ta = 1;
3805
3806 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3807 {
3808 hc_device_param_t *device_param = &data.devices_param[device_id];
3809
3810 if (device_param->skipped) continue;
3811
3812 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3813
3814 const int temperature = hm_get_temperature_with_device_id (device_id);
3815
3816 if (temperature > (int) data.gpu_temp_abort)
3817 {
3818 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3819
3820 if (data.devices_status != STATUS_QUIT) myabort ();
3821
3822 break;
3823 }
3824
3825 #ifdef HAVE_ADL
3826 const int gpu_temp_retain = data.gpu_temp_retain;
3827
3828 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3829 {
3830 if (data.hm_device[device_id].fan_supported == 1)
3831 {
3832 int temp_cur = temperature;
3833
3834 int temp_diff_new = gpu_temp_retain - temp_cur;
3835
3836 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3837
3838 // calculate Ta value (time difference in seconds between the last check and this check)
3839
3840 last_temp_check_time = temp_check_time;
3841
3842 float Kp = 1.8;
3843 float Ki = 0.005;
3844 float Kd = 6;
3845
3846 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3847
3848 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3849
3850 if (abs (fan_diff_required) >= temp_threshold)
3851 {
3852 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3853
3854 int fan_speed_level = fan_speed_cur;
3855
3856 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3857
3858 int fan_speed_new = fan_speed_level - fan_diff_required;
3859
3860 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3861 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3862
3863 if (fan_speed_new != fan_speed_cur)
3864 {
3865 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3866 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3867
3868 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3869 {
3870 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3871
3872 fan_speed_chgd[device_id] = 1;
3873 }
3874
3875 temp_diff_old[device_id] = temp_diff_new;
3876 }
3877 }
3878 }
3879 }
3880 #endif // HAVE_ADL
3881 }
3882
3883 hc_thread_mutex_unlock (mux_adl);
3884 }
3885 #endif // HAVE_HWMON
3886
3887 if (restore_check == 1)
3888 {
3889 restore_left--;
3890
3891 if (restore_left == 0)
3892 {
3893 if (data.restore_disable == 0) cycle_restore ();
3894
3895 restore_left = data.restore_timer;
3896 }
3897 }
3898
3899 if ((runtime_check == 1) && (data.runtime_start > 0))
3900 {
3901 time_t runtime_cur;
3902
3903 time (&runtime_cur);
3904
3905 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3906
3907 if (runtime_left <= 0)
3908 {
3909 if (data.benchmark == 0)
3910 {
3911 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3912 }
3913
3914 if (data.devices_status != STATUS_QUIT) myabort ();
3915 }
3916 }
3917
3918 if (remove_check == 1)
3919 {
3920 remove_left--;
3921
3922 if (remove_left == 0)
3923 {
3924 if (data.digests_saved != data.digests_done)
3925 {
3926 data.digests_saved = data.digests_done;
3927
3928 save_hash ();
3929 }
3930
3931 remove_left = data.remove_timer;
3932 }
3933 }
3934
3935 if (status_check == 1)
3936 {
3937 status_left--;
3938
3939 if (status_left == 0)
3940 {
3941 //hc_thread_mutex_lock (mux_display);
3942
3943 if (data.quiet == 0) clear_prompt ();
3944
3945 if (data.quiet == 0) log_info ("");
3946
3947 status_display ();
3948
3949 if (data.quiet == 0) log_info ("");
3950
3951 //hc_thread_mutex_unlock (mux_display);
3952
3953 status_left = data.status_timer;
3954 }
3955 }
3956 }
3957
3958 #ifdef HAVE_HWMON
3959 myfree (fan_speed_chgd);
3960
3961 myfree (temp_diff_old);
3962 myfree (temp_diff_sum);
3963 #endif
3964
3965 p = NULL;
3966
3967 return (p);
3968 }
3969
3970 static void *thread_outfile_remove (void *p)
3971 {
3972 // some hash-dependent constants
3973 char *outfile_dir = data.outfile_check_directory;
3974 uint dgst_size = data.dgst_size;
3975 uint isSalted = data.isSalted;
3976 uint esalt_size = data.esalt_size;
3977 uint hash_mode = data.hash_mode;
3978
3979 uint outfile_check_timer = data.outfile_check_timer;
3980
3981 char separator = data.separator;
3982
3983 // some hash-dependent functions
3984 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3985 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3986
3987 // buffers
3988 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3989
3990 hash_buf.digest = mymalloc (dgst_size);
3991
3992 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3993
3994 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3995
3996 uint digest_buf[64] = { 0 };
3997
3998 outfile_data_t *out_info = NULL;
3999
4000 char **out_files = NULL;
4001
4002 time_t folder_mtime = 0;
4003
4004 int out_cnt = 0;
4005
4006 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4007
4008 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4009 {
4010 hc_sleep (1);
4011
4012 if (data.devices_status != STATUS_RUNNING) continue;
4013
4014 check_left--;
4015
4016 if (check_left == 0)
4017 {
4018 struct stat outfile_check_stat;
4019
4020 if (stat (outfile_dir, &outfile_check_stat) == 0)
4021 {
4022 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4023
4024 if (is_dir == 1)
4025 {
4026 if (outfile_check_stat.st_mtime > folder_mtime)
4027 {
4028 char **out_files_new = scan_directory (outfile_dir);
4029
4030 int out_cnt_new = count_dictionaries (out_files_new);
4031
4032 outfile_data_t *out_info_new = NULL;
4033
4034 if (out_cnt_new > 0)
4035 {
4036 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4037
4038 for (int i = 0; i < out_cnt_new; i++)
4039 {
4040 out_info_new[i].file_name = out_files_new[i];
4041
4042 // check if there are files that we have seen/checked before (and not changed)
4043
4044 for (int j = 0; j < out_cnt; j++)
4045 {
4046 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4047 {
4048 struct stat outfile_stat;
4049
4050 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4051 {
4052 if (outfile_stat.st_ctime == out_info[j].ctime)
4053 {
4054 out_info_new[i].ctime = out_info[j].ctime;
4055 out_info_new[i].seek = out_info[j].seek;
4056 }
4057 }
4058 }
4059 }
4060 }
4061 }
4062
4063 local_free (out_info);
4064 local_free (out_files);
4065
4066 out_files = out_files_new;
4067 out_cnt = out_cnt_new;
4068 out_info = out_info_new;
4069
4070 folder_mtime = outfile_check_stat.st_mtime;
4071 }
4072
4073 for (int j = 0; j < out_cnt; j++)
4074 {
4075 FILE *fp = fopen (out_info[j].file_name, "rb");
4076
4077 if (fp != NULL)
4078 {
4079 //hc_thread_mutex_lock (mux_display);
4080
4081 #ifdef _POSIX
4082 struct stat outfile_stat;
4083
4084 fstat (fileno (fp), &outfile_stat);
4085 #endif
4086
4087 #ifdef _WIN
4088 struct stat64 outfile_stat;
4089
4090 _fstat64 (fileno (fp), &outfile_stat);
4091 #endif
4092
4093 if (outfile_stat.st_ctime > out_info[j].ctime)
4094 {
4095 out_info[j].ctime = outfile_stat.st_ctime;
4096 out_info[j].seek = 0;
4097 }
4098
4099 fseek (fp, out_info[j].seek, SEEK_SET);
4100
4101 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4102
4103 while (!feof (fp))
4104 {
4105 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4106
4107 if (ptr == NULL) break;
4108
4109 int line_len = strlen (line_buf);
4110
4111 if (line_len <= 0) continue;
4112
4113 int iter = MAX_CUT_TRIES;
4114
4115 for (uint i = line_len - 1; i && iter; i--, line_len--)
4116 {
4117 if (line_buf[i] != separator) continue;
4118
4119 int parser_status = PARSER_OK;
4120
4121 if ((hash_mode != 2500) && (hash_mode != 6800))
4122 {
4123 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4124 }
4125
4126 uint found = 0;
4127
4128 if (parser_status == PARSER_OK)
4129 {
4130 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4131 {
4132 if (data.salts_shown[salt_pos] == 1) continue;
4133
4134 salt_t *salt_buf = &data.salts_buf[salt_pos];
4135
4136 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4137 {
4138 uint idx = salt_buf->digests_offset + digest_pos;
4139
4140 if (data.digests_shown[idx] == 1) continue;
4141
4142 uint cracked = 0;
4143
4144 if (hash_mode == 6800)
4145 {
4146 if (i == salt_buf->salt_len)
4147 {
4148 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4149 }
4150 }
4151 else if (hash_mode == 2500)
4152 {
4153 // BSSID : MAC1 : MAC2 (:plain)
4154 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4155 {
4156 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4157
4158 if (!cracked) continue;
4159
4160 // now compare MAC1 and MAC2 too, since we have this additional info
4161 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4162 char *mac2_pos = mac1_pos + 12 + 1;
4163
4164 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4165 wpa_t *wpa = &wpas[salt_pos];
4166
4167 // compare hex string(s) vs binary MAC address(es)
4168
4169 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4170 {
4171 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4172 {
4173 cracked = 0;
4174
4175 break;
4176 }
4177 }
4178
4179 // early skip ;)
4180 if (!cracked) continue;
4181
4182 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4183 {
4184 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4185 {
4186 cracked = 0;
4187
4188 break;
4189 }
4190 }
4191 }
4192 }
4193 else
4194 {
4195 char *digests_buf_ptr = (char *) data.digests_buf;
4196
4197 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4198
4199 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4200 }
4201
4202 if (cracked == 1)
4203 {
4204 found = 1;
4205
4206 data.digests_shown[idx] = 1;
4207
4208 data.digests_done++;
4209
4210 salt_buf->digests_done++;
4211
4212 if (salt_buf->digests_done == salt_buf->digests_cnt)
4213 {
4214 data.salts_shown[salt_pos] = 1;
4215
4216 data.salts_done++;
4217
4218 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4219 }
4220 }
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225 }
4226
4227 if (found) break;
4228
4229 if (data.devices_status == STATUS_CRACKED) break;
4230
4231 iter--;
4232 }
4233
4234 if (data.devices_status == STATUS_CRACKED) break;
4235 }
4236
4237 myfree (line_buf);
4238
4239 out_info[j].seek = ftell (fp);
4240
4241 //hc_thread_mutex_unlock (mux_display);
4242
4243 fclose (fp);
4244 }
4245 }
4246 }
4247 }
4248
4249 check_left = outfile_check_timer;
4250 }
4251 }
4252
4253 if (esalt_size) local_free (hash_buf.esalt);
4254
4255 if (isSalted) local_free (hash_buf.salt);
4256
4257 local_free (hash_buf.digest);
4258
4259 local_free (out_info);
4260
4261 local_free (out_files);
4262
4263 p = NULL;
4264
4265 return (p);
4266 }
4267
4268 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4269 {
4270 if (device_param->pws_cnt < device_param->kernel_power)
4271 {
4272 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4273
4274 u8 *ptr = (u8 *) pw->i;
4275
4276 memcpy (ptr, pw_buf, pw_len);
4277
4278 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4279
4280 pw->pw_len = pw_len;
4281
4282 device_param->pws_cnt++;
4283 }
4284 else
4285 {
4286 fprintf (stderr, "BUG pw_add()!!\n");
4287
4288 return;
4289 }
4290 }
4291
4292 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4293 {
4294 hc_thread_mutex_lock (mux_dispatcher);
4295
4296 const u64 words_cur = data.words_cur;
4297 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4298
4299 device_param->words_off = words_cur;
4300
4301 const u64 words_left = words_base - words_cur;
4302
4303 if (allow_div)
4304 {
4305 if (data.kernel_power_all > words_left)
4306 {
4307 if (data.kernel_power_div == 0)
4308 {
4309 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4310 }
4311 }
4312
4313 if (data.kernel_power_div)
4314 {
4315 if (device_param->kernel_power == device_param->kernel_power_user)
4316 {
4317 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4318
4319 if (kernel_power_new < device_param->kernel_power)
4320 {
4321 device_param->kernel_power = kernel_power_new;
4322 }
4323 }
4324 }
4325 }
4326
4327 const uint kernel_power = device_param->kernel_power;
4328
4329 uint work = MIN (words_left, kernel_power);
4330
4331 work = MIN (work, max);
4332
4333 data.words_cur += work;
4334
4335 hc_thread_mutex_unlock (mux_dispatcher);
4336
4337 return work;
4338 }
4339
4340 static void *thread_calc_stdin (void *p)
4341 {
4342 hc_device_param_t *device_param = (hc_device_param_t *) p;
4343
4344 if (device_param->skipped) return NULL;
4345
4346 autotune (device_param);
4347
4348 char *buf = (char *) mymalloc (HCBUFSIZ);
4349
4350 const uint attack_kern = data.attack_kern;
4351
4352 const uint kernel_power = device_param->kernel_power;
4353
4354 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4355 {
4356 hc_thread_mutex_lock (mux_dispatcher);
4357
4358 if (feof (stdin) != 0)
4359 {
4360 hc_thread_mutex_unlock (mux_dispatcher);
4361
4362 break;
4363 }
4364
4365 uint words_cur = 0;
4366
4367 while (words_cur < kernel_power)
4368 {
4369 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4370
4371 if (line_buf == NULL) break;
4372
4373 uint line_len = in_superchop (line_buf);
4374
4375 line_len = convert_from_hex (line_buf, line_len);
4376
4377 // post-process rule engine
4378
4379 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4380 {
4381 char rule_buf_out[BLOCK_SIZE] = { 0 };
4382
4383 int rule_len_out = -1;
4384
4385 if (line_len < BLOCK_SIZE)
4386 {
4387 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4388 }
4389
4390 if (rule_len_out < 0) continue;
4391
4392 line_buf = rule_buf_out;
4393 line_len = rule_len_out;
4394 }
4395
4396 if (line_len > PW_MAX)
4397 {
4398 continue;
4399 }
4400
4401 if (attack_kern == ATTACK_KERN_STRAIGHT)
4402 {
4403 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4404 {
4405 hc_thread_mutex_lock (mux_counter);
4406
4407 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4408 {
4409 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4410 }
4411
4412 hc_thread_mutex_unlock (mux_counter);
4413
4414 continue;
4415 }
4416 }
4417 else if (attack_kern == ATTACK_KERN_COMBI)
4418 {
4419 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4420 // since we still need to combine the plains
4421
4422 if (line_len > data.pw_max)
4423 {
4424 hc_thread_mutex_lock (mux_counter);
4425
4426 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4427 {
4428 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4429 }
4430
4431 hc_thread_mutex_unlock (mux_counter);
4432
4433 continue;
4434 }
4435 }
4436
4437 pw_add (device_param, (u8 *) line_buf, line_len);
4438
4439 words_cur++;
4440
4441 if (data.devices_status == STATUS_CRACKED) break;
4442 if (data.devices_status == STATUS_ABORTED) break;
4443 if (data.devices_status == STATUS_QUIT) break;
4444 if (data.devices_status == STATUS_BYPASS) break;
4445 }
4446
4447 hc_thread_mutex_unlock (mux_dispatcher);
4448
4449 if (data.devices_status == STATUS_CRACKED) break;
4450 if (data.devices_status == STATUS_ABORTED) break;
4451 if (data.devices_status == STATUS_QUIT) break;
4452 if (data.devices_status == STATUS_BYPASS) break;
4453
4454 // flush
4455
4456 const uint pws_cnt = device_param->pws_cnt;
4457
4458 if (pws_cnt)
4459 {
4460 run_copy (device_param, pws_cnt);
4461
4462 run_cracker (device_param, pws_cnt);
4463
4464 device_param->pws_cnt = 0;
4465
4466 /*
4467 still required?
4468 if (attack_kern == ATTACK_KERN_STRAIGHT)
4469 {
4470 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4471 }
4472 else if (attack_kern == ATTACK_KERN_COMBI)
4473 {
4474 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4475 }
4476 */
4477 }
4478 }
4479
4480 device_param->kernel_accel = 0;
4481 device_param->kernel_loops = 0;
4482
4483 myfree (buf);
4484
4485 return NULL;
4486 }
4487
4488 static void *thread_calc (void *p)
4489 {
4490 hc_device_param_t *device_param = (hc_device_param_t *) p;
4491
4492 if (device_param->skipped) return NULL;
4493
4494 autotune (device_param);
4495
4496 const uint attack_mode = data.attack_mode;
4497 const uint attack_kern = data.attack_kern;
4498
4499 if (attack_mode == ATTACK_MODE_BF)
4500 {
4501 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4502 {
4503 const uint work = get_work (device_param, -1, true);
4504
4505 if (work == 0) break;
4506
4507 const u64 words_off = device_param->words_off;
4508 const u64 words_fin = words_off + work;
4509
4510 const uint pws_cnt = work;
4511
4512 device_param->pws_cnt = pws_cnt;
4513
4514 if (pws_cnt)
4515 {
4516 run_copy (device_param, pws_cnt);
4517
4518 run_cracker (device_param, pws_cnt);
4519
4520 device_param->pws_cnt = 0;
4521
4522 /*
4523 still required?
4524 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4525 */
4526 }
4527
4528 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4529
4530 if (data.devices_status == STATUS_CRACKED) break;
4531 if (data.devices_status == STATUS_ABORTED) break;
4532 if (data.devices_status == STATUS_QUIT) break;
4533 if (data.devices_status == STATUS_BYPASS) break;
4534
4535 if (data.benchmark == 1) break;
4536
4537 device_param->words_done = words_fin;
4538 }
4539 }
4540 else
4541 {
4542 const uint segment_size = data.segment_size;
4543
4544 char *dictfile = data.dictfile;
4545
4546 if (attack_mode == ATTACK_MODE_COMBI)
4547 {
4548 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4549 {
4550 dictfile = data.dictfile2;
4551 }
4552 }
4553
4554 FILE *fd = fopen (dictfile, "rb");
4555
4556 if (fd == NULL)
4557 {
4558 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4559
4560 return NULL;
4561 }
4562
4563 if (attack_mode == ATTACK_MODE_COMBI)
4564 {
4565 const uint combs_mode = data.combs_mode;
4566
4567 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4568 {
4569 const char *dictfilec = data.dictfile2;
4570
4571 FILE *combs_fp = fopen (dictfilec, "rb");
4572
4573 if (combs_fp == NULL)
4574 {
4575 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4576
4577 fclose (fd);
4578
4579 return NULL;
4580 }
4581
4582 device_param->combs_fp = combs_fp;
4583 }
4584 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4585 {
4586 const char *dictfilec = data.dictfile;
4587
4588 FILE *combs_fp = fopen (dictfilec, "rb");
4589
4590 if (combs_fp == NULL)
4591 {
4592 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4593
4594 fclose (fd);
4595
4596 return NULL;
4597 }
4598
4599 device_param->combs_fp = combs_fp;
4600 }
4601 }
4602
4603 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4604
4605 wl_data->buf = (char *) mymalloc (segment_size);
4606 wl_data->avail = segment_size;
4607 wl_data->incr = segment_size;
4608 wl_data->cnt = 0;
4609 wl_data->pos = 0;
4610
4611 u64 words_cur = 0;
4612
4613 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4614 {
4615 u64 words_off = 0;
4616 u64 words_fin = 0;
4617
4618 bool allow_div = true;
4619
4620 u64 max = -1;
4621
4622 while (max)
4623 {
4624 const uint work = get_work (device_param, max, allow_div);
4625
4626 allow_div = false;
4627
4628 if (work == 0) break;
4629
4630 words_off = device_param->words_off;
4631 words_fin = words_off + work;
4632
4633 char *line_buf;
4634 uint line_len;
4635
4636 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4637
4638 max = 0;
4639
4640 for ( ; words_cur < words_fin; words_cur++)
4641 {
4642 get_next_word (wl_data, fd, &line_buf, &line_len);
4643
4644 line_len = convert_from_hex (line_buf, line_len);
4645
4646 // post-process rule engine
4647
4648 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4649 {
4650 char rule_buf_out[BLOCK_SIZE] = { 0 };
4651
4652 int rule_len_out = -1;
4653
4654 if (line_len < BLOCK_SIZE)
4655 {
4656 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4657 }
4658
4659 if (rule_len_out < 0) continue;
4660
4661 line_buf = rule_buf_out;
4662 line_len = rule_len_out;
4663 }
4664
4665 if (attack_kern == ATTACK_KERN_STRAIGHT)
4666 {
4667 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4668 {
4669 max++;
4670
4671 hc_thread_mutex_lock (mux_counter);
4672
4673 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4674 {
4675 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4676 }
4677
4678 hc_thread_mutex_unlock (mux_counter);
4679
4680 continue;
4681 }
4682 }
4683 else if (attack_kern == ATTACK_KERN_COMBI)
4684 {
4685 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4686 // since we still need to combine the plains
4687
4688 if (line_len > data.pw_max)
4689 {
4690 max++;
4691
4692 hc_thread_mutex_lock (mux_counter);
4693
4694 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4695 {
4696 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4697 }
4698
4699 hc_thread_mutex_unlock (mux_counter);
4700
4701 continue;
4702 }
4703 }
4704
4705 pw_add (device_param, (u8 *) line_buf, line_len);
4706
4707 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4708
4709 if (data.devices_status == STATUS_CRACKED) break;
4710 if (data.devices_status == STATUS_ABORTED) break;
4711 if (data.devices_status == STATUS_QUIT) break;
4712 if (data.devices_status == STATUS_BYPASS) break;
4713 }
4714
4715 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4716
4717 if (data.devices_status == STATUS_CRACKED) break;
4718 if (data.devices_status == STATUS_ABORTED) break;
4719 if (data.devices_status == STATUS_QUIT) break;
4720 if (data.devices_status == STATUS_BYPASS) break;
4721 }
4722
4723 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4724
4725 if (data.devices_status == STATUS_CRACKED) break;
4726 if (data.devices_status == STATUS_ABORTED) break;
4727 if (data.devices_status == STATUS_QUIT) break;
4728 if (data.devices_status == STATUS_BYPASS) break;
4729
4730 //
4731 // flush
4732 //
4733
4734 const uint pws_cnt = device_param->pws_cnt;
4735
4736 if (pws_cnt)
4737 {
4738 run_copy (device_param, pws_cnt);
4739
4740 run_cracker (device_param, pws_cnt);
4741
4742 device_param->pws_cnt = 0;
4743
4744 /*
4745 still required?
4746 if (attack_kern == ATTACK_KERN_STRAIGHT)
4747 {
4748 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4749 }
4750 else if (attack_kern == ATTACK_KERN_COMBI)
4751 {
4752 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4753 }
4754 */
4755 }
4756
4757 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4758
4759 if (data.devices_status == STATUS_CRACKED) break;
4760 if (data.devices_status == STATUS_ABORTED) break;
4761 if (data.devices_status == STATUS_QUIT) break;
4762 if (data.devices_status == STATUS_BYPASS) break;
4763
4764 if (words_fin == 0) break;
4765
4766 device_param->words_done = words_fin;
4767 }
4768
4769 if (attack_mode == ATTACK_MODE_COMBI)
4770 {
4771 fclose (device_param->combs_fp);
4772 }
4773
4774 free (wl_data->buf);
4775 free (wl_data);
4776
4777 fclose (fd);
4778 }
4779
4780 device_param->kernel_accel = 0;
4781 device_param->kernel_loops = 0;
4782
4783 return NULL;
4784 }
4785
4786 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4787 {
4788 if (!device_param)
4789 {
4790 log_error ("ERROR: %s : Invalid argument", __func__);
4791
4792 exit (-1);
4793 }
4794
4795 salt_t *salt_buf = &data.salts_buf[salt_pos];
4796
4797 device_param->kernel_params_buf32[24] = salt_pos;
4798 device_param->kernel_params_buf32[27] = 1;
4799 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4800 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4801 device_param->kernel_params_buf32[30] = 0;
4802 device_param->kernel_params_buf32[31] = 1;
4803
4804 char *dictfile_old = data.dictfile;
4805
4806 const char *weak_hash_check = "weak-hash-check";
4807
4808 data.dictfile = (char *) weak_hash_check;
4809
4810 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4811
4812 data.kernel_rules_buf[0].cmds[0] = 0;
4813
4814 /**
4815 * run the kernel
4816 */
4817
4818 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4819 {
4820 run_kernel (KERN_RUN_1, device_param, 1, false);
4821 }
4822 else
4823 {
4824 run_kernel (KERN_RUN_1, device_param, 1, false);
4825
4826 uint loop_step = 16;
4827
4828 const uint iter = salt_buf->salt_iter;
4829
4830 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4831 {
4832 uint loop_left = iter - loop_pos;
4833
4834 loop_left = MIN (loop_left, loop_step);
4835
4836 device_param->kernel_params_buf32[25] = loop_pos;
4837 device_param->kernel_params_buf32[26] = loop_left;
4838
4839 run_kernel (KERN_RUN_2, device_param, 1, false);
4840 }
4841
4842 run_kernel (KERN_RUN_3, device_param, 1, false);
4843 }
4844
4845 /**
4846 * result
4847 */
4848
4849 check_cracked (device_param, salt_pos);
4850
4851 /**
4852 * cleanup
4853 */
4854
4855 device_param->kernel_params_buf32[24] = 0;
4856 device_param->kernel_params_buf32[25] = 0;
4857 device_param->kernel_params_buf32[26] = 0;
4858 device_param->kernel_params_buf32[27] = 0;
4859 device_param->kernel_params_buf32[28] = 0;
4860 device_param->kernel_params_buf32[29] = 0;
4861 device_param->kernel_params_buf32[30] = 0;
4862 device_param->kernel_params_buf32[31] = 0;
4863
4864 data.dictfile = dictfile_old;
4865
4866 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4867 }
4868
4869 // hlfmt hashcat
4870
4871 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4872 {
4873 if (data.username == 0)
4874 {
4875 *hashbuf_pos = line_buf;
4876 *hashbuf_len = line_len;
4877 }
4878 else
4879 {
4880 char *pos = line_buf;
4881 int len = line_len;
4882
4883 for (int i = 0; i < line_len; i++, pos++, len--)
4884 {
4885 if (line_buf[i] == data.separator)
4886 {
4887 pos++;
4888
4889 len--;
4890
4891 break;
4892 }
4893 }
4894
4895 *hashbuf_pos = pos;
4896 *hashbuf_len = len;
4897 }
4898 }
4899
4900 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4901 {
4902 char *pos = NULL;
4903 int len = 0;
4904
4905 int sep_cnt = 0;
4906
4907 for (int i = 0; i < line_len; i++)
4908 {
4909 if (line_buf[i] == data.separator)
4910 {
4911 sep_cnt++;
4912
4913 continue;
4914 }
4915
4916 if (sep_cnt == 0)
4917 {
4918 if (pos == NULL) pos = line_buf + i;
4919
4920 len++;
4921 }
4922 }
4923
4924 *userbuf_pos = pos;
4925 *userbuf_len = len;
4926 }
4927
4928 // hlfmt pwdump
4929
4930 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4931 {
4932 int sep_cnt = 0;
4933
4934 int sep2_len = 0;
4935 int sep3_len = 0;
4936
4937 for (int i = 0; i < line_len; i++)
4938 {
4939 if (line_buf[i] == ':')
4940 {
4941 sep_cnt++;
4942
4943 continue;
4944 }
4945
4946 if (sep_cnt == 2) sep2_len++;
4947 if (sep_cnt == 3) sep3_len++;
4948 }
4949
4950 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4951
4952 return 0;
4953 }
4954
4955 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4956 {
4957 char *pos = NULL;
4958 int len = 0;
4959
4960 int sep_cnt = 0;
4961
4962 for (int i = 0; i < line_len; i++)
4963 {
4964 if (line_buf[i] == ':')
4965 {
4966 sep_cnt++;
4967
4968 continue;
4969 }
4970
4971 if (data.hash_mode == 1000)
4972 {
4973 if (sep_cnt == 3)
4974 {
4975 if (pos == NULL) pos = line_buf + i;
4976
4977 len++;
4978 }
4979 }
4980 else if (data.hash_mode == 3000)
4981 {
4982 if (sep_cnt == 2)
4983 {
4984 if (pos == NULL) pos = line_buf + i;
4985
4986 len++;
4987 }
4988 }
4989 }
4990
4991 *hashbuf_pos = pos;
4992 *hashbuf_len = len;
4993 }
4994
4995 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4996 {
4997 char *pos = NULL;
4998 int len = 0;
4999
5000 int sep_cnt = 0;
5001
5002 for (int i = 0; i < line_len; i++)
5003 {
5004 if (line_buf[i] == ':')
5005 {
5006 sep_cnt++;
5007
5008 continue;
5009 }
5010
5011 if (sep_cnt == 0)
5012 {
5013 if (pos == NULL) pos = line_buf + i;
5014
5015 len++;
5016 }
5017 }
5018
5019 *userbuf_pos = pos;
5020 *userbuf_len = len;
5021 }
5022
5023 // hlfmt passwd
5024
5025 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5026 {
5027 int sep_cnt = 0;
5028
5029 char sep5_first = 0;
5030 char sep6_first = 0;
5031
5032 for (int i = 0; i < line_len; i++)
5033 {
5034 if (line_buf[i] == ':')
5035 {
5036 sep_cnt++;
5037
5038 continue;
5039 }
5040
5041 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5042 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5043 }
5044
5045 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5046
5047 return 0;
5048 }
5049
5050 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5051 {
5052 char *pos = NULL;
5053 int len = 0;
5054
5055 int sep_cnt = 0;
5056
5057 for (int i = 0; i < line_len; i++)
5058 {
5059 if (line_buf[i] == ':')
5060 {
5061 sep_cnt++;
5062
5063 continue;
5064 }
5065
5066 if (sep_cnt == 1)
5067 {
5068 if (pos == NULL) pos = line_buf + i;
5069
5070 len++;
5071 }
5072 }
5073
5074 *hashbuf_pos = pos;
5075 *hashbuf_len = len;
5076 }
5077
5078 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5079 {
5080 char *pos = NULL;
5081 int len = 0;
5082
5083 int sep_cnt = 0;
5084
5085 for (int i = 0; i < line_len; i++)
5086 {
5087 if (line_buf[i] == ':')
5088 {
5089 sep_cnt++;
5090
5091 continue;
5092 }
5093
5094 if (sep_cnt == 0)
5095 {
5096 if (pos == NULL) pos = line_buf + i;
5097
5098 len++;
5099 }
5100 }
5101
5102 *userbuf_pos = pos;
5103 *userbuf_len = len;
5104 }
5105
5106 // hlfmt shadow
5107
5108 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5109 {
5110 int sep_cnt = 0;
5111
5112 for (int i = 0; i < line_len; i++)
5113 {
5114 if (line_buf[i] == ':') sep_cnt++;
5115 }
5116
5117 if (sep_cnt == 8) return 1;
5118
5119 return 0;
5120 }
5121
5122 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5123 {
5124 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5125 }
5126
5127 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5128 {
5129 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5130 }
5131
5132 // hlfmt main
5133
5134 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5135 {
5136 switch (hashfile_format)
5137 {
5138 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5139 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5140 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5141 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5142 }
5143 }
5144
5145 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5146 {
5147 switch (hashfile_format)
5148 {
5149 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5150 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5151 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5152 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5153 }
5154 }
5155
5156 char *strhlfmt (const uint hashfile_format)
5157 {
5158 switch (hashfile_format)
5159 {
5160 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5161 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5162 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5163 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5164 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5165 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5166 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5167 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5168 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5169 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5170 }
5171
5172 return ((char *) "Unknown");
5173 }
5174
5175 static uint hlfmt_detect (FILE *fp, uint max_check)
5176 {
5177 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5178
5179 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5180 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5181
5182 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5183
5184 uint num_check = 0;
5185
5186 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5187
5188 while (!feof (fp))
5189 {
5190 int line_len = fgetl (fp, line_buf);
5191
5192 if (line_len == 0) continue;
5193
5194 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5195 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5196 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5197
5198 if (num_check == max_check) break;
5199
5200 num_check++;
5201 }
5202
5203 myfree (line_buf);
5204
5205 uint hashlist_format = HLFMT_HASHCAT;
5206
5207 for (int i = 1; i < HLFMTS_CNT; i++)
5208 {
5209 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5210
5211 hashlist_format = i;
5212 }
5213
5214 free (formats_cnt);
5215
5216 return hashlist_format;
5217 }
5218
5219 /**
5220 * some further helper function
5221 */
5222
5223 // wrapper around mymalloc for ADL
5224
5225 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5226 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5227 {
5228 return mymalloc (iSize);
5229 }
5230 #endif
5231
5232 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5233 {
5234 u64 collisions = 0;
5235
5236 const uint dgst_pos0 = data.dgst_pos0;
5237 const uint dgst_pos1 = data.dgst_pos1;
5238 const uint dgst_pos2 = data.dgst_pos2;
5239 const uint dgst_pos3 = data.dgst_pos3;
5240
5241 memset (bitmap_a, 0, bitmap_size);
5242 memset (bitmap_b, 0, bitmap_size);
5243 memset (bitmap_c, 0, bitmap_size);
5244 memset (bitmap_d, 0, bitmap_size);
5245
5246 for (uint i = 0; i < digests_cnt; i++)
5247 {
5248 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5249
5250 uint *digest_ptr = (uint *) digests_buf_ptr;
5251
5252 digests_buf_ptr += dgst_size;
5253
5254 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5255 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5256 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5257 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5258
5259 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5260 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5261 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5262 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5263
5264 if (bitmap_a[idx0] & val0) collisions++;
5265 if (bitmap_b[idx1] & val1) collisions++;
5266 if (bitmap_c[idx2] & val2) collisions++;
5267 if (bitmap_d[idx3] & val3) collisions++;
5268
5269 bitmap_a[idx0] |= val0;
5270 bitmap_b[idx1] |= val1;
5271 bitmap_c[idx2] |= val2;
5272 bitmap_d[idx3] |= val3;
5273
5274 if (collisions >= collisions_max) return 0x7fffffff;
5275 }
5276
5277 return collisions;
5278 }
5279
5280 /**
5281 * main
5282 */
5283
5284 int main (int argc, char **argv)
5285 {
5286 /**
5287 * To help users a bit
5288 */
5289
5290 char *compute = getenv ("COMPUTE");
5291
5292 if (compute)
5293 {
5294 static char display[100];
5295
5296 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5297
5298 putenv (display);
5299 }
5300 else
5301 {
5302 if (getenv ("DISPLAY") == NULL)
5303 putenv ((char *) "DISPLAY=:0");
5304 }
5305
5306 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5307 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5308
5309 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5310 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5311
5312 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5313 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5314
5315 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5316 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5317
5318 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5319 putenv ((char *) "POCL_KERNEL_CACHE=0");
5320
5321 umask (077);
5322
5323 /**
5324 * Real init
5325 */
5326
5327 memset (&data, 0, sizeof (hc_global_data_t));
5328
5329 time_t proc_start;
5330
5331 time (&proc_start);
5332
5333 data.proc_start = proc_start;
5334
5335 int myargc = argc;
5336 char **myargv = argv;
5337
5338 hc_thread_mutex_init (mux_dispatcher);
5339 hc_thread_mutex_init (mux_counter);
5340 hc_thread_mutex_init (mux_display);
5341 hc_thread_mutex_init (mux_adl);
5342
5343 /**
5344 * commandline parameters
5345 */
5346
5347 uint usage = USAGE;
5348 uint version = VERSION;
5349 uint quiet = QUIET;
5350 uint benchmark = BENCHMARK;
5351 uint show = SHOW;
5352 uint left = LEFT;
5353 uint username = USERNAME;
5354 uint remove = REMOVE;
5355 uint remove_timer = REMOVE_TIMER;
5356 u64 skip = SKIP;
5357 u64 limit = LIMIT;
5358 uint keyspace = KEYSPACE;
5359 uint potfile_disable = POTFILE_DISABLE;
5360 char *potfile_path = NULL;
5361 uint debug_mode = DEBUG_MODE;
5362 char *debug_file = NULL;
5363 char *induction_dir = NULL;
5364 char *outfile_check_dir = NULL;
5365 uint force = FORCE;
5366 uint runtime = RUNTIME;
5367 uint hash_mode = HASH_MODE;
5368 uint attack_mode = ATTACK_MODE;
5369 uint markov_disable = MARKOV_DISABLE;
5370 uint markov_classic = MARKOV_CLASSIC;
5371 uint markov_threshold = MARKOV_THRESHOLD;
5372 char *markov_hcstat = NULL;
5373 char *outfile = NULL;
5374 uint outfile_format = OUTFILE_FORMAT;
5375 uint outfile_autohex = OUTFILE_AUTOHEX;
5376 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5377 uint restore = RESTORE;
5378 uint restore_timer = RESTORE_TIMER;
5379 uint restore_disable = RESTORE_DISABLE;
5380 uint status = STATUS;
5381 uint status_timer = STATUS_TIMER;
5382 uint status_automat = STATUS_AUTOMAT;
5383 uint loopback = LOOPBACK;
5384 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5385 char *session = NULL;
5386 uint hex_charset = HEX_CHARSET;
5387 uint hex_salt = HEX_SALT;
5388 uint hex_wordlist = HEX_WORDLIST;
5389 uint rp_gen = RP_GEN;
5390 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5391 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5392 uint rp_gen_seed = RP_GEN_SEED;
5393 char *rule_buf_l = (char *) RULE_BUF_L;
5394 char *rule_buf_r = (char *) RULE_BUF_R;
5395 uint increment = INCREMENT;
5396 uint increment_min = INCREMENT_MIN;
5397 uint increment_max = INCREMENT_MAX;
5398 char *cpu_affinity = NULL;
5399 OCL_PTR *ocl = NULL;
5400 char *opencl_devices = NULL;
5401 char *opencl_platforms = NULL;
5402 char *opencl_device_types = NULL;
5403 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5404 char *truecrypt_keyfiles = NULL;
5405 char *veracrypt_keyfiles = NULL;
5406 uint veracrypt_pim = 0;
5407 uint workload_profile = WORKLOAD_PROFILE;
5408 uint kernel_accel = KERNEL_ACCEL;
5409 uint kernel_loops = KERNEL_LOOPS;
5410 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5411 #ifdef HAVE_HWMON
5412 uint gpu_temp_abort = GPU_TEMP_ABORT;
5413 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5414 #ifdef HAVE_ADL
5415 uint powertune_enable = POWERTUNE_ENABLE;
5416 #endif
5417 #endif
5418 uint logfile_disable = LOGFILE_DISABLE;
5419 uint segment_size = SEGMENT_SIZE;
5420 uint scrypt_tmto = SCRYPT_TMTO;
5421 char separator = SEPARATOR;
5422 uint bitmap_min = BITMAP_MIN;
5423 uint bitmap_max = BITMAP_MAX;
5424 char *custom_charset_1 = NULL;
5425 char *custom_charset_2 = NULL;
5426 char *custom_charset_3 = NULL;
5427 char *custom_charset_4 = NULL;
5428
5429 #define IDX_HELP 'h'
5430 #define IDX_VERSION 'V'
5431 #define IDX_VERSION_LOWER 'v'
5432 #define IDX_QUIET 0xff02
5433 #define IDX_SHOW 0xff03
5434 #define IDX_LEFT 0xff04
5435 #define IDX_REMOVE 0xff05
5436 #define IDX_REMOVE_TIMER 0xff37
5437 #define IDX_SKIP 's'
5438 #define IDX_LIMIT 'l'
5439 #define IDX_KEYSPACE 0xff35
5440 #define IDX_POTFILE_DISABLE 0xff06
5441 #define IDX_POTFILE_PATH 0xffe0
5442 #define IDX_DEBUG_MODE 0xff43
5443 #define IDX_DEBUG_FILE 0xff44
5444 #define IDX_INDUCTION_DIR 0xff46
5445 #define IDX_OUTFILE_CHECK_DIR 0xff47
5446 #define IDX_USERNAME 0xff07
5447 #define IDX_FORCE 0xff08
5448 #define IDX_RUNTIME 0xff09
5449 #define IDX_BENCHMARK 'b'
5450 #define IDX_HASH_MODE 'm'
5451 #define IDX_ATTACK_MODE 'a'
5452 #define IDX_RP_FILE 'r'
5453 #define IDX_RP_GEN 'g'
5454 #define IDX_RP_GEN_FUNC_MIN 0xff10
5455 #define IDX_RP_GEN_FUNC_MAX 0xff11
5456 #define IDX_RP_GEN_SEED 0xff34
5457 #define IDX_RULE_BUF_L 'j'
5458 #define IDX_RULE_BUF_R 'k'
5459 #define IDX_INCREMENT 'i'
5460 #define IDX_INCREMENT_MIN 0xff12
5461 #define IDX_INCREMENT_MAX 0xff13
5462 #define IDX_OUTFILE 'o'
5463 #define IDX_OUTFILE_FORMAT 0xff14
5464 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5465 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5466 #define IDX_RESTORE 0xff15
5467 #define IDX_RESTORE_DISABLE 0xff27
5468 #define IDX_STATUS 0xff17
5469 #define IDX_STATUS_TIMER 0xff18
5470 #define IDX_STATUS_AUTOMAT 0xff50
5471 #define IDX_LOOPBACK 0xff38
5472 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5473 #define IDX_SESSION 0xff19
5474 #define IDX_HEX_CHARSET 0xff20
5475 #define IDX_HEX_SALT 0xff21
5476 #define IDX_HEX_WORDLIST 0xff40
5477 #define IDX_MARKOV_DISABLE 0xff22
5478 #define IDX_MARKOV_CLASSIC 0xff23
5479 #define IDX_MARKOV_THRESHOLD 't'
5480 #define IDX_MARKOV_HCSTAT 0xff24
5481 #define IDX_CPU_AFFINITY 0xff25
5482 #define IDX_OPENCL_DEVICES 'd'
5483 #define IDX_OPENCL_PLATFORMS 0xff72
5484 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5485 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5486 #define IDX_WORKLOAD_PROFILE 'w'
5487 #define IDX_KERNEL_ACCEL 'n'
5488 #define IDX_KERNEL_LOOPS 'u'
5489 #define IDX_GPU_TEMP_DISABLE 0xff29
5490 #define IDX_GPU_TEMP_ABORT 0xff30
5491 #define IDX_GPU_TEMP_RETAIN 0xff31
5492 #define IDX_POWERTUNE_ENABLE 0xff41
5493 #define IDX_LOGFILE_DISABLE 0xff51
5494 #define IDX_TRUECRYPT_KEYFILES 0xff52
5495 #define IDX_VERACRYPT_KEYFILES 0xff53
5496 #define IDX_VERACRYPT_PIM 0xff54
5497 #define IDX_SCRYPT_TMTO 0xff61
5498 #define IDX_SEGMENT_SIZE 'c'
5499 #define IDX_SEPARATOR 'p'
5500 #define IDX_BITMAP_MIN 0xff70
5501 #define IDX_BITMAP_MAX 0xff71
5502 #define IDX_CUSTOM_CHARSET_1 '1'
5503 #define IDX_CUSTOM_CHARSET_2 '2'
5504 #define IDX_CUSTOM_CHARSET_3 '3'
5505 #define IDX_CUSTOM_CHARSET_4 '4'
5506
5507 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5508
5509 struct option long_options[] =
5510 {
5511 {"help", no_argument, 0, IDX_HELP},
5512 {"version", no_argument, 0, IDX_VERSION},
5513 {"quiet", no_argument, 0, IDX_QUIET},
5514 {"show", no_argument, 0, IDX_SHOW},
5515 {"left", no_argument, 0, IDX_LEFT},
5516 {"username", no_argument, 0, IDX_USERNAME},
5517 {"remove", no_argument, 0, IDX_REMOVE},
5518 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5519 {"skip", required_argument, 0, IDX_SKIP},
5520 {"limit", required_argument, 0, IDX_LIMIT},
5521 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5522 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5523 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5524 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5525 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5526 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5527 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5528 {"force", no_argument, 0, IDX_FORCE},
5529 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5530 {"restore", no_argument, 0, IDX_RESTORE},
5531 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5532 {"status", no_argument, 0, IDX_STATUS},
5533 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5534 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5535 {"loopback", no_argument, 0, IDX_LOOPBACK},
5536 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5537 {"session", required_argument, 0, IDX_SESSION},
5538 {"runtime", required_argument, 0, IDX_RUNTIME},
5539 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5540 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5541 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5542 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5543 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5544 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5545 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5546 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5547 {"rules-file", required_argument, 0, IDX_RP_FILE},
5548 {"outfile", required_argument, 0, IDX_OUTFILE},
5549 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5550 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5551 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5552 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5553 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5554 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5555 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5556 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5557 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5558 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5559 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5560 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5561 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5562 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5563 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5564 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5565 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5566 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5567 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5568 #ifdef HAVE_HWMON
5569 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5570 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5571 #ifdef HAVE_ADL
5572 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5573 #endif
5574 #endif // HAVE_HWMON
5575 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5576 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5577 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5578 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5579 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5580 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5581 {"seperator", required_argument, 0, IDX_SEPARATOR},
5582 {"separator", required_argument, 0, IDX_SEPARATOR},
5583 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5584 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5585 {"increment", no_argument, 0, IDX_INCREMENT},
5586 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5587 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5588 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5589 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5590 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5591 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5592 {0, 0, 0, 0}
5593 };
5594
5595 uint rp_files_cnt = 0;
5596
5597 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5598
5599 int option_index = 0;
5600 int c = -1;
5601
5602 optind = 1;
5603 optopt = 0;
5604
5605 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5606 {
5607 switch (c)
5608 {
5609 case IDX_HELP: usage = 1; break;
5610 case IDX_VERSION:
5611 case IDX_VERSION_LOWER: version = 1; break;
5612 case IDX_RESTORE: restore = 1; break;
5613 case IDX_SESSION: session = optarg; break;
5614 case IDX_SHOW: show = 1; break;
5615 case IDX_LEFT: left = 1; break;
5616 case '?': return (-1);
5617 }
5618 }
5619
5620 if (optopt != 0)
5621 {
5622 log_error ("ERROR: Invalid argument specified");
5623
5624 return (-1);
5625 }
5626
5627 /**
5628 * exit functions
5629 */
5630
5631 if (version)
5632 {
5633 log_info ("%s", VERSION_TAG);
5634
5635 return (0);
5636 }
5637
5638 if (usage)
5639 {
5640 usage_big_print (PROGNAME);
5641
5642 return (0);
5643 }
5644
5645 /**
5646 * session needs to be set, always!
5647 */
5648
5649 if (session == NULL) session = (char *) PROGNAME;
5650
5651 /**
5652 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5653 */
5654
5655 char *exec_path = get_exec_path ();
5656
5657 #ifdef LINUX
5658
5659 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5660 char *resolved_exec_path = realpath (exec_path, NULL);
5661
5662 char *install_dir = get_install_dir (resolved_exec_path);
5663 char *profile_dir = NULL;
5664 char *session_dir = NULL;
5665 char *shared_dir = NULL;
5666
5667 if (strcmp (install_dir, resolved_install_folder) == 0)
5668 {
5669 struct passwd *pw = getpwuid (getuid ());
5670
5671 const char *homedir = pw->pw_dir;
5672
5673 profile_dir = get_profile_dir (homedir);
5674 session_dir = get_session_dir (profile_dir);
5675 shared_dir = strdup (SHARED_FOLDER);
5676
5677 mkdir (profile_dir, 0700);
5678 mkdir (session_dir, 0700);
5679 }
5680 else
5681 {
5682 profile_dir = install_dir;
5683 session_dir = install_dir;
5684 shared_dir = install_dir;
5685 }
5686
5687 myfree (resolved_install_folder);
5688 myfree (resolved_exec_path);
5689
5690 #else
5691
5692 char *install_dir = get_install_dir (exec_path);
5693 char *profile_dir = install_dir;
5694 char *session_dir = install_dir;
5695 char *shared_dir = install_dir;
5696
5697 #endif
5698
5699 data.install_dir = install_dir;
5700 data.profile_dir = profile_dir;
5701 data.session_dir = session_dir;
5702 data.shared_dir = shared_dir;
5703
5704 myfree (exec_path);
5705
5706 /**
5707 * kernel cache, we need to make sure folder exist
5708 */
5709
5710 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5711
5712 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5713
5714 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5715
5716 mkdir (kernels_folder, 0700);
5717
5718 myfree (kernels_folder);
5719
5720 /**
5721 * session
5722 */
5723
5724 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5725
5726 data.session = session;
5727
5728 char *eff_restore_file = (char *) mymalloc (session_size);
5729 char *new_restore_file = (char *) mymalloc (session_size);
5730
5731 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5732 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5733
5734 data.eff_restore_file = eff_restore_file;
5735 data.new_restore_file = new_restore_file;
5736
5737 if (((show == 1) || (left == 1)) && (restore == 1))
5738 {
5739 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5740 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5741
5742 return (-1);
5743 }
5744
5745 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5746 if ((show == 1) || (left == 1))
5747 {
5748 restore_disable = 1;
5749
5750 restore = 0;
5751 }
5752
5753 data.restore_disable = restore_disable;
5754
5755 restore_data_t *rd = init_restore (argc, argv);
5756
5757 data.rd = rd;
5758
5759 /**
5760 * restore file
5761 */
5762
5763 if (restore == 1)
5764 {
5765 read_restore (eff_restore_file, rd);
5766
5767 if (rd->version_bin < RESTORE_MIN)
5768 {
5769 log_error ("ERROR: Incompatible restore-file version");
5770
5771 return (-1);
5772 }
5773
5774 myargc = rd->argc;
5775 myargv = rd->argv;
5776
5777 #ifdef _POSIX
5778 rd->pid = getpid ();
5779 #elif _WIN
5780 rd->pid = GetCurrentProcessId ();
5781 #endif
5782 }
5783
5784 uint hash_mode_chgd = 0;
5785 uint runtime_chgd = 0;
5786 uint kernel_loops_chgd = 0;
5787 uint kernel_accel_chgd = 0;
5788 uint attack_mode_chgd = 0;
5789 uint outfile_format_chgd = 0;
5790 uint rp_gen_seed_chgd = 0;
5791 uint remove_timer_chgd = 0;
5792 uint increment_min_chgd = 0;
5793 uint increment_max_chgd = 0;
5794 uint workload_profile_chgd = 0;
5795 uint opencl_vector_width_chgd = 0;
5796
5797 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5798 uint gpu_temp_retain_chgd = 0;
5799 uint gpu_temp_abort_chgd = 0;
5800 #endif
5801
5802 optind = 1;
5803 optopt = 0;
5804 option_index = 0;
5805
5806 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5807 {
5808 switch (c)
5809 {
5810 //case IDX_HELP: usage = 1; break;
5811 //case IDX_VERSION: version = 1; break;
5812 //case IDX_RESTORE: restore = 1; break;
5813 case IDX_QUIET: quiet = 1; break;
5814 //case IDX_SHOW: show = 1; break;
5815 case IDX_SHOW: break;
5816 //case IDX_LEFT: left = 1; break;
5817 case IDX_LEFT: break;
5818 case IDX_USERNAME: username = 1; break;
5819 case IDX_REMOVE: remove = 1; break;
5820 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5821 remove_timer_chgd = 1; break;
5822 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5823 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5824 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5825 case IDX_DEBUG_FILE: debug_file = optarg; break;
5826 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5827 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5828 case IDX_FORCE: force = 1; break;
5829 case IDX_SKIP: skip = atoll (optarg); break;
5830 case IDX_LIMIT: limit = atoll (optarg); break;
5831 case IDX_KEYSPACE: keyspace = 1; break;
5832 case IDX_BENCHMARK: benchmark = 1; break;
5833 case IDX_RESTORE: break;
5834 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5835 case IDX_STATUS: status = 1; break;
5836 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5837 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5838 case IDX_LOOPBACK: loopback = 1; break;
5839 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5840 //case IDX_SESSION: session = optarg; break;
5841 case IDX_SESSION: break;
5842 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5843 hash_mode_chgd = 1; break;
5844 case IDX_RUNTIME: runtime = atoi (optarg);
5845 runtime_chgd = 1; break;
5846 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5847 attack_mode_chgd = 1; break;
5848 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5849 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5850 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5851 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5852 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5853 rp_gen_seed_chgd = 1; break;
5854 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5855 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5856 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5857 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5858 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5859 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5860 case IDX_OUTFILE: outfile = optarg; break;
5861 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5862 outfile_format_chgd = 1; break;
5863 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5864 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5865 case IDX_HEX_CHARSET: hex_charset = 1; break;
5866 case IDX_HEX_SALT: hex_salt = 1; break;
5867 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5868 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5869 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5870 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5871 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5872 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5873 opencl_vector_width_chgd = 1; break;
5874 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5875 workload_profile_chgd = 1; break;
5876 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5877 kernel_accel_chgd = 1; break;
5878 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5879 kernel_loops_chgd = 1; break;
5880 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5881 #ifdef HAVE_HWMON
5882 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_abort_chgd = 1;
5885 #endif
5886 break;
5887 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5888 #ifdef HAVE_ADL
5889 gpu_temp_retain_chgd = 1;
5890 #endif
5891 break;
5892 #ifdef HAVE_ADL
5893 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5894 #endif
5895 #endif // HAVE_HWMON
5896 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5897 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5898 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5899 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5900 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5901 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5902 case IDX_SEPARATOR: separator = optarg[0]; break;
5903 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5904 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5905 case IDX_INCREMENT: increment = 1; break;
5906 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5907 increment_min_chgd = 1; break;
5908 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5909 increment_max_chgd = 1; break;
5910 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5911 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5912 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5913 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5914
5915 default:
5916 log_error ("ERROR: Invalid argument specified");
5917 return (-1);
5918 }
5919 }
5920
5921 if (optopt != 0)
5922 {
5923 log_error ("ERROR: Invalid argument specified");
5924
5925 return (-1);
5926 }
5927
5928 /**
5929 * Inform user things getting started,
5930 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5931 * - we do not need to check algorithm_pos
5932 */
5933
5934 if (quiet == 0)
5935 {
5936 if (benchmark == 1)
5937 {
5938 if (status_automat == 0)
5939 {
5940 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5941 log_info ("");
5942 }
5943 else
5944 {
5945 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5946 }
5947 }
5948 else if (restore == 1)
5949 {
5950 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5951 log_info ("");
5952 }
5953 else
5954 {
5955 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5956 log_info ("");
5957 }
5958 }
5959
5960 /**
5961 * sanity check
5962 */
5963
5964 if (attack_mode > 7)
5965 {
5966 log_error ("ERROR: Invalid attack-mode specified");
5967
5968 return (-1);
5969 }
5970
5971 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5972 {
5973 log_error ("ERROR: Invalid runtime specified");
5974
5975 return (-1);
5976 }
5977
5978 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5979 {
5980 log_error ("ERROR: Invalid hash-type specified");
5981
5982 return (-1);
5983 }
5984
5985 // renamed hash modes
5986
5987 if (hash_mode_chgd)
5988 {
5989 int n = -1;
5990
5991 switch (hash_mode)
5992 {
5993 case 123: n = 124;
5994 break;
5995 }
5996
5997 if (n >= 0)
5998 {
5999 log_error ("Old -m specified, use -m %d instead", n);
6000
6001 return (-1);
6002 }
6003 }
6004
6005 if (username == 1)
6006 {
6007 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6008 {
6009 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6010
6011 return (-1);
6012 }
6013 }
6014
6015 if (outfile_format > 16)
6016 {
6017 log_error ("ERROR: Invalid outfile-format specified");
6018
6019 return (-1);
6020 }
6021
6022 if (left == 1)
6023 {
6024 if (outfile_format_chgd == 1)
6025 {
6026 if (outfile_format > 1)
6027 {
6028 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6029
6030 return (-1);
6031 }
6032 }
6033 else
6034 {
6035 outfile_format = OUTFILE_FMT_HASH;
6036 }
6037 }
6038
6039 if (show == 1)
6040 {
6041 if (outfile_format_chgd == 1)
6042 {
6043 if ((outfile_format > 7) && (outfile_format < 16))
6044 {
6045 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6046
6047 return (-1);
6048 }
6049 }
6050 }
6051
6052 if (increment_min < INCREMENT_MIN)
6053 {
6054 log_error ("ERROR: Invalid increment-min specified");
6055
6056 return (-1);
6057 }
6058
6059 if (increment_max > INCREMENT_MAX)
6060 {
6061 log_error ("ERROR: Invalid increment-max specified");
6062
6063 return (-1);
6064 }
6065
6066 if (increment_min > increment_max)
6067 {
6068 log_error ("ERROR: Invalid increment-min specified");
6069
6070 return (-1);
6071 }
6072
6073 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6074 {
6075 log_error ("ERROR: increment is not allowed in attack-mode 0");
6076
6077 return (-1);
6078 }
6079
6080 if ((increment == 0) && (increment_min_chgd == 1))
6081 {
6082 log_error ("ERROR: increment-min is only supported together with increment switch");
6083
6084 return (-1);
6085 }
6086
6087 if ((increment == 0) && (increment_max_chgd == 1))
6088 {
6089 log_error ("ERROR: increment-max is only supported together with increment switch");
6090
6091 return (-1);
6092 }
6093
6094 if (rp_files_cnt && rp_gen)
6095 {
6096 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6097
6098 return (-1);
6099 }
6100
6101 if (rp_files_cnt || rp_gen)
6102 {
6103 if (attack_mode != ATTACK_MODE_STRAIGHT)
6104 {
6105 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6106
6107 return (-1);
6108 }
6109 }
6110
6111 if (rp_gen_func_min > rp_gen_func_max)
6112 {
6113 log_error ("ERROR: Invalid rp-gen-func-min specified");
6114
6115 return (-1);
6116 }
6117
6118 if (kernel_accel_chgd == 1)
6119 {
6120 if (force == 0)
6121 {
6122 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6123 log_info ("Please consider using the option -w instead");
6124 log_info ("You can use --force to override this but do not post error reports if you do so");
6125 log_info ("");
6126
6127 return (-1);
6128 }
6129
6130 if (kernel_accel < 1)
6131 {
6132 log_error ("ERROR: Invalid kernel-accel specified");
6133
6134 return (-1);
6135 }
6136
6137 if (kernel_accel > 1024)
6138 {
6139 log_error ("ERROR: Invalid kernel-accel specified");
6140
6141 return (-1);
6142 }
6143 }
6144
6145 if (kernel_loops_chgd == 1)
6146 {
6147 if (force == 0)
6148 {
6149 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6150 log_info ("Please consider using the option -w instead");
6151 log_info ("You can use --force to override this but do not post error reports if you do so");
6152 log_info ("");
6153
6154 return (-1);
6155 }
6156
6157 if (kernel_loops < 1)
6158 {
6159 log_error ("ERROR: Invalid kernel-loops specified");
6160
6161 return (-1);
6162 }
6163
6164 if (kernel_loops > 1024)
6165 {
6166 log_error ("ERROR: Invalid kernel-loops specified");
6167
6168 return (-1);
6169 }
6170 }
6171
6172 if ((workload_profile < 1) || (workload_profile > 4))
6173 {
6174 log_error ("ERROR: workload-profile %i not available", workload_profile);
6175
6176 return (-1);
6177 }
6178
6179 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6180 {
6181 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6182
6183 return (-1);
6184 }
6185
6186 if (show == 1 || left == 1)
6187 {
6188 attack_mode = ATTACK_MODE_NONE;
6189
6190 if (remove == 1)
6191 {
6192 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6193
6194 return (-1);
6195 }
6196
6197 if (potfile_disable == 1)
6198 {
6199 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6200
6201 return (-1);
6202 }
6203 }
6204
6205 uint attack_kern = ATTACK_KERN_NONE;
6206
6207 switch (attack_mode)
6208 {
6209 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6210 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6211 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6212 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6213 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6214 }
6215
6216 if (benchmark == 0)
6217 {
6218 if (keyspace == 1)
6219 {
6220 int num_additional_params = 1;
6221
6222 if (attack_kern == ATTACK_KERN_COMBI)
6223 {
6224 num_additional_params = 2;
6225 }
6226
6227 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6228
6229 if (keyspace_wordlist_specified == 0) optind--;
6230 }
6231
6232 if (attack_kern == ATTACK_KERN_NONE)
6233 {
6234 if ((optind + 1) != myargc)
6235 {
6236 usage_mini_print (myargv[0]);
6237
6238 return (-1);
6239 }
6240 }
6241 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6242 {
6243 if ((optind + 1) > myargc)
6244 {
6245 usage_mini_print (myargv[0]);
6246
6247 return (-1);
6248 }
6249 }
6250 else if (attack_kern == ATTACK_KERN_COMBI)
6251 {
6252 if ((optind + 3) != myargc)
6253 {
6254 usage_mini_print (myargv[0]);
6255
6256 return (-1);
6257 }
6258 }
6259 else if (attack_kern == ATTACK_KERN_BF)
6260 {
6261 if ((optind + 1) > myargc)
6262 {
6263 usage_mini_print (myargv[0]);
6264
6265 return (-1);
6266 }
6267 }
6268 else
6269 {
6270 usage_mini_print (myargv[0]);
6271
6272 return (-1);
6273 }
6274 }
6275 else
6276 {
6277 if (myargv[optind] != 0)
6278 {
6279 log_error ("ERROR: Invalid argument for benchmark mode specified");
6280
6281 return (-1);
6282 }
6283
6284 if (attack_mode_chgd == 1)
6285 {
6286 if (attack_mode != ATTACK_MODE_BF)
6287 {
6288 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6289
6290 return (-1);
6291 }
6292 }
6293 }
6294
6295 if (skip != 0 && limit != 0)
6296 {
6297 limit += skip;
6298 }
6299
6300 if (keyspace == 1)
6301 {
6302 if (show == 1)
6303 {
6304 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6305
6306 return (-1);
6307 }
6308 else if (left == 1)
6309 {
6310 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6311
6312 return (-1);
6313 }
6314
6315 potfile_disable = 1;
6316
6317 restore_disable = 1;
6318
6319 restore = 0;
6320
6321 weak_hash_threshold = 0;
6322
6323 quiet = 1;
6324 }
6325
6326 if (remove_timer_chgd == 1)
6327 {
6328 if (remove == 0)
6329 {
6330 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6331
6332 return (-1);
6333 }
6334
6335 if (remove_timer < 1)
6336 {
6337 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6338
6339 return (-1);
6340 }
6341 }
6342
6343 if (loopback == 1)
6344 {
6345 if (attack_mode == ATTACK_MODE_STRAIGHT)
6346 {
6347 if ((rp_files_cnt == 0) && (rp_gen == 0))
6348 {
6349 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6350
6351 return (-1);
6352 }
6353 }
6354 else
6355 {
6356 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6357
6358 return (-1);
6359 }
6360 }
6361
6362 if (debug_mode > 0)
6363 {
6364 if (attack_mode != ATTACK_MODE_STRAIGHT)
6365 {
6366 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6367
6368 return (-1);
6369 }
6370
6371 if ((rp_files_cnt == 0) && (rp_gen == 0))
6372 {
6373 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6374
6375 return (-1);
6376 }
6377 }
6378
6379 if (debug_mode > 4)
6380 {
6381 log_error ("ERROR: Invalid debug-mode specified");
6382
6383 return (-1);
6384 }
6385
6386 if (debug_file != NULL)
6387 {
6388 if (debug_mode < 1)
6389 {
6390 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6391
6392 return (-1);
6393 }
6394 }
6395
6396 if (induction_dir != NULL)
6397 {
6398 if (attack_mode == ATTACK_MODE_BF)
6399 {
6400 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6401
6402 return (-1);
6403 }
6404 }
6405
6406 if (attack_mode != ATTACK_MODE_STRAIGHT)
6407 {
6408 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6409 {
6410 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6411
6412 return (-1);
6413 }
6414
6415 weak_hash_threshold = 0;
6416 }
6417
6418 /**
6419 * induction directory
6420 */
6421
6422 char *induction_directory = NULL;
6423
6424 if (attack_mode != ATTACK_MODE_BF)
6425 {
6426 if (induction_dir == NULL)
6427 {
6428 induction_directory = (char *) mymalloc (session_size);
6429
6430 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6431
6432 // create induction folder if it does not already exist
6433
6434 if (keyspace == 0)
6435 {
6436 if (rmdir (induction_directory) == -1)
6437 {
6438 if (errno == ENOENT)
6439 {
6440 // good, we can ignore
6441 }
6442 else if (errno == ENOTEMPTY)
6443 {
6444 char *induction_directory_mv = (char *) mymalloc (session_size);
6445
6446 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6447
6448 if (rename (induction_directory, induction_directory_mv) != 0)
6449 {
6450 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6451
6452 return (-1);
6453 }
6454 }
6455 else
6456 {
6457 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6458
6459 return (-1);
6460 }
6461 }
6462
6463 if (mkdir (induction_directory, 0700) == -1)
6464 {
6465 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6466
6467 return (-1);
6468 }
6469 }
6470 }
6471 else
6472 {
6473 induction_directory = induction_dir;
6474 }
6475 }
6476
6477 data.induction_directory = induction_directory;
6478
6479 /**
6480 * loopback
6481 */
6482
6483 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6484
6485 char *loopback_file = (char *) mymalloc (loopback_size);
6486
6487 /**
6488 * tuning db
6489 */
6490
6491 char tuning_db_file[256] = { 0 };
6492
6493 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6494
6495 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6496
6497 /**
6498 * outfile-check directory
6499 */
6500
6501 char *outfile_check_directory = NULL;
6502
6503 if (outfile_check_dir == NULL)
6504 {
6505 outfile_check_directory = (char *) mymalloc (session_size);
6506
6507 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6508 }
6509 else
6510 {
6511 outfile_check_directory = outfile_check_dir;
6512 }
6513
6514 data.outfile_check_directory = outfile_check_directory;
6515
6516 if (keyspace == 0)
6517 {
6518 struct stat outfile_check_stat;
6519
6520 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6521 {
6522 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6523
6524 if (is_dir == 0)
6525 {
6526 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6527
6528 return (-1);
6529 }
6530 }
6531 else if (outfile_check_dir == NULL)
6532 {
6533 if (mkdir (outfile_check_directory, 0700) == -1)
6534 {
6535 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6536
6537 return (-1);
6538 }
6539 }
6540 }
6541
6542 /**
6543 * special other stuff
6544 */
6545
6546 if (hash_mode == 9710)
6547 {
6548 outfile_format = 5;
6549 outfile_format_chgd = 1;
6550 }
6551
6552 if (hash_mode == 9810)
6553 {
6554 outfile_format = 5;
6555 outfile_format_chgd = 1;
6556 }
6557
6558 if (hash_mode == 10410)
6559 {
6560 outfile_format = 5;
6561 outfile_format_chgd = 1;
6562 }
6563
6564 /**
6565 * store stuff
6566 */
6567
6568 data.hash_mode = hash_mode;
6569 data.restore = restore;
6570 data.restore_timer = restore_timer;
6571 data.restore_disable = restore_disable;
6572 data.status = status;
6573 data.status_timer = status_timer;
6574 data.status_automat = status_automat;
6575 data.loopback = loopback;
6576 data.runtime = runtime;
6577 data.remove = remove;
6578 data.remove_timer = remove_timer;
6579 data.debug_mode = debug_mode;
6580 data.debug_file = debug_file;
6581 data.username = username;
6582 data.quiet = quiet;
6583 data.outfile = outfile;
6584 data.outfile_format = outfile_format;
6585 data.outfile_autohex = outfile_autohex;
6586 data.hex_charset = hex_charset;
6587 data.hex_salt = hex_salt;
6588 data.hex_wordlist = hex_wordlist;
6589 data.separator = separator;
6590 data.rp_files = rp_files;
6591 data.rp_files_cnt = rp_files_cnt;
6592 data.rp_gen = rp_gen;
6593 data.rp_gen_seed = rp_gen_seed;
6594 data.force = force;
6595 data.benchmark = benchmark;
6596 data.skip = skip;
6597 data.limit = limit;
6598 #ifdef HAVE_HWMON
6599 #ifdef HAVE_ADL
6600 data.powertune_enable = powertune_enable;
6601 #endif
6602 #endif
6603 data.logfile_disable = logfile_disable;
6604 data.truecrypt_keyfiles = truecrypt_keyfiles;
6605 data.veracrypt_keyfiles = veracrypt_keyfiles;
6606 data.veracrypt_pim = veracrypt_pim;
6607 data.scrypt_tmto = scrypt_tmto;
6608 data.workload_profile = workload_profile;
6609
6610 /**
6611 * cpu affinity
6612 */
6613
6614 if (cpu_affinity)
6615 {
6616 set_cpu_affinity (cpu_affinity);
6617 }
6618
6619 if (rp_gen_seed_chgd == 0)
6620 {
6621 srand (proc_start);
6622 }
6623 else
6624 {
6625 srand (rp_gen_seed);
6626 }
6627
6628 /**
6629 * logfile init
6630 */
6631
6632 if (logfile_disable == 0)
6633 {
6634 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6635
6636 char *logfile = (char *) mymalloc (logfile_size);
6637
6638 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6639
6640 data.logfile = logfile;
6641
6642 char *topid = logfile_generate_topid ();
6643
6644 data.topid = topid;
6645 }
6646
6647 // logfile_append() checks for logfile_disable internally to make it easier from here
6648
6649 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6650 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6651 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6652 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6653 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6654 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6655 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6656 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6657 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6658 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6659
6660 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6661 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6662 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6663 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6664 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6665 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6666 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6667 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6668
6669 logfile_top_msg ("START");
6670
6671 logfile_top_uint (attack_mode);
6672 logfile_top_uint (attack_kern);
6673 logfile_top_uint (benchmark);
6674 logfile_top_uint (bitmap_min);
6675 logfile_top_uint (bitmap_max);
6676 logfile_top_uint (debug_mode);
6677 logfile_top_uint (force);
6678 logfile_top_uint (kernel_accel);
6679 logfile_top_uint (kernel_loops);
6680 logfile_top_uint (gpu_temp_disable);
6681 #ifdef HAVE_HWMON
6682 logfile_top_uint (gpu_temp_abort);
6683 logfile_top_uint (gpu_temp_retain);
6684 #endif
6685 logfile_top_uint (hash_mode);
6686 logfile_top_uint (hex_charset);
6687 logfile_top_uint (hex_salt);
6688 logfile_top_uint (hex_wordlist);
6689 logfile_top_uint (increment);
6690 logfile_top_uint (increment_max);
6691 logfile_top_uint (increment_min);
6692 logfile_top_uint (keyspace);
6693 logfile_top_uint (left);
6694 logfile_top_uint (logfile_disable);
6695 logfile_top_uint (loopback);
6696 logfile_top_uint (markov_classic);
6697 logfile_top_uint (markov_disable);
6698 logfile_top_uint (markov_threshold);
6699 logfile_top_uint (outfile_autohex);
6700 logfile_top_uint (outfile_check_timer);
6701 logfile_top_uint (outfile_format);
6702 logfile_top_uint (potfile_disable);
6703 logfile_top_string (potfile_path);
6704 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6705 logfile_top_uint (powertune_enable);
6706 #endif
6707 logfile_top_uint (scrypt_tmto);
6708 logfile_top_uint (quiet);
6709 logfile_top_uint (remove);
6710 logfile_top_uint (remove_timer);
6711 logfile_top_uint (restore);
6712 logfile_top_uint (restore_disable);
6713 logfile_top_uint (restore_timer);
6714 logfile_top_uint (rp_gen);
6715 logfile_top_uint (rp_gen_func_max);
6716 logfile_top_uint (rp_gen_func_min);
6717 logfile_top_uint (rp_gen_seed);
6718 logfile_top_uint (runtime);
6719 logfile_top_uint (segment_size);
6720 logfile_top_uint (show);
6721 logfile_top_uint (status);
6722 logfile_top_uint (status_automat);
6723 logfile_top_uint (status_timer);
6724 logfile_top_uint (usage);
6725 logfile_top_uint (username);
6726 logfile_top_uint (version);
6727 logfile_top_uint (weak_hash_threshold);
6728 logfile_top_uint (workload_profile);
6729 logfile_top_uint64 (limit);
6730 logfile_top_uint64 (skip);
6731 logfile_top_char (separator);
6732 logfile_top_string (cpu_affinity);
6733 logfile_top_string (custom_charset_1);
6734 logfile_top_string (custom_charset_2);
6735 logfile_top_string (custom_charset_3);
6736 logfile_top_string (custom_charset_4);
6737 logfile_top_string (debug_file);
6738 logfile_top_string (opencl_devices);
6739 logfile_top_string (opencl_platforms);
6740 logfile_top_string (opencl_device_types);
6741 logfile_top_uint (opencl_vector_width);
6742 logfile_top_string (induction_dir);
6743 logfile_top_string (markov_hcstat);
6744 logfile_top_string (outfile);
6745 logfile_top_string (outfile_check_dir);
6746 logfile_top_string (rule_buf_l);
6747 logfile_top_string (rule_buf_r);
6748 logfile_top_string (session);
6749 logfile_top_string (truecrypt_keyfiles);
6750 logfile_top_string (veracrypt_keyfiles);
6751 logfile_top_uint (veracrypt_pim);
6752
6753 /**
6754 * Init OpenCL library loader
6755 */
6756
6757 if (keyspace == 0)
6758 {
6759 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6760
6761 ocl_init (ocl);
6762
6763 data.ocl = ocl;
6764 }
6765
6766 /**
6767 * OpenCL platform selection
6768 */
6769
6770 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6771
6772 /**
6773 * OpenCL device selection
6774 */
6775
6776 u32 devices_filter = setup_devices_filter (opencl_devices);
6777
6778 /**
6779 * OpenCL device type selection
6780 */
6781
6782 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6783
6784 /**
6785 * benchmark
6786 */
6787
6788 if (benchmark == 1)
6789 {
6790 /**
6791 * disable useless stuff for benchmark
6792 */
6793
6794 status_timer = 0;
6795 restore_timer = 0;
6796 restore_disable = 1;
6797 potfile_disable = 1;
6798 weak_hash_threshold = 0;
6799 gpu_temp_disable = 1;
6800
6801 data.status_timer = status_timer;
6802 data.restore_timer = restore_timer;
6803 data.restore_disable = restore_disable;
6804
6805 /**
6806 * force attack mode to be bruteforce
6807 */
6808
6809 attack_mode = ATTACK_MODE_BF;
6810 attack_kern = ATTACK_KERN_BF;
6811
6812 if (workload_profile_chgd == 0)
6813 {
6814 workload_profile = 3;
6815
6816 data.workload_profile = workload_profile;
6817 }
6818 }
6819
6820 /**
6821 * config
6822 */
6823
6824 uint hash_type = 0;
6825 uint salt_type = 0;
6826 uint attack_exec = 0;
6827 uint opts_type = 0;
6828 uint kern_type = 0;
6829 uint dgst_size = 0;
6830 uint esalt_size = 0;
6831 uint opti_type = 0;
6832 uint dgst_pos0 = -1;
6833 uint dgst_pos1 = -1;
6834 uint dgst_pos2 = -1;
6835 uint dgst_pos3 = -1;
6836
6837 int (*parse_func) (char *, uint, hash_t *);
6838 int (*sort_by_digest) (const void *, const void *);
6839
6840 uint algorithm_pos = 0;
6841 uint algorithm_max = 1;
6842
6843 uint *algorithms = default_benchmark_algorithms;
6844
6845 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6846
6847 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6848 {
6849 /*
6850 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6851 * the following algos are skipped entirely
6852 */
6853
6854 if (algorithm_pos > 0)
6855 {
6856 local_free (rd);
6857
6858 rd = init_restore (argc, argv);
6859
6860 data.rd = rd;
6861 }
6862
6863 /**
6864 * update hash_mode in case of multihash benchmark
6865 */
6866
6867 if (benchmark == 1)
6868 {
6869 if (hash_mode_chgd == 0)
6870 {
6871 hash_mode = algorithms[algorithm_pos];
6872
6873 data.hash_mode = hash_mode;
6874 }
6875
6876 quiet = 1;
6877
6878 data.quiet = quiet;
6879 }
6880
6881 switch (hash_mode)
6882 {
6883 case 0: hash_type = HASH_TYPE_MD5;
6884 salt_type = SALT_TYPE_NONE;
6885 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6886 opts_type = OPTS_TYPE_PT_GENERATE_LE
6887 | OPTS_TYPE_PT_ADD80
6888 | OPTS_TYPE_PT_ADDBITS14;
6889 kern_type = KERN_TYPE_MD5;
6890 dgst_size = DGST_SIZE_4_4;
6891 parse_func = md5_parse_hash;
6892 sort_by_digest = sort_by_digest_4_4;
6893 opti_type = OPTI_TYPE_ZERO_BYTE
6894 | OPTI_TYPE_PRECOMPUTE_INIT
6895 | OPTI_TYPE_PRECOMPUTE_MERKLE
6896 | OPTI_TYPE_MEET_IN_MIDDLE
6897 | OPTI_TYPE_EARLY_SKIP
6898 | OPTI_TYPE_NOT_ITERATED
6899 | OPTI_TYPE_NOT_SALTED
6900 | OPTI_TYPE_RAW_HASH;
6901 dgst_pos0 = 0;
6902 dgst_pos1 = 3;
6903 dgst_pos2 = 2;
6904 dgst_pos3 = 1;
6905 break;
6906
6907 case 10: hash_type = HASH_TYPE_MD5;
6908 salt_type = SALT_TYPE_INTERN;
6909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6910 opts_type = OPTS_TYPE_PT_GENERATE_LE
6911 | OPTS_TYPE_ST_ADD80
6912 | OPTS_TYPE_ST_ADDBITS14;
6913 kern_type = KERN_TYPE_MD5_PWSLT;
6914 dgst_size = DGST_SIZE_4_4;
6915 parse_func = md5s_parse_hash;
6916 sort_by_digest = sort_by_digest_4_4;
6917 opti_type = OPTI_TYPE_ZERO_BYTE
6918 | OPTI_TYPE_PRECOMPUTE_INIT
6919 | OPTI_TYPE_PRECOMPUTE_MERKLE
6920 | OPTI_TYPE_MEET_IN_MIDDLE
6921 | OPTI_TYPE_EARLY_SKIP
6922 | OPTI_TYPE_NOT_ITERATED
6923 | OPTI_TYPE_APPENDED_SALT
6924 | OPTI_TYPE_RAW_HASH;
6925 dgst_pos0 = 0;
6926 dgst_pos1 = 3;
6927 dgst_pos2 = 2;
6928 dgst_pos3 = 1;
6929 break;
6930
6931 case 11: hash_type = HASH_TYPE_MD5;
6932 salt_type = SALT_TYPE_INTERN;
6933 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6934 opts_type = OPTS_TYPE_PT_GENERATE_LE
6935 | OPTS_TYPE_ST_ADD80
6936 | OPTS_TYPE_ST_ADDBITS14;
6937 kern_type = KERN_TYPE_MD5_PWSLT;
6938 dgst_size = DGST_SIZE_4_4;
6939 parse_func = joomla_parse_hash;
6940 sort_by_digest = sort_by_digest_4_4;
6941 opti_type = OPTI_TYPE_ZERO_BYTE
6942 | OPTI_TYPE_PRECOMPUTE_INIT
6943 | OPTI_TYPE_PRECOMPUTE_MERKLE
6944 | OPTI_TYPE_MEET_IN_MIDDLE
6945 | OPTI_TYPE_EARLY_SKIP
6946 | OPTI_TYPE_NOT_ITERATED
6947 | OPTI_TYPE_APPENDED_SALT
6948 | OPTI_TYPE_RAW_HASH;
6949 dgst_pos0 = 0;
6950 dgst_pos1 = 3;
6951 dgst_pos2 = 2;
6952 dgst_pos3 = 1;
6953 break;
6954
6955 case 12: hash_type = HASH_TYPE_MD5;
6956 salt_type = SALT_TYPE_INTERN;
6957 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6958 opts_type = OPTS_TYPE_PT_GENERATE_LE
6959 | OPTS_TYPE_ST_ADD80
6960 | OPTS_TYPE_ST_ADDBITS14;
6961 kern_type = KERN_TYPE_MD5_PWSLT;
6962 dgst_size = DGST_SIZE_4_4;
6963 parse_func = postgresql_parse_hash;
6964 sort_by_digest = sort_by_digest_4_4;
6965 opti_type = OPTI_TYPE_ZERO_BYTE
6966 | OPTI_TYPE_PRECOMPUTE_INIT
6967 | OPTI_TYPE_PRECOMPUTE_MERKLE
6968 | OPTI_TYPE_MEET_IN_MIDDLE
6969 | OPTI_TYPE_EARLY_SKIP
6970 | OPTI_TYPE_NOT_ITERATED
6971 | OPTI_TYPE_APPENDED_SALT
6972 | OPTI_TYPE_RAW_HASH;
6973 dgst_pos0 = 0;
6974 dgst_pos1 = 3;
6975 dgst_pos2 = 2;
6976 dgst_pos3 = 1;
6977 break;
6978
6979 case 20: hash_type = HASH_TYPE_MD5;
6980 salt_type = SALT_TYPE_INTERN;
6981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6982 opts_type = OPTS_TYPE_PT_GENERATE_LE
6983 | OPTS_TYPE_PT_ADD80
6984 | OPTS_TYPE_PT_ADDBITS14;
6985 kern_type = KERN_TYPE_MD5_SLTPW;
6986 dgst_size = DGST_SIZE_4_4;
6987 parse_func = md5s_parse_hash;
6988 sort_by_digest = sort_by_digest_4_4;
6989 opti_type = OPTI_TYPE_ZERO_BYTE
6990 | OPTI_TYPE_PRECOMPUTE_INIT
6991 | OPTI_TYPE_PRECOMPUTE_MERKLE
6992 | OPTI_TYPE_EARLY_SKIP
6993 | OPTI_TYPE_NOT_ITERATED
6994 | OPTI_TYPE_PREPENDED_SALT
6995 | OPTI_TYPE_RAW_HASH;
6996 dgst_pos0 = 0;
6997 dgst_pos1 = 3;
6998 dgst_pos2 = 2;
6999 dgst_pos3 = 1;
7000 break;
7001
7002 case 21: hash_type = HASH_TYPE_MD5;
7003 salt_type = SALT_TYPE_INTERN;
7004 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7005 opts_type = OPTS_TYPE_PT_GENERATE_LE
7006 | OPTS_TYPE_PT_ADD80
7007 | OPTS_TYPE_PT_ADDBITS14;
7008 kern_type = KERN_TYPE_MD5_SLTPW;
7009 dgst_size = DGST_SIZE_4_4;
7010 parse_func = osc_parse_hash;
7011 sort_by_digest = sort_by_digest_4_4;
7012 opti_type = OPTI_TYPE_ZERO_BYTE
7013 | OPTI_TYPE_PRECOMPUTE_INIT
7014 | OPTI_TYPE_PRECOMPUTE_MERKLE
7015 | OPTI_TYPE_EARLY_SKIP
7016 | OPTI_TYPE_NOT_ITERATED
7017 | OPTI_TYPE_PREPENDED_SALT
7018 | OPTI_TYPE_RAW_HASH;
7019 dgst_pos0 = 0;
7020 dgst_pos1 = 3;
7021 dgst_pos2 = 2;
7022 dgst_pos3 = 1;
7023 break;
7024
7025 case 22: hash_type = HASH_TYPE_MD5;
7026 salt_type = SALT_TYPE_EMBEDDED;
7027 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7028 opts_type = OPTS_TYPE_PT_GENERATE_LE
7029 | OPTS_TYPE_PT_ADD80
7030 | OPTS_TYPE_PT_ADDBITS14;
7031 kern_type = KERN_TYPE_MD5_SLTPW;
7032 dgst_size = DGST_SIZE_4_4;
7033 parse_func = netscreen_parse_hash;
7034 sort_by_digest = sort_by_digest_4_4;
7035 opti_type = OPTI_TYPE_ZERO_BYTE
7036 | OPTI_TYPE_PRECOMPUTE_INIT
7037 | OPTI_TYPE_PRECOMPUTE_MERKLE
7038 | OPTI_TYPE_EARLY_SKIP
7039 | OPTI_TYPE_NOT_ITERATED
7040 | OPTI_TYPE_PREPENDED_SALT
7041 | OPTI_TYPE_RAW_HASH;
7042 dgst_pos0 = 0;
7043 dgst_pos1 = 3;
7044 dgst_pos2 = 2;
7045 dgst_pos3 = 1;
7046 break;
7047
7048 case 23: hash_type = HASH_TYPE_MD5;
7049 salt_type = SALT_TYPE_EMBEDDED;
7050 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7051 opts_type = OPTS_TYPE_PT_GENERATE_LE
7052 | OPTS_TYPE_PT_ADD80
7053 | OPTS_TYPE_PT_ADDBITS14;
7054 kern_type = KERN_TYPE_MD5_SLTPW;
7055 dgst_size = DGST_SIZE_4_4;
7056 parse_func = skype_parse_hash;
7057 sort_by_digest = sort_by_digest_4_4;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_PRECOMPUTE_INIT
7060 | OPTI_TYPE_PRECOMPUTE_MERKLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_PREPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 30: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_PT_UNICODE
7076 | OPTS_TYPE_ST_ADD80
7077 | OPTS_TYPE_ST_ADDBITS14;
7078 kern_type = KERN_TYPE_MD5_PWUSLT;
7079 dgst_size = DGST_SIZE_4_4;
7080 parse_func = md5s_parse_hash;
7081 sort_by_digest = sort_by_digest_4_4;
7082 opti_type = OPTI_TYPE_ZERO_BYTE
7083 | OPTI_TYPE_PRECOMPUTE_INIT
7084 | OPTI_TYPE_PRECOMPUTE_MERKLE
7085 | OPTI_TYPE_MEET_IN_MIDDLE
7086 | OPTI_TYPE_EARLY_SKIP
7087 | OPTI_TYPE_NOT_ITERATED
7088 | OPTI_TYPE_APPENDED_SALT
7089 | OPTI_TYPE_RAW_HASH;
7090 dgst_pos0 = 0;
7091 dgst_pos1 = 3;
7092 dgst_pos2 = 2;
7093 dgst_pos3 = 1;
7094 break;
7095
7096 case 40: hash_type = HASH_TYPE_MD5;
7097 salt_type = SALT_TYPE_INTERN;
7098 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7099 opts_type = OPTS_TYPE_PT_GENERATE_LE
7100 | OPTS_TYPE_PT_ADD80
7101 | OPTS_TYPE_PT_ADDBITS14
7102 | OPTS_TYPE_PT_UNICODE;
7103 kern_type = KERN_TYPE_MD5_SLTPWU;
7104 dgst_size = DGST_SIZE_4_4;
7105 parse_func = md5s_parse_hash;
7106 sort_by_digest = sort_by_digest_4_4;
7107 opti_type = OPTI_TYPE_ZERO_BYTE
7108 | OPTI_TYPE_PRECOMPUTE_INIT
7109 | OPTI_TYPE_PRECOMPUTE_MERKLE
7110 | OPTI_TYPE_EARLY_SKIP
7111 | OPTI_TYPE_NOT_ITERATED
7112 | OPTI_TYPE_PREPENDED_SALT
7113 | OPTI_TYPE_RAW_HASH;
7114 dgst_pos0 = 0;
7115 dgst_pos1 = 3;
7116 dgst_pos2 = 2;
7117 dgst_pos3 = 1;
7118 break;
7119
7120 case 50: hash_type = HASH_TYPE_MD5;
7121 salt_type = SALT_TYPE_INTERN;
7122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7123 opts_type = OPTS_TYPE_PT_GENERATE_LE
7124 | OPTS_TYPE_ST_ADD80
7125 | OPTS_TYPE_ST_ADDBITS14;
7126 kern_type = KERN_TYPE_HMACMD5_PW;
7127 dgst_size = DGST_SIZE_4_4;
7128 parse_func = hmacmd5_parse_hash;
7129 sort_by_digest = sort_by_digest_4_4;
7130 opti_type = OPTI_TYPE_ZERO_BYTE
7131 | OPTI_TYPE_NOT_ITERATED;
7132 dgst_pos0 = 0;
7133 dgst_pos1 = 3;
7134 dgst_pos2 = 2;
7135 dgst_pos3 = 1;
7136 break;
7137
7138 case 60: hash_type = HASH_TYPE_MD5;
7139 salt_type = SALT_TYPE_INTERN;
7140 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7141 opts_type = OPTS_TYPE_PT_GENERATE_LE
7142 | OPTS_TYPE_PT_ADD80
7143 | OPTS_TYPE_PT_ADDBITS14;
7144 kern_type = KERN_TYPE_HMACMD5_SLT;
7145 dgst_size = DGST_SIZE_4_4;
7146 parse_func = hmacmd5_parse_hash;
7147 sort_by_digest = sort_by_digest_4_4;
7148 opti_type = OPTI_TYPE_ZERO_BYTE
7149 | OPTI_TYPE_NOT_ITERATED;
7150 dgst_pos0 = 0;
7151 dgst_pos1 = 3;
7152 dgst_pos2 = 2;
7153 dgst_pos3 = 1;
7154 break;
7155
7156 case 100: hash_type = HASH_TYPE_SHA1;
7157 salt_type = SALT_TYPE_NONE;
7158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7159 opts_type = OPTS_TYPE_PT_GENERATE_BE
7160 | OPTS_TYPE_PT_ADD80
7161 | OPTS_TYPE_PT_ADDBITS15;
7162 kern_type = KERN_TYPE_SHA1;
7163 dgst_size = DGST_SIZE_4_5;
7164 parse_func = sha1_parse_hash;
7165 sort_by_digest = sort_by_digest_4_5;
7166 opti_type = OPTI_TYPE_ZERO_BYTE
7167 | OPTI_TYPE_PRECOMPUTE_INIT
7168 | OPTI_TYPE_PRECOMPUTE_MERKLE
7169 | OPTI_TYPE_EARLY_SKIP
7170 | OPTI_TYPE_NOT_ITERATED
7171 | OPTI_TYPE_NOT_SALTED
7172 | OPTI_TYPE_RAW_HASH;
7173 dgst_pos0 = 3;
7174 dgst_pos1 = 4;
7175 dgst_pos2 = 2;
7176 dgst_pos3 = 1;
7177 break;
7178
7179 case 101: hash_type = HASH_TYPE_SHA1;
7180 salt_type = SALT_TYPE_NONE;
7181 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7182 opts_type = OPTS_TYPE_PT_GENERATE_BE
7183 | OPTS_TYPE_PT_ADD80
7184 | OPTS_TYPE_PT_ADDBITS15;
7185 kern_type = KERN_TYPE_SHA1;
7186 dgst_size = DGST_SIZE_4_5;
7187 parse_func = sha1b64_parse_hash;
7188 sort_by_digest = sort_by_digest_4_5;
7189 opti_type = OPTI_TYPE_ZERO_BYTE
7190 | OPTI_TYPE_PRECOMPUTE_INIT
7191 | OPTI_TYPE_PRECOMPUTE_MERKLE
7192 | OPTI_TYPE_EARLY_SKIP
7193 | OPTI_TYPE_NOT_ITERATED
7194 | OPTI_TYPE_NOT_SALTED
7195 | OPTI_TYPE_RAW_HASH;
7196 dgst_pos0 = 3;
7197 dgst_pos1 = 4;
7198 dgst_pos2 = 2;
7199 dgst_pos3 = 1;
7200 break;
7201
7202 case 110: hash_type = HASH_TYPE_SHA1;
7203 salt_type = SALT_TYPE_INTERN;
7204 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7205 opts_type = OPTS_TYPE_PT_GENERATE_BE
7206 | OPTS_TYPE_ST_ADD80
7207 | OPTS_TYPE_ST_ADDBITS15;
7208 kern_type = KERN_TYPE_SHA1_PWSLT;
7209 dgst_size = DGST_SIZE_4_5;
7210 parse_func = sha1s_parse_hash;
7211 sort_by_digest = sort_by_digest_4_5;
7212 opti_type = OPTI_TYPE_ZERO_BYTE
7213 | OPTI_TYPE_PRECOMPUTE_INIT
7214 | OPTI_TYPE_PRECOMPUTE_MERKLE
7215 | OPTI_TYPE_EARLY_SKIP
7216 | OPTI_TYPE_NOT_ITERATED
7217 | OPTI_TYPE_APPENDED_SALT
7218 | OPTI_TYPE_RAW_HASH;
7219 dgst_pos0 = 3;
7220 dgst_pos1 = 4;
7221 dgst_pos2 = 2;
7222 dgst_pos3 = 1;
7223 break;
7224
7225 case 111: hash_type = HASH_TYPE_SHA1;
7226 salt_type = SALT_TYPE_EMBEDDED;
7227 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7228 opts_type = OPTS_TYPE_PT_GENERATE_BE
7229 | OPTS_TYPE_ST_ADD80
7230 | OPTS_TYPE_ST_ADDBITS15;
7231 kern_type = KERN_TYPE_SHA1_PWSLT;
7232 dgst_size = DGST_SIZE_4_5;
7233 parse_func = sha1b64s_parse_hash;
7234 sort_by_digest = sort_by_digest_4_5;
7235 opti_type = OPTI_TYPE_ZERO_BYTE
7236 | OPTI_TYPE_PRECOMPUTE_INIT
7237 | OPTI_TYPE_PRECOMPUTE_MERKLE
7238 | OPTI_TYPE_EARLY_SKIP
7239 | OPTI_TYPE_NOT_ITERATED
7240 | OPTI_TYPE_APPENDED_SALT
7241 | OPTI_TYPE_RAW_HASH;
7242 dgst_pos0 = 3;
7243 dgst_pos1 = 4;
7244 dgst_pos2 = 2;
7245 dgst_pos3 = 1;
7246 break;
7247
7248 case 112: hash_type = HASH_TYPE_SHA1;
7249 salt_type = SALT_TYPE_INTERN;
7250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7251 opts_type = OPTS_TYPE_PT_GENERATE_BE
7252 | OPTS_TYPE_ST_ADD80
7253 | OPTS_TYPE_ST_ADDBITS15
7254 | OPTS_TYPE_ST_HEX;
7255 kern_type = KERN_TYPE_SHA1_PWSLT;
7256 dgst_size = DGST_SIZE_4_5;
7257 parse_func = oracles_parse_hash;
7258 sort_by_digest = sort_by_digest_4_5;
7259 opti_type = OPTI_TYPE_ZERO_BYTE
7260 | OPTI_TYPE_PRECOMPUTE_INIT
7261 | OPTI_TYPE_PRECOMPUTE_MERKLE
7262 | OPTI_TYPE_EARLY_SKIP
7263 | OPTI_TYPE_NOT_ITERATED
7264 | OPTI_TYPE_APPENDED_SALT
7265 | OPTI_TYPE_RAW_HASH;
7266 dgst_pos0 = 3;
7267 dgst_pos1 = 4;
7268 dgst_pos2 = 2;
7269 dgst_pos3 = 1;
7270 break;
7271
7272 case 120: hash_type = HASH_TYPE_SHA1;
7273 salt_type = SALT_TYPE_INTERN;
7274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7275 opts_type = OPTS_TYPE_PT_GENERATE_BE
7276 | OPTS_TYPE_PT_ADD80
7277 | OPTS_TYPE_PT_ADDBITS15;
7278 kern_type = KERN_TYPE_SHA1_SLTPW;
7279 dgst_size = DGST_SIZE_4_5;
7280 parse_func = sha1s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_5;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 3;
7290 dgst_pos1 = 4;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 121: hash_type = HASH_TYPE_SHA1;
7296 salt_type = SALT_TYPE_INTERN;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_BE
7299 | OPTS_TYPE_PT_ADD80
7300 | OPTS_TYPE_PT_ADDBITS15
7301 | OPTS_TYPE_ST_LOWER;
7302 kern_type = KERN_TYPE_SHA1_SLTPW;
7303 dgst_size = DGST_SIZE_4_5;
7304 parse_func = smf_parse_hash;
7305 sort_by_digest = sort_by_digest_4_5;
7306 opti_type = OPTI_TYPE_ZERO_BYTE
7307 | OPTI_TYPE_PRECOMPUTE_INIT
7308 | OPTI_TYPE_PRECOMPUTE_MERKLE
7309 | OPTI_TYPE_EARLY_SKIP
7310 | OPTI_TYPE_NOT_ITERATED
7311 | OPTI_TYPE_PREPENDED_SALT
7312 | OPTI_TYPE_RAW_HASH;
7313 dgst_pos0 = 3;
7314 dgst_pos1 = 4;
7315 dgst_pos2 = 2;
7316 dgst_pos3 = 1;
7317 break;
7318
7319 case 122: hash_type = HASH_TYPE_SHA1;
7320 salt_type = SALT_TYPE_EMBEDDED;
7321 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7322 opts_type = OPTS_TYPE_PT_GENERATE_BE
7323 | OPTS_TYPE_PT_ADD80
7324 | OPTS_TYPE_PT_ADDBITS15
7325 | OPTS_TYPE_ST_HEX;
7326 kern_type = KERN_TYPE_SHA1_SLTPW;
7327 dgst_size = DGST_SIZE_4_5;
7328 parse_func = osx1_parse_hash;
7329 sort_by_digest = sort_by_digest_4_5;
7330 opti_type = OPTI_TYPE_ZERO_BYTE
7331 | OPTI_TYPE_PRECOMPUTE_INIT
7332 | OPTI_TYPE_PRECOMPUTE_MERKLE
7333 | OPTI_TYPE_EARLY_SKIP
7334 | OPTI_TYPE_NOT_ITERATED
7335 | OPTI_TYPE_PREPENDED_SALT
7336 | OPTI_TYPE_RAW_HASH;
7337 dgst_pos0 = 3;
7338 dgst_pos1 = 4;
7339 dgst_pos2 = 2;
7340 dgst_pos3 = 1;
7341 break;
7342
7343 case 124: hash_type = HASH_TYPE_SHA1;
7344 salt_type = SALT_TYPE_EMBEDDED;
7345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7346 opts_type = OPTS_TYPE_PT_GENERATE_BE
7347 | OPTS_TYPE_PT_ADD80
7348 | OPTS_TYPE_PT_ADDBITS15;
7349 kern_type = KERN_TYPE_SHA1_SLTPW;
7350 dgst_size = DGST_SIZE_4_5;
7351 parse_func = djangosha1_parse_hash;
7352 sort_by_digest = sort_by_digest_4_5;
7353 opti_type = OPTI_TYPE_ZERO_BYTE
7354 | OPTI_TYPE_PRECOMPUTE_INIT
7355 | OPTI_TYPE_PRECOMPUTE_MERKLE
7356 | OPTI_TYPE_EARLY_SKIP
7357 | OPTI_TYPE_NOT_ITERATED
7358 | OPTI_TYPE_PREPENDED_SALT
7359 | OPTI_TYPE_RAW_HASH;
7360 dgst_pos0 = 3;
7361 dgst_pos1 = 4;
7362 dgst_pos2 = 2;
7363 dgst_pos3 = 1;
7364 break;
7365
7366 case 125: hash_type = HASH_TYPE_SHA1;
7367 salt_type = SALT_TYPE_EMBEDDED;
7368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7369 opts_type = OPTS_TYPE_PT_GENERATE_BE
7370 | OPTS_TYPE_PT_ADD80
7371 | OPTS_TYPE_PT_ADDBITS15
7372 | OPTS_TYPE_ST_HEX;
7373 kern_type = KERN_TYPE_SHA1_SLTPW;
7374 dgst_size = DGST_SIZE_4_5;
7375 parse_func = arubaos_parse_hash;
7376 sort_by_digest = sort_by_digest_4_5;
7377 opti_type = OPTI_TYPE_ZERO_BYTE
7378 | OPTI_TYPE_PRECOMPUTE_INIT
7379 | OPTI_TYPE_PRECOMPUTE_MERKLE
7380 | OPTI_TYPE_EARLY_SKIP
7381 | OPTI_TYPE_NOT_ITERATED
7382 | OPTI_TYPE_PREPENDED_SALT
7383 | OPTI_TYPE_RAW_HASH;
7384 dgst_pos0 = 3;
7385 dgst_pos1 = 4;
7386 dgst_pos2 = 2;
7387 dgst_pos3 = 1;
7388 break;
7389
7390 case 130: hash_type = HASH_TYPE_SHA1;
7391 salt_type = SALT_TYPE_INTERN;
7392 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7393 opts_type = OPTS_TYPE_PT_GENERATE_BE
7394 | OPTS_TYPE_PT_UNICODE
7395 | OPTS_TYPE_ST_ADD80
7396 | OPTS_TYPE_ST_ADDBITS15;
7397 kern_type = KERN_TYPE_SHA1_PWUSLT;
7398 dgst_size = DGST_SIZE_4_5;
7399 parse_func = sha1s_parse_hash;
7400 sort_by_digest = sort_by_digest_4_5;
7401 opti_type = OPTI_TYPE_ZERO_BYTE
7402 | OPTI_TYPE_PRECOMPUTE_INIT
7403 | OPTI_TYPE_PRECOMPUTE_MERKLE
7404 | OPTI_TYPE_EARLY_SKIP
7405 | OPTI_TYPE_NOT_ITERATED
7406 | OPTI_TYPE_APPENDED_SALT
7407 | OPTI_TYPE_RAW_HASH;
7408 dgst_pos0 = 3;
7409 dgst_pos1 = 4;
7410 dgst_pos2 = 2;
7411 dgst_pos3 = 1;
7412 break;
7413
7414 case 131: hash_type = HASH_TYPE_SHA1;
7415 salt_type = SALT_TYPE_EMBEDDED;
7416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7417 opts_type = OPTS_TYPE_PT_GENERATE_BE
7418 | OPTS_TYPE_PT_UNICODE
7419 | OPTS_TYPE_PT_UPPER
7420 | OPTS_TYPE_ST_ADD80
7421 | OPTS_TYPE_ST_ADDBITS15
7422 | OPTS_TYPE_ST_HEX;
7423 kern_type = KERN_TYPE_SHA1_PWUSLT;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = mssql2000_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_APPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 132: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_EMBEDDED;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_UNICODE
7445 | OPTS_TYPE_ST_ADD80
7446 | OPTS_TYPE_ST_ADDBITS15
7447 | OPTS_TYPE_ST_HEX;
7448 kern_type = KERN_TYPE_SHA1_PWUSLT;
7449 dgst_size = DGST_SIZE_4_5;
7450 parse_func = mssql2005_parse_hash;
7451 sort_by_digest = sort_by_digest_4_5;
7452 opti_type = OPTI_TYPE_ZERO_BYTE
7453 | OPTI_TYPE_PRECOMPUTE_INIT
7454 | OPTI_TYPE_PRECOMPUTE_MERKLE
7455 | OPTI_TYPE_EARLY_SKIP
7456 | OPTI_TYPE_NOT_ITERATED
7457 | OPTI_TYPE_APPENDED_SALT
7458 | OPTI_TYPE_RAW_HASH;
7459 dgst_pos0 = 3;
7460 dgst_pos1 = 4;
7461 dgst_pos2 = 2;
7462 dgst_pos3 = 1;
7463 break;
7464
7465 case 133: hash_type = HASH_TYPE_SHA1;
7466 salt_type = SALT_TYPE_EMBEDDED;
7467 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7468 opts_type = OPTS_TYPE_PT_GENERATE_BE
7469 | OPTS_TYPE_PT_UNICODE
7470 | OPTS_TYPE_ST_ADD80
7471 | OPTS_TYPE_ST_ADDBITS15;
7472 kern_type = KERN_TYPE_SHA1_PWUSLT;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = peoplesoft_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_APPENDED_SALT
7482 | OPTI_TYPE_RAW_HASH;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 4;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 1;
7487 break;
7488
7489 case 140: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_INTERN;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_PT_ADD80
7494 | OPTS_TYPE_PT_ADDBITS15
7495 | OPTS_TYPE_PT_UNICODE;
7496 kern_type = KERN_TYPE_SHA1_SLTPWU;
7497 dgst_size = DGST_SIZE_4_5;
7498 parse_func = sha1s_parse_hash;
7499 sort_by_digest = sort_by_digest_4_5;
7500 opti_type = OPTI_TYPE_ZERO_BYTE
7501 | OPTI_TYPE_PRECOMPUTE_INIT
7502 | OPTI_TYPE_PRECOMPUTE_MERKLE
7503 | OPTI_TYPE_EARLY_SKIP
7504 | OPTI_TYPE_NOT_ITERATED
7505 | OPTI_TYPE_PREPENDED_SALT
7506 | OPTI_TYPE_RAW_HASH;
7507 dgst_pos0 = 3;
7508 dgst_pos1 = 4;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 141: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_EMBEDDED;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15
7519 | OPTS_TYPE_PT_UNICODE
7520 | OPTS_TYPE_ST_BASE64;
7521 kern_type = KERN_TYPE_SHA1_SLTPWU;
7522 dgst_size = DGST_SIZE_4_5;
7523 parse_func = episerver_parse_hash;
7524 sort_by_digest = sort_by_digest_4_5;
7525 opti_type = OPTI_TYPE_ZERO_BYTE
7526 | OPTI_TYPE_PRECOMPUTE_INIT
7527 | OPTI_TYPE_PRECOMPUTE_MERKLE
7528 | OPTI_TYPE_EARLY_SKIP
7529 | OPTI_TYPE_NOT_ITERATED
7530 | OPTI_TYPE_PREPENDED_SALT
7531 | OPTI_TYPE_RAW_HASH;
7532 dgst_pos0 = 3;
7533 dgst_pos1 = 4;
7534 dgst_pos2 = 2;
7535 dgst_pos3 = 1;
7536 break;
7537
7538 case 150: hash_type = HASH_TYPE_SHA1;
7539 salt_type = SALT_TYPE_INTERN;
7540 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7541 opts_type = OPTS_TYPE_PT_GENERATE_BE
7542 | OPTS_TYPE_ST_ADD80
7543 | OPTS_TYPE_ST_ADDBITS15;
7544 kern_type = KERN_TYPE_HMACSHA1_PW;
7545 dgst_size = DGST_SIZE_4_5;
7546 parse_func = hmacsha1_parse_hash;
7547 sort_by_digest = sort_by_digest_4_5;
7548 opti_type = OPTI_TYPE_ZERO_BYTE
7549 | OPTI_TYPE_NOT_ITERATED;
7550 dgst_pos0 = 3;
7551 dgst_pos1 = 4;
7552 dgst_pos2 = 2;
7553 dgst_pos3 = 1;
7554 break;
7555
7556 case 160: hash_type = HASH_TYPE_SHA1;
7557 salt_type = SALT_TYPE_INTERN;
7558 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7559 opts_type = OPTS_TYPE_PT_GENERATE_BE
7560 | OPTS_TYPE_PT_ADD80
7561 | OPTS_TYPE_PT_ADDBITS15;
7562 kern_type = KERN_TYPE_HMACSHA1_SLT;
7563 dgst_size = DGST_SIZE_4_5;
7564 parse_func = hmacsha1_parse_hash;
7565 sort_by_digest = sort_by_digest_4_5;
7566 opti_type = OPTI_TYPE_ZERO_BYTE
7567 | OPTI_TYPE_NOT_ITERATED;
7568 dgst_pos0 = 3;
7569 dgst_pos1 = 4;
7570 dgst_pos2 = 2;
7571 dgst_pos3 = 1;
7572 break;
7573
7574 case 190: hash_type = HASH_TYPE_SHA1;
7575 salt_type = SALT_TYPE_NONE;
7576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7577 opts_type = OPTS_TYPE_PT_GENERATE_BE
7578 | OPTS_TYPE_PT_ADD80
7579 | OPTS_TYPE_PT_ADDBITS15;
7580 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7581 dgst_size = DGST_SIZE_4_5;
7582 parse_func = sha1linkedin_parse_hash;
7583 sort_by_digest = sort_by_digest_4_5;
7584 opti_type = OPTI_TYPE_ZERO_BYTE
7585 | OPTI_TYPE_PRECOMPUTE_INIT
7586 | OPTI_TYPE_EARLY_SKIP
7587 | OPTI_TYPE_NOT_ITERATED
7588 | OPTI_TYPE_NOT_SALTED;
7589 dgst_pos0 = 0;
7590 dgst_pos1 = 4;
7591 dgst_pos2 = 3;
7592 dgst_pos3 = 2;
7593 break;
7594
7595 case 200: hash_type = HASH_TYPE_MYSQL;
7596 salt_type = SALT_TYPE_NONE;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = 0;
7599 kern_type = KERN_TYPE_MYSQL;
7600 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7601 parse_func = mysql323_parse_hash;
7602 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7603 opti_type = OPTI_TYPE_ZERO_BYTE;
7604 dgst_pos0 = 0;
7605 dgst_pos1 = 1;
7606 dgst_pos2 = 2;
7607 dgst_pos3 = 3;
7608 break;
7609
7610 case 300: hash_type = HASH_TYPE_SHA1;
7611 salt_type = SALT_TYPE_NONE;
7612 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7613 opts_type = OPTS_TYPE_PT_GENERATE_BE
7614 | OPTS_TYPE_PT_ADD80
7615 | OPTS_TYPE_PT_ADDBITS15;
7616 kern_type = KERN_TYPE_MYSQL41;
7617 dgst_size = DGST_SIZE_4_5;
7618 parse_func = sha1_parse_hash;
7619 sort_by_digest = sort_by_digest_4_5;
7620 opti_type = OPTI_TYPE_ZERO_BYTE
7621 | OPTI_TYPE_PRECOMPUTE_INIT
7622 | OPTI_TYPE_PRECOMPUTE_MERKLE
7623 | OPTI_TYPE_EARLY_SKIP
7624 | OPTI_TYPE_NOT_ITERATED
7625 | OPTI_TYPE_NOT_SALTED;
7626 dgst_pos0 = 3;
7627 dgst_pos1 = 4;
7628 dgst_pos2 = 2;
7629 dgst_pos3 = 1;
7630 break;
7631
7632 case 400: hash_type = HASH_TYPE_MD5;
7633 salt_type = SALT_TYPE_EMBEDDED;
7634 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7635 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7636 kern_type = KERN_TYPE_PHPASS;
7637 dgst_size = DGST_SIZE_4_4;
7638 parse_func = phpass_parse_hash;
7639 sort_by_digest = sort_by_digest_4_4;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_SLOW_HASH_SIMD;
7642 dgst_pos0 = 0;
7643 dgst_pos1 = 1;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 3;
7646 break;
7647
7648 case 500: hash_type = HASH_TYPE_MD5;
7649 salt_type = SALT_TYPE_EMBEDDED;
7650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7652 kern_type = KERN_TYPE_MD5CRYPT;
7653 dgst_size = DGST_SIZE_4_4;
7654 parse_func = md5crypt_parse_hash;
7655 sort_by_digest = sort_by_digest_4_4;
7656 opti_type = OPTI_TYPE_ZERO_BYTE;
7657 dgst_pos0 = 0;
7658 dgst_pos1 = 1;
7659 dgst_pos2 = 2;
7660 dgst_pos3 = 3;
7661 break;
7662
7663 case 501: hash_type = HASH_TYPE_MD5;
7664 salt_type = SALT_TYPE_EMBEDDED;
7665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7666 opts_type = OPTS_TYPE_PT_GENERATE_LE
7667 | OPTS_TYPE_HASH_COPY;
7668 kern_type = KERN_TYPE_MD5CRYPT;
7669 dgst_size = DGST_SIZE_4_4;
7670 parse_func = juniper_parse_hash;
7671 sort_by_digest = sort_by_digest_4_4;
7672 opti_type = OPTI_TYPE_ZERO_BYTE;
7673 dgst_pos0 = 0;
7674 dgst_pos1 = 1;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 3;
7677 break;
7678
7679 case 900: hash_type = HASH_TYPE_MD4;
7680 salt_type = SALT_TYPE_NONE;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_LE
7683 | OPTS_TYPE_PT_ADD80
7684 | OPTS_TYPE_PT_ADDBITS14;
7685 kern_type = KERN_TYPE_MD4;
7686 dgst_size = DGST_SIZE_4_4;
7687 parse_func = md4_parse_hash;
7688 sort_by_digest = sort_by_digest_4_4;
7689 opti_type = OPTI_TYPE_ZERO_BYTE
7690 | OPTI_TYPE_PRECOMPUTE_INIT
7691 | OPTI_TYPE_PRECOMPUTE_MERKLE
7692 | OPTI_TYPE_MEET_IN_MIDDLE
7693 | OPTI_TYPE_EARLY_SKIP
7694 | OPTI_TYPE_NOT_ITERATED
7695 | OPTI_TYPE_NOT_SALTED
7696 | OPTI_TYPE_RAW_HASH;
7697 dgst_pos0 = 0;
7698 dgst_pos1 = 3;
7699 dgst_pos2 = 2;
7700 dgst_pos3 = 1;
7701 break;
7702
7703 case 1000: hash_type = HASH_TYPE_MD4;
7704 salt_type = SALT_TYPE_NONE;
7705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7706 opts_type = OPTS_TYPE_PT_GENERATE_LE
7707 | OPTS_TYPE_PT_ADD80
7708 | OPTS_TYPE_PT_ADDBITS14
7709 | OPTS_TYPE_PT_UNICODE;
7710 kern_type = KERN_TYPE_MD4_PWU;
7711 dgst_size = DGST_SIZE_4_4;
7712 parse_func = md4_parse_hash;
7713 sort_by_digest = sort_by_digest_4_4;
7714 opti_type = OPTI_TYPE_ZERO_BYTE
7715 | OPTI_TYPE_PRECOMPUTE_INIT
7716 | OPTI_TYPE_PRECOMPUTE_MERKLE
7717 | OPTI_TYPE_MEET_IN_MIDDLE
7718 | OPTI_TYPE_EARLY_SKIP
7719 | OPTI_TYPE_NOT_ITERATED
7720 | OPTI_TYPE_NOT_SALTED
7721 | OPTI_TYPE_RAW_HASH;
7722 dgst_pos0 = 0;
7723 dgst_pos1 = 3;
7724 dgst_pos2 = 2;
7725 dgst_pos3 = 1;
7726 break;
7727
7728 case 1100: hash_type = HASH_TYPE_MD4;
7729 salt_type = SALT_TYPE_INTERN;
7730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7731 opts_type = OPTS_TYPE_PT_GENERATE_LE
7732 | OPTS_TYPE_PT_ADD80
7733 | OPTS_TYPE_PT_ADDBITS14
7734 | OPTS_TYPE_PT_UNICODE
7735 | OPTS_TYPE_ST_ADD80
7736 | OPTS_TYPE_ST_UNICODE
7737 | OPTS_TYPE_ST_LOWER;
7738 kern_type = KERN_TYPE_MD44_PWUSLT;
7739 dgst_size = DGST_SIZE_4_4;
7740 parse_func = dcc_parse_hash;
7741 sort_by_digest = sort_by_digest_4_4;
7742 opti_type = OPTI_TYPE_ZERO_BYTE
7743 | OPTI_TYPE_PRECOMPUTE_INIT
7744 | OPTI_TYPE_PRECOMPUTE_MERKLE
7745 | OPTI_TYPE_EARLY_SKIP
7746 | OPTI_TYPE_NOT_ITERATED;
7747 dgst_pos0 = 0;
7748 dgst_pos1 = 3;
7749 dgst_pos2 = 2;
7750 dgst_pos3 = 1;
7751 break;
7752
7753 case 1400: hash_type = HASH_TYPE_SHA256;
7754 salt_type = SALT_TYPE_NONE;
7755 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7756 opts_type = OPTS_TYPE_PT_GENERATE_BE
7757 | OPTS_TYPE_PT_ADD80
7758 | OPTS_TYPE_PT_ADDBITS15;
7759 kern_type = KERN_TYPE_SHA256;
7760 dgst_size = DGST_SIZE_4_8;
7761 parse_func = sha256_parse_hash;
7762 sort_by_digest = sort_by_digest_4_8;
7763 opti_type = OPTI_TYPE_ZERO_BYTE
7764 | OPTI_TYPE_PRECOMPUTE_INIT
7765 | OPTI_TYPE_PRECOMPUTE_MERKLE
7766 | OPTI_TYPE_EARLY_SKIP
7767 | OPTI_TYPE_NOT_ITERATED
7768 | OPTI_TYPE_NOT_SALTED
7769 | OPTI_TYPE_RAW_HASH;
7770 dgst_pos0 = 3;
7771 dgst_pos1 = 7;
7772 dgst_pos2 = 2;
7773 dgst_pos3 = 6;
7774 break;
7775
7776 case 1410: hash_type = HASH_TYPE_SHA256;
7777 salt_type = SALT_TYPE_INTERN;
7778 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7779 opts_type = OPTS_TYPE_PT_GENERATE_BE
7780 | OPTS_TYPE_ST_ADD80
7781 | OPTS_TYPE_ST_ADDBITS15;
7782 kern_type = KERN_TYPE_SHA256_PWSLT;
7783 dgst_size = DGST_SIZE_4_8;
7784 parse_func = sha256s_parse_hash;
7785 sort_by_digest = sort_by_digest_4_8;
7786 opti_type = OPTI_TYPE_ZERO_BYTE
7787 | OPTI_TYPE_PRECOMPUTE_INIT
7788 | OPTI_TYPE_PRECOMPUTE_MERKLE
7789 | OPTI_TYPE_EARLY_SKIP
7790 | OPTI_TYPE_NOT_ITERATED
7791 | OPTI_TYPE_APPENDED_SALT
7792 | OPTI_TYPE_RAW_HASH;
7793 dgst_pos0 = 3;
7794 dgst_pos1 = 7;
7795 dgst_pos2 = 2;
7796 dgst_pos3 = 6;
7797 break;
7798
7799 case 1420: hash_type = HASH_TYPE_SHA256;
7800 salt_type = SALT_TYPE_INTERN;
7801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7802 opts_type = OPTS_TYPE_PT_GENERATE_BE
7803 | OPTS_TYPE_PT_ADD80
7804 | OPTS_TYPE_PT_ADDBITS15;
7805 kern_type = KERN_TYPE_SHA256_SLTPW;
7806 dgst_size = DGST_SIZE_4_8;
7807 parse_func = sha256s_parse_hash;
7808 sort_by_digest = sort_by_digest_4_8;
7809 opti_type = OPTI_TYPE_ZERO_BYTE
7810 | OPTI_TYPE_PRECOMPUTE_INIT
7811 | OPTI_TYPE_PRECOMPUTE_MERKLE
7812 | OPTI_TYPE_EARLY_SKIP
7813 | OPTI_TYPE_NOT_ITERATED
7814 | OPTI_TYPE_PREPENDED_SALT
7815 | OPTI_TYPE_RAW_HASH;
7816 dgst_pos0 = 3;
7817 dgst_pos1 = 7;
7818 dgst_pos2 = 2;
7819 dgst_pos3 = 6;
7820 break;
7821
7822 case 1421: hash_type = HASH_TYPE_SHA256;
7823 salt_type = SALT_TYPE_EMBEDDED;
7824 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7825 opts_type = OPTS_TYPE_PT_GENERATE_BE
7826 | OPTS_TYPE_PT_ADD80
7827 | OPTS_TYPE_PT_ADDBITS15;
7828 kern_type = KERN_TYPE_SHA256_SLTPW;
7829 dgst_size = DGST_SIZE_4_8;
7830 parse_func = hmailserver_parse_hash;
7831 sort_by_digest = sort_by_digest_4_8;
7832 opti_type = OPTI_TYPE_ZERO_BYTE
7833 | OPTI_TYPE_PRECOMPUTE_INIT
7834 | OPTI_TYPE_PRECOMPUTE_MERKLE
7835 | OPTI_TYPE_EARLY_SKIP
7836 | OPTI_TYPE_NOT_ITERATED
7837 | OPTI_TYPE_PREPENDED_SALT
7838 | OPTI_TYPE_RAW_HASH;
7839 dgst_pos0 = 3;
7840 dgst_pos1 = 7;
7841 dgst_pos2 = 2;
7842 dgst_pos3 = 6;
7843 break;
7844
7845 case 1430: hash_type = HASH_TYPE_SHA256;
7846 salt_type = SALT_TYPE_INTERN;
7847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7848 opts_type = OPTS_TYPE_PT_GENERATE_BE
7849 | OPTS_TYPE_PT_UNICODE
7850 | OPTS_TYPE_ST_ADD80
7851 | OPTS_TYPE_ST_ADDBITS15;
7852 kern_type = KERN_TYPE_SHA256_PWUSLT;
7853 dgst_size = DGST_SIZE_4_8;
7854 parse_func = sha256s_parse_hash;
7855 sort_by_digest = sort_by_digest_4_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_APPENDED_SALT
7862 | OPTI_TYPE_RAW_HASH;
7863 dgst_pos0 = 3;
7864 dgst_pos1 = 7;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 6;
7867 break;
7868
7869 case 1440: hash_type = HASH_TYPE_SHA256;
7870 salt_type = SALT_TYPE_INTERN;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_BE
7873 | OPTS_TYPE_PT_ADD80
7874 | OPTS_TYPE_PT_ADDBITS15
7875 | OPTS_TYPE_PT_UNICODE;
7876 kern_type = KERN_TYPE_SHA256_SLTPWU;
7877 dgst_size = DGST_SIZE_4_8;
7878 parse_func = sha256s_parse_hash;
7879 sort_by_digest = sort_by_digest_4_8;
7880 opti_type = OPTI_TYPE_ZERO_BYTE
7881 | OPTI_TYPE_PRECOMPUTE_INIT
7882 | OPTI_TYPE_PRECOMPUTE_MERKLE
7883 | OPTI_TYPE_EARLY_SKIP
7884 | OPTI_TYPE_NOT_ITERATED
7885 | OPTI_TYPE_PREPENDED_SALT
7886 | OPTI_TYPE_RAW_HASH;
7887 dgst_pos0 = 3;
7888 dgst_pos1 = 7;
7889 dgst_pos2 = 2;
7890 dgst_pos3 = 6;
7891 break;
7892
7893 case 1441: hash_type = HASH_TYPE_SHA256;
7894 salt_type = SALT_TYPE_EMBEDDED;
7895 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7896 opts_type = OPTS_TYPE_PT_GENERATE_BE
7897 | OPTS_TYPE_PT_ADD80
7898 | OPTS_TYPE_PT_ADDBITS15
7899 | OPTS_TYPE_PT_UNICODE
7900 | OPTS_TYPE_ST_BASE64;
7901 kern_type = KERN_TYPE_SHA256_SLTPWU;
7902 dgst_size = DGST_SIZE_4_8;
7903 parse_func = episerver4_parse_hash;
7904 sort_by_digest = sort_by_digest_4_8;
7905 opti_type = OPTI_TYPE_ZERO_BYTE
7906 | OPTI_TYPE_PRECOMPUTE_INIT
7907 | OPTI_TYPE_PRECOMPUTE_MERKLE
7908 | OPTI_TYPE_EARLY_SKIP
7909 | OPTI_TYPE_NOT_ITERATED
7910 | OPTI_TYPE_PREPENDED_SALT
7911 | OPTI_TYPE_RAW_HASH;
7912 dgst_pos0 = 3;
7913 dgst_pos1 = 7;
7914 dgst_pos2 = 2;
7915 dgst_pos3 = 6;
7916 break;
7917
7918 case 1450: hash_type = HASH_TYPE_SHA256;
7919 salt_type = SALT_TYPE_INTERN;
7920 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7921 opts_type = OPTS_TYPE_PT_GENERATE_BE
7922 | OPTS_TYPE_ST_ADD80;
7923 kern_type = KERN_TYPE_HMACSHA256_PW;
7924 dgst_size = DGST_SIZE_4_8;
7925 parse_func = hmacsha256_parse_hash;
7926 sort_by_digest = sort_by_digest_4_8;
7927 opti_type = OPTI_TYPE_ZERO_BYTE
7928 | OPTI_TYPE_NOT_ITERATED;
7929 dgst_pos0 = 3;
7930 dgst_pos1 = 7;
7931 dgst_pos2 = 2;
7932 dgst_pos3 = 6;
7933 break;
7934
7935 case 1460: hash_type = HASH_TYPE_SHA256;
7936 salt_type = SALT_TYPE_INTERN;
7937 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7938 opts_type = OPTS_TYPE_PT_GENERATE_BE
7939 | OPTS_TYPE_PT_ADD80
7940 | OPTS_TYPE_PT_ADDBITS15;
7941 kern_type = KERN_TYPE_HMACSHA256_SLT;
7942 dgst_size = DGST_SIZE_4_8;
7943 parse_func = hmacsha256_parse_hash;
7944 sort_by_digest = sort_by_digest_4_8;
7945 opti_type = OPTI_TYPE_ZERO_BYTE
7946 | OPTI_TYPE_NOT_ITERATED;
7947 dgst_pos0 = 3;
7948 dgst_pos1 = 7;
7949 dgst_pos2 = 2;
7950 dgst_pos3 = 6;
7951 break;
7952
7953 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7954 salt_type = SALT_TYPE_EMBEDDED;
7955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7956 opts_type = OPTS_TYPE_PT_GENERATE_LE
7957 | OPTS_TYPE_PT_BITSLICE;
7958 kern_type = KERN_TYPE_DESCRYPT;
7959 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7960 parse_func = descrypt_parse_hash;
7961 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7962 opti_type = OPTI_TYPE_ZERO_BYTE
7963 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7964 dgst_pos0 = 0;
7965 dgst_pos1 = 1;
7966 dgst_pos2 = 2;
7967 dgst_pos3 = 3;
7968 break;
7969
7970 case 1600: hash_type = HASH_TYPE_MD5;
7971 salt_type = SALT_TYPE_EMBEDDED;
7972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7973 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7974 kern_type = KERN_TYPE_APR1CRYPT;
7975 dgst_size = DGST_SIZE_4_4;
7976 parse_func = md5apr1_parse_hash;
7977 sort_by_digest = sort_by_digest_4_4;
7978 opti_type = OPTI_TYPE_ZERO_BYTE;
7979 dgst_pos0 = 0;
7980 dgst_pos1 = 1;
7981 dgst_pos2 = 2;
7982 dgst_pos3 = 3;
7983 break;
7984
7985 case 1700: hash_type = HASH_TYPE_SHA512;
7986 salt_type = SALT_TYPE_NONE;
7987 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7988 opts_type = OPTS_TYPE_PT_GENERATE_BE
7989 | OPTS_TYPE_PT_ADD80
7990 | OPTS_TYPE_PT_ADDBITS15;
7991 kern_type = KERN_TYPE_SHA512;
7992 dgst_size = DGST_SIZE_8_8;
7993 parse_func = sha512_parse_hash;
7994 sort_by_digest = sort_by_digest_8_8;
7995 opti_type = OPTI_TYPE_ZERO_BYTE
7996 | OPTI_TYPE_PRECOMPUTE_INIT
7997 | OPTI_TYPE_PRECOMPUTE_MERKLE
7998 | OPTI_TYPE_EARLY_SKIP
7999 | OPTI_TYPE_NOT_ITERATED
8000 | OPTI_TYPE_NOT_SALTED
8001 | OPTI_TYPE_USES_BITS_64
8002 | OPTI_TYPE_RAW_HASH;
8003 dgst_pos0 = 14;
8004 dgst_pos1 = 15;
8005 dgst_pos2 = 6;
8006 dgst_pos3 = 7;
8007 break;
8008
8009 case 1710: hash_type = HASH_TYPE_SHA512;
8010 salt_type = SALT_TYPE_INTERN;
8011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8012 opts_type = OPTS_TYPE_PT_GENERATE_BE
8013 | OPTS_TYPE_ST_ADD80
8014 | OPTS_TYPE_ST_ADDBITS15;
8015 kern_type = KERN_TYPE_SHA512_PWSLT;
8016 dgst_size = DGST_SIZE_8_8;
8017 parse_func = sha512s_parse_hash;
8018 sort_by_digest = sort_by_digest_8_8;
8019 opti_type = OPTI_TYPE_ZERO_BYTE
8020 | OPTI_TYPE_PRECOMPUTE_INIT
8021 | OPTI_TYPE_PRECOMPUTE_MERKLE
8022 | OPTI_TYPE_EARLY_SKIP
8023 | OPTI_TYPE_NOT_ITERATED
8024 | OPTI_TYPE_APPENDED_SALT
8025 | OPTI_TYPE_USES_BITS_64
8026 | OPTI_TYPE_RAW_HASH;
8027 dgst_pos0 = 14;
8028 dgst_pos1 = 15;
8029 dgst_pos2 = 6;
8030 dgst_pos3 = 7;
8031 break;
8032
8033 case 1711: hash_type = HASH_TYPE_SHA512;
8034 salt_type = SALT_TYPE_EMBEDDED;
8035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8036 opts_type = OPTS_TYPE_PT_GENERATE_BE
8037 | OPTS_TYPE_ST_ADD80
8038 | OPTS_TYPE_ST_ADDBITS15;
8039 kern_type = KERN_TYPE_SHA512_PWSLT;
8040 dgst_size = DGST_SIZE_8_8;
8041 parse_func = sha512b64s_parse_hash;
8042 sort_by_digest = sort_by_digest_8_8;
8043 opti_type = OPTI_TYPE_ZERO_BYTE
8044 | OPTI_TYPE_PRECOMPUTE_INIT
8045 | OPTI_TYPE_PRECOMPUTE_MERKLE
8046 | OPTI_TYPE_EARLY_SKIP
8047 | OPTI_TYPE_NOT_ITERATED
8048 | OPTI_TYPE_APPENDED_SALT
8049 | OPTI_TYPE_USES_BITS_64
8050 | OPTI_TYPE_RAW_HASH;
8051 dgst_pos0 = 14;
8052 dgst_pos1 = 15;
8053 dgst_pos2 = 6;
8054 dgst_pos3 = 7;
8055 break;
8056
8057 case 1720: hash_type = HASH_TYPE_SHA512;
8058 salt_type = SALT_TYPE_INTERN;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_ADD80
8062 | OPTS_TYPE_PT_ADDBITS15;
8063 kern_type = KERN_TYPE_SHA512_SLTPW;
8064 dgst_size = DGST_SIZE_8_8;
8065 parse_func = sha512s_parse_hash;
8066 sort_by_digest = sort_by_digest_8_8;
8067 opti_type = OPTI_TYPE_ZERO_BYTE
8068 | OPTI_TYPE_PRECOMPUTE_INIT
8069 | OPTI_TYPE_PRECOMPUTE_MERKLE
8070 | OPTI_TYPE_EARLY_SKIP
8071 | OPTI_TYPE_NOT_ITERATED
8072 | OPTI_TYPE_PREPENDED_SALT
8073 | OPTI_TYPE_USES_BITS_64
8074 | OPTI_TYPE_RAW_HASH;
8075 dgst_pos0 = 14;
8076 dgst_pos1 = 15;
8077 dgst_pos2 = 6;
8078 dgst_pos3 = 7;
8079 break;
8080
8081 case 1722: hash_type = HASH_TYPE_SHA512;
8082 salt_type = SALT_TYPE_EMBEDDED;
8083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8084 opts_type = OPTS_TYPE_PT_GENERATE_BE
8085 | OPTS_TYPE_PT_ADD80
8086 | OPTS_TYPE_PT_ADDBITS15
8087 | OPTS_TYPE_ST_HEX;
8088 kern_type = KERN_TYPE_SHA512_SLTPW;
8089 dgst_size = DGST_SIZE_8_8;
8090 parse_func = osx512_parse_hash;
8091 sort_by_digest = sort_by_digest_8_8;
8092 opti_type = OPTI_TYPE_ZERO_BYTE
8093 | OPTI_TYPE_PRECOMPUTE_INIT
8094 | OPTI_TYPE_PRECOMPUTE_MERKLE
8095 | OPTI_TYPE_EARLY_SKIP
8096 | OPTI_TYPE_NOT_ITERATED
8097 | OPTI_TYPE_PREPENDED_SALT
8098 | OPTI_TYPE_USES_BITS_64
8099 | OPTI_TYPE_RAW_HASH;
8100 dgst_pos0 = 14;
8101 dgst_pos1 = 15;
8102 dgst_pos2 = 6;
8103 dgst_pos3 = 7;
8104 break;
8105
8106 case 1730: hash_type = HASH_TYPE_SHA512;
8107 salt_type = SALT_TYPE_INTERN;
8108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8109 opts_type = OPTS_TYPE_PT_GENERATE_BE
8110 | OPTS_TYPE_PT_UNICODE
8111 | OPTS_TYPE_ST_ADD80
8112 | OPTS_TYPE_ST_ADDBITS15;
8113 kern_type = KERN_TYPE_SHA512_PWSLTU;
8114 dgst_size = DGST_SIZE_8_8;
8115 parse_func = sha512s_parse_hash;
8116 sort_by_digest = sort_by_digest_8_8;
8117 opti_type = OPTI_TYPE_ZERO_BYTE
8118 | OPTI_TYPE_PRECOMPUTE_INIT
8119 | OPTI_TYPE_PRECOMPUTE_MERKLE
8120 | OPTI_TYPE_EARLY_SKIP
8121 | OPTI_TYPE_NOT_ITERATED
8122 | OPTI_TYPE_APPENDED_SALT
8123 | OPTI_TYPE_USES_BITS_64
8124 | OPTI_TYPE_RAW_HASH;
8125 dgst_pos0 = 14;
8126 dgst_pos1 = 15;
8127 dgst_pos2 = 6;
8128 dgst_pos3 = 7;
8129 break;
8130
8131 case 1731: hash_type = HASH_TYPE_SHA512;
8132 salt_type = SALT_TYPE_EMBEDDED;
8133 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8134 opts_type = OPTS_TYPE_PT_GENERATE_BE
8135 | OPTS_TYPE_PT_UNICODE
8136 | OPTS_TYPE_ST_ADD80
8137 | OPTS_TYPE_ST_ADDBITS15
8138 | OPTS_TYPE_ST_HEX;
8139 kern_type = KERN_TYPE_SHA512_PWSLTU;
8140 dgst_size = DGST_SIZE_8_8;
8141 parse_func = mssql2012_parse_hash;
8142 sort_by_digest = sort_by_digest_8_8;
8143 opti_type = OPTI_TYPE_ZERO_BYTE
8144 | OPTI_TYPE_PRECOMPUTE_INIT
8145 | OPTI_TYPE_PRECOMPUTE_MERKLE
8146 | OPTI_TYPE_EARLY_SKIP
8147 | OPTI_TYPE_NOT_ITERATED
8148 | OPTI_TYPE_APPENDED_SALT
8149 | OPTI_TYPE_USES_BITS_64
8150 | OPTI_TYPE_RAW_HASH;
8151 dgst_pos0 = 14;
8152 dgst_pos1 = 15;
8153 dgst_pos2 = 6;
8154 dgst_pos3 = 7;
8155 break;
8156
8157 case 1740: hash_type = HASH_TYPE_SHA512;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_BE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS15
8163 | OPTS_TYPE_PT_UNICODE;
8164 kern_type = KERN_TYPE_SHA512_SLTPWU;
8165 dgst_size = DGST_SIZE_8_8;
8166 parse_func = sha512s_parse_hash;
8167 sort_by_digest = sort_by_digest_8_8;
8168 opti_type = OPTI_TYPE_ZERO_BYTE
8169 | OPTI_TYPE_PRECOMPUTE_INIT
8170 | OPTI_TYPE_PRECOMPUTE_MERKLE
8171 | OPTI_TYPE_EARLY_SKIP
8172 | OPTI_TYPE_NOT_ITERATED
8173 | OPTI_TYPE_PREPENDED_SALT
8174 | OPTI_TYPE_USES_BITS_64
8175 | OPTI_TYPE_RAW_HASH;
8176 dgst_pos0 = 14;
8177 dgst_pos1 = 15;
8178 dgst_pos2 = 6;
8179 dgst_pos3 = 7;
8180 break;
8181
8182 case 1750: hash_type = HASH_TYPE_SHA512;
8183 salt_type = SALT_TYPE_INTERN;
8184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8185 opts_type = OPTS_TYPE_PT_GENERATE_BE
8186 | OPTS_TYPE_ST_ADD80;
8187 kern_type = KERN_TYPE_HMACSHA512_PW;
8188 dgst_size = DGST_SIZE_8_8;
8189 parse_func = hmacsha512_parse_hash;
8190 sort_by_digest = sort_by_digest_8_8;
8191 opti_type = OPTI_TYPE_ZERO_BYTE
8192 | OPTI_TYPE_USES_BITS_64
8193 | OPTI_TYPE_NOT_ITERATED;
8194 dgst_pos0 = 14;
8195 dgst_pos1 = 15;
8196 dgst_pos2 = 6;
8197 dgst_pos3 = 7;
8198 break;
8199
8200 case 1760: hash_type = HASH_TYPE_SHA512;
8201 salt_type = SALT_TYPE_INTERN;
8202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8203 opts_type = OPTS_TYPE_PT_GENERATE_BE
8204 | OPTS_TYPE_PT_ADD80
8205 | OPTS_TYPE_PT_ADDBITS15;
8206 kern_type = KERN_TYPE_HMACSHA512_SLT;
8207 dgst_size = DGST_SIZE_8_8;
8208 parse_func = hmacsha512_parse_hash;
8209 sort_by_digest = sort_by_digest_8_8;
8210 opti_type = OPTI_TYPE_ZERO_BYTE
8211 | OPTI_TYPE_USES_BITS_64
8212 | OPTI_TYPE_NOT_ITERATED;
8213 dgst_pos0 = 14;
8214 dgst_pos1 = 15;
8215 dgst_pos2 = 6;
8216 dgst_pos3 = 7;
8217 break;
8218
8219 case 1800: hash_type = HASH_TYPE_SHA512;
8220 salt_type = SALT_TYPE_EMBEDDED;
8221 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8222 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8223 kern_type = KERN_TYPE_SHA512CRYPT;
8224 dgst_size = DGST_SIZE_8_8;
8225 parse_func = sha512crypt_parse_hash;
8226 sort_by_digest = sort_by_digest_8_8;
8227 opti_type = OPTI_TYPE_ZERO_BYTE
8228 | OPTI_TYPE_USES_BITS_64;
8229 dgst_pos0 = 0;
8230 dgst_pos1 = 1;
8231 dgst_pos2 = 2;
8232 dgst_pos3 = 3;
8233 break;
8234
8235 case 2100: hash_type = HASH_TYPE_DCC2;
8236 salt_type = SALT_TYPE_EMBEDDED;
8237 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8238 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8239 | OPTS_TYPE_ST_LOWER
8240 | OPTS_TYPE_ST_UNICODE;
8241 kern_type = KERN_TYPE_DCC2;
8242 dgst_size = DGST_SIZE_4_4;
8243 parse_func = dcc2_parse_hash;
8244 sort_by_digest = sort_by_digest_4_4;
8245 opti_type = OPTI_TYPE_ZERO_BYTE
8246 | OPTI_TYPE_SLOW_HASH_SIMD;
8247 dgst_pos0 = 0;
8248 dgst_pos1 = 1;
8249 dgst_pos2 = 2;
8250 dgst_pos3 = 3;
8251 break;
8252
8253 case 2400: hash_type = HASH_TYPE_MD5;
8254 salt_type = SALT_TYPE_NONE;
8255 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8256 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8257 kern_type = KERN_TYPE_MD5PIX;
8258 dgst_size = DGST_SIZE_4_4;
8259 parse_func = md5pix_parse_hash;
8260 sort_by_digest = sort_by_digest_4_4;
8261 opti_type = OPTI_TYPE_ZERO_BYTE
8262 | OPTI_TYPE_PRECOMPUTE_INIT
8263 | OPTI_TYPE_PRECOMPUTE_MERKLE
8264 | OPTI_TYPE_EARLY_SKIP
8265 | OPTI_TYPE_NOT_ITERATED
8266 | OPTI_TYPE_NOT_SALTED;
8267 dgst_pos0 = 0;
8268 dgst_pos1 = 3;
8269 dgst_pos2 = 2;
8270 dgst_pos3 = 1;
8271 break;
8272
8273 case 2410: hash_type = HASH_TYPE_MD5;
8274 salt_type = SALT_TYPE_INTERN;
8275 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8277 kern_type = KERN_TYPE_MD5ASA;
8278 dgst_size = DGST_SIZE_4_4;
8279 parse_func = md5asa_parse_hash;
8280 sort_by_digest = sort_by_digest_4_4;
8281 opti_type = OPTI_TYPE_ZERO_BYTE
8282 | OPTI_TYPE_PRECOMPUTE_INIT
8283 | OPTI_TYPE_PRECOMPUTE_MERKLE
8284 | OPTI_TYPE_EARLY_SKIP
8285 | OPTI_TYPE_NOT_ITERATED;
8286 dgst_pos0 = 0;
8287 dgst_pos1 = 3;
8288 dgst_pos2 = 2;
8289 dgst_pos3 = 1;
8290 break;
8291
8292 case 2500: hash_type = HASH_TYPE_WPA;
8293 salt_type = SALT_TYPE_EMBEDDED;
8294 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8295 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8296 kern_type = KERN_TYPE_WPA;
8297 dgst_size = DGST_SIZE_4_4;
8298 parse_func = wpa_parse_hash;
8299 sort_by_digest = sort_by_digest_4_4;
8300 opti_type = OPTI_TYPE_ZERO_BYTE
8301 | OPTI_TYPE_SLOW_HASH_SIMD;
8302 dgst_pos0 = 0;
8303 dgst_pos1 = 1;
8304 dgst_pos2 = 2;
8305 dgst_pos3 = 3;
8306 break;
8307
8308 case 2600: hash_type = HASH_TYPE_MD5;
8309 salt_type = SALT_TYPE_VIRTUAL;
8310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8311 opts_type = OPTS_TYPE_PT_GENERATE_LE
8312 | OPTS_TYPE_PT_ADD80
8313 | OPTS_TYPE_PT_ADDBITS14
8314 | OPTS_TYPE_ST_ADD80;
8315 kern_type = KERN_TYPE_MD55_PWSLT1;
8316 dgst_size = DGST_SIZE_4_4;
8317 parse_func = md5md5_parse_hash;
8318 sort_by_digest = sort_by_digest_4_4;
8319 opti_type = OPTI_TYPE_ZERO_BYTE
8320 | OPTI_TYPE_PRECOMPUTE_INIT
8321 | OPTI_TYPE_PRECOMPUTE_MERKLE
8322 | OPTI_TYPE_EARLY_SKIP;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 3;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 1;
8327 break;
8328
8329 case 2611: hash_type = HASH_TYPE_MD5;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS14
8335 | OPTS_TYPE_ST_ADD80;
8336 kern_type = KERN_TYPE_MD55_PWSLT1;
8337 dgst_size = DGST_SIZE_4_4;
8338 parse_func = vb3_parse_hash;
8339 sort_by_digest = sort_by_digest_4_4;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_PRECOMPUTE_MERKLE
8343 | OPTI_TYPE_EARLY_SKIP;
8344 dgst_pos0 = 0;
8345 dgst_pos1 = 3;
8346 dgst_pos2 = 2;
8347 dgst_pos3 = 1;
8348 break;
8349
8350 case 2612: hash_type = HASH_TYPE_MD5;
8351 salt_type = SALT_TYPE_EMBEDDED;
8352 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8353 opts_type = OPTS_TYPE_PT_GENERATE_LE
8354 | OPTS_TYPE_PT_ADD80
8355 | OPTS_TYPE_PT_ADDBITS14
8356 | OPTS_TYPE_ST_ADD80
8357 | OPTS_TYPE_ST_HEX;
8358 kern_type = KERN_TYPE_MD55_PWSLT1;
8359 dgst_size = DGST_SIZE_4_4;
8360 parse_func = phps_parse_hash;
8361 sort_by_digest = sort_by_digest_4_4;
8362 opti_type = OPTI_TYPE_ZERO_BYTE
8363 | OPTI_TYPE_PRECOMPUTE_INIT
8364 | OPTI_TYPE_PRECOMPUTE_MERKLE
8365 | OPTI_TYPE_EARLY_SKIP;
8366 dgst_pos0 = 0;
8367 dgst_pos1 = 3;
8368 dgst_pos2 = 2;
8369 dgst_pos3 = 1;
8370 break;
8371
8372 case 2711: hash_type = HASH_TYPE_MD5;
8373 salt_type = SALT_TYPE_INTERN;
8374 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8375 opts_type = OPTS_TYPE_PT_GENERATE_LE
8376 | OPTS_TYPE_PT_ADD80
8377 | OPTS_TYPE_PT_ADDBITS14
8378 | OPTS_TYPE_ST_ADD80;
8379 kern_type = KERN_TYPE_MD55_PWSLT2;
8380 dgst_size = DGST_SIZE_4_4;
8381 parse_func = vb30_parse_hash;
8382 sort_by_digest = sort_by_digest_4_4;
8383 opti_type = OPTI_TYPE_ZERO_BYTE
8384 | OPTI_TYPE_PRECOMPUTE_INIT
8385 | OPTI_TYPE_EARLY_SKIP;
8386 dgst_pos0 = 0;
8387 dgst_pos1 = 3;
8388 dgst_pos2 = 2;
8389 dgst_pos3 = 1;
8390 break;
8391
8392 case 2811: hash_type = HASH_TYPE_MD5;
8393 salt_type = SALT_TYPE_INTERN;
8394 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8395 opts_type = OPTS_TYPE_PT_GENERATE_LE
8396 | OPTS_TYPE_PT_ADD80
8397 | OPTS_TYPE_PT_ADDBITS14;
8398 kern_type = KERN_TYPE_MD55_SLTPW;
8399 dgst_size = DGST_SIZE_4_4;
8400 parse_func = ipb2_parse_hash;
8401 sort_by_digest = sort_by_digest_4_4;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_PRECOMPUTE_INIT
8404 | OPTI_TYPE_EARLY_SKIP;
8405 dgst_pos0 = 0;
8406 dgst_pos1 = 3;
8407 dgst_pos2 = 2;
8408 dgst_pos3 = 1;
8409 break;
8410
8411 case 3000: hash_type = HASH_TYPE_LM;
8412 salt_type = SALT_TYPE_NONE;
8413 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8414 opts_type = OPTS_TYPE_PT_GENERATE_LE
8415 | OPTS_TYPE_PT_UPPER
8416 | OPTS_TYPE_PT_BITSLICE;
8417 kern_type = KERN_TYPE_LM;
8418 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8419 parse_func = lm_parse_hash;
8420 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8421 opti_type = OPTI_TYPE_ZERO_BYTE
8422 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8423 dgst_pos0 = 0;
8424 dgst_pos1 = 1;
8425 dgst_pos2 = 2;
8426 dgst_pos3 = 3;
8427 break;
8428
8429 case 3100: hash_type = HASH_TYPE_ORACLEH;
8430 salt_type = SALT_TYPE_INTERN;
8431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8432 opts_type = OPTS_TYPE_PT_GENERATE_LE
8433 | OPTS_TYPE_PT_UPPER
8434 | OPTS_TYPE_ST_UPPER;
8435 kern_type = KERN_TYPE_ORACLEH;
8436 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8437 parse_func = oracleh_parse_hash;
8438 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8439 opti_type = OPTI_TYPE_ZERO_BYTE;
8440 dgst_pos0 = 0;
8441 dgst_pos1 = 1;
8442 dgst_pos2 = 2;
8443 dgst_pos3 = 3;
8444 break;
8445
8446 case 3200: hash_type = HASH_TYPE_BCRYPT;
8447 salt_type = SALT_TYPE_EMBEDDED;
8448 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8449 opts_type = OPTS_TYPE_PT_GENERATE_LE
8450 | OPTS_TYPE_ST_GENERATE_LE;
8451 kern_type = KERN_TYPE_BCRYPT;
8452 dgst_size = DGST_SIZE_4_6;
8453 parse_func = bcrypt_parse_hash;
8454 sort_by_digest = sort_by_digest_4_6;
8455 opti_type = OPTI_TYPE_ZERO_BYTE;
8456 dgst_pos0 = 0;
8457 dgst_pos1 = 1;
8458 dgst_pos2 = 2;
8459 dgst_pos3 = 3;
8460 break;
8461
8462 case 3710: hash_type = HASH_TYPE_MD5;
8463 salt_type = SALT_TYPE_INTERN;
8464 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8465 opts_type = OPTS_TYPE_PT_GENERATE_LE
8466 | OPTS_TYPE_PT_ADD80
8467 | OPTS_TYPE_PT_ADDBITS14;
8468 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8469 dgst_size = DGST_SIZE_4_4;
8470 parse_func = md5s_parse_hash;
8471 sort_by_digest = sort_by_digest_4_4;
8472 opti_type = OPTI_TYPE_ZERO_BYTE
8473 | OPTI_TYPE_PRECOMPUTE_INIT
8474 | OPTI_TYPE_PRECOMPUTE_MERKLE
8475 | OPTI_TYPE_EARLY_SKIP;
8476 dgst_pos0 = 0;
8477 dgst_pos1 = 3;
8478 dgst_pos2 = 2;
8479 dgst_pos3 = 1;
8480 break;
8481
8482 case 3711: hash_type = HASH_TYPE_MD5;
8483 salt_type = SALT_TYPE_EMBEDDED;
8484 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8485 opts_type = OPTS_TYPE_PT_GENERATE_LE
8486 | OPTS_TYPE_PT_ADD80
8487 | OPTS_TYPE_PT_ADDBITS14;
8488 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8489 dgst_size = DGST_SIZE_4_4;
8490 parse_func = mediawiki_b_parse_hash;
8491 sort_by_digest = sort_by_digest_4_4;
8492 opti_type = OPTI_TYPE_ZERO_BYTE
8493 | OPTI_TYPE_PRECOMPUTE_INIT
8494 | OPTI_TYPE_PRECOMPUTE_MERKLE
8495 | OPTI_TYPE_EARLY_SKIP;
8496 dgst_pos0 = 0;
8497 dgst_pos1 = 3;
8498 dgst_pos2 = 2;
8499 dgst_pos3 = 1;
8500 break;
8501
8502 case 3800: hash_type = HASH_TYPE_MD5;
8503 salt_type = SALT_TYPE_INTERN;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_LE
8506 | OPTS_TYPE_ST_ADDBITS14;
8507 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8508 dgst_size = DGST_SIZE_4_4;
8509 parse_func = md5s_parse_hash;
8510 sort_by_digest = sort_by_digest_4_4;
8511 opti_type = OPTI_TYPE_ZERO_BYTE
8512 | OPTI_TYPE_PRECOMPUTE_INIT
8513 | OPTI_TYPE_PRECOMPUTE_MERKLE
8514 | OPTI_TYPE_EARLY_SKIP
8515 | OPTI_TYPE_NOT_ITERATED
8516 | OPTI_TYPE_RAW_HASH;
8517 dgst_pos0 = 0;
8518 dgst_pos1 = 3;
8519 dgst_pos2 = 2;
8520 dgst_pos3 = 1;
8521 break;
8522
8523 case 4300: hash_type = HASH_TYPE_MD5;
8524 salt_type = SALT_TYPE_VIRTUAL;
8525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8526 opts_type = OPTS_TYPE_PT_GENERATE_LE
8527 | OPTS_TYPE_PT_ADD80
8528 | OPTS_TYPE_PT_ADDBITS14
8529 | OPTS_TYPE_ST_ADD80;
8530 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8531 dgst_size = DGST_SIZE_4_4;
8532 parse_func = md5md5_parse_hash;
8533 sort_by_digest = sort_by_digest_4_4;
8534 opti_type = OPTI_TYPE_ZERO_BYTE
8535 | OPTI_TYPE_PRECOMPUTE_INIT
8536 | OPTI_TYPE_PRECOMPUTE_MERKLE
8537 | OPTI_TYPE_EARLY_SKIP;
8538 dgst_pos0 = 0;
8539 dgst_pos1 = 3;
8540 dgst_pos2 = 2;
8541 dgst_pos3 = 1;
8542 break;
8543
8544
8545 case 4400: hash_type = HASH_TYPE_MD5;
8546 salt_type = SALT_TYPE_NONE;
8547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8548 opts_type = OPTS_TYPE_PT_GENERATE_BE
8549 | OPTS_TYPE_PT_ADD80
8550 | OPTS_TYPE_PT_ADDBITS15;
8551 kern_type = KERN_TYPE_MD5_SHA1;
8552 dgst_size = DGST_SIZE_4_4;
8553 parse_func = md5_parse_hash;
8554 sort_by_digest = sort_by_digest_4_4;
8555 opti_type = OPTI_TYPE_ZERO_BYTE
8556 | OPTI_TYPE_PRECOMPUTE_INIT
8557 | OPTI_TYPE_PRECOMPUTE_MERKLE
8558 | OPTI_TYPE_EARLY_SKIP
8559 | OPTI_TYPE_NOT_ITERATED
8560 | OPTI_TYPE_NOT_SALTED
8561 | OPTI_TYPE_RAW_HASH;
8562 dgst_pos0 = 0;
8563 dgst_pos1 = 3;
8564 dgst_pos2 = 2;
8565 dgst_pos3 = 1;
8566 break;
8567
8568 case 4500: hash_type = HASH_TYPE_SHA1;
8569 salt_type = SALT_TYPE_NONE;
8570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8571 opts_type = OPTS_TYPE_PT_GENERATE_BE
8572 | OPTS_TYPE_PT_ADD80
8573 | OPTS_TYPE_PT_ADDBITS15;
8574 kern_type = KERN_TYPE_SHA11;
8575 dgst_size = DGST_SIZE_4_5;
8576 parse_func = sha1_parse_hash;
8577 sort_by_digest = sort_by_digest_4_5;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_EARLY_SKIP
8582 | OPTI_TYPE_NOT_SALTED;
8583 dgst_pos0 = 3;
8584 dgst_pos1 = 4;
8585 dgst_pos2 = 2;
8586 dgst_pos3 = 1;
8587 break;
8588
8589 case 4700: hash_type = HASH_TYPE_SHA1;
8590 salt_type = SALT_TYPE_NONE;
8591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8592 opts_type = OPTS_TYPE_PT_GENERATE_LE
8593 | OPTS_TYPE_PT_ADD80
8594 | OPTS_TYPE_PT_ADDBITS14;
8595 kern_type = KERN_TYPE_SHA1_MD5;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = sha1_parse_hash;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_PRECOMPUTE_INIT
8601 | OPTI_TYPE_PRECOMPUTE_MERKLE
8602 | OPTI_TYPE_EARLY_SKIP
8603 | OPTI_TYPE_NOT_ITERATED
8604 | OPTI_TYPE_NOT_SALTED
8605 | OPTI_TYPE_RAW_HASH;
8606 dgst_pos0 = 3;
8607 dgst_pos1 = 4;
8608 dgst_pos2 = 2;
8609 dgst_pos3 = 1;
8610 break;
8611
8612 case 4800: hash_type = HASH_TYPE_MD5;
8613 salt_type = SALT_TYPE_EMBEDDED;
8614 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8615 opts_type = OPTS_TYPE_PT_GENERATE_LE
8616 | OPTS_TYPE_PT_ADDBITS14;
8617 kern_type = KERN_TYPE_MD5_CHAP;
8618 dgst_size = DGST_SIZE_4_4;
8619 parse_func = chap_parse_hash;
8620 sort_by_digest = sort_by_digest_4_4;
8621 opti_type = OPTI_TYPE_ZERO_BYTE
8622 | OPTI_TYPE_PRECOMPUTE_INIT
8623 | OPTI_TYPE_PRECOMPUTE_MERKLE
8624 | OPTI_TYPE_MEET_IN_MIDDLE
8625 | OPTI_TYPE_EARLY_SKIP
8626 | OPTI_TYPE_NOT_ITERATED
8627 | OPTI_TYPE_RAW_HASH;
8628 dgst_pos0 = 0;
8629 dgst_pos1 = 3;
8630 dgst_pos2 = 2;
8631 dgst_pos3 = 1;
8632 break;
8633
8634 case 4900: hash_type = HASH_TYPE_SHA1;
8635 salt_type = SALT_TYPE_INTERN;
8636 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8637 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8638 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8639 dgst_size = DGST_SIZE_4_5;
8640 parse_func = sha1s_parse_hash;
8641 sort_by_digest = sort_by_digest_4_5;
8642 opti_type = OPTI_TYPE_ZERO_BYTE
8643 | OPTI_TYPE_PRECOMPUTE_INIT
8644 | OPTI_TYPE_PRECOMPUTE_MERKLE
8645 | OPTI_TYPE_EARLY_SKIP;
8646 dgst_pos0 = 3;
8647 dgst_pos1 = 4;
8648 dgst_pos2 = 2;
8649 dgst_pos3 = 1;
8650 break;
8651
8652 case 5000: hash_type = HASH_TYPE_KECCAK;
8653 salt_type = SALT_TYPE_EMBEDDED;
8654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8655 opts_type = OPTS_TYPE_PT_GENERATE_LE
8656 | OPTS_TYPE_PT_ADD01;
8657 kern_type = KERN_TYPE_KECCAK;
8658 dgst_size = DGST_SIZE_8_25;
8659 parse_func = keccak_parse_hash;
8660 sort_by_digest = sort_by_digest_8_25;
8661 opti_type = OPTI_TYPE_ZERO_BYTE
8662 | OPTI_TYPE_USES_BITS_64
8663 | OPTI_TYPE_RAW_HASH;
8664 dgst_pos0 = 2;
8665 dgst_pos1 = 3;
8666 dgst_pos2 = 4;
8667 dgst_pos3 = 5;
8668 break;
8669
8670 case 5100: hash_type = HASH_TYPE_MD5H;
8671 salt_type = SALT_TYPE_NONE;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_LE
8674 | OPTS_TYPE_PT_ADD80
8675 | OPTS_TYPE_PT_ADDBITS14;
8676 kern_type = KERN_TYPE_MD5H;
8677 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8678 parse_func = md5half_parse_hash;
8679 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8680 opti_type = OPTI_TYPE_ZERO_BYTE
8681 | OPTI_TYPE_RAW_HASH;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 5200: hash_type = HASH_TYPE_SHA256;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8692 kern_type = KERN_TYPE_PSAFE3;
8693 dgst_size = DGST_SIZE_4_8;
8694 parse_func = psafe3_parse_hash;
8695 sort_by_digest = sort_by_digest_4_8;
8696 opti_type = OPTI_TYPE_ZERO_BYTE;
8697 dgst_pos0 = 0;
8698 dgst_pos1 = 1;
8699 dgst_pos2 = 2;
8700 dgst_pos3 = 3;
8701 break;
8702
8703 case 5300: hash_type = HASH_TYPE_MD5;
8704 salt_type = SALT_TYPE_EMBEDDED;
8705 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8706 opts_type = OPTS_TYPE_PT_GENERATE_LE
8707 | OPTS_TYPE_ST_ADD80;
8708 kern_type = KERN_TYPE_IKEPSK_MD5;
8709 dgst_size = DGST_SIZE_4_4;
8710 parse_func = ikepsk_md5_parse_hash;
8711 sort_by_digest = sort_by_digest_4_4;
8712 opti_type = OPTI_TYPE_ZERO_BYTE;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 3;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719 case 5400: hash_type = HASH_TYPE_SHA1;
8720 salt_type = SALT_TYPE_EMBEDDED;
8721 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8722 opts_type = OPTS_TYPE_PT_GENERATE_BE
8723 | OPTS_TYPE_ST_ADD80;
8724 kern_type = KERN_TYPE_IKEPSK_SHA1;
8725 dgst_size = DGST_SIZE_4_5;
8726 parse_func = ikepsk_sha1_parse_hash;
8727 sort_by_digest = sort_by_digest_4_5;
8728 opti_type = OPTI_TYPE_ZERO_BYTE;
8729 dgst_pos0 = 3;
8730 dgst_pos1 = 4;
8731 dgst_pos2 = 2;
8732 dgst_pos3 = 1;
8733 break;
8734
8735 case 5500: hash_type = HASH_TYPE_NETNTLM;
8736 salt_type = SALT_TYPE_EMBEDDED;
8737 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8738 opts_type = OPTS_TYPE_PT_GENERATE_LE
8739 | OPTS_TYPE_PT_ADD80
8740 | OPTS_TYPE_PT_ADDBITS14
8741 | OPTS_TYPE_PT_UNICODE
8742 | OPTS_TYPE_ST_HEX;
8743 kern_type = KERN_TYPE_NETNTLMv1;
8744 dgst_size = DGST_SIZE_4_4;
8745 parse_func = netntlmv1_parse_hash;
8746 sort_by_digest = sort_by_digest_4_4;
8747 opti_type = OPTI_TYPE_ZERO_BYTE
8748 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8749 dgst_pos0 = 0;
8750 dgst_pos1 = 1;
8751 dgst_pos2 = 2;
8752 dgst_pos3 = 3;
8753 break;
8754
8755 case 5600: hash_type = HASH_TYPE_MD5;
8756 salt_type = SALT_TYPE_EMBEDDED;
8757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8758 opts_type = OPTS_TYPE_PT_GENERATE_LE
8759 | OPTS_TYPE_PT_ADD80
8760 | OPTS_TYPE_PT_ADDBITS14
8761 | OPTS_TYPE_PT_UNICODE;
8762 kern_type = KERN_TYPE_NETNTLMv2;
8763 dgst_size = DGST_SIZE_4_4;
8764 parse_func = netntlmv2_parse_hash;
8765 sort_by_digest = sort_by_digest_4_4;
8766 opti_type = OPTI_TYPE_ZERO_BYTE;
8767 dgst_pos0 = 0;
8768 dgst_pos1 = 3;
8769 dgst_pos2 = 2;
8770 dgst_pos3 = 1;
8771 break;
8772
8773 case 5700: hash_type = HASH_TYPE_SHA256;
8774 salt_type = SALT_TYPE_NONE;
8775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8776 opts_type = OPTS_TYPE_PT_GENERATE_BE
8777 | OPTS_TYPE_PT_ADD80
8778 | OPTS_TYPE_PT_ADDBITS15;
8779 kern_type = KERN_TYPE_SHA256;
8780 dgst_size = DGST_SIZE_4_8;
8781 parse_func = cisco4_parse_hash;
8782 sort_by_digest = sort_by_digest_4_8;
8783 opti_type = OPTI_TYPE_ZERO_BYTE
8784 | OPTI_TYPE_PRECOMPUTE_INIT
8785 | OPTI_TYPE_PRECOMPUTE_MERKLE
8786 | OPTI_TYPE_EARLY_SKIP
8787 | OPTI_TYPE_NOT_ITERATED
8788 | OPTI_TYPE_NOT_SALTED
8789 | OPTI_TYPE_RAW_HASH;
8790 dgst_pos0 = 3;
8791 dgst_pos1 = 7;
8792 dgst_pos2 = 2;
8793 dgst_pos3 = 6;
8794 break;
8795
8796 case 5800: hash_type = HASH_TYPE_SHA1;
8797 salt_type = SALT_TYPE_INTERN;
8798 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8799 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8800 | OPTS_TYPE_ST_ADD80;
8801 kern_type = KERN_TYPE_ANDROIDPIN;
8802 dgst_size = DGST_SIZE_4_5;
8803 parse_func = androidpin_parse_hash;
8804 sort_by_digest = sort_by_digest_4_5;
8805 opti_type = OPTI_TYPE_ZERO_BYTE;
8806 dgst_pos0 = 0;
8807 dgst_pos1 = 1;
8808 dgst_pos2 = 2;
8809 dgst_pos3 = 3;
8810 break;
8811
8812 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8813 salt_type = SALT_TYPE_NONE;
8814 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8815 opts_type = OPTS_TYPE_PT_GENERATE_LE
8816 | OPTS_TYPE_PT_ADD80;
8817 kern_type = KERN_TYPE_RIPEMD160;
8818 dgst_size = DGST_SIZE_4_5;
8819 parse_func = ripemd160_parse_hash;
8820 sort_by_digest = sort_by_digest_4_5;
8821 opti_type = OPTI_TYPE_ZERO_BYTE;
8822 dgst_pos0 = 0;
8823 dgst_pos1 = 1;
8824 dgst_pos2 = 2;
8825 dgst_pos3 = 3;
8826 break;
8827
8828 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8829 salt_type = SALT_TYPE_NONE;
8830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8831 opts_type = OPTS_TYPE_PT_GENERATE_BE
8832 | OPTS_TYPE_PT_ADD80;
8833 kern_type = KERN_TYPE_WHIRLPOOL;
8834 dgst_size = DGST_SIZE_4_16;
8835 parse_func = whirlpool_parse_hash;
8836 sort_by_digest = sort_by_digest_4_16;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8849 dgst_size = DGST_SIZE_4_5;
8850 parse_func = truecrypt_parse_hash_2k;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8863 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8864 dgst_size = DGST_SIZE_4_5;
8865 parse_func = truecrypt_parse_hash_2k;
8866 sort_by_digest = sort_by_digest_4_5;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8878 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8879 dgst_size = DGST_SIZE_4_5;
8880 parse_func = truecrypt_parse_hash_2k;
8881 sort_by_digest = sort_by_digest_4_5;
8882 opti_type = OPTI_TYPE_ZERO_BYTE;
8883 dgst_pos0 = 0;
8884 dgst_pos1 = 1;
8885 dgst_pos2 = 2;
8886 dgst_pos3 = 3;
8887 break;
8888
8889 case 6221: hash_type = HASH_TYPE_SHA512;
8890 salt_type = SALT_TYPE_EMBEDDED;
8891 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8892 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8893 kern_type = KERN_TYPE_TCSHA512_XTS512;
8894 dgst_size = DGST_SIZE_8_8;
8895 parse_func = truecrypt_parse_hash_1k;
8896 sort_by_digest = sort_by_digest_8_8;
8897 opti_type = OPTI_TYPE_ZERO_BYTE
8898 | OPTI_TYPE_USES_BITS_64;
8899 dgst_pos0 = 0;
8900 dgst_pos1 = 1;
8901 dgst_pos2 = 2;
8902 dgst_pos3 = 3;
8903 break;
8904
8905 case 6222: hash_type = HASH_TYPE_SHA512;
8906 salt_type = SALT_TYPE_EMBEDDED;
8907 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8908 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8909 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8910 dgst_size = DGST_SIZE_8_8;
8911 parse_func = truecrypt_parse_hash_1k;
8912 sort_by_digest = sort_by_digest_8_8;
8913 opti_type = OPTI_TYPE_ZERO_BYTE
8914 | OPTI_TYPE_USES_BITS_64;
8915 dgst_pos0 = 0;
8916 dgst_pos1 = 1;
8917 dgst_pos2 = 2;
8918 dgst_pos3 = 3;
8919 break;
8920
8921 case 6223: hash_type = HASH_TYPE_SHA512;
8922 salt_type = SALT_TYPE_EMBEDDED;
8923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8924 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8925 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8926 dgst_size = DGST_SIZE_8_8;
8927 parse_func = truecrypt_parse_hash_1k;
8928 sort_by_digest = sort_by_digest_8_8;
8929 opti_type = OPTI_TYPE_ZERO_BYTE
8930 | OPTI_TYPE_USES_BITS_64;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8957 dgst_size = DGST_SIZE_4_8;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_8;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8972 dgst_size = DGST_SIZE_4_8;
8973 parse_func = truecrypt_parse_hash_1k;
8974 sort_by_digest = sort_by_digest_4_8;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8987 dgst_size = DGST_SIZE_4_5;
8988 parse_func = truecrypt_parse_hash_1k;
8989 sort_by_digest = sort_by_digest_4_5;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_1k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9017 dgst_size = DGST_SIZE_4_5;
9018 parse_func = truecrypt_parse_hash_1k;
9019 sort_by_digest = sort_by_digest_4_5;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6300: hash_type = HASH_TYPE_MD5;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9031 kern_type = KERN_TYPE_MD5AIX;
9032 dgst_size = DGST_SIZE_4_4;
9033 parse_func = md5aix_parse_hash;
9034 sort_by_digest = sort_by_digest_4_4;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6400: hash_type = HASH_TYPE_SHA256;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_SHA256AIX;
9047 dgst_size = DGST_SIZE_4_8;
9048 parse_func = sha256aix_parse_hash;
9049 sort_by_digest = sort_by_digest_4_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE;
9051 dgst_pos0 = 0;
9052 dgst_pos1 = 1;
9053 dgst_pos2 = 2;
9054 dgst_pos3 = 3;
9055 break;
9056
9057 case 6500: hash_type = HASH_TYPE_SHA512;
9058 salt_type = SALT_TYPE_EMBEDDED;
9059 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9060 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9061 kern_type = KERN_TYPE_SHA512AIX;
9062 dgst_size = DGST_SIZE_8_8;
9063 parse_func = sha512aix_parse_hash;
9064 sort_by_digest = sort_by_digest_8_8;
9065 opti_type = OPTI_TYPE_ZERO_BYTE
9066 | OPTI_TYPE_USES_BITS_64;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6600: hash_type = HASH_TYPE_AES;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9077 kern_type = KERN_TYPE_AGILEKEY;
9078 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9079 parse_func = agilekey_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 6700: hash_type = HASH_TYPE_SHA1;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9092 kern_type = KERN_TYPE_SHA1AIX;
9093 dgst_size = DGST_SIZE_4_5;
9094 parse_func = sha1aix_parse_hash;
9095 sort_by_digest = sort_by_digest_4_5;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 6800: hash_type = HASH_TYPE_AES;
9104 salt_type = SALT_TYPE_EMBEDDED;
9105 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_LASTPASS;
9108 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9109 parse_func = lastpass_parse_hash;
9110 sort_by_digest = sort_by_digest_4_8;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 6900: hash_type = HASH_TYPE_GOST;
9119 salt_type = SALT_TYPE_NONE;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9122 kern_type = KERN_TYPE_GOST;
9123 dgst_size = DGST_SIZE_4_8;
9124 parse_func = gost_parse_hash;
9125 sort_by_digest = sort_by_digest_4_8;
9126 opti_type = OPTI_TYPE_ZERO_BYTE;
9127 dgst_pos0 = 0;
9128 dgst_pos1 = 1;
9129 dgst_pos2 = 2;
9130 dgst_pos3 = 3;
9131 break;
9132
9133 case 7100: hash_type = HASH_TYPE_SHA512;
9134 salt_type = SALT_TYPE_EMBEDDED;
9135 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9136 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9137 kern_type = KERN_TYPE_PBKDF2_SHA512;
9138 dgst_size = DGST_SIZE_8_16;
9139 parse_func = sha512osx_parse_hash;
9140 sort_by_digest = sort_by_digest_8_16;
9141 opti_type = OPTI_TYPE_ZERO_BYTE
9142 | OPTI_TYPE_USES_BITS_64
9143 | OPTI_TYPE_SLOW_HASH_SIMD;
9144 dgst_pos0 = 0;
9145 dgst_pos1 = 1;
9146 dgst_pos2 = 2;
9147 dgst_pos3 = 3;
9148 break;
9149
9150 case 7200: hash_type = HASH_TYPE_SHA512;
9151 salt_type = SALT_TYPE_EMBEDDED;
9152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9153 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9154 kern_type = KERN_TYPE_PBKDF2_SHA512;
9155 dgst_size = DGST_SIZE_8_16;
9156 parse_func = sha512grub_parse_hash;
9157 sort_by_digest = sort_by_digest_8_16;
9158 opti_type = OPTI_TYPE_ZERO_BYTE
9159 | OPTI_TYPE_USES_BITS_64
9160 | OPTI_TYPE_SLOW_HASH_SIMD;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7300: hash_type = HASH_TYPE_SHA1;
9168 salt_type = SALT_TYPE_EMBEDDED;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_BE
9171 | OPTS_TYPE_ST_ADD80
9172 | OPTS_TYPE_ST_ADDBITS15;
9173 kern_type = KERN_TYPE_RAKP;
9174 dgst_size = DGST_SIZE_4_5;
9175 parse_func = rakp_parse_hash;
9176 sort_by_digest = sort_by_digest_4_5;
9177 opti_type = OPTI_TYPE_ZERO_BYTE
9178 | OPTI_TYPE_NOT_ITERATED;
9179 dgst_pos0 = 3;
9180 dgst_pos1 = 4;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 1;
9183 break;
9184
9185 case 7400: hash_type = HASH_TYPE_SHA256;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9189 kern_type = KERN_TYPE_SHA256CRYPT;
9190 dgst_size = DGST_SIZE_4_8;
9191 parse_func = sha256crypt_parse_hash;
9192 sort_by_digest = sort_by_digest_4_8;
9193 opti_type = OPTI_TYPE_ZERO_BYTE;
9194 dgst_pos0 = 0;
9195 dgst_pos1 = 1;
9196 dgst_pos2 = 2;
9197 dgst_pos3 = 3;
9198 break;
9199
9200 case 7500: hash_type = HASH_TYPE_KRB5PA;
9201 salt_type = SALT_TYPE_EMBEDDED;
9202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9203 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9204 kern_type = KERN_TYPE_KRB5PA;
9205 dgst_size = DGST_SIZE_4_4;
9206 parse_func = krb5pa_parse_hash;
9207 sort_by_digest = sort_by_digest_4_4;
9208 opti_type = OPTI_TYPE_ZERO_BYTE
9209 | OPTI_TYPE_NOT_ITERATED;
9210 dgst_pos0 = 0;
9211 dgst_pos1 = 1;
9212 dgst_pos2 = 2;
9213 dgst_pos3 = 3;
9214 break;
9215
9216 case 7600: hash_type = HASH_TYPE_SHA1;
9217 salt_type = SALT_TYPE_INTERN;
9218 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9219 opts_type = OPTS_TYPE_PT_GENERATE_BE
9220 | OPTS_TYPE_PT_ADD80
9221 | OPTS_TYPE_PT_ADDBITS15;
9222 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9223 dgst_size = DGST_SIZE_4_5;
9224 parse_func = redmine_parse_hash;
9225 sort_by_digest = sort_by_digest_4_5;
9226 opti_type = OPTI_TYPE_ZERO_BYTE
9227 | OPTI_TYPE_PRECOMPUTE_INIT
9228 | OPTI_TYPE_EARLY_SKIP
9229 | OPTI_TYPE_NOT_ITERATED
9230 | OPTI_TYPE_PREPENDED_SALT;
9231 dgst_pos0 = 3;
9232 dgst_pos1 = 4;
9233 dgst_pos2 = 2;
9234 dgst_pos3 = 1;
9235 break;
9236
9237 case 7700: hash_type = HASH_TYPE_SAPB;
9238 salt_type = SALT_TYPE_EMBEDDED;
9239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9240 opts_type = OPTS_TYPE_PT_GENERATE_LE
9241 | OPTS_TYPE_PT_UPPER
9242 | OPTS_TYPE_ST_UPPER;
9243 kern_type = KERN_TYPE_SAPB;
9244 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9245 parse_func = sapb_parse_hash;
9246 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9247 opti_type = OPTI_TYPE_ZERO_BYTE
9248 | OPTI_TYPE_PRECOMPUTE_INIT
9249 | OPTI_TYPE_NOT_ITERATED;
9250 dgst_pos0 = 0;
9251 dgst_pos1 = 1;
9252 dgst_pos2 = 2;
9253 dgst_pos3 = 3;
9254 break;
9255
9256 case 7800: hash_type = HASH_TYPE_SAPG;
9257 salt_type = SALT_TYPE_EMBEDDED;
9258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9259 opts_type = OPTS_TYPE_PT_GENERATE_BE
9260 | OPTS_TYPE_ST_ADD80
9261 | OPTS_TYPE_ST_UPPER;
9262 kern_type = KERN_TYPE_SAPG;
9263 dgst_size = DGST_SIZE_4_5;
9264 parse_func = sapg_parse_hash;
9265 sort_by_digest = sort_by_digest_4_5;
9266 opti_type = OPTI_TYPE_ZERO_BYTE
9267 | OPTI_TYPE_PRECOMPUTE_INIT
9268 | OPTI_TYPE_NOT_ITERATED;
9269 dgst_pos0 = 3;
9270 dgst_pos1 = 4;
9271 dgst_pos2 = 2;
9272 dgst_pos3 = 1;
9273 break;
9274
9275 case 7900: hash_type = HASH_TYPE_SHA512;
9276 salt_type = SALT_TYPE_EMBEDDED;
9277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9278 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9279 kern_type = KERN_TYPE_DRUPAL7;
9280 dgst_size = DGST_SIZE_8_8;
9281 parse_func = drupal7_parse_hash;
9282 sort_by_digest = sort_by_digest_8_8;
9283 opti_type = OPTI_TYPE_ZERO_BYTE
9284 | OPTI_TYPE_USES_BITS_64;
9285 dgst_pos0 = 0;
9286 dgst_pos1 = 1;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 3;
9289 break;
9290
9291 case 8000: hash_type = HASH_TYPE_SHA256;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_BE
9295 | OPTS_TYPE_PT_UNICODE
9296 | OPTS_TYPE_ST_ADD80
9297 | OPTS_TYPE_ST_HEX;
9298 kern_type = KERN_TYPE_SYBASEASE;
9299 dgst_size = DGST_SIZE_4_8;
9300 parse_func = sybasease_parse_hash;
9301 sort_by_digest = sort_by_digest_4_8;
9302 opti_type = OPTI_TYPE_ZERO_BYTE
9303 | OPTI_TYPE_PRECOMPUTE_INIT
9304 | OPTI_TYPE_EARLY_SKIP
9305 | OPTI_TYPE_NOT_ITERATED
9306 | OPTI_TYPE_RAW_HASH;
9307 dgst_pos0 = 3;
9308 dgst_pos1 = 7;
9309 dgst_pos2 = 2;
9310 dgst_pos3 = 6;
9311 break;
9312
9313 case 8100: hash_type = HASH_TYPE_SHA1;
9314 salt_type = SALT_TYPE_EMBEDDED;
9315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9316 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9317 kern_type = KERN_TYPE_NETSCALER;
9318 dgst_size = DGST_SIZE_4_5;
9319 parse_func = netscaler_parse_hash;
9320 sort_by_digest = sort_by_digest_4_5;
9321 opti_type = OPTI_TYPE_ZERO_BYTE
9322 | OPTI_TYPE_PRECOMPUTE_INIT
9323 | OPTI_TYPE_PRECOMPUTE_MERKLE
9324 | OPTI_TYPE_EARLY_SKIP
9325 | OPTI_TYPE_NOT_ITERATED
9326 | OPTI_TYPE_PREPENDED_SALT
9327 | OPTI_TYPE_RAW_HASH;
9328 dgst_pos0 = 3;
9329 dgst_pos1 = 4;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 1;
9332 break;
9333
9334 case 8200: hash_type = HASH_TYPE_SHA256;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9338 kern_type = KERN_TYPE_CLOUDKEY;
9339 dgst_size = DGST_SIZE_4_8;
9340 parse_func = cloudkey_parse_hash;
9341 sort_by_digest = sort_by_digest_4_8;
9342 opti_type = OPTI_TYPE_ZERO_BYTE;
9343 dgst_pos0 = 0;
9344 dgst_pos1 = 1;
9345 dgst_pos2 = 2;
9346 dgst_pos3 = 3;
9347 break;
9348
9349 case 8300: hash_type = HASH_TYPE_SHA1;
9350 salt_type = SALT_TYPE_EMBEDDED;
9351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9352 opts_type = OPTS_TYPE_PT_GENERATE_BE
9353 | OPTS_TYPE_ST_HEX
9354 | OPTS_TYPE_ST_ADD80;
9355 kern_type = KERN_TYPE_NSEC3;
9356 dgst_size = DGST_SIZE_4_5;
9357 parse_func = nsec3_parse_hash;
9358 sort_by_digest = sort_by_digest_4_5;
9359 opti_type = OPTI_TYPE_ZERO_BYTE;
9360 dgst_pos0 = 3;
9361 dgst_pos1 = 4;
9362 dgst_pos2 = 2;
9363 dgst_pos3 = 1;
9364 break;
9365
9366 case 8400: hash_type = HASH_TYPE_SHA1;
9367 salt_type = SALT_TYPE_INTERN;
9368 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9369 opts_type = OPTS_TYPE_PT_GENERATE_BE
9370 | OPTS_TYPE_PT_ADD80
9371 | OPTS_TYPE_PT_ADDBITS15;
9372 kern_type = KERN_TYPE_WBB3;
9373 dgst_size = DGST_SIZE_4_5;
9374 parse_func = wbb3_parse_hash;
9375 sort_by_digest = sort_by_digest_4_5;
9376 opti_type = OPTI_TYPE_ZERO_BYTE
9377 | OPTI_TYPE_PRECOMPUTE_INIT
9378 | OPTI_TYPE_NOT_ITERATED;
9379 dgst_pos0 = 3;
9380 dgst_pos1 = 4;
9381 dgst_pos2 = 2;
9382 dgst_pos3 = 1;
9383 break;
9384
9385 case 8500: hash_type = HASH_TYPE_DESRACF;
9386 salt_type = SALT_TYPE_EMBEDDED;
9387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9388 opts_type = OPTS_TYPE_PT_GENERATE_LE
9389 | OPTS_TYPE_ST_UPPER;
9390 kern_type = KERN_TYPE_RACF;
9391 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9392 parse_func = racf_parse_hash;
9393 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9394 opti_type = OPTI_TYPE_ZERO_BYTE
9395 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9396 dgst_pos0 = 0;
9397 dgst_pos1 = 1;
9398 dgst_pos2 = 2;
9399 dgst_pos3 = 3;
9400 break;
9401
9402 case 8600: hash_type = HASH_TYPE_LOTUS5;
9403 salt_type = SALT_TYPE_NONE;
9404 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9406 kern_type = KERN_TYPE_LOTUS5;
9407 dgst_size = DGST_SIZE_4_4;
9408 parse_func = lotus5_parse_hash;
9409 sort_by_digest = sort_by_digest_4_4;
9410 opti_type = OPTI_TYPE_EARLY_SKIP
9411 | OPTI_TYPE_NOT_ITERATED
9412 | OPTI_TYPE_NOT_SALTED
9413 | OPTI_TYPE_RAW_HASH;
9414 dgst_pos0 = 0;
9415 dgst_pos1 = 1;
9416 dgst_pos2 = 2;
9417 dgst_pos3 = 3;
9418 break;
9419
9420 case 8700: hash_type = HASH_TYPE_LOTUS6;
9421 salt_type = SALT_TYPE_EMBEDDED;
9422 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9424 kern_type = KERN_TYPE_LOTUS6;
9425 dgst_size = DGST_SIZE_4_4;
9426 parse_func = lotus6_parse_hash;
9427 sort_by_digest = sort_by_digest_4_4;
9428 opti_type = OPTI_TYPE_EARLY_SKIP
9429 | OPTI_TYPE_NOT_ITERATED
9430 | OPTI_TYPE_RAW_HASH;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_ANDROIDFDE;
9442 dgst_size = DGST_SIZE_4_4;
9443 parse_func = androidfde_parse_hash;
9444 sort_by_digest = sort_by_digest_4_4;
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 8900: hash_type = HASH_TYPE_SCRYPT;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9456 kern_type = KERN_TYPE_SCRYPT;
9457 dgst_size = DGST_SIZE_4_8;
9458 parse_func = scrypt_parse_hash;
9459 sort_by_digest = sort_by_digest_4_8;
9460 opti_type = OPTI_TYPE_ZERO_BYTE;
9461 dgst_pos0 = 0;
9462 dgst_pos1 = 1;
9463 dgst_pos2 = 2;
9464 dgst_pos3 = 3;
9465 break;
9466
9467 case 9000: hash_type = HASH_TYPE_SHA1;
9468 salt_type = SALT_TYPE_EMBEDDED;
9469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9470 opts_type = OPTS_TYPE_PT_GENERATE_LE
9471 | OPTS_TYPE_ST_GENERATE_LE;
9472 kern_type = KERN_TYPE_PSAFE2;
9473 dgst_size = DGST_SIZE_4_5;
9474 parse_func = psafe2_parse_hash;
9475 sort_by_digest = sort_by_digest_4_5;
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9100: hash_type = HASH_TYPE_LOTUS8;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9487 kern_type = KERN_TYPE_LOTUS8;
9488 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9489 parse_func = lotus8_parse_hash;
9490 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9491 opti_type = OPTI_TYPE_ZERO_BYTE;
9492 dgst_pos0 = 0;
9493 dgst_pos1 = 1;
9494 dgst_pos2 = 2;
9495 dgst_pos3 = 3;
9496 break;
9497
9498 case 9200: hash_type = HASH_TYPE_SHA256;
9499 salt_type = SALT_TYPE_EMBEDDED;
9500 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9501 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9502 kern_type = KERN_TYPE_PBKDF2_SHA256;
9503 dgst_size = DGST_SIZE_4_32;
9504 parse_func = cisco8_parse_hash;
9505 sort_by_digest = sort_by_digest_4_32;
9506 opti_type = OPTI_TYPE_ZERO_BYTE
9507 | OPTI_TYPE_SLOW_HASH_SIMD;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9300: hash_type = HASH_TYPE_SCRYPT;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9518 kern_type = KERN_TYPE_SCRYPT;
9519 dgst_size = DGST_SIZE_4_8;
9520 parse_func = cisco9_parse_hash;
9521 sort_by_digest = sort_by_digest_4_8;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_OFFICE2007;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = office2007_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9548 kern_type = KERN_TYPE_OFFICE2010;
9549 dgst_size = DGST_SIZE_4_4;
9550 parse_func = office2010_parse_hash;
9551 sort_by_digest = sort_by_digest_4_4;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9563 kern_type = KERN_TYPE_OFFICE2013;
9564 dgst_size = DGST_SIZE_4_4;
9565 parse_func = office2013_parse_hash;
9566 sort_by_digest = sort_by_digest_4_4;
9567 opti_type = OPTI_TYPE_ZERO_BYTE;
9568 dgst_pos0 = 0;
9569 dgst_pos1 = 1;
9570 dgst_pos2 = 2;
9571 dgst_pos3 = 3;
9572 break;
9573
9574 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9575 salt_type = SALT_TYPE_EMBEDDED;
9576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9577 opts_type = OPTS_TYPE_PT_GENERATE_LE
9578 | OPTS_TYPE_PT_ADD80
9579 | OPTS_TYPE_PT_UNICODE;
9580 kern_type = KERN_TYPE_OLDOFFICE01;
9581 dgst_size = DGST_SIZE_4_4;
9582 parse_func = oldoffice01_parse_hash;
9583 sort_by_digest = sort_by_digest_4_4;
9584 opti_type = OPTI_TYPE_ZERO_BYTE
9585 | OPTI_TYPE_PRECOMPUTE_INIT
9586 | OPTI_TYPE_NOT_ITERATED;
9587 dgst_pos0 = 0;
9588 dgst_pos1 = 1;
9589 dgst_pos2 = 2;
9590 dgst_pos3 = 3;
9591 break;
9592
9593 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9594 salt_type = SALT_TYPE_EMBEDDED;
9595 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9596 opts_type = OPTS_TYPE_PT_GENERATE_LE
9597 | OPTS_TYPE_PT_ADD80;
9598 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9599 dgst_size = DGST_SIZE_4_4;
9600 parse_func = oldoffice01cm1_parse_hash;
9601 sort_by_digest = sort_by_digest_4_4;
9602 opti_type = OPTI_TYPE_ZERO_BYTE
9603 | OPTI_TYPE_PRECOMPUTE_INIT
9604 | OPTI_TYPE_NOT_ITERATED;
9605 dgst_pos0 = 0;
9606 dgst_pos1 = 1;
9607 dgst_pos2 = 2;
9608 dgst_pos3 = 3;
9609 break;
9610
9611 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9612 salt_type = SALT_TYPE_EMBEDDED;
9613 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9614 opts_type = OPTS_TYPE_PT_GENERATE_LE
9615 | OPTS_TYPE_PT_ADD80
9616 | OPTS_TYPE_PT_UNICODE
9617 | OPTS_TYPE_PT_NEVERCRACK;
9618 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9619 dgst_size = DGST_SIZE_4_4;
9620 parse_func = oldoffice01cm2_parse_hash;
9621 sort_by_digest = sort_by_digest_4_4;
9622 opti_type = OPTI_TYPE_ZERO_BYTE
9623 | OPTI_TYPE_PRECOMPUTE_INIT
9624 | OPTI_TYPE_NOT_ITERATED;
9625 dgst_pos0 = 0;
9626 dgst_pos1 = 1;
9627 dgst_pos2 = 2;
9628 dgst_pos3 = 3;
9629 break;
9630
9631 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9632 salt_type = SALT_TYPE_EMBEDDED;
9633 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9634 opts_type = OPTS_TYPE_PT_GENERATE_BE
9635 | OPTS_TYPE_PT_ADD80
9636 | OPTS_TYPE_PT_UNICODE;
9637 kern_type = KERN_TYPE_OLDOFFICE34;
9638 dgst_size = DGST_SIZE_4_4;
9639 parse_func = oldoffice34_parse_hash;
9640 sort_by_digest = sort_by_digest_4_4;
9641 opti_type = OPTI_TYPE_ZERO_BYTE
9642 | OPTI_TYPE_PRECOMPUTE_INIT
9643 | OPTI_TYPE_NOT_ITERATED;
9644 dgst_pos0 = 0;
9645 dgst_pos1 = 1;
9646 dgst_pos2 = 2;
9647 dgst_pos3 = 3;
9648 break;
9649
9650 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9651 salt_type = SALT_TYPE_EMBEDDED;
9652 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9653 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9654 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9655 dgst_size = DGST_SIZE_4_4;
9656 parse_func = oldoffice34cm1_parse_hash;
9657 sort_by_digest = sort_by_digest_4_4;
9658 opti_type = OPTI_TYPE_ZERO_BYTE
9659 | OPTI_TYPE_PRECOMPUTE_INIT
9660 | OPTI_TYPE_NOT_ITERATED;
9661 dgst_pos0 = 0;
9662 dgst_pos1 = 1;
9663 dgst_pos2 = 2;
9664 dgst_pos3 = 3;
9665 break;
9666
9667 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9668 salt_type = SALT_TYPE_EMBEDDED;
9669 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9670 opts_type = OPTS_TYPE_PT_GENERATE_BE
9671 | OPTS_TYPE_PT_ADD80
9672 | OPTS_TYPE_PT_UNICODE
9673 | OPTS_TYPE_PT_NEVERCRACK;
9674 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9675 dgst_size = DGST_SIZE_4_4;
9676 parse_func = oldoffice34cm2_parse_hash;
9677 sort_by_digest = sort_by_digest_4_4;
9678 opti_type = OPTI_TYPE_ZERO_BYTE
9679 | OPTI_TYPE_PRECOMPUTE_INIT
9680 | OPTI_TYPE_NOT_ITERATED;
9681 dgst_pos0 = 0;
9682 dgst_pos1 = 1;
9683 dgst_pos2 = 2;
9684 dgst_pos3 = 3;
9685 break;
9686
9687 case 9900: hash_type = HASH_TYPE_MD5;
9688 salt_type = SALT_TYPE_NONE;
9689 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9690 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9691 kern_type = KERN_TYPE_RADMIN2;
9692 dgst_size = DGST_SIZE_4_4;
9693 parse_func = radmin2_parse_hash;
9694 sort_by_digest = sort_by_digest_4_4;
9695 opti_type = OPTI_TYPE_ZERO_BYTE
9696 | OPTI_TYPE_PRECOMPUTE_INIT
9697 | OPTI_TYPE_EARLY_SKIP
9698 | OPTI_TYPE_NOT_ITERATED
9699 | OPTI_TYPE_NOT_SALTED;
9700 dgst_pos0 = 0;
9701 dgst_pos1 = 3;
9702 dgst_pos2 = 2;
9703 dgst_pos3 = 1;
9704 break;
9705
9706 case 10000: hash_type = HASH_TYPE_SHA256;
9707 salt_type = SALT_TYPE_EMBEDDED;
9708 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9709 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9710 kern_type = KERN_TYPE_PBKDF2_SHA256;
9711 dgst_size = DGST_SIZE_4_32;
9712 parse_func = djangopbkdf2_parse_hash;
9713 sort_by_digest = sort_by_digest_4_32;
9714 opti_type = OPTI_TYPE_ZERO_BYTE
9715 | OPTI_TYPE_SLOW_HASH_SIMD;
9716 dgst_pos0 = 0;
9717 dgst_pos1 = 1;
9718 dgst_pos2 = 2;
9719 dgst_pos3 = 3;
9720 break;
9721
9722 case 10100: hash_type = HASH_TYPE_SIPHASH;
9723 salt_type = SALT_TYPE_EMBEDDED;
9724 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9725 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9726 kern_type = KERN_TYPE_SIPHASH;
9727 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9728 parse_func = siphash_parse_hash;
9729 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9730 opti_type = OPTI_TYPE_ZERO_BYTE
9731 | OPTI_TYPE_NOT_ITERATED
9732 | OPTI_TYPE_RAW_HASH;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10200: hash_type = HASH_TYPE_MD5;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE
9743 | OPTS_TYPE_ST_ADD80
9744 | OPTS_TYPE_ST_ADDBITS14;
9745 kern_type = KERN_TYPE_HMACMD5_PW;
9746 dgst_size = DGST_SIZE_4_4;
9747 parse_func = crammd5_parse_hash;
9748 sort_by_digest = sort_by_digest_4_4;
9749 opti_type = OPTI_TYPE_ZERO_BYTE
9750 | OPTI_TYPE_NOT_ITERATED;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 3;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 1;
9755 break;
9756
9757 case 10300: hash_type = HASH_TYPE_SHA1;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9761 kern_type = KERN_TYPE_SAPH_SHA1;
9762 dgst_size = DGST_SIZE_4_5;
9763 parse_func = saph_sha1_parse_hash;
9764 sort_by_digest = sort_by_digest_4_5;
9765 opti_type = OPTI_TYPE_ZERO_BYTE;
9766 dgst_pos0 = 0;
9767 dgst_pos1 = 1;
9768 dgst_pos2 = 2;
9769 dgst_pos3 = 3;
9770 break;
9771
9772 case 10400: hash_type = HASH_TYPE_PDFU16;
9773 salt_type = SALT_TYPE_EMBEDDED;
9774 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9775 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9776 kern_type = KERN_TYPE_PDF11;
9777 dgst_size = DGST_SIZE_4_4;
9778 parse_func = pdf11_parse_hash;
9779 sort_by_digest = sort_by_digest_4_4;
9780 opti_type = OPTI_TYPE_ZERO_BYTE
9781 | OPTI_TYPE_NOT_ITERATED;
9782 dgst_pos0 = 0;
9783 dgst_pos1 = 1;
9784 dgst_pos2 = 2;
9785 dgst_pos3 = 3;
9786 break;
9787
9788 case 10410: hash_type = HASH_TYPE_PDFU16;
9789 salt_type = SALT_TYPE_EMBEDDED;
9790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9791 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9792 kern_type = KERN_TYPE_PDF11CM1;
9793 dgst_size = DGST_SIZE_4_4;
9794 parse_func = pdf11cm1_parse_hash;
9795 sort_by_digest = sort_by_digest_4_4;
9796 opti_type = OPTI_TYPE_ZERO_BYTE
9797 | OPTI_TYPE_NOT_ITERATED;
9798 dgst_pos0 = 0;
9799 dgst_pos1 = 1;
9800 dgst_pos2 = 2;
9801 dgst_pos3 = 3;
9802 break;
9803
9804 case 10420: hash_type = HASH_TYPE_PDFU16;
9805 salt_type = SALT_TYPE_EMBEDDED;
9806 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9807 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9808 kern_type = KERN_TYPE_PDF11CM2;
9809 dgst_size = DGST_SIZE_4_4;
9810 parse_func = pdf11cm2_parse_hash;
9811 sort_by_digest = sort_by_digest_4_4;
9812 opti_type = OPTI_TYPE_ZERO_BYTE
9813 | OPTI_TYPE_NOT_ITERATED;
9814 dgst_pos0 = 0;
9815 dgst_pos1 = 1;
9816 dgst_pos2 = 2;
9817 dgst_pos3 = 3;
9818 break;
9819
9820 case 10500: hash_type = HASH_TYPE_PDFU16;
9821 salt_type = SALT_TYPE_EMBEDDED;
9822 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9823 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9824 kern_type = KERN_TYPE_PDF14;
9825 dgst_size = DGST_SIZE_4_4;
9826 parse_func = pdf14_parse_hash;
9827 sort_by_digest = sort_by_digest_4_4;
9828 opti_type = OPTI_TYPE_ZERO_BYTE
9829 | OPTI_TYPE_NOT_ITERATED;
9830 dgst_pos0 = 0;
9831 dgst_pos1 = 1;
9832 dgst_pos2 = 2;
9833 dgst_pos3 = 3;
9834 break;
9835
9836 case 10600: hash_type = HASH_TYPE_SHA256;
9837 salt_type = SALT_TYPE_EMBEDDED;
9838 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9839 opts_type = OPTS_TYPE_PT_GENERATE_BE
9840 | OPTS_TYPE_ST_ADD80
9841 | OPTS_TYPE_ST_ADDBITS15
9842 | OPTS_TYPE_HASH_COPY;
9843 kern_type = KERN_TYPE_SHA256_PWSLT;
9844 dgst_size = DGST_SIZE_4_8;
9845 parse_func = pdf17l3_parse_hash;
9846 sort_by_digest = sort_by_digest_4_8;
9847 opti_type = OPTI_TYPE_ZERO_BYTE
9848 | OPTI_TYPE_PRECOMPUTE_INIT
9849 | OPTI_TYPE_PRECOMPUTE_MERKLE
9850 | OPTI_TYPE_EARLY_SKIP
9851 | OPTI_TYPE_NOT_ITERATED
9852 | OPTI_TYPE_APPENDED_SALT
9853 | OPTI_TYPE_RAW_HASH;
9854 dgst_pos0 = 3;
9855 dgst_pos1 = 7;
9856 dgst_pos2 = 2;
9857 dgst_pos3 = 6;
9858 break;
9859
9860 case 10700: hash_type = HASH_TYPE_PDFU32;
9861 salt_type = SALT_TYPE_EMBEDDED;
9862 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9863 opts_type = OPTS_TYPE_PT_GENERATE_LE
9864 | OPTS_TYPE_HASH_COPY;
9865 kern_type = KERN_TYPE_PDF17L8;
9866 dgst_size = DGST_SIZE_4_8;
9867 parse_func = pdf17l8_parse_hash;
9868 sort_by_digest = sort_by_digest_4_8;
9869 opti_type = OPTI_TYPE_ZERO_BYTE
9870 | OPTI_TYPE_NOT_ITERATED;
9871 dgst_pos0 = 0;
9872 dgst_pos1 = 1;
9873 dgst_pos2 = 2;
9874 dgst_pos3 = 3;
9875 break;
9876
9877 case 10800: hash_type = HASH_TYPE_SHA384;
9878 salt_type = SALT_TYPE_NONE;
9879 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9880 opts_type = OPTS_TYPE_PT_GENERATE_BE
9881 | OPTS_TYPE_PT_ADD80
9882 | OPTS_TYPE_PT_ADDBITS15;
9883 kern_type = KERN_TYPE_SHA384;
9884 dgst_size = DGST_SIZE_8_8;
9885 parse_func = sha384_parse_hash;
9886 sort_by_digest = sort_by_digest_8_8;
9887 opti_type = OPTI_TYPE_ZERO_BYTE
9888 | OPTI_TYPE_PRECOMPUTE_INIT
9889 | OPTI_TYPE_PRECOMPUTE_MERKLE
9890 | OPTI_TYPE_EARLY_SKIP
9891 | OPTI_TYPE_NOT_ITERATED
9892 | OPTI_TYPE_NOT_SALTED
9893 | OPTI_TYPE_USES_BITS_64
9894 | OPTI_TYPE_RAW_HASH;
9895 dgst_pos0 = 6;
9896 dgst_pos1 = 7;
9897 dgst_pos2 = 4;
9898 dgst_pos3 = 5;
9899 break;
9900
9901 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9902 salt_type = SALT_TYPE_EMBEDDED;
9903 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9904 opts_type = OPTS_TYPE_PT_GENERATE_LE
9905 | OPTS_TYPE_ST_BASE64
9906 | OPTS_TYPE_HASH_COPY;
9907 kern_type = KERN_TYPE_PBKDF2_SHA256;
9908 dgst_size = DGST_SIZE_4_32;
9909 parse_func = pbkdf2_sha256_parse_hash;
9910 sort_by_digest = sort_by_digest_4_32;
9911 opti_type = OPTI_TYPE_ZERO_BYTE
9912 | OPTI_TYPE_SLOW_HASH_SIMD;
9913 dgst_pos0 = 0;
9914 dgst_pos1 = 1;
9915 dgst_pos2 = 2;
9916 dgst_pos3 = 3;
9917 break;
9918
9919 case 11000: hash_type = HASH_TYPE_MD5;
9920 salt_type = SALT_TYPE_INTERN;
9921 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9922 opts_type = OPTS_TYPE_PT_GENERATE_LE
9923 | OPTS_TYPE_PT_ADD80;
9924 kern_type = KERN_TYPE_PRESTASHOP;
9925 dgst_size = DGST_SIZE_4_4;
9926 parse_func = prestashop_parse_hash;
9927 sort_by_digest = sort_by_digest_4_4;
9928 opti_type = OPTI_TYPE_ZERO_BYTE
9929 | OPTI_TYPE_PRECOMPUTE_INIT
9930 | OPTI_TYPE_NOT_ITERATED
9931 | OPTI_TYPE_PREPENDED_SALT;
9932 dgst_pos0 = 0;
9933 dgst_pos1 = 3;
9934 dgst_pos2 = 2;
9935 dgst_pos3 = 1;
9936 break;
9937
9938 case 11100: hash_type = HASH_TYPE_MD5;
9939 salt_type = SALT_TYPE_EMBEDDED;
9940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9941 opts_type = OPTS_TYPE_PT_GENERATE_LE
9942 | OPTS_TYPE_ST_ADD80;
9943 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9944 dgst_size = DGST_SIZE_4_4;
9945 parse_func = postgresql_auth_parse_hash;
9946 sort_by_digest = sort_by_digest_4_4;
9947 opti_type = OPTI_TYPE_ZERO_BYTE
9948 | OPTI_TYPE_PRECOMPUTE_INIT
9949 | OPTI_TYPE_PRECOMPUTE_MERKLE
9950 | OPTI_TYPE_EARLY_SKIP;
9951 dgst_pos0 = 0;
9952 dgst_pos1 = 3;
9953 dgst_pos2 = 2;
9954 dgst_pos3 = 1;
9955 break;
9956
9957 case 11200: hash_type = HASH_TYPE_SHA1;
9958 salt_type = SALT_TYPE_EMBEDDED;
9959 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9960 opts_type = OPTS_TYPE_PT_GENERATE_BE
9961 | OPTS_TYPE_PT_ADD80
9962 | OPTS_TYPE_ST_HEX;
9963 kern_type = KERN_TYPE_MYSQL_AUTH;
9964 dgst_size = DGST_SIZE_4_5;
9965 parse_func = mysql_auth_parse_hash;
9966 sort_by_digest = sort_by_digest_4_5;
9967 opti_type = OPTI_TYPE_ZERO_BYTE
9968 | OPTI_TYPE_EARLY_SKIP;
9969 dgst_pos0 = 3;
9970 dgst_pos1 = 4;
9971 dgst_pos2 = 2;
9972 dgst_pos3 = 1;
9973 break;
9974
9975 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9976 salt_type = SALT_TYPE_EMBEDDED;
9977 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9978 opts_type = OPTS_TYPE_PT_GENERATE_LE
9979 | OPTS_TYPE_ST_HEX
9980 | OPTS_TYPE_ST_ADD80;
9981 kern_type = KERN_TYPE_BITCOIN_WALLET;
9982 dgst_size = DGST_SIZE_4_4;
9983 parse_func = bitcoin_wallet_parse_hash;
9984 sort_by_digest = sort_by_digest_4_4;
9985 opti_type = OPTI_TYPE_ZERO_BYTE;
9986 dgst_pos0 = 0;
9987 dgst_pos1 = 1;
9988 dgst_pos2 = 2;
9989 dgst_pos3 = 3;
9990 break;
9991
9992 case 11400: hash_type = HASH_TYPE_MD5;
9993 salt_type = SALT_TYPE_EMBEDDED;
9994 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9995 opts_type = OPTS_TYPE_PT_GENERATE_LE
9996 | OPTS_TYPE_PT_ADD80
9997 | OPTS_TYPE_HASH_COPY;
9998 kern_type = KERN_TYPE_SIP_AUTH;
9999 dgst_size = DGST_SIZE_4_4;
10000 parse_func = sip_auth_parse_hash;
10001 sort_by_digest = sort_by_digest_4_4;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 3;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 1;
10007 break;
10008
10009 case 11500: hash_type = HASH_TYPE_CRC32;
10010 salt_type = SALT_TYPE_INTERN;
10011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_ST_GENERATE_LE
10014 | OPTS_TYPE_ST_HEX;
10015 kern_type = KERN_TYPE_CRC32;
10016 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10017 parse_func = crc32_parse_hash;
10018 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10019 opti_type = OPTI_TYPE_ZERO_BYTE;
10020 dgst_pos0 = 0;
10021 dgst_pos1 = 1;
10022 dgst_pos2 = 2;
10023 dgst_pos3 = 3;
10024 break;
10025
10026 case 11600: hash_type = HASH_TYPE_AES;
10027 salt_type = SALT_TYPE_EMBEDDED;
10028 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10029 opts_type = OPTS_TYPE_PT_GENERATE_LE
10030 | OPTS_TYPE_PT_NEVERCRACK;
10031 kern_type = KERN_TYPE_SEVEN_ZIP;
10032 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10033 parse_func = seven_zip_parse_hash;
10034 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10035 opti_type = OPTI_TYPE_ZERO_BYTE;
10036 dgst_pos0 = 0;
10037 dgst_pos1 = 1;
10038 dgst_pos2 = 2;
10039 dgst_pos3 = 3;
10040 break;
10041
10042 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10043 salt_type = SALT_TYPE_NONE;
10044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10045 opts_type = OPTS_TYPE_PT_GENERATE_LE
10046 | OPTS_TYPE_PT_ADD01;
10047 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10048 dgst_size = DGST_SIZE_4_8;
10049 parse_func = gost2012sbog_256_parse_hash;
10050 sort_by_digest = sort_by_digest_4_8;
10051 opti_type = OPTI_TYPE_ZERO_BYTE;
10052 dgst_pos0 = 0;
10053 dgst_pos1 = 1;
10054 dgst_pos2 = 2;
10055 dgst_pos3 = 3;
10056 break;
10057
10058 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10059 salt_type = SALT_TYPE_NONE;
10060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10061 opts_type = OPTS_TYPE_PT_GENERATE_LE
10062 | OPTS_TYPE_PT_ADD01;
10063 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10064 dgst_size = DGST_SIZE_4_16;
10065 parse_func = gost2012sbog_512_parse_hash;
10066 sort_by_digest = sort_by_digest_4_16;
10067 opti_type = OPTI_TYPE_ZERO_BYTE;
10068 dgst_pos0 = 0;
10069 dgst_pos1 = 1;
10070 dgst_pos2 = 2;
10071 dgst_pos3 = 3;
10072 break;
10073
10074 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10075 salt_type = SALT_TYPE_EMBEDDED;
10076 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10077 opts_type = OPTS_TYPE_PT_GENERATE_LE
10078 | OPTS_TYPE_ST_BASE64
10079 | OPTS_TYPE_HASH_COPY;
10080 kern_type = KERN_TYPE_PBKDF2_MD5;
10081 dgst_size = DGST_SIZE_4_32;
10082 parse_func = pbkdf2_md5_parse_hash;
10083 sort_by_digest = sort_by_digest_4_32;
10084 opti_type = OPTI_TYPE_ZERO_BYTE
10085 | OPTI_TYPE_SLOW_HASH_SIMD;
10086 dgst_pos0 = 0;
10087 dgst_pos1 = 1;
10088 dgst_pos2 = 2;
10089 dgst_pos3 = 3;
10090 break;
10091
10092 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10093 salt_type = SALT_TYPE_EMBEDDED;
10094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10095 opts_type = OPTS_TYPE_PT_GENERATE_LE
10096 | OPTS_TYPE_ST_BASE64
10097 | OPTS_TYPE_HASH_COPY;
10098 kern_type = KERN_TYPE_PBKDF2_SHA1;
10099 dgst_size = DGST_SIZE_4_32;
10100 parse_func = pbkdf2_sha1_parse_hash;
10101 sort_by_digest = sort_by_digest_4_32;
10102 opti_type = OPTI_TYPE_ZERO_BYTE
10103 | OPTI_TYPE_SLOW_HASH_SIMD;
10104 dgst_pos0 = 0;
10105 dgst_pos1 = 1;
10106 dgst_pos2 = 2;
10107 dgst_pos3 = 3;
10108 break;
10109
10110 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10111 salt_type = SALT_TYPE_EMBEDDED;
10112 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10113 opts_type = OPTS_TYPE_PT_GENERATE_LE
10114 | OPTS_TYPE_ST_BASE64
10115 | OPTS_TYPE_HASH_COPY;
10116 kern_type = KERN_TYPE_PBKDF2_SHA512;
10117 dgst_size = DGST_SIZE_8_16;
10118 parse_func = pbkdf2_sha512_parse_hash;
10119 sort_by_digest = sort_by_digest_8_16;
10120 opti_type = OPTI_TYPE_ZERO_BYTE
10121 | OPTI_TYPE_USES_BITS_64
10122 | OPTI_TYPE_SLOW_HASH_SIMD;
10123 dgst_pos0 = 0;
10124 dgst_pos1 = 1;
10125 dgst_pos2 = 2;
10126 dgst_pos3 = 3;
10127 break;
10128
10129 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10130 salt_type = SALT_TYPE_EMBEDDED;
10131 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10132 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10133 kern_type = KERN_TYPE_ECRYPTFS;
10134 dgst_size = DGST_SIZE_8_8;
10135 parse_func = ecryptfs_parse_hash;
10136 sort_by_digest = sort_by_digest_8_8;
10137 opti_type = OPTI_TYPE_ZERO_BYTE
10138 | OPTI_TYPE_USES_BITS_64;
10139 dgst_pos0 = 0;
10140 dgst_pos1 = 1;
10141 dgst_pos2 = 2;
10142 dgst_pos3 = 3;
10143 break;
10144
10145 case 12300: hash_type = HASH_TYPE_ORACLET;
10146 salt_type = SALT_TYPE_EMBEDDED;
10147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10149 kern_type = KERN_TYPE_ORACLET;
10150 dgst_size = DGST_SIZE_8_16;
10151 parse_func = oraclet_parse_hash;
10152 sort_by_digest = sort_by_digest_8_16;
10153 opti_type = OPTI_TYPE_ZERO_BYTE
10154 | OPTI_TYPE_USES_BITS_64;
10155 dgst_pos0 = 0;
10156 dgst_pos1 = 1;
10157 dgst_pos2 = 2;
10158 dgst_pos3 = 3;
10159 break;
10160
10161 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10162 salt_type = SALT_TYPE_EMBEDDED;
10163 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10164 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10165 kern_type = KERN_TYPE_BSDICRYPT;
10166 dgst_size = DGST_SIZE_4_4;
10167 parse_func = bsdicrypt_parse_hash;
10168 sort_by_digest = sort_by_digest_4_4;
10169 opti_type = OPTI_TYPE_ZERO_BYTE
10170 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12500: hash_type = HASH_TYPE_RAR3HP;
10178 salt_type = SALT_TYPE_EMBEDDED;
10179 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10181 kern_type = KERN_TYPE_RAR3;
10182 dgst_size = DGST_SIZE_4_4;
10183 parse_func = rar3hp_parse_hash;
10184 sort_by_digest = sort_by_digest_4_4;
10185 opti_type = OPTI_TYPE_ZERO_BYTE;
10186 dgst_pos0 = 0;
10187 dgst_pos1 = 1;
10188 dgst_pos2 = 2;
10189 dgst_pos3 = 3;
10190 break;
10191
10192 case 12600: hash_type = HASH_TYPE_SHA256;
10193 salt_type = SALT_TYPE_INTERN;
10194 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10195 opts_type = OPTS_TYPE_PT_GENERATE_BE
10196 | OPTS_TYPE_PT_ADD80;
10197 kern_type = KERN_TYPE_CF10;
10198 dgst_size = DGST_SIZE_4_8;
10199 parse_func = cf10_parse_hash;
10200 sort_by_digest = sort_by_digest_4_8;
10201 opti_type = OPTI_TYPE_ZERO_BYTE
10202 | OPTI_TYPE_PRECOMPUTE_INIT
10203 | OPTI_TYPE_EARLY_SKIP
10204 | OPTI_TYPE_NOT_ITERATED;
10205 dgst_pos0 = 3;
10206 dgst_pos1 = 7;
10207 dgst_pos2 = 2;
10208 dgst_pos3 = 6;
10209 break;
10210
10211 case 12700: hash_type = HASH_TYPE_AES;
10212 salt_type = SALT_TYPE_EMBEDDED;
10213 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10214 opts_type = OPTS_TYPE_PT_GENERATE_LE
10215 | OPTS_TYPE_HASH_COPY;
10216 kern_type = KERN_TYPE_MYWALLET;
10217 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10218 parse_func = mywallet_parse_hash;
10219 sort_by_digest = sort_by_digest_4_5;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_MS_DRSR;
10232 dgst_size = DGST_SIZE_4_8;
10233 parse_func = ms_drsr_parse_hash;
10234 sort_by_digest = sort_by_digest_4_8;
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10247 dgst_size = DGST_SIZE_4_8;
10248 parse_func = androidfde_samsung_parse_hash;
10249 sort_by_digest = sort_by_digest_4_8;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10258 salt_type = SALT_TYPE_EMBEDDED;
10259 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10261 kern_type = KERN_TYPE_RAR5;
10262 dgst_size = DGST_SIZE_4_4;
10263 parse_func = rar5_parse_hash;
10264 sort_by_digest = sort_by_digest_4_4;
10265 opti_type = OPTI_TYPE_ZERO_BYTE;
10266 dgst_pos0 = 0;
10267 dgst_pos1 = 1;
10268 dgst_pos2 = 2;
10269 dgst_pos3 = 3;
10270 break;
10271
10272 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10273 salt_type = SALT_TYPE_EMBEDDED;
10274 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10275 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10276 kern_type = KERN_TYPE_KRB5TGS;
10277 dgst_size = DGST_SIZE_4_4;
10278 parse_func = krb5tgs_parse_hash;
10279 sort_by_digest = sort_by_digest_4_4;
10280 opti_type = OPTI_TYPE_ZERO_BYTE
10281 | OPTI_TYPE_NOT_ITERATED;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 case 13200: hash_type = HASH_TYPE_AES;
10289 salt_type = SALT_TYPE_EMBEDDED;
10290 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10291 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10292 kern_type = KERN_TYPE_AXCRYPT;
10293 dgst_size = DGST_SIZE_4_4;
10294 parse_func = axcrypt_parse_hash;
10295 sort_by_digest = sort_by_digest_4_4;
10296 opti_type = OPTI_TYPE_ZERO_BYTE;
10297 dgst_pos0 = 0;
10298 dgst_pos1 = 1;
10299 dgst_pos2 = 2;
10300 dgst_pos3 = 3;
10301 break;
10302
10303 case 13300: hash_type = HASH_TYPE_SHA1;
10304 salt_type = SALT_TYPE_NONE;
10305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10306 opts_type = OPTS_TYPE_PT_GENERATE_BE
10307 | OPTS_TYPE_PT_ADD80
10308 | OPTS_TYPE_PT_ADDBITS15;
10309 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10310 dgst_size = DGST_SIZE_4_5;
10311 parse_func = sha1axcrypt_parse_hash;
10312 sort_by_digest = sort_by_digest_4_5;
10313 opti_type = OPTI_TYPE_ZERO_BYTE
10314 | OPTI_TYPE_PRECOMPUTE_INIT
10315 | OPTI_TYPE_EARLY_SKIP
10316 | OPTI_TYPE_NOT_ITERATED
10317 | OPTI_TYPE_NOT_SALTED;
10318 dgst_pos0 = 0;
10319 dgst_pos1 = 4;
10320 dgst_pos2 = 3;
10321 dgst_pos3 = 2;
10322 break;
10323
10324 case 13400: hash_type = HASH_TYPE_AES;
10325 salt_type = SALT_TYPE_EMBEDDED;
10326 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10327 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10328 kern_type = KERN_TYPE_KEEPASS;
10329 dgst_size = DGST_SIZE_4_4;
10330 parse_func = keepass_parse_hash;
10331 sort_by_digest = sort_by_digest_4_4;
10332 opti_type = OPTI_TYPE_ZERO_BYTE;
10333 dgst_pos0 = 0;
10334 dgst_pos1 = 1;
10335 dgst_pos2 = 2;
10336 dgst_pos3 = 3;
10337 break;
10338
10339 case 13500: hash_type = HASH_TYPE_SHA1;
10340 salt_type = SALT_TYPE_EMBEDDED;
10341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10342 opts_type = OPTS_TYPE_PT_GENERATE_BE
10343 | OPTS_TYPE_PT_UNICODE
10344 | OPTS_TYPE_PT_ADD80;
10345 kern_type = KERN_TYPE_PSTOKEN;
10346 dgst_size = DGST_SIZE_4_5;
10347 parse_func = pstoken_parse_hash;
10348 sort_by_digest = sort_by_digest_4_5;
10349 opti_type = OPTI_TYPE_ZERO_BYTE
10350 | OPTI_TYPE_PRECOMPUTE_INIT
10351 | OPTI_TYPE_EARLY_SKIP
10352 | OPTI_TYPE_NOT_ITERATED
10353 | OPTI_TYPE_PREPENDED_SALT
10354 | OPTI_TYPE_RAW_HASH;
10355 dgst_pos0 = 3;
10356 dgst_pos1 = 4;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 1;
10359 break;
10360
10361 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_ZIP2;
10366 dgst_size = DGST_SIZE_4_4;
10367 parse_func = zip2_parse_hash;
10368 sort_by_digest = sort_by_digest_4_4;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10380 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10381 dgst_size = DGST_SIZE_4_5;
10382 parse_func = veracrypt_parse_hash_655331;
10383 sort_by_digest = sort_by_digest_4_5;
10384 opti_type = OPTI_TYPE_ZERO_BYTE;
10385 dgst_pos0 = 0;
10386 dgst_pos1 = 1;
10387 dgst_pos2 = 2;
10388 dgst_pos3 = 3;
10389 break;
10390
10391 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10395 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10396 dgst_size = DGST_SIZE_4_5;
10397 parse_func = veracrypt_parse_hash_655331;
10398 sort_by_digest = sort_by_digest_4_5;
10399 opti_type = OPTI_TYPE_ZERO_BYTE;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10407 salt_type = SALT_TYPE_EMBEDDED;
10408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10410 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10411 dgst_size = DGST_SIZE_4_5;
10412 parse_func = veracrypt_parse_hash_655331;
10413 sort_by_digest = sort_by_digest_4_5;
10414 opti_type = OPTI_TYPE_ZERO_BYTE;
10415 dgst_pos0 = 0;
10416 dgst_pos1 = 1;
10417 dgst_pos2 = 2;
10418 dgst_pos3 = 3;
10419 break;
10420
10421 case 13721: hash_type = HASH_TYPE_SHA512;
10422 salt_type = SALT_TYPE_EMBEDDED;
10423 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10424 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10425 kern_type = KERN_TYPE_TCSHA512_XTS512;
10426 dgst_size = DGST_SIZE_8_8;
10427 parse_func = veracrypt_parse_hash_500000;
10428 sort_by_digest = sort_by_digest_8_8;
10429 opti_type = OPTI_TYPE_ZERO_BYTE
10430 | OPTI_TYPE_USES_BITS_64;
10431 dgst_pos0 = 0;
10432 dgst_pos1 = 1;
10433 dgst_pos2 = 2;
10434 dgst_pos3 = 3;
10435 break;
10436
10437 case 13722: hash_type = HASH_TYPE_SHA512;
10438 salt_type = SALT_TYPE_EMBEDDED;
10439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10440 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10441 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10442 dgst_size = DGST_SIZE_8_8;
10443 parse_func = veracrypt_parse_hash_500000;
10444 sort_by_digest = sort_by_digest_8_8;
10445 opti_type = OPTI_TYPE_ZERO_BYTE
10446 | OPTI_TYPE_USES_BITS_64;
10447 dgst_pos0 = 0;
10448 dgst_pos1 = 1;
10449 dgst_pos2 = 2;
10450 dgst_pos3 = 3;
10451 break;
10452
10453 case 13723: hash_type = HASH_TYPE_SHA512;
10454 salt_type = SALT_TYPE_EMBEDDED;
10455 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10456 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10457 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10458 dgst_size = DGST_SIZE_8_8;
10459 parse_func = veracrypt_parse_hash_500000;
10460 sort_by_digest = sort_by_digest_8_8;
10461 opti_type = OPTI_TYPE_ZERO_BYTE
10462 | OPTI_TYPE_USES_BITS_64;
10463 dgst_pos0 = 0;
10464 dgst_pos1 = 1;
10465 dgst_pos2 = 2;
10466 dgst_pos3 = 3;
10467 break;
10468
10469 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10470 salt_type = SALT_TYPE_EMBEDDED;
10471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10473 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10474 dgst_size = DGST_SIZE_4_8;
10475 parse_func = veracrypt_parse_hash_500000;
10476 sort_by_digest = sort_by_digest_4_8;
10477 opti_type = OPTI_TYPE_ZERO_BYTE;
10478 dgst_pos0 = 0;
10479 dgst_pos1 = 1;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 3;
10482 break;
10483
10484 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10488 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10489 dgst_size = DGST_SIZE_4_8;
10490 parse_func = veracrypt_parse_hash_500000;
10491 sort_by_digest = sort_by_digest_4_8;
10492 opti_type = OPTI_TYPE_ZERO_BYTE;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 1;
10495 dgst_pos2 = 2;
10496 dgst_pos3 = 3;
10497 break;
10498
10499 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10504 dgst_size = DGST_SIZE_4_8;
10505 parse_func = veracrypt_parse_hash_500000;
10506 sort_by_digest = sort_by_digest_4_8;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10518 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10519 dgst_size = DGST_SIZE_4_5;
10520 parse_func = veracrypt_parse_hash_327661;
10521 sort_by_digest = sort_by_digest_4_5;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10534 dgst_size = DGST_SIZE_4_5;
10535 parse_func = veracrypt_parse_hash_327661;
10536 sort_by_digest = sort_by_digest_4_5;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10548 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10549 dgst_size = DGST_SIZE_4_5;
10550 parse_func = veracrypt_parse_hash_327661;
10551 sort_by_digest = sort_by_digest_4_5;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13751: hash_type = HASH_TYPE_SHA256;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10563 kern_type = KERN_TYPE_VCSHA256_XTS512;
10564 dgst_size = DGST_SIZE_4_8;
10565 parse_func = veracrypt_parse_hash_500000;
10566 sort_by_digest = sort_by_digest_4_8;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13752: hash_type = HASH_TYPE_SHA256;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10579 dgst_size = DGST_SIZE_4_8;
10580 parse_func = veracrypt_parse_hash_500000;
10581 sort_by_digest = sort_by_digest_4_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13753: hash_type = HASH_TYPE_SHA256;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10593 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10594 dgst_size = DGST_SIZE_4_8;
10595 parse_func = veracrypt_parse_hash_500000;
10596 sort_by_digest = sort_by_digest_4_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 13761: hash_type = HASH_TYPE_SHA256;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10608 kern_type = KERN_TYPE_VCSHA256_XTS512;
10609 dgst_size = DGST_SIZE_4_8;
10610 parse_func = veracrypt_parse_hash_200000;
10611 sort_by_digest = sort_by_digest_4_8;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13762: hash_type = HASH_TYPE_SHA256;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10623 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_200000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634 case 13763: hash_type = HASH_TYPE_SHA256;
10635 salt_type = SALT_TYPE_EMBEDDED;
10636 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10637 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10638 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10639 dgst_size = DGST_SIZE_4_8;
10640 parse_func = veracrypt_parse_hash_200000;
10641 sort_by_digest = sort_by_digest_4_8;
10642 opti_type = OPTI_TYPE_ZERO_BYTE;
10643 dgst_pos0 = 0;
10644 dgst_pos1 = 1;
10645 dgst_pos2 = 2;
10646 dgst_pos3 = 3;
10647 break;
10648
10649
10650 default: usage_mini_print (PROGNAME); return (-1);
10651 }
10652
10653 /**
10654 * parser
10655 */
10656
10657 data.parse_func = parse_func;
10658
10659 /**
10660 * misc stuff
10661 */
10662
10663 if (hex_salt)
10664 {
10665 if (salt_type == SALT_TYPE_INTERN)
10666 {
10667 opts_type |= OPTS_TYPE_ST_HEX;
10668 }
10669 else
10670 {
10671 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10672
10673 return (-1);
10674 }
10675 }
10676
10677 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10678 | (salt_type == SALT_TYPE_EXTERN)
10679 | (salt_type == SALT_TYPE_EMBEDDED)
10680 | (salt_type == SALT_TYPE_VIRTUAL));
10681
10682 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10683
10684 data.hash_type = hash_type;
10685 data.attack_mode = attack_mode;
10686 data.attack_kern = attack_kern;
10687 data.attack_exec = attack_exec;
10688 data.kern_type = kern_type;
10689 data.opts_type = opts_type;
10690 data.dgst_size = dgst_size;
10691 data.salt_type = salt_type;
10692 data.isSalted = isSalted;
10693 data.sort_by_digest = sort_by_digest;
10694 data.dgst_pos0 = dgst_pos0;
10695 data.dgst_pos1 = dgst_pos1;
10696 data.dgst_pos2 = dgst_pos2;
10697 data.dgst_pos3 = dgst_pos3;
10698
10699 esalt_size = 0;
10700
10701 switch (hash_mode)
10702 {
10703 case 2500: esalt_size = sizeof (wpa_t); break;
10704 case 5300: esalt_size = sizeof (ikepsk_t); break;
10705 case 5400: esalt_size = sizeof (ikepsk_t); break;
10706 case 5500: esalt_size = sizeof (netntlm_t); break;
10707 case 5600: esalt_size = sizeof (netntlm_t); break;
10708 case 6211: esalt_size = sizeof (tc_t); break;
10709 case 6212: esalt_size = sizeof (tc_t); break;
10710 case 6213: esalt_size = sizeof (tc_t); break;
10711 case 6221: esalt_size = sizeof (tc_t); break;
10712 case 6222: esalt_size = sizeof (tc_t); break;
10713 case 6223: esalt_size = sizeof (tc_t); break;
10714 case 6231: esalt_size = sizeof (tc_t); break;
10715 case 6232: esalt_size = sizeof (tc_t); break;
10716 case 6233: esalt_size = sizeof (tc_t); break;
10717 case 6241: esalt_size = sizeof (tc_t); break;
10718 case 6242: esalt_size = sizeof (tc_t); break;
10719 case 6243: esalt_size = sizeof (tc_t); break;
10720 case 6600: esalt_size = sizeof (agilekey_t); break;
10721 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10722 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10723 case 7300: esalt_size = sizeof (rakp_t); break;
10724 case 7500: esalt_size = sizeof (krb5pa_t); break;
10725 case 8200: esalt_size = sizeof (cloudkey_t); break;
10726 case 8800: esalt_size = sizeof (androidfde_t); break;
10727 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10728 case 9400: esalt_size = sizeof (office2007_t); break;
10729 case 9500: esalt_size = sizeof (office2010_t); break;
10730 case 9600: esalt_size = sizeof (office2013_t); break;
10731 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10732 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10733 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10734 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10735 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10736 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10737 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10738 case 10200: esalt_size = sizeof (cram_md5_t); break;
10739 case 10400: esalt_size = sizeof (pdf_t); break;
10740 case 10410: esalt_size = sizeof (pdf_t); break;
10741 case 10420: esalt_size = sizeof (pdf_t); break;
10742 case 10500: esalt_size = sizeof (pdf_t); break;
10743 case 10600: esalt_size = sizeof (pdf_t); break;
10744 case 10700: esalt_size = sizeof (pdf_t); break;
10745 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10746 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10747 case 11400: esalt_size = sizeof (sip_t); break;
10748 case 11600: esalt_size = sizeof (seven_zip_t); break;
10749 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10750 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10751 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10752 case 13000: esalt_size = sizeof (rar5_t); break;
10753 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10754 case 13400: esalt_size = sizeof (keepass_t); break;
10755 case 13500: esalt_size = sizeof (pstoken_t); break;
10756 case 13600: esalt_size = sizeof (zip2_t); break;
10757 case 13711: esalt_size = sizeof (tc_t); break;
10758 case 13712: esalt_size = sizeof (tc_t); break;
10759 case 13713: esalt_size = sizeof (tc_t); break;
10760 case 13721: esalt_size = sizeof (tc_t); break;
10761 case 13722: esalt_size = sizeof (tc_t); break;
10762 case 13723: esalt_size = sizeof (tc_t); break;
10763 case 13731: esalt_size = sizeof (tc_t); break;
10764 case 13732: esalt_size = sizeof (tc_t); break;
10765 case 13733: esalt_size = sizeof (tc_t); break;
10766 case 13741: esalt_size = sizeof (tc_t); break;
10767 case 13742: esalt_size = sizeof (tc_t); break;
10768 case 13743: esalt_size = sizeof (tc_t); break;
10769 case 13751: esalt_size = sizeof (tc_t); break;
10770 case 13752: esalt_size = sizeof (tc_t); break;
10771 case 13753: esalt_size = sizeof (tc_t); break;
10772 case 13761: esalt_size = sizeof (tc_t); break;
10773 case 13762: esalt_size = sizeof (tc_t); break;
10774 case 13763: esalt_size = sizeof (tc_t); break;
10775 }
10776
10777 data.esalt_size = esalt_size;
10778
10779 /**
10780 * choose dictionary parser
10781 */
10782
10783 if (hash_type == HASH_TYPE_LM)
10784 {
10785 get_next_word_func = get_next_word_lm;
10786 }
10787 else if (opts_type & OPTS_TYPE_PT_UPPER)
10788 {
10789 get_next_word_func = get_next_word_uc;
10790 }
10791 else
10792 {
10793 get_next_word_func = get_next_word_std;
10794 }
10795
10796 /**
10797 * dictstat
10798 */
10799
10800 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10801
10802 #ifdef _POSIX
10803 size_t dictstat_nmemb = 0;
10804 #endif
10805
10806 #ifdef _WIN
10807 uint dictstat_nmemb = 0;
10808 #endif
10809
10810 char dictstat[256] = { 0 };
10811
10812 FILE *dictstat_fp = NULL;
10813
10814 if (keyspace == 0)
10815 {
10816 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10817
10818 dictstat_fp = fopen (dictstat, "rb");
10819
10820 if (dictstat_fp)
10821 {
10822 #ifdef _POSIX
10823 struct stat tmpstat;
10824
10825 fstat (fileno (dictstat_fp), &tmpstat);
10826 #endif
10827
10828 #ifdef _WIN
10829 struct stat64 tmpstat;
10830
10831 _fstat64 (fileno (dictstat_fp), &tmpstat);
10832 #endif
10833
10834 if (tmpstat.st_mtime < COMPTIME)
10835 {
10836 /* with v0.15 the format changed so we have to ensure user is using a good version
10837 since there is no version-header in the dictstat file */
10838
10839 fclose (dictstat_fp);
10840
10841 unlink (dictstat);
10842 }
10843 else
10844 {
10845 while (!feof (dictstat_fp))
10846 {
10847 dictstat_t d;
10848
10849 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10850
10851 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10852
10853 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10854 {
10855 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10856
10857 return -1;
10858 }
10859 }
10860
10861 fclose (dictstat_fp);
10862 }
10863 }
10864 }
10865
10866 /**
10867 * potfile
10868 */
10869
10870 char potfile[256] = { 0 };
10871
10872 if (potfile_path == NULL)
10873 {
10874 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10875 }
10876 else
10877 {
10878 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10879 }
10880
10881 data.pot_fp = NULL;
10882
10883 FILE *out_fp = NULL;
10884 FILE *pot_fp = NULL;
10885
10886 if (show == 1 || left == 1)
10887 {
10888 pot_fp = fopen (potfile, "rb");
10889
10890 if (pot_fp == NULL)
10891 {
10892 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10893
10894 return (-1);
10895 }
10896
10897 if (outfile != NULL)
10898 {
10899 if ((out_fp = fopen (outfile, "ab")) == NULL)
10900 {
10901 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10902
10903 fclose (pot_fp);
10904
10905 return (-1);
10906 }
10907 }
10908 else
10909 {
10910 out_fp = stdout;
10911 }
10912 }
10913 else
10914 {
10915 if (potfile_disable == 0)
10916 {
10917 pot_fp = fopen (potfile, "ab");
10918
10919 if (pot_fp == NULL)
10920 {
10921 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10922
10923 return (-1);
10924 }
10925
10926 data.pot_fp = pot_fp;
10927 }
10928 }
10929
10930 pot_t *pot = NULL;
10931
10932 uint pot_cnt = 0;
10933 uint pot_avail = 0;
10934
10935 if (show == 1 || left == 1)
10936 {
10937 SUPPRESS_OUTPUT = 1;
10938
10939 pot_avail = count_lines (pot_fp);
10940
10941 rewind (pot_fp);
10942
10943 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10944
10945 uint pot_hashes_avail = 0;
10946
10947 uint line_num = 0;
10948
10949 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10950
10951 while (!feof (pot_fp))
10952 {
10953 line_num++;
10954
10955 int line_len = fgetl (pot_fp, line_buf);
10956
10957 if (line_len == 0) continue;
10958
10959 char *plain_buf = line_buf + line_len;
10960
10961 pot_t *pot_ptr = &pot[pot_cnt];
10962
10963 hash_t *hashes_buf = &pot_ptr->hash;
10964
10965 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10966 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10967
10968 if (pot_cnt == pot_hashes_avail)
10969 {
10970 uint pos = 0;
10971
10972 for (pos = 0; pos < INCR_POT; pos++)
10973 {
10974 if ((pot_cnt + pos) >= pot_avail) break;
10975
10976 pot_t *tmp_pot = &pot[pot_cnt + pos];
10977
10978 hash_t *tmp_hash = &tmp_pot->hash;
10979
10980 tmp_hash->digest = mymalloc (dgst_size);
10981
10982 if (isSalted)
10983 {
10984 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10985 }
10986
10987 if (esalt_size)
10988 {
10989 tmp_hash->esalt = mymalloc (esalt_size);
10990 }
10991
10992 pot_hashes_avail++;
10993 }
10994 }
10995
10996 int plain_len = 0;
10997
10998 int parser_status;
10999
11000 int iter = MAX_CUT_TRIES;
11001
11002 do
11003 {
11004 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11005 {
11006 if (line_buf[i] == ':')
11007 {
11008 line_len--;
11009
11010 break;
11011 }
11012 }
11013
11014 if (data.hash_mode != 2500)
11015 {
11016 parser_status = parse_func (line_buf, line_len, hashes_buf);
11017 }
11018 else
11019 {
11020 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11021
11022 if (line_len > max_salt_size)
11023 {
11024 parser_status = PARSER_GLOBAL_LENGTH;
11025 }
11026 else
11027 {
11028 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11029
11030 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11031
11032 hashes_buf->salt->salt_len = line_len;
11033
11034 parser_status = PARSER_OK;
11035 }
11036 }
11037
11038 // if NOT parsed without error, we add the ":" to the plain
11039
11040 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11041 {
11042 plain_len++;
11043 plain_buf--;
11044 }
11045
11046 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11047
11048 if (parser_status < PARSER_GLOBAL_ZERO)
11049 {
11050 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11051
11052 continue;
11053 }
11054
11055 if (plain_len >= 255) continue;
11056
11057 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11058
11059 pot_ptr->plain_len = plain_len;
11060
11061 pot_cnt++;
11062 }
11063
11064 myfree (line_buf);
11065
11066 fclose (pot_fp);
11067
11068 SUPPRESS_OUTPUT = 0;
11069
11070 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11071 }
11072
11073 /**
11074 * word len
11075 */
11076
11077 uint pw_min = PW_MIN;
11078 uint pw_max = PW_MAX;
11079
11080 switch (hash_mode)
11081 {
11082 case 125: if (pw_max > 32) pw_max = 32;
11083 break;
11084 case 400: if (pw_max > 40) pw_max = 40;
11085 break;
11086 case 500: if (pw_max > 16) pw_max = 16;
11087 break;
11088 case 1500: if (pw_max > 8) pw_max = 8;
11089 break;
11090 case 1600: if (pw_max > 16) pw_max = 16;
11091 break;
11092 case 1800: if (pw_max > 16) pw_max = 16;
11093 break;
11094 case 2100: if (pw_max > 16) pw_max = 16;
11095 break;
11096 case 2500: if (pw_min < 8) pw_min = 8;
11097 break;
11098 case 3000: if (pw_max > 7) pw_max = 7;
11099 break;
11100 case 5200: if (pw_max > 24) pw_max = 24;
11101 break;
11102 case 5800: if (pw_max > 16) pw_max = 16;
11103 break;
11104 case 6300: if (pw_max > 16) pw_max = 16;
11105 break;
11106 case 7400: if (pw_max > 16) pw_max = 16;
11107 break;
11108 case 7900: if (pw_max > 48) pw_max = 48;
11109 break;
11110 case 8500: if (pw_max > 8) pw_max = 8;
11111 break;
11112 case 8600: if (pw_max > 16) pw_max = 16;
11113 break;
11114 case 9710: pw_min = 5;
11115 pw_max = 5;
11116 break;
11117 case 9810: pw_min = 5;
11118 pw_max = 5;
11119 break;
11120 case 10410: pw_min = 5;
11121 pw_max = 5;
11122 break;
11123 case 10300: if (pw_max < 3) pw_min = 3;
11124 if (pw_max > 40) pw_max = 40;
11125 break;
11126 case 10500: if (pw_max < 3) pw_min = 3;
11127 if (pw_max > 40) pw_max = 40;
11128 break;
11129 case 10700: if (pw_max > 16) pw_max = 16;
11130 break;
11131 case 11300: if (pw_max > 40) pw_max = 40;
11132 break;
11133 case 11600: if (pw_max > 32) pw_max = 32;
11134 break;
11135 case 12500: if (pw_max > 20) pw_max = 20;
11136 break;
11137 case 12800: if (pw_max > 24) pw_max = 24;
11138 break;
11139 }
11140
11141 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11142 {
11143 switch (attack_kern)
11144 {
11145 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11146 break;
11147 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11148 break;
11149 }
11150 }
11151
11152 /**
11153 * charsets : keep them together for more easy maintainnce
11154 */
11155
11156 cs_t mp_sys[6] = { { { 0 }, 0 } };
11157 cs_t mp_usr[4] = { { { 0 }, 0 } };
11158
11159 mp_setup_sys (mp_sys);
11160
11161 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11162 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11163 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11164 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11165
11166 /**
11167 * load hashes, part I: find input mode, count hashes
11168 */
11169
11170 uint hashlist_mode = 0;
11171 uint hashlist_format = HLFMT_HASHCAT;
11172
11173 uint hashes_avail = 0;
11174
11175 if (benchmark == 0)
11176 {
11177 struct stat f;
11178
11179 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11180
11181 if ((hash_mode == 2500) ||
11182 (hash_mode == 5200) ||
11183 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11184 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11185 (hash_mode == 9000))
11186 {
11187 hashlist_mode = HL_MODE_ARG;
11188
11189 char *hashfile = myargv[optind];
11190
11191 data.hashfile = hashfile;
11192
11193 logfile_top_var_string ("target", hashfile);
11194 }
11195
11196 if (hashlist_mode == HL_MODE_ARG)
11197 {
11198 if (hash_mode == 2500)
11199 {
11200 struct stat st;
11201
11202 if (stat (data.hashfile, &st) == -1)
11203 {
11204 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11205
11206 return (-1);
11207 }
11208
11209 hashes_avail = st.st_size / sizeof (hccap_t);
11210 }
11211 else
11212 {
11213 hashes_avail = 1;
11214 }
11215 }
11216 else if (hashlist_mode == HL_MODE_FILE)
11217 {
11218 char *hashfile = myargv[optind];
11219
11220 data.hashfile = hashfile;
11221
11222 logfile_top_var_string ("target", hashfile);
11223
11224 FILE *fp = NULL;
11225
11226 if ((fp = fopen (hashfile, "rb")) == NULL)
11227 {
11228 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11229
11230 return (-1);
11231 }
11232
11233 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11234
11235 hashes_avail = count_lines (fp);
11236
11237 rewind (fp);
11238
11239 if (hashes_avail == 0)
11240 {
11241 log_error ("ERROR: hashfile is empty or corrupt");
11242
11243 fclose (fp);
11244
11245 return (-1);
11246 }
11247
11248 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11249
11250 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11251 {
11252 log_error ("ERROR: remove not supported in native hashfile-format mode");
11253
11254 fclose (fp);
11255
11256 return (-1);
11257 }
11258
11259 fclose (fp);
11260 }
11261 }
11262 else
11263 {
11264 hashlist_mode = HL_MODE_ARG;
11265
11266 hashes_avail = 1;
11267 }
11268
11269 if (hash_mode == 3000) hashes_avail *= 2;
11270
11271 data.hashlist_mode = hashlist_mode;
11272 data.hashlist_format = hashlist_format;
11273
11274 logfile_top_uint (hashlist_mode);
11275 logfile_top_uint (hashlist_format);
11276
11277 /**
11278 * load hashes, part II: allocate required memory, set pointers
11279 */
11280
11281 hash_t *hashes_buf = NULL;
11282 void *digests_buf = NULL;
11283 salt_t *salts_buf = NULL;
11284 void *esalts_buf = NULL;
11285
11286 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11287
11288 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11289
11290 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11291 {
11292 u32 hash_pos;
11293
11294 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11295 {
11296 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11297
11298 hashes_buf[hash_pos].hash_info = hash_info;
11299
11300 if (username && (remove || show || left))
11301 {
11302 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11303 }
11304
11305 if (benchmark)
11306 {
11307 hash_info->orighash = (char *) mymalloc (256);
11308 }
11309 }
11310 }
11311
11312 if (isSalted)
11313 {
11314 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11315
11316 if (esalt_size)
11317 {
11318 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11319 }
11320 }
11321 else
11322 {
11323 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11324 }
11325
11326 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11327 {
11328 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11329
11330 if (isSalted)
11331 {
11332 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11333
11334 if (esalt_size)
11335 {
11336 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11337 }
11338 }
11339 else
11340 {
11341 hashes_buf[hash_pos].salt = &salts_buf[0];
11342 }
11343 }
11344
11345 /**
11346 * load hashes, part III: parse hashes or generate them if benchmark
11347 */
11348
11349 uint hashes_cnt = 0;
11350
11351 if (benchmark == 0)
11352 {
11353 if (keyspace == 1)
11354 {
11355 // useless to read hash file for keyspace, cheat a little bit w/ optind
11356 }
11357 else if (hashes_avail == 0)
11358 {
11359 }
11360 else if (hashlist_mode == HL_MODE_ARG)
11361 {
11362 char *input_buf = myargv[optind];
11363
11364 uint input_len = strlen (input_buf);
11365
11366 logfile_top_var_string ("target", input_buf);
11367
11368 char *hash_buf = NULL;
11369 int hash_len = 0;
11370
11371 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11372
11373 bool hash_fmt_error = 0;
11374
11375 if (hash_len < 1) hash_fmt_error = 1;
11376 if (hash_buf == NULL) hash_fmt_error = 1;
11377
11378 if (hash_fmt_error)
11379 {
11380 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11381 }
11382 else
11383 {
11384 if (opts_type & OPTS_TYPE_HASH_COPY)
11385 {
11386 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11387
11388 hash_info_tmp->orighash = mystrdup (hash_buf);
11389 }
11390
11391 if (isSalted)
11392 {
11393 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11394 }
11395
11396 int parser_status = PARSER_OK;
11397
11398 if (hash_mode == 2500)
11399 {
11400 if (hash_len == 0)
11401 {
11402 log_error ("ERROR: hccap file not specified");
11403
11404 return (-1);
11405 }
11406
11407 hashlist_mode = HL_MODE_FILE;
11408
11409 data.hashlist_mode = hashlist_mode;
11410
11411 FILE *fp = fopen (hash_buf, "rb");
11412
11413 if (fp == NULL)
11414 {
11415 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11416
11417 return (-1);
11418 }
11419
11420 if (hashes_avail < 1)
11421 {
11422 log_error ("ERROR: hccap file is empty or corrupt");
11423
11424 fclose (fp);
11425
11426 return (-1);
11427 }
11428
11429 uint hccap_size = sizeof (hccap_t);
11430
11431 char *in = (char *) mymalloc (hccap_size);
11432
11433 while (!feof (fp))
11434 {
11435 int n = fread (in, hccap_size, 1, fp);
11436
11437 if (n != 1)
11438 {
11439 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11440
11441 break;
11442 }
11443
11444 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11445
11446 if (parser_status != PARSER_OK)
11447 {
11448 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11449
11450 continue;
11451 }
11452
11453 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11454
11455 if ((show == 1) || (left == 1))
11456 {
11457 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11458
11459 char *salt_ptr = (char *) tmp_salt->salt_buf;
11460
11461 int cur_pos = tmp_salt->salt_len;
11462 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11463
11464 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11465
11466 // do the appending task
11467
11468 snprintf (salt_ptr + cur_pos,
11469 rem_len,
11470 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11471 wpa->orig_mac1[0],
11472 wpa->orig_mac1[1],
11473 wpa->orig_mac1[2],
11474 wpa->orig_mac1[3],
11475 wpa->orig_mac1[4],
11476 wpa->orig_mac1[5],
11477 wpa->orig_mac2[0],
11478 wpa->orig_mac2[1],
11479 wpa->orig_mac2[2],
11480 wpa->orig_mac2[3],
11481 wpa->orig_mac2[4],
11482 wpa->orig_mac2[5]);
11483
11484 // memset () the remaining part of the salt
11485
11486 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11487 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11488
11489 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11490
11491 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11492 }
11493
11494 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11495 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11496
11497 hashes_cnt++;
11498 }
11499
11500 fclose (fp);
11501
11502 myfree (in);
11503 }
11504 else if (hash_mode == 3000)
11505 {
11506 if (hash_len == 32)
11507 {
11508 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11509
11510 hash_t *lm_hash_left = NULL;
11511
11512 if (parser_status == PARSER_OK)
11513 {
11514 lm_hash_left = &hashes_buf[hashes_cnt];
11515
11516 hashes_cnt++;
11517 }
11518 else
11519 {
11520 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11521 }
11522
11523 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11524
11525 hash_t *lm_hash_right = NULL;
11526
11527 if (parser_status == PARSER_OK)
11528 {
11529 lm_hash_right = &hashes_buf[hashes_cnt];
11530
11531 hashes_cnt++;
11532 }
11533 else
11534 {
11535 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11536 }
11537
11538 // show / left
11539
11540 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11541 {
11542 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11543 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11544 }
11545 }
11546 else
11547 {
11548 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11549
11550 if (parser_status == PARSER_OK)
11551 {
11552 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11553 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11554 }
11555
11556 if (parser_status == PARSER_OK)
11557 {
11558 hashes_cnt++;
11559 }
11560 else
11561 {
11562 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11563 }
11564 }
11565 }
11566 else
11567 {
11568 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11569
11570 if (parser_status == PARSER_OK)
11571 {
11572 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11573 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11574 }
11575
11576 if (parser_status == PARSER_OK)
11577 {
11578 hashes_cnt++;
11579 }
11580 else
11581 {
11582 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11583 }
11584 }
11585 }
11586 }
11587 else if (hashlist_mode == HL_MODE_FILE)
11588 {
11589 char *hashfile = data.hashfile;
11590
11591 FILE *fp;
11592
11593 if ((fp = fopen (hashfile, "rb")) == NULL)
11594 {
11595 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11596
11597 return (-1);
11598 }
11599
11600 uint line_num = 0;
11601
11602 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11603
11604 while (!feof (fp))
11605 {
11606 line_num++;
11607
11608 int line_len = fgetl (fp, line_buf);
11609
11610 if (line_len == 0) continue;
11611
11612 char *hash_buf = NULL;
11613 int hash_len = 0;
11614
11615 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11616
11617 bool hash_fmt_error = 0;
11618
11619 if (hash_len < 1) hash_fmt_error = 1;
11620 if (hash_buf == NULL) hash_fmt_error = 1;
11621
11622 if (hash_fmt_error)
11623 {
11624 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11625
11626 continue;
11627 }
11628
11629 if (username)
11630 {
11631 char *user_buf = NULL;
11632 int user_len = 0;
11633
11634 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11635
11636 if (remove || show)
11637 {
11638 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11639
11640 *user = (user_t *) mymalloc (sizeof (user_t));
11641
11642 user_t *user_ptr = *user;
11643
11644 if (user_buf != NULL)
11645 {
11646 user_ptr->user_name = mystrdup (user_buf);
11647 }
11648 else
11649 {
11650 user_ptr->user_name = mystrdup ("");
11651 }
11652
11653 user_ptr->user_len = user_len;
11654 }
11655 }
11656
11657 if (opts_type & OPTS_TYPE_HASH_COPY)
11658 {
11659 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11660
11661 hash_info_tmp->orighash = mystrdup (hash_buf);
11662 }
11663
11664 if (isSalted)
11665 {
11666 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11667 }
11668
11669 if (hash_mode == 3000)
11670 {
11671 if (hash_len == 32)
11672 {
11673 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11674
11675 if (parser_status < PARSER_GLOBAL_ZERO)
11676 {
11677 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11678
11679 continue;
11680 }
11681
11682 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11683
11684 hashes_cnt++;
11685
11686 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11687
11688 if (parser_status < PARSER_GLOBAL_ZERO)
11689 {
11690 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11691
11692 continue;
11693 }
11694
11695 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11696
11697 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11698
11699 hashes_cnt++;
11700
11701 // show / left
11702
11703 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11704 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11705 }
11706 else
11707 {
11708 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11709
11710 if (parser_status < PARSER_GLOBAL_ZERO)
11711 {
11712 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11713
11714 continue;
11715 }
11716
11717 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11718
11719 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11720 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11721
11722 hashes_cnt++;
11723 }
11724 }
11725 else
11726 {
11727 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11728
11729 if (parser_status < PARSER_GLOBAL_ZERO)
11730 {
11731 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11732
11733 continue;
11734 }
11735
11736 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11737
11738 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11739 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11740
11741 hashes_cnt++;
11742 }
11743 }
11744
11745 myfree (line_buf);
11746
11747 fclose (fp);
11748
11749 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11750
11751 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11752 }
11753 }
11754 else
11755 {
11756 if (isSalted)
11757 {
11758 hashes_buf[0].salt->salt_len = 8;
11759
11760 // special salt handling
11761
11762 switch (hash_mode)
11763 {
11764 case 1500: hashes_buf[0].salt->salt_len = 2;
11765 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11766 break;
11767 case 1731: hashes_buf[0].salt->salt_len = 4;
11768 break;
11769 case 2410: hashes_buf[0].salt->salt_len = 4;
11770 break;
11771 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11772 break;
11773 case 3100: hashes_buf[0].salt->salt_len = 1;
11774 break;
11775 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11776 break;
11777 case 5800: hashes_buf[0].salt->salt_len = 16;
11778 break;
11779 case 6800: hashes_buf[0].salt->salt_len = 32;
11780 break;
11781 case 8400: hashes_buf[0].salt->salt_len = 40;
11782 break;
11783 case 8800: hashes_buf[0].salt->salt_len = 16;
11784 break;
11785 case 8900: hashes_buf[0].salt->salt_len = 16;
11786 hashes_buf[0].salt->scrypt_N = 1024;
11787 hashes_buf[0].salt->scrypt_r = 1;
11788 hashes_buf[0].salt->scrypt_p = 1;
11789 break;
11790 case 9100: hashes_buf[0].salt->salt_len = 16;
11791 break;
11792 case 9300: hashes_buf[0].salt->salt_len = 14;
11793 hashes_buf[0].salt->scrypt_N = 16384;
11794 hashes_buf[0].salt->scrypt_r = 1;
11795 hashes_buf[0].salt->scrypt_p = 1;
11796 break;
11797 case 9400: hashes_buf[0].salt->salt_len = 16;
11798 break;
11799 case 9500: hashes_buf[0].salt->salt_len = 16;
11800 break;
11801 case 9600: hashes_buf[0].salt->salt_len = 16;
11802 break;
11803 case 9700: hashes_buf[0].salt->salt_len = 16;
11804 break;
11805 case 9710: hashes_buf[0].salt->salt_len = 16;
11806 break;
11807 case 9720: hashes_buf[0].salt->salt_len = 16;
11808 break;
11809 case 9800: hashes_buf[0].salt->salt_len = 16;
11810 break;
11811 case 9810: hashes_buf[0].salt->salt_len = 16;
11812 break;
11813 case 9820: hashes_buf[0].salt->salt_len = 16;
11814 break;
11815 case 10300: hashes_buf[0].salt->salt_len = 12;
11816 break;
11817 case 11500: hashes_buf[0].salt->salt_len = 4;
11818 break;
11819 case 11600: hashes_buf[0].salt->salt_len = 4;
11820 break;
11821 case 12400: hashes_buf[0].salt->salt_len = 4;
11822 break;
11823 case 12500: hashes_buf[0].salt->salt_len = 8;
11824 break;
11825 case 12600: hashes_buf[0].salt->salt_len = 64;
11826 break;
11827 }
11828
11829 // special esalt handling
11830
11831 switch (hash_mode)
11832 {
11833 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11834 break;
11835 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11836 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11837 break;
11838 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11839 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11840 break;
11841 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11842 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11843 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11844 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11845 break;
11846 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11847 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11848 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11849 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11850 break;
11851 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11852 break;
11853 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11854 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11855 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11856 break;
11857 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11858 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11859 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11860 break;
11861 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11862 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11863 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11864 break;
11865 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11866 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11867 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11868 break;
11869 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11870 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11871 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11872 break;
11873 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11874 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11875 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11876 break;
11877 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11878 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11879 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11880 break;
11881 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11882 break;
11883 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11884 break;
11885 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11886 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11887 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11888 break;
11889 }
11890 }
11891
11892 // set hashfile
11893
11894 switch (hash_mode)
11895 {
11896 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11897 break;
11898 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11899 break;
11900 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11901 break;
11902 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11903 break;
11904 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11905 break;
11906 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11907 break;
11908 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11909 break;
11910 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11911 break;
11912 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11913 break;
11914 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11915 break;
11916 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11917 break;
11918 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11919 break;
11920 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11921 break;
11922 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11923 break;
11924 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11925 break;
11926 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11927 break;
11928 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11929 break;
11930 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11931 break;
11932 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11933 break;
11934 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11935 break;
11936 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11937 break;
11938 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11939 break;
11940 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11941 break;
11942 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11943 break;
11944 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11945 break;
11946 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11947 break;
11948 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11949 break;
11950 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11951 break;
11952 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11953 break;
11954 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11955 break;
11956 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11957 break;
11958 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11959 break;
11960 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11961 break;
11962 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11963 break;
11964 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11965 break;
11966 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11967 break;
11968 }
11969
11970 // set default iterations
11971
11972 switch (hash_mode)
11973 {
11974 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11975 break;
11976 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11977 break;
11978 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11979 break;
11980 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11981 break;
11982 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11983 break;
11984 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11985 break;
11986 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11987 break;
11988 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11989 break;
11990 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11991 break;
11992 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11993 break;
11994 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11995 break;
11996 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11997 break;
11998 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11999 break;
12000 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12001 break;
12002 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12003 break;
12004 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12005 break;
12006 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12007 break;
12008 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12009 break;
12010 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12011 break;
12012 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12013 break;
12014 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12015 break;
12016 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12017 break;
12018 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12019 break;
12020 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12021 break;
12022 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12023 break;
12024 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12025 break;
12026 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12027 break;
12028 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12029 break;
12030 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12031 break;
12032 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12033 break;
12034 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12035 break;
12036 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12037 break;
12038 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12039 break;
12040 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12041 break;
12042 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12043 break;
12044 case 8900: hashes_buf[0].salt->salt_iter = 1;
12045 break;
12046 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12047 break;
12048 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12049 break;
12050 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12051 break;
12052 case 9300: hashes_buf[0].salt->salt_iter = 1;
12053 break;
12054 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12055 break;
12056 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12057 break;
12058 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12059 break;
12060 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12061 break;
12062 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12063 break;
12064 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12065 break;
12066 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12067 break;
12068 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12069 break;
12070 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12071 break;
12072 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12073 break;
12074 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12075 break;
12076 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12077 break;
12078 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12079 break;
12080 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12081 break;
12082 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12083 break;
12084 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12085 break;
12086 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12087 break;
12088 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12089 break;
12090 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12091 break;
12092 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12093 break;
12094 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12095 break;
12096 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12097 break;
12098 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12099 break;
12100 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12101 break;
12102 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12103 break;
12104 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12105 break;
12106 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12107 break;
12108 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12109 break;
12110 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12111 break;
12112 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12113 break;
12114 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12115 break;
12116 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12117 break;
12118 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12119 break;
12120 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12121 break;
12122 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12123 break;
12124 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12125 break;
12126 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12127 break;
12128 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12129 break;
12130 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12131 break;
12132 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12133 break;
12134 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12135 break;
12136 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12137 break;
12138 }
12139
12140 hashes_cnt = 1;
12141 }
12142
12143 if (show == 1 || left == 1)
12144 {
12145 for (uint i = 0; i < pot_cnt; i++)
12146 {
12147 pot_t *pot_ptr = &pot[i];
12148
12149 hash_t *hashes_buf = &pot_ptr->hash;
12150
12151 local_free (hashes_buf->digest);
12152
12153 if (isSalted)
12154 {
12155 local_free (hashes_buf->salt);
12156 }
12157 }
12158
12159 local_free (pot);
12160
12161 if (data.quiet == 0) log_info_nn ("");
12162
12163 return (0);
12164 }
12165
12166 if (keyspace == 0)
12167 {
12168 if (hashes_cnt == 0)
12169 {
12170 log_error ("ERROR: No hashes loaded");
12171
12172 return (-1);
12173 }
12174 }
12175
12176 /**
12177 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12178 */
12179
12180 if (data.outfile != NULL)
12181 {
12182 if (data.hashfile != NULL)
12183 {
12184 #ifdef _POSIX
12185 struct stat tmpstat_outfile;
12186 struct stat tmpstat_hashfile;
12187 #endif
12188
12189 #ifdef _WIN
12190 struct stat64 tmpstat_outfile;
12191 struct stat64 tmpstat_hashfile;
12192 #endif
12193
12194 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12195
12196 if (tmp_outfile_fp)
12197 {
12198 #ifdef _POSIX
12199 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12200 #endif
12201
12202 #ifdef _WIN
12203 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12204 #endif
12205
12206 fclose (tmp_outfile_fp);
12207 }
12208
12209 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12210
12211 if (tmp_hashfile_fp)
12212 {
12213 #ifdef _POSIX
12214 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12215 #endif
12216
12217 #ifdef _WIN
12218 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12219 #endif
12220
12221 fclose (tmp_hashfile_fp);
12222 }
12223
12224 if (tmp_outfile_fp && tmp_outfile_fp)
12225 {
12226 tmpstat_outfile.st_mode = 0;
12227 tmpstat_outfile.st_nlink = 0;
12228 tmpstat_outfile.st_uid = 0;
12229 tmpstat_outfile.st_gid = 0;
12230 tmpstat_outfile.st_rdev = 0;
12231 tmpstat_outfile.st_atime = 0;
12232
12233 tmpstat_hashfile.st_mode = 0;
12234 tmpstat_hashfile.st_nlink = 0;
12235 tmpstat_hashfile.st_uid = 0;
12236 tmpstat_hashfile.st_gid = 0;
12237 tmpstat_hashfile.st_rdev = 0;
12238 tmpstat_hashfile.st_atime = 0;
12239
12240 #ifdef _POSIX
12241 tmpstat_outfile.st_blksize = 0;
12242 tmpstat_outfile.st_blocks = 0;
12243
12244 tmpstat_hashfile.st_blksize = 0;
12245 tmpstat_hashfile.st_blocks = 0;
12246 #endif
12247
12248 #ifdef _POSIX
12249 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12250 {
12251 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12252
12253 return (-1);
12254 }
12255 #endif
12256
12257 #ifdef _WIN
12258 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12259 {
12260 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12261
12262 return (-1);
12263 }
12264 #endif
12265 }
12266 }
12267 }
12268
12269 /**
12270 * Remove duplicates
12271 */
12272
12273 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12274
12275 if (isSalted)
12276 {
12277 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12278 }
12279 else
12280 {
12281 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12282 }
12283
12284 uint hashes_cnt_orig = hashes_cnt;
12285
12286 hashes_cnt = 1;
12287
12288 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12289 {
12290 if (isSalted)
12291 {
12292 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12293 {
12294 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12295 }
12296 }
12297 else
12298 {
12299 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12300 }
12301
12302 if (hashes_pos > hashes_cnt)
12303 {
12304 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12305 }
12306
12307 hashes_cnt++;
12308 }
12309
12310 /**
12311 * Potfile removes
12312 */
12313
12314 uint potfile_remove_cracks = 0;
12315
12316 if (potfile_disable == 0)
12317 {
12318 hash_t hash_buf;
12319
12320 hash_buf.digest = mymalloc (dgst_size);
12321 hash_buf.salt = NULL;
12322 hash_buf.esalt = NULL;
12323 hash_buf.hash_info = NULL;
12324 hash_buf.cracked = 0;
12325
12326 if (isSalted)
12327 {
12328 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12329 }
12330
12331 if (esalt_size)
12332 {
12333 hash_buf.esalt = mymalloc (esalt_size);
12334 }
12335
12336 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12337
12338 // no solution for these special hash types (for instane because they use hashfile in output etc)
12339 if ((hash_mode != 5200) &&
12340 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12341 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12342 (hash_mode != 9000))
12343 {
12344 FILE *fp = fopen (potfile, "rb");
12345
12346 if (fp != NULL)
12347 {
12348 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12349
12350 // to be safe work with a copy (because of line_len loop, i etc)
12351 // moved up here because it's easier to handle continue case
12352 // it's just 64kb
12353
12354 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12355
12356 while (!feof (fp))
12357 {
12358 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12359
12360 if (ptr == NULL) break;
12361
12362 int line_len = strlen (line_buf);
12363
12364 if (line_len == 0) continue;
12365
12366 int iter = MAX_CUT_TRIES;
12367
12368 for (int i = line_len - 1; i && iter; i--, line_len--)
12369 {
12370 if (line_buf[i] != ':') continue;
12371
12372 if (isSalted)
12373 {
12374 memset (hash_buf.salt, 0, sizeof (salt_t));
12375 }
12376
12377 hash_t *found = NULL;
12378
12379 if (hash_mode == 6800)
12380 {
12381 if (i < 64) // 64 = 16 * uint in salt_buf[]
12382 {
12383 // manipulate salt_buf
12384 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12385
12386 hash_buf.salt->salt_len = i;
12387
12388 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12389 }
12390 }
12391 else if (hash_mode == 2500)
12392 {
12393 if (i < 64) // 64 = 16 * uint in salt_buf[]
12394 {
12395 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12396 // manipulate salt_buf
12397
12398 memcpy (line_buf_cpy, line_buf, i);
12399
12400 char *mac2_pos = strrchr (line_buf_cpy, ':');
12401
12402 if (mac2_pos == NULL) continue;
12403
12404 mac2_pos[0] = 0;
12405 mac2_pos++;
12406
12407 if (strlen (mac2_pos) != 12) continue;
12408
12409 char *mac1_pos = strrchr (line_buf_cpy, ':');
12410
12411 if (mac1_pos == NULL) continue;
12412
12413 mac1_pos[0] = 0;
12414 mac1_pos++;
12415
12416 if (strlen (mac1_pos) != 12) continue;
12417
12418 uint essid_length = mac1_pos - line_buf_cpy - 1;
12419
12420 // here we need the ESSID
12421 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12422
12423 hash_buf.salt->salt_len = essid_length;
12424
12425 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12426
12427 if (found)
12428 {
12429 wpa_t *wpa = (wpa_t *) found->esalt;
12430
12431 // compare hex string(s) vs binary MAC address(es)
12432
12433 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12434 {
12435 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12436 {
12437 found = NULL;
12438
12439 break;
12440 }
12441 }
12442
12443 // early skip ;)
12444 if (!found) continue;
12445
12446 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12447 {
12448 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12449 {
12450 found = NULL;
12451
12452 break;
12453 }
12454 }
12455 }
12456 }
12457 }
12458 else
12459 {
12460 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12461
12462 if (parser_status == PARSER_OK)
12463 {
12464 if (isSalted)
12465 {
12466 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12467 }
12468 else
12469 {
12470 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12471 }
12472 }
12473 }
12474
12475 if (found == NULL) continue;
12476
12477 if (!found->cracked) potfile_remove_cracks++;
12478
12479 found->cracked = 1;
12480
12481 if (found) break;
12482
12483 iter--;
12484 }
12485 }
12486
12487 myfree (line_buf_cpy);
12488
12489 myfree (line_buf);
12490
12491 fclose (fp);
12492 }
12493 }
12494
12495 if (esalt_size)
12496 {
12497 local_free (hash_buf.esalt);
12498 }
12499
12500 if (isSalted)
12501 {
12502 local_free (hash_buf.salt);
12503 }
12504
12505 local_free (hash_buf.digest);
12506 }
12507
12508 /**
12509 * Now generate all the buffers required for later
12510 */
12511
12512 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12513
12514 salt_t *salts_buf_new = NULL;
12515 void *esalts_buf_new = NULL;
12516
12517 if (isSalted)
12518 {
12519 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12520
12521 if (esalt_size)
12522 {
12523 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12524 }
12525 }
12526 else
12527 {
12528 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12529 }
12530
12531 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12532
12533 uint digests_cnt = hashes_cnt;
12534 uint digests_done = 0;
12535
12536 size_t size_digests = digests_cnt * dgst_size;
12537 size_t size_shown = digests_cnt * sizeof (uint);
12538
12539 uint *digests_shown = (uint *) mymalloc (size_shown);
12540 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12541
12542 uint salts_cnt = 0;
12543 uint salts_done = 0;
12544
12545 hashinfo_t **hash_info = NULL;
12546
12547 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12548 {
12549 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12550
12551 if (username && (remove || show))
12552 {
12553 uint user_pos;
12554
12555 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12556 {
12557 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12558
12559 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12560 }
12561 }
12562 }
12563
12564 uint *salts_shown = (uint *) mymalloc (size_shown);
12565
12566 salt_t *salt_buf;
12567
12568 {
12569 // copied from inner loop
12570
12571 salt_buf = &salts_buf_new[salts_cnt];
12572
12573 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12574
12575 if (esalt_size)
12576 {
12577 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12578 }
12579
12580 salt_buf->digests_cnt = 0;
12581 salt_buf->digests_done = 0;
12582 salt_buf->digests_offset = 0;
12583
12584 salts_cnt++;
12585 }
12586
12587 if (hashes_buf[0].cracked == 1)
12588 {
12589 digests_shown[0] = 1;
12590
12591 digests_done++;
12592
12593 salt_buf->digests_done++;
12594 }
12595
12596 salt_buf->digests_cnt++;
12597
12598 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12599
12600 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12601 {
12602 hash_info[0] = hashes_buf[0].hash_info;
12603 }
12604
12605 // copy from inner loop
12606
12607 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12608 {
12609 if (isSalted)
12610 {
12611 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12612 {
12613 salt_buf = &salts_buf_new[salts_cnt];
12614
12615 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12616
12617 if (esalt_size)
12618 {
12619 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12620 }
12621
12622 salt_buf->digests_cnt = 0;
12623 salt_buf->digests_done = 0;
12624 salt_buf->digests_offset = hashes_pos;
12625
12626 salts_cnt++;
12627 }
12628 }
12629
12630 if (hashes_buf[hashes_pos].cracked == 1)
12631 {
12632 digests_shown[hashes_pos] = 1;
12633
12634 digests_done++;
12635
12636 salt_buf->digests_done++;
12637 }
12638
12639 salt_buf->digests_cnt++;
12640
12641 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12642
12643 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12644 {
12645 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12646 }
12647 }
12648
12649 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12650 {
12651 salt_t *salt_buf = &salts_buf_new[salt_pos];
12652
12653 if (salt_buf->digests_done == salt_buf->digests_cnt)
12654 {
12655 salts_shown[salt_pos] = 1;
12656
12657 salts_done++;
12658 }
12659
12660 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12661 }
12662
12663 local_free (digests_buf);
12664 local_free (salts_buf);
12665 local_free (esalts_buf);
12666
12667 digests_buf = digests_buf_new;
12668 salts_buf = salts_buf_new;
12669 esalts_buf = esalts_buf_new;
12670
12671 local_free (hashes_buf);
12672
12673 /**
12674 * special modification not set from parser
12675 */
12676
12677 switch (hash_mode)
12678 {
12679 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12680 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12681 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12682 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12683 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12684 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12685 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12686 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12687 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12688 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12689 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12690 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12691 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12692 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12693 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12694 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12695 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12696 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12697 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12698 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12699 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12700 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12701 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12702 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12703 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12704 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12705 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12706 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12707 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12708 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12709 }
12710
12711 if (truecrypt_keyfiles)
12712 {
12713 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12714
12715 char *keyfiles = strdup (truecrypt_keyfiles);
12716
12717 char *keyfile = strtok (keyfiles, ",");
12718
12719 do
12720 {
12721 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12722
12723 } while ((keyfile = strtok (NULL, ",")) != NULL);
12724
12725 free (keyfiles);
12726 }
12727
12728 if (veracrypt_keyfiles)
12729 {
12730 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12731
12732 char *keyfiles = strdup (veracrypt_keyfiles);
12733
12734 char *keyfile = strtok (keyfiles, ",");
12735
12736 do
12737 {
12738 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12739
12740 } while ((keyfile = strtok (NULL, ",")) != NULL);
12741
12742 free (keyfiles);
12743 }
12744
12745 data.digests_cnt = digests_cnt;
12746 data.digests_done = digests_done;
12747 data.digests_buf = digests_buf;
12748 data.digests_shown = digests_shown;
12749 data.digests_shown_tmp = digests_shown_tmp;
12750
12751 data.salts_cnt = salts_cnt;
12752 data.salts_done = salts_done;
12753 data.salts_buf = salts_buf;
12754 data.salts_shown = salts_shown;
12755
12756 data.esalts_buf = esalts_buf;
12757 data.hash_info = hash_info;
12758
12759 /**
12760 * Automatic Optimizers
12761 */
12762
12763 if (salts_cnt == 1)
12764 opti_type |= OPTI_TYPE_SINGLE_SALT;
12765
12766 if (digests_cnt == 1)
12767 opti_type |= OPTI_TYPE_SINGLE_HASH;
12768
12769 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12770 opti_type |= OPTI_TYPE_NOT_ITERATED;
12771
12772 if (attack_mode == ATTACK_MODE_BF)
12773 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12774
12775 data.opti_type = opti_type;
12776
12777 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12778 {
12779 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12780 {
12781 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12782 {
12783 if (opts_type & OPTS_TYPE_ST_ADD80)
12784 {
12785 opts_type &= ~OPTS_TYPE_ST_ADD80;
12786 opts_type |= OPTS_TYPE_PT_ADD80;
12787 }
12788
12789 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12790 {
12791 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12792 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12793 }
12794
12795 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12796 {
12797 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12798 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12799 }
12800 }
12801 }
12802 }
12803
12804 /**
12805 * Some algorithm, like descrypt, can benefit from JIT compilation
12806 */
12807
12808 int force_jit_compilation = -1;
12809
12810 if (hash_mode == 8900)
12811 {
12812 force_jit_compilation = 8900;
12813 }
12814 else if (hash_mode == 9300)
12815 {
12816 force_jit_compilation = 8900;
12817 }
12818 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12819 {
12820 force_jit_compilation = 1500;
12821 }
12822
12823 /**
12824 * generate bitmap tables
12825 */
12826
12827 const uint bitmap_shift1 = 5;
12828 const uint bitmap_shift2 = 13;
12829
12830 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12831
12832 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12833 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12834 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12835 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12836 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12837 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12838 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12839 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12840
12841 uint bitmap_bits;
12842 uint bitmap_nums;
12843 uint bitmap_mask;
12844 uint bitmap_size;
12845
12846 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12847 {
12848 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12849
12850 bitmap_nums = 1 << bitmap_bits;
12851
12852 bitmap_mask = bitmap_nums - 1;
12853
12854 bitmap_size = bitmap_nums * sizeof (uint);
12855
12856 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12857
12858 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12859 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12860
12861 break;
12862 }
12863
12864 bitmap_nums = 1 << bitmap_bits;
12865
12866 bitmap_mask = bitmap_nums - 1;
12867
12868 bitmap_size = bitmap_nums * sizeof (uint);
12869
12870 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
12871 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
12872
12873 /**
12874 * prepare quick rule
12875 */
12876
12877 data.rule_buf_l = rule_buf_l;
12878 data.rule_buf_r = rule_buf_r;
12879
12880 int rule_len_l = (int) strlen (rule_buf_l);
12881 int rule_len_r = (int) strlen (rule_buf_r);
12882
12883 data.rule_len_l = rule_len_l;
12884 data.rule_len_r = rule_len_r;
12885
12886 /**
12887 * load rules
12888 */
12889
12890 uint *all_kernel_rules_cnt = NULL;
12891
12892 kernel_rule_t **all_kernel_rules_buf = NULL;
12893
12894 if (rp_files_cnt)
12895 {
12896 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12897
12898 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12899 }
12900
12901 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12902
12903 int rule_len = 0;
12904
12905 for (uint i = 0; i < rp_files_cnt; i++)
12906 {
12907 uint kernel_rules_avail = 0;
12908
12909 uint kernel_rules_cnt = 0;
12910
12911 kernel_rule_t *kernel_rules_buf = NULL;
12912
12913 char *rp_file = rp_files[i];
12914
12915 char in[BLOCK_SIZE] = { 0 };
12916 char out[BLOCK_SIZE] = { 0 };
12917
12918 FILE *fp = NULL;
12919
12920 uint rule_line = 0;
12921
12922 if ((fp = fopen (rp_file, "rb")) == NULL)
12923 {
12924 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12925
12926 return (-1);
12927 }
12928
12929 while (!feof (fp))
12930 {
12931 memset (rule_buf, 0, HCBUFSIZ);
12932
12933 rule_len = fgetl (fp, rule_buf);
12934
12935 rule_line++;
12936
12937 if (rule_len == 0) continue;
12938
12939 if (rule_buf[0] == '#') continue;
12940
12941 if (kernel_rules_avail == kernel_rules_cnt)
12942 {
12943 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12944
12945 kernel_rules_avail += INCR_RULES;
12946 }
12947
12948 memset (in, 0, BLOCK_SIZE);
12949 memset (out, 0, BLOCK_SIZE);
12950
12951 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12952
12953 if (result == -1)
12954 {
12955 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12956
12957 continue;
12958 }
12959
12960 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12961 {
12962 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12963
12964 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12965
12966 continue;
12967 }
12968
12969 /* its so slow
12970 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12971 {
12972 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12973
12974 continue;
12975 }
12976 */
12977
12978 kernel_rules_cnt++;
12979 }
12980
12981 fclose (fp);
12982
12983 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12984
12985 all_kernel_rules_buf[i] = kernel_rules_buf;
12986 }
12987
12988 /**
12989 * merge rules or automatic rule generator
12990 */
12991
12992 uint kernel_rules_cnt = 0;
12993
12994 kernel_rule_t *kernel_rules_buf = NULL;
12995
12996 if (attack_mode == ATTACK_MODE_STRAIGHT)
12997 {
12998 if (rp_files_cnt)
12999 {
13000 kernel_rules_cnt = 1;
13001
13002 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13003
13004 repeats[0] = kernel_rules_cnt;
13005
13006 for (uint i = 0; i < rp_files_cnt; i++)
13007 {
13008 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13009
13010 repeats[i + 1] = kernel_rules_cnt;
13011 }
13012
13013 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13014
13015 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13016
13017 for (uint i = 0; i < kernel_rules_cnt; i++)
13018 {
13019 uint out_pos = 0;
13020
13021 kernel_rule_t *out = &kernel_rules_buf[i];
13022
13023 for (uint j = 0; j < rp_files_cnt; j++)
13024 {
13025 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13026 uint in_pos;
13027
13028 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13029
13030 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13031 {
13032 if (out_pos == RULES_MAX - 1)
13033 {
13034 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13035
13036 break;
13037 }
13038
13039 out->cmds[out_pos] = in->cmds[in_pos];
13040 }
13041 }
13042 }
13043
13044 local_free (repeats);
13045 }
13046 else if (rp_gen)
13047 {
13048 uint kernel_rules_avail = 0;
13049
13050 while (kernel_rules_cnt < rp_gen)
13051 {
13052 if (kernel_rules_avail == kernel_rules_cnt)
13053 {
13054 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13055
13056 kernel_rules_avail += INCR_RULES;
13057 }
13058
13059 memset (rule_buf, 0, HCBUFSIZ);
13060
13061 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13062
13063 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13064
13065 kernel_rules_cnt++;
13066 }
13067 }
13068 }
13069
13070 myfree (rule_buf);
13071
13072 /**
13073 * generate NOP rules
13074 */
13075
13076 if (kernel_rules_cnt == 0)
13077 {
13078 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13079
13080 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13081
13082 kernel_rules_cnt++;
13083 }
13084
13085 data.kernel_rules_cnt = kernel_rules_cnt;
13086 data.kernel_rules_buf = kernel_rules_buf;
13087
13088 /**
13089 * OpenCL platforms: detect
13090 */
13091
13092 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13093 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13094
13095 cl_uint platforms_cnt = 0;
13096 cl_uint platform_devices_cnt = 0;
13097
13098 if (keyspace == 0)
13099 {
13100 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13101
13102 if (platforms_cnt == 0)
13103 {
13104 log_info ("");
13105 log_info ("ATTENTION! No OpenCL compatible platform found");
13106 log_info ("");
13107 log_info ("You're probably missing the OpenCL runtime installation");
13108 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13109 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13110 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13111 log_info ("");
13112
13113 return (-1);
13114 }
13115
13116 if (opencl_platforms_filter != (uint) -1)
13117 {
13118 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13119
13120 if (opencl_platforms_filter > platform_cnt_mask)
13121 {
13122 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13123
13124 return (-1);
13125 }
13126 }
13127 }
13128
13129 /**
13130 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13131 */
13132
13133 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13134 {
13135 cl_platform_id platform = platforms[platform_id];
13136
13137 char platform_vendor[INFOSZ] = { 0 };
13138
13139 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13140
13141 #ifdef HAVE_HWMON
13142 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13143 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13144 {
13145 // make sure that we do not directly control the fan for NVidia
13146
13147 gpu_temp_retain = 0;
13148
13149 data.gpu_temp_retain = gpu_temp_retain;
13150 }
13151 #endif // HAVE_NVML || HAVE_NVAPI
13152 #endif
13153 }
13154
13155 /**
13156 * OpenCL device types:
13157 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13158 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13159 */
13160
13161 if (opencl_device_types == NULL)
13162 {
13163 cl_device_type device_types_all = 0;
13164
13165 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13166 {
13167 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13168
13169 cl_platform_id platform = platforms[platform_id];
13170
13171 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13172
13173 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13174 {
13175 cl_device_id device = platform_devices[platform_devices_id];
13176
13177 cl_device_type device_type;
13178
13179 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13180
13181 device_types_all |= device_type;
13182 }
13183 }
13184
13185 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13186 {
13187 device_types_filter |= CL_DEVICE_TYPE_CPU;
13188 }
13189 }
13190
13191 /**
13192 * OpenCL devices: simply push all devices from all platforms into the same device array
13193 */
13194
13195 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13196
13197 data.devices_param = devices_param;
13198
13199 uint devices_cnt = 0;
13200
13201 uint devices_active = 0;
13202
13203 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13204 {
13205 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13206
13207 cl_platform_id platform = platforms[platform_id];
13208
13209 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13210
13211 char platform_vendor[INFOSZ] = { 0 };
13212
13213 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13214
13215 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13216 // this causes trouble with vendor id based macros
13217 // we'll assign generic to those without special optimization available
13218
13219 cl_uint platform_vendor_id = 0;
13220
13221 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13222 {
13223 platform_vendor_id = VENDOR_ID_AMD;
13224 }
13225 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13226 {
13227 platform_vendor_id = VENDOR_ID_APPLE;
13228 }
13229 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13230 {
13231 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13232 }
13233 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13234 {
13235 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13236 }
13237 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13238 {
13239 platform_vendor_id = VENDOR_ID_MESA;
13240 }
13241 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13242 {
13243 platform_vendor_id = VENDOR_ID_NV;
13244 }
13245 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13246 {
13247 platform_vendor_id = VENDOR_ID_POCL;
13248 }
13249 else
13250 {
13251 platform_vendor_id = VENDOR_ID_GENERIC;
13252 }
13253
13254 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13255 {
13256 size_t param_value_size = 0;
13257
13258 const uint device_id = devices_cnt;
13259
13260 hc_device_param_t *device_param = &data.devices_param[device_id];
13261
13262 device_param->platform_vendor_id = platform_vendor_id;
13263
13264 device_param->device = platform_devices[platform_devices_id];
13265
13266 device_param->device_id = device_id;
13267
13268 device_param->platform_devices_id = platform_devices_id;
13269
13270 // device_type
13271
13272 cl_device_type device_type;
13273
13274 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13275
13276 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13277
13278 device_param->device_type = device_type;
13279
13280 // device_name
13281
13282 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13283
13284 char *device_name = (char *) mymalloc (param_value_size);
13285
13286 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13287
13288 device_param->device_name = device_name;
13289
13290 // device_vendor
13291
13292 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13293
13294 char *device_vendor = (char *) mymalloc (param_value_size);
13295
13296 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13297
13298 device_param->device_vendor = device_vendor;
13299
13300 // tuning db
13301
13302 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13303
13304 // device_version
13305
13306 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13307
13308 char *device_version = (char *) mymalloc (param_value_size);
13309
13310 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13311
13312 device_param->device_version = device_version;
13313
13314 // device_opencl_version
13315
13316 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13317
13318 char *device_opencl_version = (char *) mymalloc (param_value_size);
13319
13320 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13321
13322 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13323
13324 myfree (device_opencl_version);
13325
13326 // vector_width
13327
13328 cl_uint vector_width;
13329
13330 if (opencl_vector_width_chgd == 0)
13331 {
13332 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13333 {
13334 if (opti_type & OPTI_TYPE_USES_BITS_64)
13335 {
13336 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13337 }
13338 else
13339 {
13340 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13341 }
13342 }
13343 else
13344 {
13345 vector_width = (cl_uint) tuningdb_entry->vector_width;
13346 }
13347 }
13348 else
13349 {
13350 vector_width = opencl_vector_width;
13351 }
13352
13353 if (vector_width > 16) vector_width = 16;
13354
13355 device_param->vector_width = vector_width;
13356
13357 // max_compute_units
13358
13359 cl_uint device_processors;
13360
13361 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13362
13363 device_param->device_processors = device_processors;
13364
13365 // device_maxmem_alloc
13366 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13367
13368 cl_ulong device_maxmem_alloc;
13369
13370 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13371
13372 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13373
13374 // device_global_mem
13375
13376 cl_ulong device_global_mem;
13377
13378 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13379
13380 device_param->device_global_mem = device_global_mem;
13381
13382 // max_work_group_size
13383
13384 size_t device_maxworkgroup_size;
13385
13386 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13387
13388 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13389
13390 // max_clock_frequency
13391
13392 cl_uint device_maxclock_frequency;
13393
13394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13395
13396 device_param->device_maxclock_frequency = device_maxclock_frequency;
13397
13398 // device_endian_little
13399
13400 cl_bool device_endian_little;
13401
13402 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13403
13404 if (device_endian_little == CL_FALSE)
13405 {
13406 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13407
13408 device_param->skipped = 1;
13409 }
13410
13411 // device_available
13412
13413 cl_bool device_available;
13414
13415 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13416
13417 if (device_available == CL_FALSE)
13418 {
13419 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13420
13421 device_param->skipped = 1;
13422 }
13423
13424 // device_compiler_available
13425
13426 cl_bool device_compiler_available;
13427
13428 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13429
13430 if (device_compiler_available == CL_FALSE)
13431 {
13432 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13433
13434 device_param->skipped = 1;
13435 }
13436
13437 // device_execution_capabilities
13438
13439 cl_device_exec_capabilities device_execution_capabilities;
13440
13441 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13442
13443 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13444 {
13445 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13446
13447 device_param->skipped = 1;
13448 }
13449
13450 // device_extensions
13451
13452 size_t device_extensions_size;
13453
13454 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13455
13456 char *device_extensions = mymalloc (device_extensions_size + 1);
13457
13458 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13459
13460 if (strstr (device_extensions, "base_atomics") == 0)
13461 {
13462 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13463
13464 device_param->skipped = 1;
13465 }
13466
13467 if (strstr (device_extensions, "byte_addressable_store") == 0)
13468 {
13469 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13470
13471 device_param->skipped = 1;
13472 }
13473
13474 myfree (device_extensions);
13475
13476 // device_local_mem_size
13477
13478 cl_ulong device_local_mem_size;
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13481
13482 if (device_local_mem_size < 32768)
13483 {
13484 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13485
13486 device_param->skipped = 1;
13487 }
13488
13489 // if we have an Intel CPU and an not Intel OpenCL runtime that's a tricky situation
13490 // both platforms will support CPU device types and therefore both will use 50% of the physical resources
13491 // however, intel has better simd control over their own hardware so it makes sense
13492 // to give them full control over their own hardware
13493
13494 if (device_type & CL_DEVICE_TYPE_CPU)
13495 {
13496 if ((device_param->device_vendor_id == VENDOR_ID_INTEL_SDK) && (device_param->platform_vendor_id != VENDOR_ID_INTEL_SDK))
13497 {
13498 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13499
13500 device_param->skipped = 1;
13501 }
13502 }
13503
13504 // skipped
13505
13506 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13507 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13508
13509 // driver_version
13510
13511 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13512
13513 char *driver_version = (char *) mymalloc (param_value_size);
13514
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13516
13517 device_param->driver_version = driver_version;
13518
13519 // device_name_chksum
13520
13521 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13522
13523 #if __x86_64__
13524 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13525 #else
13526 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13527 #endif
13528
13529 uint device_name_digest[4] = { 0 };
13530
13531 md5_64 ((uint *) device_name_chksum, device_name_digest);
13532
13533 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13534
13535 device_param->device_name_chksum = device_name_chksum;
13536
13537 // device_processor_cores
13538
13539 if (device_type & CL_DEVICE_TYPE_CPU)
13540 {
13541 cl_uint device_processor_cores = 1;
13542
13543 device_param->device_processor_cores = device_processor_cores;
13544 }
13545
13546 if (device_type & CL_DEVICE_TYPE_GPU)
13547 {
13548 if (platform_vendor_id == VENDOR_ID_AMD)
13549 {
13550 cl_uint device_processor_cores = 0;
13551
13552 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13553
13554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13555
13556 device_param->device_processor_cores = device_processor_cores;
13557 }
13558 else if (platform_vendor_id == VENDOR_ID_NV)
13559 {
13560 cl_uint kernel_exec_timeout = 0;
13561
13562 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13563
13564 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13565
13566 device_param->kernel_exec_timeout = kernel_exec_timeout;
13567
13568 cl_uint device_processor_cores = 0;
13569
13570 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13571
13572 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13573
13574 device_param->device_processor_cores = device_processor_cores;
13575
13576 cl_uint sm_minor = 0;
13577 cl_uint sm_major = 0;
13578
13579 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13580 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13581
13582 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13584
13585 device_param->sm_minor = sm_minor;
13586 device_param->sm_major = sm_major;
13587 }
13588 else
13589 {
13590 cl_uint device_processor_cores = 1;
13591
13592 device_param->device_processor_cores = device_processor_cores;
13593 }
13594 }
13595
13596 // display results
13597
13598 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13599 {
13600 if (status_automat == 0)
13601 {
13602 if (device_param->skipped == 0)
13603 {
13604 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13605 device_id + 1,
13606 device_name,
13607 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13608 (unsigned int) (device_global_mem / 1024 / 1024),
13609 (unsigned int) (device_maxclock_frequency),
13610 (unsigned int) device_processors);
13611 }
13612 else
13613 {
13614 log_info ("Device #%u: %s, skipped",
13615 device_id + 1,
13616 device_name);
13617 }
13618 }
13619 }
13620
13621 // common driver check
13622
13623 if (device_param->skipped == 0)
13624 {
13625 if (device_type & CL_DEVICE_TYPE_GPU)
13626 {
13627 if (platform_vendor_id == VENDOR_ID_AMD)
13628 {
13629 int catalyst_check = (force == 1) ? 0 : 1;
13630
13631 int catalyst_warn = 0;
13632
13633 int catalyst_broken = 0;
13634
13635 if (catalyst_check == 1)
13636 {
13637 catalyst_warn = 1;
13638
13639 // v14.9 and higher
13640 if (atoi (device_param->driver_version) >= 1573)
13641 {
13642 catalyst_warn = 0;
13643 }
13644
13645 catalyst_check = 0;
13646 }
13647
13648 if (catalyst_broken == 1)
13649 {
13650 log_info ("");
13651 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13652 log_info ("It will pass over cracked hashes and does not report them as cracked");
13653 log_info ("You are STRONGLY encouraged not to use it");
13654 log_info ("You can use --force to override this but do not post error reports if you do so");
13655 log_info ("");
13656
13657 return (-1);
13658 }
13659
13660 if (catalyst_warn == 1)
13661 {
13662 log_info ("");
13663 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13664 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13665 log_info ("See hashcat's homepage for official supported catalyst drivers");
13666 #ifdef _WIN
13667 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13668 #endif
13669 log_info ("You can use --force to override this but do not post error reports if you do so");
13670 log_info ("");
13671
13672 return (-1);
13673 }
13674 }
13675 else if (platform_vendor_id == VENDOR_ID_NV)
13676 {
13677 if (device_param->kernel_exec_timeout != 0)
13678 {
13679 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);
13680 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13681 }
13682 }
13683 }
13684
13685 /* turns out pocl still creates segfaults (because of llvm)
13686 if (device_type & CL_DEVICE_TYPE_CPU)
13687 {
13688 if (platform_vendor_id == VENDOR_ID_AMD)
13689 {
13690 if (force == 0)
13691 {
13692 log_info ("");
13693 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13694 log_info ("You are STRONGLY encouraged not to use it");
13695 log_info ("You can use --force to override this but do not post error reports if you do so");
13696 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13697 log_info ("");
13698
13699 return (-1);
13700 }
13701 }
13702 }
13703 */
13704
13705 /**
13706 * kernel accel and loops tuning db adjustment
13707 */
13708
13709 device_param->kernel_accel_min = 1;
13710 device_param->kernel_accel_max = 1024;
13711
13712 device_param->kernel_loops_min = 1;
13713 device_param->kernel_loops_max = 1024;
13714
13715 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13716
13717 if (tuningdb_entry)
13718 {
13719 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13720 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13721
13722 if (_kernel_accel)
13723 {
13724 device_param->kernel_accel_min = _kernel_accel;
13725 device_param->kernel_accel_max = _kernel_accel;
13726 }
13727
13728 if (_kernel_loops)
13729 {
13730 if (workload_profile == 1)
13731 {
13732 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13733 }
13734 else if (workload_profile == 2)
13735 {
13736 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13737 }
13738
13739 device_param->kernel_loops_min = _kernel_loops;
13740 device_param->kernel_loops_max = _kernel_loops;
13741 }
13742 }
13743
13744 // commandline parameters overwrite tuningdb entries
13745
13746 if (kernel_accel)
13747 {
13748 device_param->kernel_accel_min = kernel_accel;
13749 device_param->kernel_accel_max = kernel_accel;
13750 }
13751
13752 if (kernel_loops)
13753 {
13754 device_param->kernel_loops_min = kernel_loops;
13755 device_param->kernel_loops_max = kernel_loops;
13756 }
13757
13758 /**
13759 * activate device
13760 */
13761
13762 devices_active++;
13763 }
13764
13765 // next please
13766
13767 devices_cnt++;
13768 }
13769 }
13770
13771 if (keyspace == 0 && devices_active == 0)
13772 {
13773 log_error ("ERROR: No devices found/left");
13774
13775 return (-1);
13776 }
13777
13778 // 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)
13779
13780 if (devices_filter != (uint) -1)
13781 {
13782 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13783
13784 if (devices_filter > devices_cnt_mask)
13785 {
13786 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13787
13788 return (-1);
13789 }
13790 }
13791
13792 data.devices_cnt = devices_cnt;
13793
13794 data.devices_active = devices_active;
13795
13796 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13797 {
13798 if (status_automat == 0)
13799 {
13800 log_info ("");
13801 }
13802 }
13803
13804 /**
13805 * HM devices: init
13806 */
13807
13808 #ifdef HAVE_HWMON
13809 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13810 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13811 #endif
13812
13813 #ifdef HAVE_ADL
13814 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13815 #endif
13816
13817 if (gpu_temp_disable == 0)
13818 {
13819 #if defined(WIN) && defined(HAVE_NVAPI)
13820 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13821
13822 if (nvapi_init (nvapi) == 0)
13823 data.hm_nv = nvapi;
13824
13825 if (data.hm_nv)
13826 {
13827 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13828 {
13829 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13830
13831 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13832
13833 int tmp_out = 0;
13834
13835 for (int i = 0; i < tmp_in; i++)
13836 {
13837 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13838 }
13839
13840 for (int i = 0; i < tmp_out; i++)
13841 {
13842 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13843
13844 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13845
13846 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;
13847 }
13848 }
13849 }
13850 #endif // WIN && HAVE_NVAPI
13851
13852 #if defined(LINUX) && defined(HAVE_NVML)
13853 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13854
13855 if (nvml_init (nvml) == 0)
13856 data.hm_nv = nvml;
13857
13858 if (data.hm_nv)
13859 {
13860 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13861 {
13862 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13863
13864 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13865
13866 int tmp_out = 0;
13867
13868 for (int i = 0; i < tmp_in; i++)
13869 {
13870 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13871 }
13872
13873 for (int i = 0; i < tmp_out; i++)
13874 {
13875 unsigned int speed;
13876
13877 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;
13878 }
13879 }
13880 }
13881 #endif // LINUX && HAVE_NVML
13882
13883 data.hm_amd = NULL;
13884
13885 #ifdef HAVE_ADL
13886 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13887
13888 if (adl_init (adl) == 0)
13889 data.hm_amd = adl;
13890
13891 if (data.hm_amd)
13892 {
13893 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13894 {
13895 // total number of adapters
13896
13897 int hm_adapters_num;
13898
13899 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13900
13901 // adapter info
13902
13903 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13904
13905 if (lpAdapterInfo == NULL) return (-1);
13906
13907 // get a list (of ids of) valid/usable adapters
13908
13909 int num_adl_adapters = 0;
13910
13911 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13912
13913 if (num_adl_adapters > 0)
13914 {
13915 hc_thread_mutex_lock (mux_adl);
13916
13917 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13918
13919 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13920
13921 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13922 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13923
13924 hc_thread_mutex_unlock (mux_adl);
13925 }
13926
13927 myfree (valid_adl_device_list);
13928 myfree (lpAdapterInfo);
13929 }
13930 }
13931 #endif // HAVE_ADL
13932
13933 if (data.hm_amd == NULL && data.hm_nv == NULL)
13934 {
13935 gpu_temp_disable = 1;
13936 }
13937 }
13938
13939 /**
13940 * OpenCL devices: allocate buffer for device specific information
13941 */
13942
13943 #ifdef HAVE_HWMON
13944 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13945
13946 #ifdef HAVE_ADL
13947 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13948
13949 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13950 #endif // ADL
13951 #endif
13952
13953 /**
13954 * enable custom signal handler(s)
13955 */
13956
13957 if (benchmark == 0)
13958 {
13959 hc_signal (sigHandler_default);
13960 }
13961 else
13962 {
13963 hc_signal (sigHandler_benchmark);
13964 }
13965
13966 /**
13967 * User-defined GPU temp handling
13968 */
13969
13970 #ifdef HAVE_HWMON
13971 if (gpu_temp_disable == 1)
13972 {
13973 gpu_temp_abort = 0;
13974 gpu_temp_retain = 0;
13975 }
13976
13977 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13978 {
13979 if (gpu_temp_abort < gpu_temp_retain)
13980 {
13981 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13982
13983 return (-1);
13984 }
13985 }
13986
13987 data.gpu_temp_disable = gpu_temp_disable;
13988 data.gpu_temp_abort = gpu_temp_abort;
13989 data.gpu_temp_retain = gpu_temp_retain;
13990 #endif
13991
13992 /**
13993 * inform the user
13994 */
13995
13996 if (data.quiet == 0)
13997 {
13998 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13999
14000 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);
14001
14002 if (attack_mode == ATTACK_MODE_STRAIGHT)
14003 {
14004 log_info ("Rules: %u", kernel_rules_cnt);
14005 }
14006
14007 if (opti_type)
14008 {
14009 log_info ("Applicable Optimizers:");
14010
14011 for (uint i = 0; i < 32; i++)
14012 {
14013 const uint opti_bit = 1u << i;
14014
14015 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14016 }
14017 }
14018
14019 /**
14020 * Watchdog and Temperature balance
14021 */
14022
14023 #ifdef HAVE_HWMON
14024 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14025 {
14026 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14027 }
14028
14029 if (gpu_temp_abort == 0)
14030 {
14031 log_info ("Watchdog: Temperature abort trigger disabled");
14032 }
14033 else
14034 {
14035 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14036 }
14037
14038 if (gpu_temp_retain == 0)
14039 {
14040 log_info ("Watchdog: Temperature retain trigger disabled");
14041 }
14042 else
14043 {
14044 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14045 }
14046
14047 if (data.quiet == 0) log_info ("");
14048 #endif
14049 }
14050
14051 /**
14052 * HM devices: copy
14053 */
14054
14055 if (gpu_temp_disable == 0)
14056 {
14057 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14058 {
14059 hc_device_param_t *device_param = &data.devices_param[device_id];
14060
14061 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14062
14063 if (device_param->skipped) continue;
14064
14065 const uint platform_devices_id = device_param->platform_devices_id;
14066
14067 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14068 if (device_param->platform_vendor_id == VENDOR_ID_NV)
14069 {
14070 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14071 }
14072 #endif
14073
14074 #ifdef HAVE_ADL
14075 if (device_param->platform_vendor_id == VENDOR_ID_AMD)
14076 {
14077 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14078 }
14079 #endif
14080 }
14081 }
14082
14083 /*
14084 * Temporary fix:
14085 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14086 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14087 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14088 * Driver / ADL bug?
14089 */
14090
14091 #ifdef HAVE_ADL
14092 if (powertune_enable == 1)
14093 {
14094 hc_thread_mutex_lock (mux_adl);
14095
14096 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14097 {
14098 hc_device_param_t *device_param = &data.devices_param[device_id];
14099
14100 if (device_param->skipped) continue;
14101
14102 if (data.hm_device[device_id].od_version == 6)
14103 {
14104 // set powertune value only
14105
14106 int powertune_supported = 0;
14107
14108 int ADL_rc = 0;
14109
14110 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14111 {
14112 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14113
14114 return (-1);
14115 }
14116
14117 if (powertune_supported != 0)
14118 {
14119 // powertune set
14120 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14121
14122 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14123 {
14124 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14125
14126 return (-1);
14127 }
14128
14129 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14130 {
14131 log_error ("ERROR: Failed to set new ADL PowerControl values");
14132
14133 return (-1);
14134 }
14135 }
14136 }
14137 }
14138
14139 hc_thread_mutex_unlock (mux_adl);
14140 }
14141 #endif // HAVE_ADK
14142 #endif // HAVE_HWMON
14143
14144 #ifdef DEBUG
14145 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14146 #endif
14147
14148 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14149
14150 uint kernel_power_all = 0;
14151
14152 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14153 {
14154 /**
14155 * host buffer
14156 */
14157
14158 hc_device_param_t *device_param = &data.devices_param[device_id];
14159
14160 if (device_param->skipped) continue;
14161
14162 /**
14163 * device properties
14164 */
14165
14166 const char *device_name_chksum = device_param->device_name_chksum;
14167 const u32 device_processors = device_param->device_processors;
14168 const u32 device_processor_cores = device_param->device_processor_cores;
14169
14170 /**
14171 * create context for each device
14172 */
14173
14174 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14175
14176 /**
14177 * create command-queue
14178 */
14179
14180 // not supported with NV
14181 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14182
14183 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14184
14185 /**
14186 * kernel threads: some algorithms need a fixed kernel-threads count
14187 * because of shared memory usage or bitslice
14188 * there needs to be some upper limit, otherwise there's too much overhead
14189 */
14190
14191 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14192
14193 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14194 {
14195 kernel_threads = KERNEL_THREADS_MAX_CPU;
14196 }
14197
14198 if (hash_mode == 1500) kernel_threads = 64; // DES
14199 if (hash_mode == 3000) kernel_threads = 64; // DES
14200 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14201 if (hash_mode == 7500) kernel_threads = 64; // RC4
14202 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14203 if (hash_mode == 9700) kernel_threads = 64; // RC4
14204 if (hash_mode == 9710) kernel_threads = 64; // RC4
14205 if (hash_mode == 9800) kernel_threads = 64; // RC4
14206 if (hash_mode == 9810) kernel_threads = 64; // RC4
14207 if (hash_mode == 10400) kernel_threads = 64; // RC4
14208 if (hash_mode == 10410) kernel_threads = 64; // RC4
14209 if (hash_mode == 10500) kernel_threads = 64; // RC4
14210 if (hash_mode == 13100) kernel_threads = 64; // RC4
14211
14212 /**
14213 * create input buffers on device : calculate size of fixed memory buffers
14214 */
14215
14216 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14217 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14218
14219 device_param->size_root_css = size_root_css;
14220 device_param->size_markov_css = size_markov_css;
14221
14222 size_t size_results = sizeof (uint);
14223
14224 device_param->size_results = size_results;
14225
14226 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14227 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14228
14229 size_t size_plains = digests_cnt * sizeof (plain_t);
14230 size_t size_salts = salts_cnt * sizeof (salt_t);
14231 size_t size_esalts = salts_cnt * esalt_size;
14232
14233 device_param->size_plains = size_plains;
14234 device_param->size_digests = size_digests;
14235 device_param->size_shown = size_shown;
14236 device_param->size_salts = size_salts;
14237
14238 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14239 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14240 size_t size_tm = 32 * sizeof (bs_word_t);
14241
14242 // scryptV stuff
14243
14244 size_t size_scryptV = 1;
14245
14246 if ((hash_mode == 8900) || (hash_mode == 9300))
14247 {
14248 uint tmto_start = 0;
14249 uint tmto_stop = 10;
14250
14251 if (scrypt_tmto)
14252 {
14253 tmto_start = scrypt_tmto;
14254 }
14255 else
14256 {
14257 // in case the user did not specify the tmto manually
14258 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14259 // but set the lower end only in case the user has a device with too less memory
14260
14261 if (hash_mode == 8900)
14262 {
14263 if (device_param->platform_vendor_id == VENDOR_ID_AMD)
14264 {
14265 tmto_start = 1;
14266 }
14267 else if (device_param->platform_vendor_id == VENDOR_ID_NV)
14268 {
14269 tmto_start = 2;
14270 }
14271 }
14272 else if (hash_mode == 9300)
14273 {
14274 if (device_param->platform_vendor_id == VENDOR_ID_AMD)
14275 {
14276 tmto_start = 2;
14277 }
14278 else if (device_param->platform_vendor_id == VENDOR_ID_NV)
14279 {
14280 tmto_start = 2;
14281 }
14282 }
14283 }
14284
14285 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14286 {
14287 // TODO: in theory the following calculation needs to be done per salt, not global
14288 // we assume all hashes have the same scrypt settings
14289
14290 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14291
14292 size_scryptV /= 1 << tmto;
14293
14294 size_scryptV *= device_processors * device_processor_cores;
14295
14296 if (size_scryptV > device_param->device_maxmem_alloc)
14297 {
14298 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14299
14300 continue;
14301 }
14302
14303 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14304 {
14305 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14306 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14307 }
14308
14309 break;
14310 }
14311
14312 if (data.salts_buf[0].scrypt_phy == 0)
14313 {
14314 log_error ("ERROR: can't allocate enough device memory");
14315
14316 return -1;
14317 }
14318
14319 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14320 }
14321
14322 /**
14323 * some algorithms need a fixed kernel-loops count
14324 */
14325
14326 if (hash_mode == 1500)
14327 {
14328 const u32 kernel_loops_fixed = 1024;
14329
14330 device_param->kernel_loops_min = kernel_loops_fixed;
14331 device_param->kernel_loops_max = kernel_loops_fixed;
14332 }
14333
14334 if (hash_mode == 3000)
14335 {
14336 const u32 kernel_loops_fixed = 1024;
14337
14338 device_param->kernel_loops_min = kernel_loops_fixed;
14339 device_param->kernel_loops_max = kernel_loops_fixed;
14340 }
14341
14342 if (hash_mode == 8900)
14343 {
14344 const u32 kernel_loops_fixed = 1;
14345
14346 device_param->kernel_loops_min = kernel_loops_fixed;
14347 device_param->kernel_loops_max = kernel_loops_fixed;
14348 }
14349
14350 if (hash_mode == 9300)
14351 {
14352 const u32 kernel_loops_fixed = 1;
14353
14354 device_param->kernel_loops_min = kernel_loops_fixed;
14355 device_param->kernel_loops_max = kernel_loops_fixed;
14356 }
14357
14358 if (hash_mode == 12500)
14359 {
14360 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14361
14362 device_param->kernel_loops_min = kernel_loops_fixed;
14363 device_param->kernel_loops_max = kernel_loops_fixed;
14364 }
14365
14366 /**
14367 * some algorithms have a maximum kernel-loops count
14368 */
14369
14370 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14371 {
14372 u32 innerloop_cnt = 0;
14373
14374 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14375 {
14376 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14377 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14378 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14379 }
14380 else
14381 {
14382 innerloop_cnt = data.salts_buf[0].salt_iter;
14383 }
14384
14385 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14386 (innerloop_cnt <= device_param->kernel_loops_max))
14387 {
14388 device_param->kernel_loops_max = innerloop_cnt;
14389 }
14390 }
14391
14392 u32 kernel_accel_min = device_param->kernel_accel_min;
14393 u32 kernel_accel_max = device_param->kernel_accel_max;
14394
14395 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14396
14397 size_t size_pws = 4;
14398 size_t size_tmps = 4;
14399 size_t size_hooks = 4;
14400
14401 while (kernel_accel_max >= kernel_accel_min)
14402 {
14403 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14404
14405 // size_pws
14406
14407 size_pws = kernel_power_max * sizeof (pw_t);
14408
14409 // size_tmps
14410
14411 switch (hash_mode)
14412 {
14413 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14414 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14415 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14416 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14417 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14418 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14419 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14420 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14421 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14422 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14423 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14424 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14425 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14426 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14427 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14428 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14429 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14430 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14431 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14432 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14433 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14434 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14435 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14436 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14437 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14438 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14439 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14440 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14441 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14442 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14443 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14444 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14445 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14446 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14447 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14448 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14449 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14450 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14451 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14452 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14453 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14454 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14455 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14456 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14457 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14458 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14459 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14460 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14461 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14462 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14463 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14464 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14465 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14466 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14467 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14468 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14469 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14470 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14471 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14472 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14473 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14474 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14475 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14476 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14477 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14478 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14479 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14480 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14481 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14482 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14483 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14484 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14485 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14486 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14487 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14488 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14489 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14490 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14491 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14492 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14493 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14494 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14495 };
14496
14497 // size_hooks
14498
14499 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14500 {
14501 // none yet
14502 }
14503
14504 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14505 // if not, decrease amplifier and try again
14506
14507 int skip = 0;
14508
14509 const u64 size_total
14510 = bitmap_size
14511 + bitmap_size
14512 + bitmap_size
14513 + bitmap_size
14514 + bitmap_size
14515 + bitmap_size
14516 + bitmap_size
14517 + bitmap_size
14518 + size_bfs
14519 + size_combs
14520 + size_digests
14521 + size_esalts
14522 + size_hooks
14523 + size_markov_css
14524 + size_plains
14525 + size_pws
14526 + size_pws // not a bug
14527 + size_results
14528 + size_root_css
14529 + size_rules
14530 + size_rules_c
14531 + size_salts
14532 + size_scryptV
14533 + size_shown
14534 + size_tm
14535 + size_tmps;
14536
14537 // Don't ask me, ask AMD!
14538
14539 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14540 if (size_total > device_param->device_global_mem) skip = 1;
14541
14542 if (skip == 1)
14543 {
14544 kernel_accel_max--;
14545
14546 continue;
14547 }
14548
14549 break;
14550 }
14551
14552 /*
14553 if (kernel_accel_max == 0)
14554 {
14555 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14556
14557 return -1;
14558 }
14559 */
14560
14561 device_param->kernel_accel_min = kernel_accel_min;
14562 device_param->kernel_accel_max = kernel_accel_max;
14563
14564 /*
14565 if (kernel_accel_max < kernel_accel)
14566 {
14567 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14568
14569 device_param->kernel_accel = kernel_accel_max;
14570 }
14571 */
14572
14573 device_param->size_bfs = size_bfs;
14574 device_param->size_combs = size_combs;
14575 device_param->size_rules = size_rules;
14576 device_param->size_rules_c = size_rules_c;
14577 device_param->size_pws = size_pws;
14578 device_param->size_tmps = size_tmps;
14579 device_param->size_hooks = size_hooks;
14580
14581 // do not confuse kernel_accel_max with kernel_accel here
14582
14583 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14584
14585 device_param->kernel_threads = kernel_threads;
14586 device_param->kernel_power_user = kernel_power;
14587
14588 kernel_power_all += kernel_power;
14589
14590 /**
14591 * default building options
14592 */
14593
14594 char build_opts[1024] = { 0 };
14595
14596 // we don't have sm_* on vendors not NV but it doesn't matter
14597
14598 #if _WIN
14599 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);
14600 #else
14601 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);
14602 #endif
14603
14604 char build_opts_new[1024] = { 0 };
14605
14606 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->platform_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14607
14608 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14609
14610
14611 if (device_param->platform_vendor_id == VENDOR_ID_INTEL_SDK)
14612 {
14613 // we do vectorizing much better than the auto-vectorizer
14614
14615 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14616
14617 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14618 }
14619
14620 #ifdef DEBUG
14621 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14622 #endif
14623
14624 /**
14625 * main kernel
14626 */
14627
14628 {
14629 /**
14630 * kernel source filename
14631 */
14632
14633 char source_file[256] = { 0 };
14634
14635 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14636
14637 struct stat sst;
14638
14639 if (stat (source_file, &sst) == -1)
14640 {
14641 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14642
14643 return -1;
14644 }
14645
14646 /**
14647 * kernel cached filename
14648 */
14649
14650 char cached_file[256] = { 0 };
14651
14652 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14653
14654 int cached = 1;
14655
14656 struct stat cst;
14657
14658 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14659 {
14660 cached = 0;
14661 }
14662
14663 /**
14664 * kernel compile or load
14665 */
14666
14667 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14668
14669 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14670
14671 if (force_jit_compilation == -1)
14672 {
14673 if (cached == 0)
14674 {
14675 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14676
14677 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14678
14679 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14680
14681 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14682
14683 #ifdef DEBUG
14684 size_t build_log_size = 0;
14685
14686 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14687
14688 if (build_log_size > 1)
14689 {
14690 char *build_log = (char *) malloc (build_log_size + 1);
14691
14692 memset (build_log, 0, build_log_size + 1);
14693
14694 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14695
14696 puts (build_log);
14697
14698 free (build_log);
14699 }
14700 #endif
14701
14702 if (rc != 0)
14703 {
14704 device_param->skipped = true;
14705
14706 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14707
14708 continue;
14709 }
14710
14711 size_t binary_size;
14712
14713 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14714
14715 u8 *binary = (u8 *) mymalloc (binary_size);
14716
14717 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14718
14719 writeProgramBin (cached_file, binary, binary_size);
14720
14721 local_free (binary);
14722 }
14723 else
14724 {
14725 #ifdef DEBUG
14726 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14727 #endif
14728
14729 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14730
14731 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14732
14733 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14734 }
14735 }
14736 else
14737 {
14738 #ifdef DEBUG
14739 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14740 #endif
14741
14742 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14743
14744 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14745
14746 char build_opts_update[1024] = { 0 };
14747
14748 if (force_jit_compilation == 1500)
14749 {
14750 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14751 }
14752 else if (force_jit_compilation == 8900)
14753 {
14754 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);
14755 }
14756 else
14757 {
14758 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14759 }
14760
14761 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14762
14763 #ifdef DEBUG
14764 size_t build_log_size = 0;
14765
14766 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14767
14768 if (build_log_size > 1)
14769 {
14770 char *build_log = (char *) malloc (build_log_size + 1);
14771
14772 memset (build_log, 0, build_log_size + 1);
14773
14774 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14775
14776 puts (build_log);
14777
14778 free (build_log);
14779 }
14780 #endif
14781
14782 if (rc != 0)
14783 {
14784 device_param->skipped = true;
14785
14786 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14787 }
14788 }
14789
14790 local_free (kernel_lengths);
14791 local_free (kernel_sources[0]);
14792 local_free (kernel_sources);
14793 }
14794
14795 /**
14796 * word generator kernel
14797 */
14798
14799 if (attack_mode != ATTACK_MODE_STRAIGHT)
14800 {
14801 /**
14802 * kernel mp source filename
14803 */
14804
14805 char source_file[256] = { 0 };
14806
14807 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14808
14809 struct stat sst;
14810
14811 if (stat (source_file, &sst) == -1)
14812 {
14813 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14814
14815 return -1;
14816 }
14817
14818 /**
14819 * kernel mp cached filename
14820 */
14821
14822 char cached_file[256] = { 0 };
14823
14824 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14825
14826 int cached = 1;
14827
14828 struct stat cst;
14829
14830 if (stat (cached_file, &cst) == -1)
14831 {
14832 cached = 0;
14833 }
14834
14835 /**
14836 * kernel compile or load
14837 */
14838
14839 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14840
14841 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14842
14843 if (cached == 0)
14844 {
14845 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14846 if (quiet == 0) log_info ("");
14847
14848 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14849
14850 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14851
14852 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14853
14854 if (rc != 0)
14855 {
14856 device_param->skipped = true;
14857
14858 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14859
14860 continue;
14861 }
14862
14863 size_t binary_size;
14864
14865 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14866
14867 u8 *binary = (u8 *) mymalloc (binary_size);
14868
14869 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14870
14871 writeProgramBin (cached_file, binary, binary_size);
14872
14873 local_free (binary);
14874 }
14875 else
14876 {
14877 #ifdef DEBUG
14878 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14879 #endif
14880
14881 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14882
14883 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14884
14885 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14886 }
14887
14888 local_free (kernel_lengths);
14889 local_free (kernel_sources[0]);
14890 local_free (kernel_sources);
14891 }
14892
14893 /**
14894 * amplifier kernel
14895 */
14896
14897 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14898 {
14899
14900 }
14901 else
14902 {
14903 /**
14904 * kernel amp source filename
14905 */
14906
14907 char source_file[256] = { 0 };
14908
14909 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14910
14911 struct stat sst;
14912
14913 if (stat (source_file, &sst) == -1)
14914 {
14915 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14916
14917 return -1;
14918 }
14919
14920 /**
14921 * kernel amp cached filename
14922 */
14923
14924 char cached_file[256] = { 0 };
14925
14926 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14927
14928 int cached = 1;
14929
14930 struct stat cst;
14931
14932 if (stat (cached_file, &cst) == -1)
14933 {
14934 cached = 0;
14935 }
14936
14937 /**
14938 * kernel compile or load
14939 */
14940
14941 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14942
14943 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14944
14945 if (cached == 0)
14946 {
14947 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14948 if (quiet == 0) log_info ("");
14949
14950 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14951
14952 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14953
14954 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14955
14956 if (rc != 0)
14957 {
14958 device_param->skipped = true;
14959
14960 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14961
14962 continue;
14963 }
14964
14965 size_t binary_size;
14966
14967 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14968
14969 u8 *binary = (u8 *) mymalloc (binary_size);
14970
14971 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14972
14973 writeProgramBin (cached_file, binary, binary_size);
14974
14975 local_free (binary);
14976 }
14977 else
14978 {
14979 #ifdef DEBUG
14980 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14981 #endif
14982
14983 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14984
14985 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14986
14987 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14988 }
14989
14990 local_free (kernel_lengths);
14991 local_free (kernel_sources[0]);
14992 local_free (kernel_sources);
14993 }
14994
14995 // some algorithm collide too fast, make that impossible
14996
14997 if (benchmark == 1)
14998 {
14999 ((uint *) digests_buf)[0] = -1;
15000 ((uint *) digests_buf)[1] = -1;
15001 ((uint *) digests_buf)[2] = -1;
15002 ((uint *) digests_buf)[3] = -1;
15003 }
15004
15005 /**
15006 * global buffers
15007 */
15008
15009 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15010 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15011 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15012 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15013 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15014 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15015 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15016 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15017 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15018 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15019 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15020 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15021 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15022 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15023 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15024 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15025 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15026 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15027
15028 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);
15029 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);
15030 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);
15031 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);
15032 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);
15033 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);
15034 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);
15035 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);
15036 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15037 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15038 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15039
15040 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15041 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15042 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15043 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15044 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15045 run_kernel_bzero (device_param, device_param->d_result, size_results);
15046
15047 /**
15048 * special buffers
15049 */
15050
15051 if (attack_kern == ATTACK_KERN_STRAIGHT)
15052 {
15053 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15054 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15055
15056 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15057
15058 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15059 }
15060 else if (attack_kern == ATTACK_KERN_COMBI)
15061 {
15062 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15063 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15064 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15065 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15066
15067 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15068 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15069 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15070 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15071 }
15072 else if (attack_kern == ATTACK_KERN_BF)
15073 {
15074 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15075 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15076 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15077 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15078 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15079
15080 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15081 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15082 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15083 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15084 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15085 }
15086
15087 if (size_esalts)
15088 {
15089 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15090
15091 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15092 }
15093
15094 /**
15095 * main host data
15096 */
15097
15098 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15099
15100 device_param->pws_buf = pws_buf;
15101
15102 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15103
15104 device_param->combs_buf = combs_buf;
15105
15106 void *hooks_buf = mymalloc (size_hooks);
15107
15108 device_param->hooks_buf = hooks_buf;
15109
15110 /**
15111 * kernel args
15112 */
15113
15114 device_param->kernel_params_buf32[21] = bitmap_mask;
15115 device_param->kernel_params_buf32[22] = bitmap_shift1;
15116 device_param->kernel_params_buf32[23] = bitmap_shift2;
15117 device_param->kernel_params_buf32[24] = 0; // salt_pos
15118 device_param->kernel_params_buf32[25] = 0; // loop_pos
15119 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15120 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15121 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15122 device_param->kernel_params_buf32[29] = 0; // digests_offset
15123 device_param->kernel_params_buf32[30] = 0; // combs_mode
15124 device_param->kernel_params_buf32[31] = 0; // gid_max
15125
15126 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15127 ? &device_param->d_pws_buf
15128 : &device_param->d_pws_amp_buf;
15129 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15130 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15131 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15132 device_param->kernel_params[ 4] = &device_param->d_tmps;
15133 device_param->kernel_params[ 5] = &device_param->d_hooks;
15134 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15135 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15136 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15137 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15138 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15139 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15140 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15141 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15142 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15143 device_param->kernel_params[15] = &device_param->d_digests_buf;
15144 device_param->kernel_params[16] = &device_param->d_digests_shown;
15145 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15146 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15147 device_param->kernel_params[19] = &device_param->d_result;
15148 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15149 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15150 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15151 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15152 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15153 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15154 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15155 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15156 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15157 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15158 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15159 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15160
15161 device_param->kernel_params_mp_buf64[3] = 0;
15162 device_param->kernel_params_mp_buf32[4] = 0;
15163 device_param->kernel_params_mp_buf32[5] = 0;
15164 device_param->kernel_params_mp_buf32[6] = 0;
15165 device_param->kernel_params_mp_buf32[7] = 0;
15166 device_param->kernel_params_mp_buf32[8] = 0;
15167
15168 device_param->kernel_params_mp[0] = NULL;
15169 device_param->kernel_params_mp[1] = NULL;
15170 device_param->kernel_params_mp[2] = NULL;
15171 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15172 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15173 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15174 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15175 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15176 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15177
15178 device_param->kernel_params_mp_l_buf64[3] = 0;
15179 device_param->kernel_params_mp_l_buf32[4] = 0;
15180 device_param->kernel_params_mp_l_buf32[5] = 0;
15181 device_param->kernel_params_mp_l_buf32[6] = 0;
15182 device_param->kernel_params_mp_l_buf32[7] = 0;
15183 device_param->kernel_params_mp_l_buf32[8] = 0;
15184 device_param->kernel_params_mp_l_buf32[9] = 0;
15185
15186 device_param->kernel_params_mp_l[0] = NULL;
15187 device_param->kernel_params_mp_l[1] = NULL;
15188 device_param->kernel_params_mp_l[2] = NULL;
15189 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15190 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15191 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15192 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15193 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15194 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15195 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15196
15197 device_param->kernel_params_mp_r_buf64[3] = 0;
15198 device_param->kernel_params_mp_r_buf32[4] = 0;
15199 device_param->kernel_params_mp_r_buf32[5] = 0;
15200 device_param->kernel_params_mp_r_buf32[6] = 0;
15201 device_param->kernel_params_mp_r_buf32[7] = 0;
15202 device_param->kernel_params_mp_r_buf32[8] = 0;
15203
15204 device_param->kernel_params_mp_r[0] = NULL;
15205 device_param->kernel_params_mp_r[1] = NULL;
15206 device_param->kernel_params_mp_r[2] = NULL;
15207 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15208 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15209 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15210 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15211 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15212 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15213
15214 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15215 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15216
15217 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15218 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15219 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15220 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15221 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15222 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15223 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15224
15225 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15226 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15227
15228 /**
15229 * kernel name
15230 */
15231
15232 size_t kernel_wgs_tmp;
15233
15234 char kernel_name[64] = { 0 };
15235
15236 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15237 {
15238 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15239 {
15240 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15241
15242 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15243
15244 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15245
15246 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15247
15248 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15249
15250 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15251 }
15252 else
15253 {
15254 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15255
15256 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15257
15258 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15259
15260 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15261
15262 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15263
15264 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15265 }
15266
15267 if (data.attack_mode == ATTACK_MODE_BF)
15268 {
15269 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15270 {
15271 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15272
15273 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15274
15275 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);
15276 }
15277 }
15278 }
15279 else
15280 {
15281 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15282
15283 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15284
15285 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15286
15287 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15288
15289 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15290
15291 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15292
15293 if (opts_type & OPTS_TYPE_HOOK12)
15294 {
15295 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15296
15297 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15298
15299 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);
15300 }
15301
15302 if (opts_type & OPTS_TYPE_HOOK23)
15303 {
15304 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15305
15306 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15307
15308 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);
15309 }
15310 }
15311
15312 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);
15313 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);
15314 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);
15315
15316 for (uint i = 0; i <= 20; i++)
15317 {
15318 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15319 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15320 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15321
15322 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15323 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15324 }
15325
15326 for (uint i = 21; i <= 31; i++)
15327 {
15328 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15329 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15330 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15331
15332 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15333 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15334 }
15335
15336 if (attack_mode == ATTACK_MODE_BF)
15337 {
15338 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15339 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15340
15341 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);
15342 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);
15343
15344 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15345 {
15346 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15347 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15348 }
15349 }
15350 else if (attack_mode == ATTACK_MODE_HYBRID1)
15351 {
15352 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15353
15354 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);
15355 }
15356 else if (attack_mode == ATTACK_MODE_HYBRID2)
15357 {
15358 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15359
15360 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);
15361 }
15362
15363 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15364 {
15365 // nothing to do
15366 }
15367 else
15368 {
15369 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15370
15371 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);
15372 }
15373
15374 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15375 {
15376 // nothing to do
15377 }
15378 else
15379 {
15380 for (uint i = 0; i < 5; i++)
15381 {
15382 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15383 }
15384
15385 for (uint i = 5; i < 7; i++)
15386 {
15387 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15388 }
15389 }
15390
15391 // maybe this has been updated by clGetKernelWorkGroupInfo()
15392 // value can only be decreased, so we don't need to reallocate buffers
15393
15394 device_param->kernel_threads = kernel_threads;
15395
15396 /**
15397 * Store initial fanspeed if gpu_temp_retain is enabled
15398 */
15399
15400 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15401 int gpu_temp_retain_set = 0;
15402
15403 if (gpu_temp_disable == 0)
15404 {
15405 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15406 {
15407 hc_thread_mutex_lock (mux_adl);
15408
15409 if (data.hm_device[device_id].fan_supported == 1)
15410 {
15411 if (gpu_temp_retain_chgd == 0)
15412 {
15413 uint cur_temp = 0;
15414 uint default_temp = 0;
15415
15416 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);
15417
15418 if (ADL_rc == ADL_OK)
15419 {
15420 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15421
15422 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15423
15424 // special case with multi gpu setups: always use minimum retain
15425
15426 if (gpu_temp_retain_set == 0)
15427 {
15428 gpu_temp_retain = gpu_temp_retain_target;
15429 gpu_temp_retain_set = 1;
15430 }
15431 else
15432 {
15433 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15434 }
15435
15436 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15437 }
15438 }
15439
15440 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15441
15442 temp_retain_fanspeed_value[device_id] = fan_speed;
15443
15444 if (fan_speed == -1)
15445 {
15446 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15447
15448 temp_retain_fanspeed_value[device_id] = 0;
15449 }
15450 }
15451
15452 hc_thread_mutex_unlock (mux_adl);
15453 }
15454 }
15455
15456 /**
15457 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15458 */
15459
15460 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15461 {
15462 hc_thread_mutex_lock (mux_adl);
15463
15464 if (data.hm_device[device_id].od_version == 6)
15465 {
15466 int ADL_rc;
15467
15468 // check powertune capabilities first, if not available then skip device
15469
15470 int powertune_supported = 0;
15471
15472 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15473 {
15474 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15475
15476 return (-1);
15477 }
15478
15479 if (powertune_supported != 0)
15480 {
15481 // powercontrol settings
15482
15483 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15484
15485 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15486 {
15487 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15488 }
15489
15490 if (ADL_rc != ADL_OK)
15491 {
15492 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15493
15494 return (-1);
15495 }
15496
15497 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15498 {
15499 log_error ("ERROR: Failed to set new ADL PowerControl values");
15500
15501 return (-1);
15502 }
15503
15504 // clocks
15505
15506 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15507
15508 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15509
15510 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)
15511 {
15512 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15513
15514 return (-1);
15515 }
15516
15517 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15518
15519 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15520
15521 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15522 {
15523 log_error ("ERROR: Failed to get ADL device capabilities");
15524
15525 return (-1);
15526 }
15527
15528 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15529 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15530
15531 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15532 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15533
15534 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15535 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15536
15537 // warning if profile has too low max values
15538
15539 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15540 {
15541 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15542 }
15543
15544 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15545 {
15546 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15547 }
15548
15549 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15550
15551 performance_state->iNumberOfPerformanceLevels = 2;
15552
15553 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15554 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15555 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15556 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15557
15558 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)
15559 {
15560 log_info ("ERROR: Failed to set ADL performance state");
15561
15562 return (-1);
15563 }
15564
15565 local_free (performance_state);
15566 }
15567 }
15568
15569 hc_thread_mutex_unlock (mux_adl);
15570 }
15571 #endif // HAVE_HWMON && HAVE_ADL
15572 }
15573
15574 data.kernel_power_all = kernel_power_all;
15575
15576 if (data.quiet == 0) log_info_nn ("");
15577
15578 /**
15579 * In benchmark-mode, inform user which algorithm is checked
15580 */
15581
15582 if (benchmark == 1)
15583 {
15584 if (status_automat == 0)
15585 {
15586 quiet = 0;
15587
15588 data.quiet = quiet;
15589
15590 char *hash_type = strhashtype (data.hash_mode); // not a bug
15591
15592 log_info ("Hashtype: %s", hash_type);
15593 log_info ("");
15594 }
15595 }
15596
15597 /**
15598 * keep track of the progress
15599 */
15600
15601 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15602 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15603 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15604
15605 /**
15606 * open filehandles
15607 */
15608
15609 #if _WIN
15610 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15611 {
15612 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15613
15614 return (-1);
15615 }
15616
15617 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15618 {
15619 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15620
15621 return (-1);
15622 }
15623
15624 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15625 {
15626 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15627
15628 return (-1);
15629 }
15630 #endif
15631
15632 /**
15633 * dictionary pad
15634 */
15635
15636 segment_size *= (1024 * 1024);
15637
15638 data.segment_size = segment_size;
15639
15640 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15641
15642 wl_data->buf = (char *) mymalloc (segment_size);
15643 wl_data->avail = segment_size;
15644 wl_data->incr = segment_size;
15645 wl_data->cnt = 0;
15646 wl_data->pos = 0;
15647
15648 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15649
15650 data.wordlist_mode = wordlist_mode;
15651
15652 cs_t *css_buf = NULL;
15653 uint css_cnt = 0;
15654 uint dictcnt = 0;
15655 uint maskcnt = 1;
15656 char **masks = NULL;
15657 char **dictfiles = NULL;
15658
15659 uint mask_from_file = 0;
15660
15661 if (attack_mode == ATTACK_MODE_STRAIGHT)
15662 {
15663 if (wordlist_mode == WL_MODE_FILE)
15664 {
15665 int wls_left = myargc - (optind + 1);
15666
15667 for (int i = 0; i < wls_left; i++)
15668 {
15669 char *l0_filename = myargv[optind + 1 + i];
15670
15671 struct stat l0_stat;
15672
15673 if (stat (l0_filename, &l0_stat) == -1)
15674 {
15675 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15676
15677 return (-1);
15678 }
15679
15680 uint is_dir = S_ISDIR (l0_stat.st_mode);
15681
15682 if (is_dir == 0)
15683 {
15684 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15685
15686 dictcnt++;
15687
15688 dictfiles[dictcnt - 1] = l0_filename;
15689 }
15690 else
15691 {
15692 // do not allow --keyspace w/ a directory
15693
15694 if (keyspace == 1)
15695 {
15696 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15697
15698 return (-1);
15699 }
15700
15701 char **dictionary_files = NULL;
15702
15703 dictionary_files = scan_directory (l0_filename);
15704
15705 if (dictionary_files != NULL)
15706 {
15707 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15708
15709 for (int d = 0; dictionary_files[d] != NULL; d++)
15710 {
15711 char *l1_filename = dictionary_files[d];
15712
15713 struct stat l1_stat;
15714
15715 if (stat (l1_filename, &l1_stat) == -1)
15716 {
15717 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15718
15719 return (-1);
15720 }
15721
15722 if (S_ISREG (l1_stat.st_mode))
15723 {
15724 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15725
15726 dictcnt++;
15727
15728 dictfiles[dictcnt - 1] = strdup (l1_filename);
15729 }
15730 }
15731 }
15732
15733 local_free (dictionary_files);
15734 }
15735 }
15736
15737 if (dictcnt < 1)
15738 {
15739 log_error ("ERROR: No usable dictionary file found.");
15740
15741 return (-1);
15742 }
15743 }
15744 else if (wordlist_mode == WL_MODE_STDIN)
15745 {
15746 dictcnt = 1;
15747 }
15748 }
15749 else if (attack_mode == ATTACK_MODE_COMBI)
15750 {
15751 // display
15752
15753 char *dictfile1 = myargv[optind + 1 + 0];
15754 char *dictfile2 = myargv[optind + 1 + 1];
15755
15756 // find the bigger dictionary and use as base
15757
15758 FILE *fp1 = NULL;
15759 FILE *fp2 = NULL;
15760
15761 struct stat tmp_stat;
15762
15763 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15764 {
15765 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15766
15767 return (-1);
15768 }
15769
15770 if (stat (dictfile1, &tmp_stat) == -1)
15771 {
15772 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15773
15774 fclose (fp1);
15775
15776 return (-1);
15777 }
15778
15779 if (S_ISDIR (tmp_stat.st_mode))
15780 {
15781 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15782
15783 fclose (fp1);
15784
15785 return (-1);
15786 }
15787
15788 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15789 {
15790 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15791
15792 fclose (fp1);
15793
15794 return (-1);
15795 }
15796
15797 if (stat (dictfile2, &tmp_stat) == -1)
15798 {
15799 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15800
15801 fclose (fp1);
15802 fclose (fp2);
15803
15804 return (-1);
15805 }
15806
15807 if (S_ISDIR (tmp_stat.st_mode))
15808 {
15809 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15810
15811 fclose (fp1);
15812 fclose (fp2);
15813
15814 return (-1);
15815 }
15816
15817 data.combs_cnt = 1;
15818
15819 data.quiet = 1;
15820
15821 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15822
15823 data.quiet = quiet;
15824
15825 if (words1_cnt == 0)
15826 {
15827 log_error ("ERROR: %s: empty file", dictfile1);
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 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15840
15841 data.quiet = quiet;
15842
15843 if (words2_cnt == 0)
15844 {
15845 log_error ("ERROR: %s: empty file", dictfile2);
15846
15847 fclose (fp1);
15848 fclose (fp2);
15849
15850 return (-1);
15851 }
15852
15853 fclose (fp1);
15854 fclose (fp2);
15855
15856 data.dictfile = dictfile1;
15857 data.dictfile2 = dictfile2;
15858
15859 if (words1_cnt >= words2_cnt)
15860 {
15861 data.combs_cnt = words2_cnt;
15862 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15863
15864 dictfiles = &data.dictfile;
15865
15866 dictcnt = 1;
15867 }
15868 else
15869 {
15870 data.combs_cnt = words1_cnt;
15871 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15872
15873 dictfiles = &data.dictfile2;
15874
15875 dictcnt = 1;
15876
15877 // we also have to switch wordlist related rules!
15878
15879 char *tmpc = data.rule_buf_l;
15880
15881 data.rule_buf_l = data.rule_buf_r;
15882 data.rule_buf_r = tmpc;
15883
15884 int tmpi = data.rule_len_l;
15885
15886 data.rule_len_l = data.rule_len_r;
15887 data.rule_len_r = tmpi;
15888 }
15889 }
15890 else if (attack_mode == ATTACK_MODE_BF)
15891 {
15892 char *mask = NULL;
15893
15894 maskcnt = 0;
15895
15896 if (benchmark == 0)
15897 {
15898 mask = myargv[optind + 1];
15899
15900 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15901
15902 if ((optind + 2) <= myargc)
15903 {
15904 struct stat file_stat;
15905
15906 if (stat (mask, &file_stat) == -1)
15907 {
15908 maskcnt = 1;
15909
15910 masks[maskcnt - 1] = mystrdup (mask);
15911 }
15912 else
15913 {
15914 int wls_left = myargc - (optind + 1);
15915
15916 uint masks_avail = INCR_MASKS;
15917
15918 for (int i = 0; i < wls_left; i++)
15919 {
15920 if (i != 0)
15921 {
15922 mask = myargv[optind + 1 + i];
15923
15924 if (stat (mask, &file_stat) == -1)
15925 {
15926 log_error ("ERROR: %s: %s", mask, strerror (errno));
15927
15928 return (-1);
15929 }
15930 }
15931
15932 uint is_file = S_ISREG (file_stat.st_mode);
15933
15934 if (is_file == 1)
15935 {
15936 FILE *mask_fp;
15937
15938 if ((mask_fp = fopen (mask, "r")) == NULL)
15939 {
15940 log_error ("ERROR: %s: %s", mask, strerror (errno));
15941
15942 return (-1);
15943 }
15944
15945 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15946
15947 while (!feof (mask_fp))
15948 {
15949 memset (line_buf, 0, HCBUFSIZ);
15950
15951 int line_len = fgetl (mask_fp, line_buf);
15952
15953 if (line_len == 0) continue;
15954
15955 if (line_buf[0] == '#') continue;
15956
15957 if (masks_avail == maskcnt)
15958 {
15959 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15960
15961 masks_avail += INCR_MASKS;
15962 }
15963
15964 masks[maskcnt] = mystrdup (line_buf);
15965
15966 maskcnt++;
15967 }
15968
15969 myfree (line_buf);
15970
15971 fclose (mask_fp);
15972 }
15973 else
15974 {
15975 log_error ("ERROR: %s: unsupported file-type", mask);
15976
15977 return (-1);
15978 }
15979 }
15980
15981 mask_from_file = 1;
15982 }
15983 }
15984 else
15985 {
15986 custom_charset_1 = (char *) "?l?d?u";
15987 custom_charset_2 = (char *) "?l?d";
15988 custom_charset_3 = (char *) "?l?d*!$@_";
15989
15990 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15991 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15992 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15993
15994 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15995
15996 wordlist_mode = WL_MODE_MASK;
15997
15998 data.wordlist_mode = wordlist_mode;
15999
16000 increment = 1;
16001
16002 maskcnt = 1;
16003 }
16004 }
16005 else
16006 {
16007 /**
16008 * generate full masks and charsets
16009 */
16010
16011 masks = (char **) mymalloc (sizeof (char *));
16012
16013 switch (hash_mode)
16014 {
16015 case 1731: pw_min = 5;
16016 pw_max = 5;
16017 mask = mystrdup ("?b?b?b?b?b");
16018 break;
16019 case 12500: pw_min = 5;
16020 pw_max = 5;
16021 mask = mystrdup ("?b?b?b?b?b");
16022 break;
16023 default: pw_min = 7;
16024 pw_max = 7;
16025 mask = mystrdup ("?b?b?b?b?b?b?b");
16026 break;
16027 }
16028
16029 maskcnt = 1;
16030
16031 masks[maskcnt - 1] = mystrdup (mask);
16032
16033 wordlist_mode = WL_MODE_MASK;
16034
16035 data.wordlist_mode = wordlist_mode;
16036
16037 increment = 1;
16038 }
16039
16040 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16041
16042 if (increment)
16043 {
16044 if (increment_min > pw_min) pw_min = increment_min;
16045
16046 if (increment_max < pw_max) pw_max = increment_max;
16047 }
16048 }
16049 else if (attack_mode == ATTACK_MODE_HYBRID1)
16050 {
16051 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16052
16053 // display
16054
16055 char *mask = myargv[myargc - 1];
16056
16057 maskcnt = 0;
16058
16059 masks = (char **) mymalloc (1 * sizeof (char *));
16060
16061 // mod
16062
16063 struct stat file_stat;
16064
16065 if (stat (mask, &file_stat) == -1)
16066 {
16067 maskcnt = 1;
16068
16069 masks[maskcnt - 1] = mystrdup (mask);
16070 }
16071 else
16072 {
16073 uint is_file = S_ISREG (file_stat.st_mode);
16074
16075 if (is_file == 1)
16076 {
16077 FILE *mask_fp;
16078
16079 if ((mask_fp = fopen (mask, "r")) == NULL)
16080 {
16081 log_error ("ERROR: %s: %s", mask, strerror (errno));
16082
16083 return (-1);
16084 }
16085
16086 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16087
16088 uint masks_avail = 1;
16089
16090 while (!feof (mask_fp))
16091 {
16092 memset (line_buf, 0, HCBUFSIZ);
16093
16094 int line_len = fgetl (mask_fp, line_buf);
16095
16096 if (line_len == 0) continue;
16097
16098 if (line_buf[0] == '#') continue;
16099
16100 if (masks_avail == maskcnt)
16101 {
16102 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16103
16104 masks_avail += INCR_MASKS;
16105 }
16106
16107 masks[maskcnt] = mystrdup (line_buf);
16108
16109 maskcnt++;
16110 }
16111
16112 myfree (line_buf);
16113
16114 fclose (mask_fp);
16115
16116 mask_from_file = 1;
16117 }
16118 else
16119 {
16120 maskcnt = 1;
16121
16122 masks[maskcnt - 1] = mystrdup (mask);
16123 }
16124 }
16125
16126 // base
16127
16128 int wls_left = myargc - (optind + 2);
16129
16130 for (int i = 0; i < wls_left; i++)
16131 {
16132 char *filename = myargv[optind + 1 + i];
16133
16134 struct stat file_stat;
16135
16136 if (stat (filename, &file_stat) == -1)
16137 {
16138 log_error ("ERROR: %s: %s", filename, strerror (errno));
16139
16140 return (-1);
16141 }
16142
16143 uint is_dir = S_ISDIR (file_stat.st_mode);
16144
16145 if (is_dir == 0)
16146 {
16147 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16148
16149 dictcnt++;
16150
16151 dictfiles[dictcnt - 1] = filename;
16152 }
16153 else
16154 {
16155 // do not allow --keyspace w/ a directory
16156
16157 if (keyspace == 1)
16158 {
16159 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16160
16161 return (-1);
16162 }
16163
16164 char **dictionary_files = NULL;
16165
16166 dictionary_files = scan_directory (filename);
16167
16168 if (dictionary_files != NULL)
16169 {
16170 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16171
16172 for (int d = 0; dictionary_files[d] != NULL; d++)
16173 {
16174 char *l1_filename = dictionary_files[d];
16175
16176 struct stat l1_stat;
16177
16178 if (stat (l1_filename, &l1_stat) == -1)
16179 {
16180 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16181
16182 return (-1);
16183 }
16184
16185 if (S_ISREG (l1_stat.st_mode))
16186 {
16187 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16188
16189 dictcnt++;
16190
16191 dictfiles[dictcnt - 1] = strdup (l1_filename);
16192 }
16193 }
16194 }
16195
16196 local_free (dictionary_files);
16197 }
16198 }
16199
16200 if (dictcnt < 1)
16201 {
16202 log_error ("ERROR: No usable dictionary file found.");
16203
16204 return (-1);
16205 }
16206
16207 if (increment)
16208 {
16209 maskcnt = 0;
16210
16211 uint mask_min = increment_min; // we can't reject smaller masks here
16212 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16213
16214 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16215 {
16216 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16217
16218 if (cur_mask == NULL) break;
16219
16220 masks[maskcnt] = cur_mask;
16221
16222 maskcnt++;
16223
16224 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16225 }
16226 }
16227 }
16228 else if (attack_mode == ATTACK_MODE_HYBRID2)
16229 {
16230 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16231
16232 // display
16233
16234 char *mask = myargv[optind + 1 + 0];
16235
16236 maskcnt = 0;
16237
16238 masks = (char **) mymalloc (1 * sizeof (char *));
16239
16240 // mod
16241
16242 struct stat file_stat;
16243
16244 if (stat (mask, &file_stat) == -1)
16245 {
16246 maskcnt = 1;
16247
16248 masks[maskcnt - 1] = mystrdup (mask);
16249 }
16250 else
16251 {
16252 uint is_file = S_ISREG (file_stat.st_mode);
16253
16254 if (is_file == 1)
16255 {
16256 FILE *mask_fp;
16257
16258 if ((mask_fp = fopen (mask, "r")) == NULL)
16259 {
16260 log_error ("ERROR: %s: %s", mask, strerror (errno));
16261
16262 return (-1);
16263 }
16264
16265 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16266
16267 uint masks_avail = 1;
16268
16269 while (!feof (mask_fp))
16270 {
16271 memset (line_buf, 0, HCBUFSIZ);
16272
16273 int line_len = fgetl (mask_fp, line_buf);
16274
16275 if (line_len == 0) continue;
16276
16277 if (line_buf[0] == '#') continue;
16278
16279 if (masks_avail == maskcnt)
16280 {
16281 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16282
16283 masks_avail += INCR_MASKS;
16284 }
16285
16286 masks[maskcnt] = mystrdup (line_buf);
16287
16288 maskcnt++;
16289 }
16290
16291 myfree (line_buf);
16292
16293 fclose (mask_fp);
16294
16295 mask_from_file = 1;
16296 }
16297 else
16298 {
16299 maskcnt = 1;
16300
16301 masks[maskcnt - 1] = mystrdup (mask);
16302 }
16303 }
16304
16305 // base
16306
16307 int wls_left = myargc - (optind + 2);
16308
16309 for (int i = 0; i < wls_left; i++)
16310 {
16311 char *filename = myargv[optind + 2 + i];
16312
16313 struct stat file_stat;
16314
16315 if (stat (filename, &file_stat) == -1)
16316 {
16317 log_error ("ERROR: %s: %s", filename, strerror (errno));
16318
16319 return (-1);
16320 }
16321
16322 uint is_dir = S_ISDIR (file_stat.st_mode);
16323
16324 if (is_dir == 0)
16325 {
16326 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16327
16328 dictcnt++;
16329
16330 dictfiles[dictcnt - 1] = filename;
16331 }
16332 else
16333 {
16334 // do not allow --keyspace w/ a directory
16335
16336 if (keyspace == 1)
16337 {
16338 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16339
16340 return (-1);
16341 }
16342
16343 char **dictionary_files = NULL;
16344
16345 dictionary_files = scan_directory (filename);
16346
16347 if (dictionary_files != NULL)
16348 {
16349 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16350
16351 for (int d = 0; dictionary_files[d] != NULL; d++)
16352 {
16353 char *l1_filename = dictionary_files[d];
16354
16355 struct stat l1_stat;
16356
16357 if (stat (l1_filename, &l1_stat) == -1)
16358 {
16359 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16360
16361 return (-1);
16362 }
16363
16364 if (S_ISREG (l1_stat.st_mode))
16365 {
16366 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16367
16368 dictcnt++;
16369
16370 dictfiles[dictcnt - 1] = strdup (l1_filename);
16371 }
16372 }
16373 }
16374
16375 local_free (dictionary_files);
16376 }
16377 }
16378
16379 if (dictcnt < 1)
16380 {
16381 log_error ("ERROR: No usable dictionary file found.");
16382
16383 return (-1);
16384 }
16385
16386 if (increment)
16387 {
16388 maskcnt = 0;
16389
16390 uint mask_min = increment_min; // we can't reject smaller masks here
16391 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16392
16393 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16394 {
16395 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16396
16397 if (cur_mask == NULL) break;
16398
16399 masks[maskcnt] = cur_mask;
16400
16401 maskcnt++;
16402
16403 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16404 }
16405 }
16406 }
16407
16408 data.pw_min = pw_min;
16409 data.pw_max = pw_max;
16410
16411 /**
16412 * weak hash check
16413 */
16414
16415 if (weak_hash_threshold >= salts_cnt)
16416 {
16417 hc_device_param_t *device_param = NULL;
16418
16419 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16420 {
16421 device_param = &data.devices_param[device_id];
16422
16423 if (device_param->skipped) continue;
16424
16425 break;
16426 }
16427
16428 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16429
16430 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16431 {
16432 weak_hash_check (device_param, salt_pos);
16433 }
16434
16435 // Display hack, guarantee that there is at least one \r before real start
16436
16437 //if (data.quiet == 0) log_info ("");
16438 }
16439
16440 /**
16441 * status and monitor threads
16442 */
16443
16444 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16445
16446 hc_thread_t i_thread = 0;
16447
16448 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16449 {
16450 hc_thread_create (i_thread, thread_keypress, &benchmark);
16451 }
16452
16453 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16454
16455 uint ni_threads_cnt = 0;
16456
16457 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16458
16459 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16460
16461 ni_threads_cnt++;
16462
16463 /**
16464 * Outfile remove
16465 */
16466
16467 if (keyspace == 0)
16468 {
16469 if (outfile_check_timer != 0)
16470 {
16471 if (data.outfile_check_directory != NULL)
16472 {
16473 if ((hash_mode != 5200) &&
16474 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16475 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16476 (hash_mode != 9000))
16477 {
16478 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16479
16480 ni_threads_cnt++;
16481 }
16482 else
16483 {
16484 outfile_check_timer = 0;
16485 }
16486 }
16487 else
16488 {
16489 outfile_check_timer = 0;
16490 }
16491 }
16492 }
16493
16494 /**
16495 * Inform the user if we got some hashes remove because of the pot file remove feature
16496 */
16497
16498 if (data.quiet == 0)
16499 {
16500 if (potfile_remove_cracks > 0)
16501 {
16502 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16503 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16504 }
16505 }
16506
16507 data.outfile_check_timer = outfile_check_timer;
16508
16509 /**
16510 * main loop
16511 */
16512
16513 char **induction_dictionaries = NULL;
16514
16515 int induction_dictionaries_cnt = 0;
16516
16517 hcstat_table_t *root_table_buf = NULL;
16518 hcstat_table_t *markov_table_buf = NULL;
16519
16520 uint initial_restore_done = 0;
16521
16522 data.maskcnt = maskcnt;
16523
16524 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16525 {
16526 if (data.devices_status == STATUS_CRACKED) break;
16527
16528 data.devices_status = STATUS_INIT;
16529
16530 if (maskpos > rd->maskpos)
16531 {
16532 rd->dictpos = 0;
16533 }
16534
16535 rd->maskpos = maskpos;
16536 data.maskpos = maskpos;
16537
16538 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16539 {
16540 char *mask = masks[maskpos];
16541
16542 if (mask_from_file == 1)
16543 {
16544 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16545
16546 char *str_ptr;
16547 uint str_pos;
16548
16549 uint mask_offset = 0;
16550
16551 uint separator_cnt;
16552
16553 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16554 {
16555 str_ptr = strstr (mask + mask_offset, ",");
16556
16557 if (str_ptr == NULL) break;
16558
16559 str_pos = str_ptr - mask;
16560
16561 // escaped separator, i.e. "\,"
16562
16563 if (str_pos > 0)
16564 {
16565 if (mask[str_pos - 1] == '\\')
16566 {
16567 separator_cnt --;
16568
16569 mask_offset = str_pos + 1;
16570
16571 continue;
16572 }
16573 }
16574
16575 // reset the offset
16576
16577 mask_offset = 0;
16578
16579 mask[str_pos] = '\0';
16580
16581 switch (separator_cnt)
16582 {
16583 case 0:
16584 mp_reset_usr (mp_usr, 0);
16585
16586 custom_charset_1 = mask;
16587 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16588 break;
16589
16590 case 1:
16591 mp_reset_usr (mp_usr, 1);
16592
16593 custom_charset_2 = mask;
16594 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16595 break;
16596
16597 case 2:
16598 mp_reset_usr (mp_usr, 2);
16599
16600 custom_charset_3 = mask;
16601 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16602 break;
16603
16604 case 3:
16605 mp_reset_usr (mp_usr, 3);
16606
16607 custom_charset_4 = mask;
16608 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16609 break;
16610 }
16611
16612 mask = mask + str_pos + 1;
16613 }
16614 }
16615
16616 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16617 {
16618 if (maskpos > 0)
16619 {
16620 local_free (css_buf);
16621 local_free (data.root_css_buf);
16622 local_free (data.markov_css_buf);
16623
16624 local_free (masks[maskpos - 1]);
16625 }
16626
16627 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16628
16629 data.mask = mask;
16630 data.css_cnt = css_cnt;
16631 data.css_buf = css_buf;
16632
16633 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16634
16635 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16636
16637 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16638 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16639
16640 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16641
16642 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16643
16644 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16645 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16646
16647 data.root_css_buf = root_css_buf;
16648 data.markov_css_buf = markov_css_buf;
16649
16650 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16651
16652 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16653
16654 local_free (root_table_buf);
16655 local_free (markov_table_buf);
16656
16657 // args
16658
16659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16660 {
16661 hc_device_param_t *device_param = &data.devices_param[device_id];
16662
16663 if (device_param->skipped) continue;
16664
16665 device_param->kernel_params_mp[0] = &device_param->d_combs;
16666 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16667 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16668
16669 device_param->kernel_params_mp_buf64[3] = 0;
16670 device_param->kernel_params_mp_buf32[4] = css_cnt;
16671 device_param->kernel_params_mp_buf32[5] = 0;
16672 device_param->kernel_params_mp_buf32[6] = 0;
16673 device_param->kernel_params_mp_buf32[7] = 0;
16674
16675 if (attack_mode == ATTACK_MODE_HYBRID1)
16676 {
16677 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16678 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16679 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16680 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16681 }
16682 else if (attack_mode == ATTACK_MODE_HYBRID2)
16683 {
16684 device_param->kernel_params_mp_buf32[5] = 0;
16685 device_param->kernel_params_mp_buf32[6] = 0;
16686 device_param->kernel_params_mp_buf32[7] = 0;
16687 }
16688
16689 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]);
16690 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]);
16691 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]);
16692
16693 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);
16694 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);
16695 }
16696 }
16697 else if (attack_mode == ATTACK_MODE_BF)
16698 {
16699 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16700
16701 if (increment)
16702 {
16703 for (uint i = 0; i < dictcnt; i++)
16704 {
16705 local_free (dictfiles[i]);
16706 }
16707
16708 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16709 {
16710 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16711
16712 if (l1_filename == NULL) break;
16713
16714 dictcnt++;
16715
16716 dictfiles[dictcnt - 1] = l1_filename;
16717 }
16718 }
16719 else
16720 {
16721 dictcnt++;
16722
16723 dictfiles[dictcnt - 1] = mask;
16724 }
16725
16726 if (dictcnt == 0)
16727 {
16728 log_error ("ERROR: Mask is too small");
16729
16730 return (-1);
16731 }
16732 }
16733 }
16734
16735 free (induction_dictionaries);
16736
16737 // induction_dictionaries_cnt = 0; // implied
16738
16739 if (attack_mode != ATTACK_MODE_BF)
16740 {
16741 if (keyspace == 0)
16742 {
16743 induction_dictionaries = scan_directory (induction_directory);
16744
16745 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16746 }
16747 }
16748
16749 if (induction_dictionaries_cnt)
16750 {
16751 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16752 }
16753
16754 /**
16755 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16756 */
16757 if (keyspace == 1)
16758 {
16759 if ((maskcnt > 1) || (dictcnt > 1))
16760 {
16761 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16762
16763 return (-1);
16764 }
16765 }
16766
16767 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16768 {
16769 char *subid = logfile_generate_subid ();
16770
16771 data.subid = subid;
16772
16773 logfile_sub_msg ("START");
16774
16775 data.devices_status = STATUS_INIT;
16776
16777 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16778 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16779 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16780
16781 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16782
16783 data.cpt_pos = 0;
16784
16785 data.cpt_start = time (NULL);
16786
16787 data.cpt_total = 0;
16788
16789 if (data.restore == 0)
16790 {
16791 rd->words_cur = skip;
16792
16793 skip = 0;
16794
16795 data.skip = 0;
16796 }
16797
16798 data.ms_paused = 0;
16799
16800 data.words_cur = rd->words_cur;
16801
16802 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16803 {
16804 hc_device_param_t *device_param = &data.devices_param[device_id];
16805
16806 if (device_param->skipped) continue;
16807
16808 device_param->speed_pos = 0;
16809
16810 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16811 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16812
16813 device_param->exec_pos = 0;
16814
16815 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16816
16817 device_param->kernel_power = device_param->kernel_power_user;
16818
16819 device_param->outerloop_pos = 0;
16820 device_param->outerloop_left = 0;
16821 device_param->innerloop_pos = 0;
16822 device_param->innerloop_left = 0;
16823
16824 // some more resets:
16825
16826 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16827
16828 device_param->pws_cnt = 0;
16829
16830 device_param->words_off = 0;
16831 device_param->words_done = 0;
16832 }
16833
16834 data.kernel_power_div = 0;
16835
16836 // figure out some workload
16837
16838 if (attack_mode == ATTACK_MODE_STRAIGHT)
16839 {
16840 if (data.wordlist_mode == WL_MODE_FILE)
16841 {
16842 char *dictfile = NULL;
16843
16844 if (induction_dictionaries_cnt)
16845 {
16846 dictfile = induction_dictionaries[0];
16847 }
16848 else
16849 {
16850 dictfile = dictfiles[dictpos];
16851 }
16852
16853 data.dictfile = dictfile;
16854
16855 logfile_sub_string (dictfile);
16856
16857 for (uint i = 0; i < rp_files_cnt; i++)
16858 {
16859 logfile_sub_var_string ("rulefile", rp_files[i]);
16860 }
16861
16862 FILE *fd2 = fopen (dictfile, "rb");
16863
16864 if (fd2 == NULL)
16865 {
16866 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16867
16868 return (-1);
16869 }
16870
16871 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16872
16873 fclose (fd2);
16874
16875 if (data.words_cnt == 0)
16876 {
16877 if (data.devices_status == STATUS_CRACKED) break;
16878 if (data.devices_status == STATUS_ABORTED) break;
16879
16880 dictpos++;
16881
16882 continue;
16883 }
16884 }
16885 }
16886 else if (attack_mode == ATTACK_MODE_COMBI)
16887 {
16888 char *dictfile = data.dictfile;
16889 char *dictfile2 = data.dictfile2;
16890
16891 logfile_sub_string (dictfile);
16892 logfile_sub_string (dictfile2);
16893
16894 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16895 {
16896 FILE *fd2 = fopen (dictfile, "rb");
16897
16898 if (fd2 == NULL)
16899 {
16900 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16901
16902 return (-1);
16903 }
16904
16905 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16906
16907 fclose (fd2);
16908 }
16909 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16910 {
16911 FILE *fd2 = fopen (dictfile2, "rb");
16912
16913 if (fd2 == NULL)
16914 {
16915 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16916
16917 return (-1);
16918 }
16919
16920 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16921
16922 fclose (fd2);
16923 }
16924
16925 if (data.words_cnt == 0)
16926 {
16927 if (data.devices_status == STATUS_CRACKED) break;
16928 if (data.devices_status == STATUS_ABORTED) break;
16929
16930 dictpos++;
16931
16932 continue;
16933 }
16934 }
16935 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16936 {
16937 char *dictfile = NULL;
16938
16939 if (induction_dictionaries_cnt)
16940 {
16941 dictfile = induction_dictionaries[0];
16942 }
16943 else
16944 {
16945 dictfile = dictfiles[dictpos];
16946 }
16947
16948 data.dictfile = dictfile;
16949
16950 char *mask = data.mask;
16951
16952 logfile_sub_string (dictfile);
16953 logfile_sub_string (mask);
16954
16955 FILE *fd2 = fopen (dictfile, "rb");
16956
16957 if (fd2 == NULL)
16958 {
16959 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16960
16961 return (-1);
16962 }
16963
16964 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16965
16966 fclose (fd2);
16967
16968 if (data.words_cnt == 0)
16969 {
16970 if (data.devices_status == STATUS_CRACKED) break;
16971 if (data.devices_status == STATUS_ABORTED) break;
16972
16973 dictpos++;
16974
16975 continue;
16976 }
16977 }
16978 else if (attack_mode == ATTACK_MODE_BF)
16979 {
16980 local_free (css_buf);
16981 local_free (data.root_css_buf);
16982 local_free (data.markov_css_buf);
16983
16984 char *mask = dictfiles[dictpos];
16985
16986 logfile_sub_string (mask);
16987
16988 // base
16989
16990 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16991
16992 if (opts_type & OPTS_TYPE_PT_UNICODE)
16993 {
16994 uint css_cnt_unicode = css_cnt * 2;
16995
16996 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16997
16998 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16999 {
17000 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17001
17002 css_buf_unicode[j + 1].cs_buf[0] = 0;
17003 css_buf_unicode[j + 1].cs_len = 1;
17004 }
17005
17006 free (css_buf);
17007
17008 css_buf = css_buf_unicode;
17009 css_cnt = css_cnt_unicode;
17010 }
17011
17012 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17013
17014 uint mask_min = pw_min;
17015 uint mask_max = pw_max;
17016
17017 if (opts_type & OPTS_TYPE_PT_UNICODE)
17018 {
17019 mask_min *= 2;
17020 mask_max *= 2;
17021 }
17022
17023 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17024 {
17025 if (css_cnt < mask_min)
17026 {
17027 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17028 }
17029
17030 if (css_cnt > mask_max)
17031 {
17032 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17033 }
17034
17035 // skip to next mask
17036
17037 dictpos++;
17038
17039 rd->dictpos = dictpos;
17040
17041 logfile_sub_msg ("STOP");
17042
17043 continue;
17044 }
17045
17046 uint save_css_cnt = css_cnt;
17047
17048 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17049 {
17050 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17051 {
17052 uint salt_len = (uint) data.salts_buf[0].salt_len;
17053 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17054
17055 uint css_cnt_salt = css_cnt + salt_len;
17056
17057 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17058
17059 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17060
17061 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17062 {
17063 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17064 css_buf_salt[j].cs_len = 1;
17065 }
17066
17067 free (css_buf);
17068
17069 css_buf = css_buf_salt;
17070 css_cnt = css_cnt_salt;
17071 }
17072 }
17073
17074 data.mask = mask;
17075 data.css_cnt = css_cnt;
17076 data.css_buf = css_buf;
17077
17078 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17079
17080 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17081
17082 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17083
17084 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17085 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17086
17087 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17088
17089 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17090
17091 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17092 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17093
17094 data.root_css_buf = root_css_buf;
17095 data.markov_css_buf = markov_css_buf;
17096
17097 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17098
17099 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17100
17101 local_free (root_table_buf);
17102 local_free (markov_table_buf);
17103
17104 // copy + args
17105
17106 uint css_cnt_l = css_cnt;
17107 uint css_cnt_r;
17108
17109 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17110 {
17111 if (save_css_cnt < 6)
17112 {
17113 css_cnt_r = 1;
17114 }
17115 else if (save_css_cnt == 6)
17116 {
17117 css_cnt_r = 2;
17118 }
17119 else
17120 {
17121 if (opts_type & OPTS_TYPE_PT_UNICODE)
17122 {
17123 if (save_css_cnt == 8 || save_css_cnt == 10)
17124 {
17125 css_cnt_r = 2;
17126 }
17127 else
17128 {
17129 css_cnt_r = 4;
17130 }
17131 }
17132 else
17133 {
17134 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17135 {
17136 css_cnt_r = 3;
17137 }
17138 else
17139 {
17140 css_cnt_r = 4;
17141 }
17142 }
17143 }
17144 }
17145 else
17146 {
17147 css_cnt_r = 1;
17148
17149 /* unfinished code?
17150 int sum = css_buf[css_cnt_r - 1].cs_len;
17151
17152 for (uint i = 1; i < 4 && i < css_cnt; i++)
17153 {
17154 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17155
17156 css_cnt_r++;
17157
17158 sum *= css_buf[css_cnt_r - 1].cs_len;
17159 }
17160 */
17161 }
17162
17163 css_cnt_l -= css_cnt_r;
17164
17165 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17166
17167 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17168 {
17169 hc_device_param_t *device_param = &data.devices_param[device_id];
17170
17171 if (device_param->skipped) continue;
17172
17173 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17174 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17175 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17176
17177 device_param->kernel_params_mp_l_buf64[3] = 0;
17178 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17179 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17180 device_param->kernel_params_mp_l_buf32[6] = 0;
17181 device_param->kernel_params_mp_l_buf32[7] = 0;
17182 device_param->kernel_params_mp_l_buf32[8] = 0;
17183
17184 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17185 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17186 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17187 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17188
17189 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17190 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17191 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17192
17193 device_param->kernel_params_mp_r_buf64[3] = 0;
17194 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17195 device_param->kernel_params_mp_r_buf32[5] = 0;
17196 device_param->kernel_params_mp_r_buf32[6] = 0;
17197 device_param->kernel_params_mp_r_buf32[7] = 0;
17198
17199 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]);
17200 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]);
17201 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]);
17202
17203 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]);
17204 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]);
17205 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]);
17206
17207 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);
17208 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);
17209 }
17210 }
17211
17212 u64 words_base = data.words_cnt;
17213
17214 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17215 {
17216 if (data.kernel_rules_cnt)
17217 {
17218 words_base /= data.kernel_rules_cnt;
17219 }
17220 }
17221 else if (data.attack_kern == ATTACK_KERN_COMBI)
17222 {
17223 if (data.combs_cnt)
17224 {
17225 words_base /= data.combs_cnt;
17226 }
17227 }
17228 else if (data.attack_kern == ATTACK_KERN_BF)
17229 {
17230 if (data.bfs_cnt)
17231 {
17232 words_base /= data.bfs_cnt;
17233 }
17234 }
17235
17236 data.words_base = words_base;
17237
17238 if (keyspace == 1)
17239 {
17240 log_info ("%llu", (unsigned long long int) words_base);
17241
17242 return (0);
17243 }
17244
17245 if (data.words_cur > data.words_base)
17246 {
17247 log_error ("ERROR: restore value greater keyspace");
17248
17249 return (-1);
17250 }
17251
17252 if (data.words_cur)
17253 {
17254 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17255 {
17256 for (uint i = 0; i < data.salts_cnt; i++)
17257 {
17258 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17259 }
17260 }
17261 else if (data.attack_kern == ATTACK_KERN_COMBI)
17262 {
17263 for (uint i = 0; i < data.salts_cnt; i++)
17264 {
17265 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17266 }
17267 }
17268 else if (data.attack_kern == ATTACK_KERN_BF)
17269 {
17270 for (uint i = 0; i < data.salts_cnt; i++)
17271 {
17272 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17273 }
17274 }
17275 }
17276
17277 /*
17278 * Inform user about possible slow speeds
17279 */
17280
17281 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17282 {
17283 if (data.words_base < kernel_power_all)
17284 {
17285 if (quiet == 0)
17286 {
17287 log_info ("ATTENTION!");
17288 log_info (" The wordlist or mask you are using is too small.");
17289 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17290 log_info (" The cracking speed will drop.");
17291 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17292 log_info ("");
17293 }
17294 }
17295 }
17296
17297 /*
17298 * Update loopback file
17299 */
17300
17301 if (loopback == 1)
17302 {
17303 time_t now;
17304
17305 time (&now);
17306
17307 uint random_num = get_random_num (0, 9999);
17308
17309 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17310
17311 data.loopback_file = loopback_file;
17312 }
17313
17314 /*
17315 * Update dictionary statistic
17316 */
17317
17318 if (keyspace == 0)
17319 {
17320 dictstat_fp = fopen (dictstat, "wb");
17321
17322 if (dictstat_fp)
17323 {
17324 lock_file (dictstat_fp);
17325
17326 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17327
17328 fclose (dictstat_fp);
17329 }
17330 }
17331
17332 data.devices_status = STATUS_RUNNING;
17333
17334 if (initial_restore_done == 0)
17335 {
17336 if (data.restore_disable == 0) cycle_restore ();
17337
17338 initial_restore_done = 1;
17339 }
17340
17341 hc_timer_set (&data.timer_running);
17342
17343 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17344 {
17345 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17346 {
17347 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17348 if (quiet == 0) fflush (stdout);
17349 }
17350 }
17351 else if (wordlist_mode == WL_MODE_STDIN)
17352 {
17353 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17354 if (data.quiet == 0) log_info ("");
17355 }
17356
17357 time_t runtime_start;
17358
17359 time (&runtime_start);
17360
17361 data.runtime_start = runtime_start;
17362
17363 /**
17364 * create cracker threads
17365 */
17366
17367 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17368
17369 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17370 {
17371 hc_device_param_t *device_param = &devices_param[device_id];
17372
17373 if (wordlist_mode == WL_MODE_STDIN)
17374 {
17375 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17376 }
17377 else
17378 {
17379 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17380 }
17381 }
17382
17383 // wait for crack threads to exit
17384
17385 hc_thread_wait (data.devices_cnt, c_threads);
17386
17387 local_free (c_threads);
17388
17389 data.restore = 0;
17390
17391 // finalize task
17392
17393 logfile_sub_var_uint ("status-after-work", data.devices_status);
17394
17395 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17396
17397 if (data.devices_status == STATUS_CRACKED) break;
17398 if (data.devices_status == STATUS_ABORTED) break;
17399
17400 if (data.devices_status == STATUS_BYPASS)
17401 {
17402 data.devices_status = STATUS_RUNNING;
17403 }
17404
17405 if (induction_dictionaries_cnt)
17406 {
17407 unlink (induction_dictionaries[0]);
17408 }
17409
17410 free (induction_dictionaries);
17411
17412 if (attack_mode != ATTACK_MODE_BF)
17413 {
17414 induction_dictionaries = scan_directory (induction_directory);
17415
17416 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17417 }
17418
17419 if (benchmark == 0)
17420 {
17421 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17422 {
17423 if (quiet == 0) clear_prompt ();
17424
17425 if (quiet == 0) log_info ("");
17426
17427 if (status == 1)
17428 {
17429 status_display ();
17430 }
17431 else
17432 {
17433 if (quiet == 0) status_display ();
17434 }
17435
17436 if (quiet == 0) log_info ("");
17437 }
17438 }
17439
17440 if (attack_mode == ATTACK_MODE_BF)
17441 {
17442 dictpos++;
17443
17444 rd->dictpos = dictpos;
17445 }
17446 else
17447 {
17448 if (induction_dictionaries_cnt)
17449 {
17450 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17451 }
17452 else
17453 {
17454 dictpos++;
17455
17456 rd->dictpos = dictpos;
17457 }
17458 }
17459
17460 time_t runtime_stop;
17461
17462 time (&runtime_stop);
17463
17464 data.runtime_stop = runtime_stop;
17465
17466 logfile_sub_uint (runtime_start);
17467 logfile_sub_uint (runtime_stop);
17468
17469 logfile_sub_msg ("STOP");
17470
17471 global_free (subid);
17472 }
17473
17474 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17475
17476 if (data.devices_status == STATUS_CRACKED) break;
17477 if (data.devices_status == STATUS_ABORTED) break;
17478 if (data.devices_status == STATUS_QUIT) break;
17479
17480 if (data.devices_status == STATUS_BYPASS)
17481 {
17482 data.devices_status = STATUS_RUNNING;
17483 }
17484 }
17485
17486 // 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
17487
17488 if (attack_mode == ATTACK_MODE_STRAIGHT)
17489 {
17490 if (data.wordlist_mode == WL_MODE_FILE)
17491 {
17492 if (data.dictfile == NULL)
17493 {
17494 if (dictfiles != NULL)
17495 {
17496 data.dictfile = dictfiles[0];
17497
17498 hc_timer_set (&data.timer_running);
17499 }
17500 }
17501 }
17502 }
17503 // NOTE: combi is okay because it is already set beforehand
17504 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17505 {
17506 if (data.dictfile == NULL)
17507 {
17508 if (dictfiles != NULL)
17509 {
17510 hc_timer_set (&data.timer_running);
17511
17512 data.dictfile = dictfiles[0];
17513 }
17514 }
17515 }
17516 else if (attack_mode == ATTACK_MODE_BF)
17517 {
17518 if (data.mask == NULL)
17519 {
17520 hc_timer_set (&data.timer_running);
17521
17522 data.mask = masks[0];
17523 }
17524 }
17525
17526 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17527 {
17528 data.devices_status = STATUS_EXHAUSTED;
17529 }
17530
17531 // if cracked / aborted remove last induction dictionary
17532
17533 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17534 {
17535 struct stat induct_stat;
17536
17537 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17538 {
17539 unlink (induction_dictionaries[file_pos]);
17540 }
17541 }
17542
17543 // wait for non-interactive threads
17544
17545 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17546 {
17547 hc_thread_wait (1, &ni_threads[thread_idx]);
17548 }
17549
17550 local_free (ni_threads);
17551
17552 // wait for interactive threads
17553
17554 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17555 {
17556 hc_thread_wait (1, &i_thread);
17557 }
17558
17559 // we dont need restore file anymore
17560 if (data.restore_disable == 0)
17561 {
17562 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17563 {
17564 unlink (eff_restore_file);
17565 unlink (new_restore_file);
17566 }
17567 else
17568 {
17569 cycle_restore ();
17570 }
17571 }
17572
17573 // finally save left hashes
17574
17575 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17576 {
17577 save_hash ();
17578 }
17579
17580 /**
17581 * Clean up
17582 */
17583
17584 if (benchmark == 1)
17585 {
17586 status_benchmark ();
17587
17588 if (status_automat == 0)
17589 {
17590 log_info ("");
17591 }
17592 }
17593 else
17594 {
17595 if (quiet == 0) clear_prompt ();
17596
17597 if (quiet == 0) log_info ("");
17598
17599 if (status == 1)
17600 {
17601 status_display ();
17602 }
17603 else
17604 {
17605 if (quiet == 0) status_display ();
17606 }
17607
17608 if (quiet == 0) log_info ("");
17609 }
17610
17611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17612 {
17613 hc_device_param_t *device_param = &data.devices_param[device_id];
17614
17615 if (device_param->skipped) continue;
17616
17617 local_free (device_param->combs_buf);
17618
17619 local_free (device_param->hooks_buf);
17620
17621 local_free (device_param->device_name);
17622
17623 local_free (device_param->device_name_chksum);
17624
17625 local_free (device_param->device_version);
17626
17627 local_free (device_param->driver_version);
17628
17629 if (device_param->pws_buf) myfree (device_param->pws_buf);
17630 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17631 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17632 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17633 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17634 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17635 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17636 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17637 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17638 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17639 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17640 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17641 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17642 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17643 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17644 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17645 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17646 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17647 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17648 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17649 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17650 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17651 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17652 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17653 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17654 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17655 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17656 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17657 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17658
17659 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17660 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17661 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17662 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17663 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17664 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17665 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17666 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17667 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17668 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17669
17670 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17671 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17672 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17673
17674 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17675 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17676 }
17677
17678 // reset default fan speed
17679
17680 #ifdef HAVE_HWMON
17681 if (gpu_temp_disable == 0)
17682 {
17683 #ifdef HAVE_ADL
17684 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17685 {
17686 hc_thread_mutex_lock (mux_adl);
17687
17688 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17689 {
17690 hc_device_param_t *device_param = &data.devices_param[device_id];
17691
17692 if (device_param->skipped) continue;
17693
17694 if (data.hm_device[device_id].fan_supported == 1)
17695 {
17696 int fanspeed = temp_retain_fanspeed_value[device_id];
17697
17698 if (fanspeed == -1) continue;
17699
17700 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17701
17702 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17703 }
17704 }
17705
17706 hc_thread_mutex_unlock (mux_adl);
17707 }
17708 #endif // HAVE_ADL
17709 }
17710
17711 #ifdef HAVE_ADL
17712 // reset power tuning
17713
17714 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17715 {
17716 hc_thread_mutex_lock (mux_adl);
17717
17718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17719 {
17720 hc_device_param_t *device_param = &data.devices_param[device_id];
17721
17722 if (device_param->skipped) continue;
17723
17724 if (data.hm_device[device_id].od_version == 6)
17725 {
17726 // check powertune capabilities first, if not available then skip device
17727
17728 int powertune_supported = 0;
17729
17730 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17731 {
17732 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17733
17734 return (-1);
17735 }
17736
17737 if (powertune_supported != 0)
17738 {
17739 // powercontrol settings
17740
17741 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)
17742 {
17743 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17744
17745 return (-1);
17746 }
17747
17748 // clocks
17749
17750 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17751
17752 performance_state->iNumberOfPerformanceLevels = 2;
17753
17754 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17755 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17756 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17757 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17758
17759 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)
17760 {
17761 log_info ("ERROR: Failed to restore ADL performance state");
17762
17763 return (-1);
17764 }
17765
17766 local_free (performance_state);
17767 }
17768 }
17769 }
17770
17771 hc_thread_mutex_unlock (mux_adl);
17772 }
17773 #endif // HAVE_ADL
17774
17775 if (gpu_temp_disable == 0)
17776 {
17777 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17778 if (data.hm_nv)
17779 {
17780 #if defined(LINUX) && defined(HAVE_NVML)
17781
17782 hm_NVML_nvmlShutdown (data.hm_nv);
17783
17784 nvml_close (data.hm_nv);
17785
17786 #elif defined(WIN) && (HAVE_NVAPI)
17787
17788 hm_NvAPI_Unload (data.hm_nv);
17789
17790 nvapi_close (data.hm_nv);
17791
17792 #endif
17793
17794 data.hm_nv = NULL;
17795 }
17796 #endif
17797
17798 #ifdef HAVE_ADL
17799 if (data.hm_amd)
17800 {
17801 hm_ADL_Main_Control_Destroy (data.hm_amd);
17802
17803 adl_close (data.hm_amd);
17804 data.hm_amd = NULL;
17805 }
17806 #endif
17807 }
17808 #endif // HAVE_HWMON
17809
17810 // free memory
17811
17812 local_free (masks);
17813
17814 local_free (dictstat_base);
17815
17816 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17817 {
17818 pot_t *pot_ptr = &pot[pot_pos];
17819
17820 hash_t *hash = &pot_ptr->hash;
17821
17822 local_free (hash->digest);
17823
17824 if (isSalted)
17825 {
17826 local_free (hash->salt);
17827 }
17828 }
17829
17830 local_free (pot);
17831
17832 local_free (all_kernel_rules_cnt);
17833 local_free (all_kernel_rules_buf);
17834
17835 local_free (wl_data->buf);
17836 local_free (wl_data);
17837
17838 local_free (bitmap_s1_a);
17839 local_free (bitmap_s1_b);
17840 local_free (bitmap_s1_c);
17841 local_free (bitmap_s1_d);
17842 local_free (bitmap_s2_a);
17843 local_free (bitmap_s2_b);
17844 local_free (bitmap_s2_c);
17845 local_free (bitmap_s2_d);
17846
17847 #ifdef HAVE_HWMON
17848 local_free (temp_retain_fanspeed_value);
17849 #ifdef HAVE_ADL
17850 local_free (od_clock_mem_status);
17851 local_free (od_power_control_status);
17852 #endif // ADL
17853 #endif
17854
17855 global_free (devices_param);
17856
17857 global_free (kernel_rules_buf);
17858
17859 global_free (root_css_buf);
17860 global_free (markov_css_buf);
17861
17862 global_free (digests_buf);
17863 global_free (digests_shown);
17864 global_free (digests_shown_tmp);
17865
17866 global_free (salts_buf);
17867 global_free (salts_shown);
17868
17869 global_free (esalts_buf);
17870
17871 global_free (words_progress_done);
17872 global_free (words_progress_rejected);
17873 global_free (words_progress_restored);
17874
17875 if (pot_fp) fclose (pot_fp);
17876
17877 if (data.devices_status == STATUS_QUIT) break;
17878 }
17879
17880 // destroy others mutex
17881
17882 hc_thread_mutex_delete (mux_dispatcher);
17883 hc_thread_mutex_delete (mux_counter);
17884 hc_thread_mutex_delete (mux_display);
17885 hc_thread_mutex_delete (mux_adl);
17886
17887 // free memory
17888
17889 local_free (eff_restore_file);
17890 local_free (new_restore_file);
17891
17892 local_free (rd);
17893
17894 // tuning db
17895
17896 tuning_db_destroy (tuning_db);
17897
17898 // loopback
17899
17900 local_free (loopback_file);
17901
17902 if (loopback == 1) unlink (loopback_file);
17903
17904 // induction directory
17905
17906 if (induction_dir == NULL)
17907 {
17908 if (attack_mode != ATTACK_MODE_BF)
17909 {
17910 if (rmdir (induction_directory) == -1)
17911 {
17912 if (errno == ENOENT)
17913 {
17914 // good, we can ignore
17915 }
17916 else if (errno == ENOTEMPTY)
17917 {
17918 // good, we can ignore
17919 }
17920 else
17921 {
17922 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17923
17924 return (-1);
17925 }
17926 }
17927
17928 local_free (induction_directory);
17929 }
17930 }
17931
17932 // outfile-check directory
17933
17934 if (outfile_check_dir == NULL)
17935 {
17936 if (rmdir (outfile_check_directory) == -1)
17937 {
17938 if (errno == ENOENT)
17939 {
17940 // good, we can ignore
17941 }
17942 else if (errno == ENOTEMPTY)
17943 {
17944 // good, we can ignore
17945 }
17946 else
17947 {
17948 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17949
17950 return (-1);
17951 }
17952 }
17953
17954 local_free (outfile_check_directory);
17955 }
17956
17957 time_t proc_stop;
17958
17959 time (&proc_stop);
17960
17961 logfile_top_uint (proc_start);
17962 logfile_top_uint (proc_stop);
17963
17964 logfile_top_msg ("STOP");
17965
17966 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17967 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17968
17969 if (data.ocl) ocl_close (data.ocl);
17970
17971 if (data.devices_status == STATUS_ABORTED) return 2;
17972 if (data.devices_status == STATUS_QUIT) return 2;
17973 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17974 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17975 if (data.devices_status == STATUS_CRACKED) return 0;
17976
17977 return -1;
17978 }
Hashcat additions to support pwdhash