projects / hashcat.git / blob
? search:


417b60d0ae992edb2d9f4232a3d36f6abce66440
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2613 {
2614 int rc = -1;
2615
2616 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2617 {
2618 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2619
2620 const cl_uchar zero = 0;
2621
2622 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2623 }
2624
2625 if (rc != 0)
2626 {
2627 // NOTE: clEnqueueFillBuffer () always fails with -59
2628 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2629 // How's that possible, OpenCL 1.2 support is advertised??
2630 // We need to workaround...
2631
2632 #define FILLSZ 0x100000
2633
2634 char *tmp = (char *) mymalloc (FILLSZ);
2635
2636 for (size_t i = 0; i < size; i += FILLSZ)
2637 {
2638 const size_t left = size - i;
2639
2640 const size_t fillsz = MIN (FILLSZ, left);
2641
2642 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2643 }
2644
2645 myfree (tmp);
2646 }
2647 }
2648
2649 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2650 {
2651 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2652 {
2653 if (attack_mode == ATTACK_MODE_BF)
2654 {
2655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2656 {
2657 const uint size_tm = 32 * sizeof (bs_word_t);
2658
2659 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2660
2661 run_kernel_tm (device_param);
2662
2663 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2664 }
2665 }
2666
2667 if (highest_pw_len < 16)
2668 {
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2670 }
2671 else if (highest_pw_len < 32)
2672 {
2673 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2674 }
2675 else
2676 {
2677 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2678 }
2679 }
2680 else
2681 {
2682 run_kernel_amp (device_param, pws_cnt);
2683
2684 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2685
2686 if (opts_type & OPTS_TYPE_HOOK12)
2687 {
2688 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2689 }
2690
2691 uint iter = salt_buf->salt_iter;
2692
2693 uint loop_step = device_param->kernel_loops;
2694
2695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2696 {
2697 uint loop_left = iter - loop_pos;
2698
2699 loop_left = MIN (loop_left, loop_step);
2700
2701 device_param->kernel_params_buf32[25] = loop_pos;
2702 device_param->kernel_params_buf32[26] = loop_left;
2703
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705
2706 if (data.devices_status == STATUS_CRACKED) break;
2707 if (data.devices_status == STATUS_ABORTED) break;
2708 if (data.devices_status == STATUS_QUIT) break;
2709
2710 /**
2711 * speed
2712 */
2713
2714 const float iter_part = (float) (loop_pos + loop_left) / iter;
2715
2716 const u64 perf_sum_all = pws_cnt * iter_part;
2717
2718 double speed_ms;
2719
2720 hc_timer_get (device_param->timer_speed, speed_ms);
2721
2722 const u32 speed_pos = device_param->speed_pos;
2723
2724 device_param->speed_cnt[speed_pos] = perf_sum_all;
2725
2726 device_param->speed_ms[speed_pos] = speed_ms;
2727
2728 if (data.benchmark == 1)
2729 {
2730 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2731 }
2732 }
2733
2734 if (opts_type & OPTS_TYPE_HOOK23)
2735 {
2736 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2737
2738 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2739
2740 // do something with data
2741
2742 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2743 }
2744
2745 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2746 }
2747 }
2748
2749 static int run_rule_engine (const int rule_len, const char *rule_buf)
2750 {
2751 if (rule_len == 0)
2752 {
2753 return 0;
2754 }
2755 else if (rule_len == 1)
2756 {
2757 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2758 }
2759
2760 return 1;
2761 }
2762
2763 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2764 {
2765 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2766 {
2767 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_COMBI)
2770 {
2771 if (data.attack_mode == ATTACK_MODE_COMBI)
2772 {
2773 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2774 {
2775 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2776 {
2777 for (u32 i = 0; i < pws_cnt; i++)
2778 {
2779 const u32 pw_len = device_param->pws_buf[i].pw_len;
2780
2781 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2782
2783 ptr[pw_len] = 0x01;
2784 }
2785 }
2786 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2787 {
2788 for (u32 i = 0; i < pws_cnt; i++)
2789 {
2790 const u32 pw_len = device_param->pws_buf[i].pw_len;
2791
2792 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2793
2794 ptr[pw_len] = 0x80;
2795 }
2796 }
2797 }
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x01;
2810 }
2811 }
2812 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x80;
2821 }
2822 }
2823 }
2824
2825 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2826 }
2827 else if (data.attack_kern == ATTACK_KERN_BF)
2828 {
2829 const u64 off = device_param->words_off;
2830
2831 device_param->kernel_params_mp_l_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2834 }
2835 }
2836
2837 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2838 {
2839 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2840
2841 device_param->kernel_params_buf32[25] = 0;
2842 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2843 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2844
2845 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2846 {
2847 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2848 }
2849 else
2850 {
2851 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2852 }
2853
2854 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2855
2856 return exec_ms_prev;
2857 }
2858
2859 static void autotune (hc_device_param_t *device_param)
2860 {
2861 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2862
2863 const u32 kernel_accel_min = device_param->kernel_accel_min;
2864 const u32 kernel_accel_max = device_param->kernel_accel_max;
2865
2866 const u32 kernel_loops_min = device_param->kernel_loops_min;
2867 const u32 kernel_loops_max = device_param->kernel_loops_max;
2868
2869 u32 kernel_accel = kernel_accel_min;
2870 u32 kernel_loops = kernel_loops_min;
2871
2872 // in this case the user specified a fixed -u and -n on the commandline
2873 // no way to tune anything
2874 // but we need to run a few caching rounds
2875
2876 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2877 {
2878 try_run (device_param, kernel_accel, kernel_loops);
2879 try_run (device_param, kernel_accel, kernel_loops);
2880 try_run (device_param, kernel_accel, kernel_loops);
2881 try_run (device_param, kernel_accel, kernel_loops);
2882
2883 device_param->kernel_accel = kernel_accel;
2884 device_param->kernel_loops = kernel_loops;
2885
2886 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2887
2888 device_param->kernel_power = kernel_power;
2889
2890 return;
2891 }
2892
2893 // from here it's clear we are allowed to autotune
2894 // so let's init some fake words
2895
2896 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].i[0] = i;
2901 device_param->pws_buf[i].i[1] = 0x01234567;
2902 device_param->pws_buf[i].pw_len = 7;
2903 }
2904
2905 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2906
2907 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2908 {
2909 run_kernel_amp (device_param, kernel_power_max);
2910 }
2911
2912 #define VERIFIER_CNT 1
2913
2914 // first find out highest kernel-loops that stays below target_ms
2915
2916 if (kernel_loops_min < kernel_loops_max)
2917 {
2918 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2919 {
2920 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2921
2922 for (int i = 0; i < VERIFIER_CNT; i++)
2923 {
2924 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2925
2926 exec_ms = MIN (exec_ms, exec_ms_v);
2927 }
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931 }
2932
2933 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2934
2935 #define STEPS_CNT 10
2936
2937 if (kernel_accel_min < kernel_accel_max)
2938 {
2939 for (int i = 0; i < STEPS_CNT; i++)
2940 {
2941 const u32 kernel_accel_try = 1 << i;
2942
2943 if (kernel_accel_try < kernel_accel_min) continue;
2944 if (kernel_accel_try > kernel_accel_max) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms > target_ms) break;
2956
2957 kernel_accel = kernel_accel_try;
2958 }
2959 }
2960
2961 // at this point we want to know the actual runtime for the following reason:
2962 // we need a reference for the balancing loop following up, and this
2963 // the balancing loop can have an effect that the creates a new opportunity, for example:
2964 // if the target is 95 ms and the current runtime is 48ms the above loop
2965 // stopped the execution because the previous exec_ms was > 95ms
2966 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2967 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2968
2969 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2970
2971 for (int i = 0; i < VERIFIER_CNT; i++)
2972 {
2973 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2974
2975 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2976 }
2977
2978 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2979 {
2980 for (u32 f = 2; f < 1024; f++)
2981 {
2982 const u32 kernel_accel_try = kernel_accel * f;
2983 const u32 kernel_loops_try = kernel_loops / f;
2984
2985 if (kernel_accel_try > kernel_accel_max) break;
2986 if (kernel_loops_try < kernel_loops_min) break;
2987
2988 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2989
2990 for (int i = 0; i < VERIFIER_CNT; i++)
2991 {
2992 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2993
2994 exec_ms = MIN (exec_ms, exec_ms_v);
2995 }
2996
2997 if (exec_ms < exec_ms_pre_final)
2998 {
2999 exec_ms_pre_final = exec_ms;
3000
3001 kernel_accel = kernel_accel_try;
3002 kernel_loops = kernel_loops_try;
3003 }
3004 }
3005 }
3006
3007 const double exec_left = target_ms / exec_ms_pre_final;
3008
3009 const double accel_left = kernel_accel_max / kernel_accel;
3010
3011 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3012
3013 if (exec_accel_min >= 1.0)
3014 {
3015 // this is safe to not overflow kernel_accel_max because of accel_left
3016
3017 kernel_accel = (double) kernel_accel * exec_accel_min;
3018 }
3019
3020 // reset them fake words
3021
3022 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3023
3024 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);
3025 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);
3026
3027 // reset timer
3028
3029 device_param->exec_pos = 0;
3030
3031 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3032
3033 // store
3034
3035 device_param->kernel_accel = kernel_accel;
3036 device_param->kernel_loops = kernel_loops;
3037
3038 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3039
3040 device_param->kernel_power = kernel_power;
3041
3042 #ifdef DEBUG
3043
3044 if (data.quiet == 0)
3045 {
3046 clear_prompt ();
3047
3048 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3049 "Device #%u: autotuned kernel-loops to %u\n",
3050 device_param->device_id + 1, kernel_accel,
3051 device_param->device_id + 1, kernel_loops);
3052
3053 fprintf (stdout, "%s", PROMPT);
3054
3055 fflush (stdout);
3056 }
3057
3058 #endif
3059 }
3060
3061 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3062 {
3063 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3064
3065 // init speed timer
3066
3067 uint speed_pos = device_param->speed_pos;
3068
3069 #ifdef _POSIX
3070 if (device_param->timer_speed.tv_sec == 0)
3071 {
3072 hc_timer_set (&device_param->timer_speed);
3073 }
3074 #endif
3075
3076 #ifdef _WIN
3077 if (device_param->timer_speed.QuadPart == 0)
3078 {
3079 hc_timer_set (&device_param->timer_speed);
3080 }
3081 #endif
3082
3083 // find higest password length, this is for optimization stuff
3084
3085 uint highest_pw_len = 0;
3086
3087 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3088 {
3089 }
3090 else if (data.attack_kern == ATTACK_KERN_COMBI)
3091 {
3092 }
3093 else if (data.attack_kern == ATTACK_KERN_BF)
3094 {
3095 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3096 + device_param->kernel_params_mp_l_buf32[5];
3097 }
3098
3099 // iteration type
3100
3101 uint innerloop_step = 0;
3102 uint innerloop_cnt = 0;
3103
3104 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3105 else innerloop_step = 1;
3106
3107 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3109 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3110
3111 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3112
3113 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3114 {
3115 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3116
3117 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3118
3119 if (data.devices_status == STATUS_CRACKED) break;
3120 if (data.devices_status == STATUS_ABORTED) break;
3121 if (data.devices_status == STATUS_QUIT) break;
3122 if (data.devices_status == STATUS_BYPASS) break;
3123
3124 salt_t *salt_buf = &data.salts_buf[salt_pos];
3125
3126 device_param->kernel_params_buf32[24] = salt_pos;
3127 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3128 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3129
3130 FILE *combs_fp = device_param->combs_fp;
3131
3132 if (data.attack_mode == ATTACK_MODE_COMBI)
3133 {
3134 rewind (combs_fp);
3135 }
3136
3137 // innerloops
3138
3139 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3140 {
3141 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3142
3143 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3144
3145 if (data.devices_status == STATUS_CRACKED) break;
3146 if (data.devices_status == STATUS_ABORTED) break;
3147 if (data.devices_status == STATUS_QUIT) break;
3148 if (data.devices_status == STATUS_BYPASS) break;
3149
3150 uint innerloop_left = innerloop_cnt - innerloop_pos;
3151
3152 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3153
3154 device_param->innerloop_pos = innerloop_pos;
3155 device_param->innerloop_left = innerloop_left;
3156
3157 device_param->kernel_params_buf32[27] = innerloop_left;
3158
3159 // i think we can get rid of this
3160 if (innerloop_left == 0)
3161 {
3162 puts ("bug, how should this happen????\n");
3163
3164 continue;
3165 }
3166
3167 if (data.salts_shown[salt_pos] == 1)
3168 {
3169 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3170
3171 continue;
3172 }
3173
3174 // initialize amplifiers
3175
3176 if (data.attack_mode == ATTACK_MODE_COMBI)
3177 {
3178 uint i = 0;
3179
3180 while (i < innerloop_left)
3181 {
3182 if (feof (combs_fp)) break;
3183
3184 int line_len = fgetl (combs_fp, line_buf);
3185
3186 if (line_len >= PW_MAX1) continue;
3187
3188 line_len = convert_from_hex (line_buf, line_len);
3189
3190 char *line_buf_new = line_buf;
3191
3192 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3193 {
3194 char rule_buf_out[BLOCK_SIZE] = { 0 };
3195
3196 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3197
3198 if (rule_len_out < 0)
3199 {
3200 data.words_progress_rejected[salt_pos] += pws_cnt;
3201
3202 continue;
3203 }
3204
3205 line_len = rule_len_out;
3206
3207 line_buf_new = rule_buf_out;
3208 }
3209
3210 line_len = MIN (line_len, PW_DICTMAX);
3211
3212 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3213
3214 memcpy (ptr, line_buf_new, line_len);
3215
3216 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3217
3218 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3219 {
3220 uppercase (ptr, line_len);
3221 }
3222
3223 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3224 {
3225 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3226 {
3227 ptr[line_len] = 0x80;
3228 }
3229
3230 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3231 {
3232 ptr[line_len] = 0x01;
3233 }
3234 }
3235
3236 device_param->combs_buf[i].pw_len = line_len;
3237
3238 i++;
3239 }
3240
3241 for (uint j = i; j < innerloop_left; j++)
3242 {
3243 device_param->combs_buf[j].i[0] = 0;
3244 device_param->combs_buf[j].i[1] = 0;
3245 device_param->combs_buf[j].i[2] = 0;
3246 device_param->combs_buf[j].i[3] = 0;
3247 device_param->combs_buf[j].i[4] = 0;
3248 device_param->combs_buf[j].i[5] = 0;
3249 device_param->combs_buf[j].i[6] = 0;
3250 device_param->combs_buf[j].i[7] = 0;
3251
3252 device_param->combs_buf[j].pw_len = 0;
3253 }
3254
3255 innerloop_left = i;
3256 }
3257 else if (data.attack_mode == ATTACK_MODE_BF)
3258 {
3259 u64 off = innerloop_pos;
3260
3261 device_param->kernel_params_mp_r_buf64[3] = off;
3262
3263 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3264 }
3265 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3266 {
3267 u64 off = innerloop_pos;
3268
3269 device_param->kernel_params_mp_buf64[3] = off;
3270
3271 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3272 }
3273 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3274 {
3275 u64 off = innerloop_pos;
3276
3277 device_param->kernel_params_mp_buf64[3] = off;
3278
3279 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3280 }
3281
3282 // copy amplifiers
3283
3284 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3285 {
3286 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_COMBI)
3289 {
3290 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);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_BF)
3293 {
3294 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);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3297 {
3298 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);
3299 }
3300 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3301 {
3302 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);
3303 }
3304
3305 if (data.benchmark == 1)
3306 {
3307 hc_timer_set (&device_param->timer_speed);
3308 }
3309
3310 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3311
3312 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3313
3314 if (data.devices_status == STATUS_CRACKED) break;
3315 if (data.devices_status == STATUS_ABORTED) break;
3316 if (data.devices_status == STATUS_QUIT) break;
3317
3318 /**
3319 * result
3320 */
3321
3322 check_cracked (device_param, salt_pos);
3323
3324 /**
3325 * progress
3326 */
3327
3328 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3329
3330 hc_thread_mutex_lock (mux_counter);
3331
3332 data.words_progress_done[salt_pos] += perf_sum_all;
3333
3334 hc_thread_mutex_unlock (mux_counter);
3335
3336 /**
3337 * speed
3338 */
3339
3340 double speed_ms;
3341
3342 hc_timer_get (device_param->timer_speed, speed_ms);
3343
3344 hc_timer_set (&device_param->timer_speed);
3345
3346 // current speed
3347
3348 //hc_thread_mutex_lock (mux_display);
3349
3350 device_param->speed_cnt[speed_pos] = perf_sum_all;
3351
3352 device_param->speed_ms[speed_pos] = speed_ms;
3353
3354 //hc_thread_mutex_unlock (mux_display);
3355
3356 speed_pos++;
3357
3358 if (speed_pos == SPEED_CACHE)
3359 {
3360 speed_pos = 0;
3361 }
3362
3363 /**
3364 * benchmark
3365 */
3366
3367 if (data.benchmark == 1) break;
3368 }
3369 }
3370
3371 device_param->speed_pos = speed_pos;
3372
3373 myfree (line_buf);
3374 }
3375
3376 static void load_segment (wl_data_t *wl_data, FILE *fd)
3377 {
3378 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3379
3380 wl_data->pos = 0;
3381
3382 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3383
3384 wl_data->buf[wl_data->cnt] = 0;
3385
3386 if (wl_data->cnt == 0) return;
3387
3388 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3389
3390 while (!feof (fd))
3391 {
3392 if (wl_data->cnt == wl_data->avail)
3393 {
3394 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3395
3396 wl_data->avail += wl_data->incr;
3397 }
3398
3399 const int c = fgetc (fd);
3400
3401 if (c == EOF) break;
3402
3403 wl_data->buf[wl_data->cnt] = (char) c;
3404
3405 wl_data->cnt++;
3406
3407 if (c == '\n') break;
3408 }
3409
3410 // ensure stream ends with a newline
3411
3412 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3413 {
3414 wl_data->cnt++;
3415
3416 wl_data->buf[wl_data->cnt - 1] = '\n';
3417 }
3418
3419 return;
3420 }
3421
3422 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3423 {
3424 char *ptr = buf;
3425
3426 for (u32 i = 0; i < sz; i++, ptr++)
3427 {
3428 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3429
3430 if (i == 7)
3431 {
3432 *off = i;
3433 *len = i;
3434
3435 return;
3436 }
3437
3438 if (*ptr != '\n') continue;
3439
3440 *off = i + 1;
3441
3442 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3443
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 *off = sz;
3450 *len = sz;
3451 }
3452
3453 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3454 {
3455 char *ptr = buf;
3456
3457 for (u32 i = 0; i < sz; i++, ptr++)
3458 {
3459 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3460
3461 if (*ptr != '\n') continue;
3462
3463 *off = i + 1;
3464
3465 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3466
3467 *len = i;
3468
3469 return;
3470 }
3471
3472 *off = sz;
3473 *len = sz;
3474 }
3475
3476 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3477 {
3478 char *ptr = buf;
3479
3480 for (u32 i = 0; i < sz; i++, ptr++)
3481 {
3482 if (*ptr != '\n') continue;
3483
3484 *off = i + 1;
3485
3486 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3487
3488 *len = i;
3489
3490 return;
3491 }
3492
3493 *off = sz;
3494 *len = sz;
3495 }
3496
3497 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3498 {
3499 while (wl_data->pos < wl_data->cnt)
3500 {
3501 uint off;
3502 uint len;
3503
3504 char *ptr = wl_data->buf + wl_data->pos;
3505
3506 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3507
3508 wl_data->pos += off;
3509
3510 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3511 {
3512 char rule_buf_out[BLOCK_SIZE] = { 0 };
3513
3514 int rule_len_out = -1;
3515
3516 if (len < BLOCK_SIZE)
3517 {
3518 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3519 }
3520
3521 if (rule_len_out < 0)
3522 {
3523 continue;
3524 }
3525
3526 if (rule_len_out > PW_MAX)
3527 {
3528 continue;
3529 }
3530 }
3531 else
3532 {
3533 if (len > PW_MAX)
3534 {
3535 continue;
3536 }
3537 }
3538
3539 *out_buf = ptr;
3540 *out_len = len;
3541
3542 return;
3543 }
3544
3545 if (feof (fd))
3546 {
3547 fprintf (stderr, "BUG feof()!!\n");
3548
3549 return;
3550 }
3551
3552 load_segment (wl_data, fd);
3553
3554 get_next_word (wl_data, fd, out_buf, out_len);
3555 }
3556
3557 #ifdef _POSIX
3558 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3559 #endif
3560
3561 #ifdef _WIN
3562 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3563 #endif
3564 {
3565 hc_signal (NULL);
3566
3567 dictstat_t d;
3568
3569 d.cnt = 0;
3570
3571 #ifdef _POSIX
3572 fstat (fileno (fd), &d.stat);
3573 #endif
3574
3575 #ifdef _WIN
3576 _fstat64 (fileno (fd), &d.stat);
3577 #endif
3578
3579 d.stat.st_mode = 0;
3580 d.stat.st_nlink = 0;
3581 d.stat.st_uid = 0;
3582 d.stat.st_gid = 0;
3583 d.stat.st_rdev = 0;
3584 d.stat.st_atime = 0;
3585
3586 #ifdef _POSIX
3587 d.stat.st_blksize = 0;
3588 d.stat.st_blocks = 0;
3589 #endif
3590
3591 if (d.stat.st_size == 0) return 0;
3592
3593 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3594
3595 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3596 {
3597 if (d_cache)
3598 {
3599 u64 cnt = d_cache->cnt;
3600
3601 u64 keyspace = cnt;
3602
3603 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3604 {
3605 keyspace *= data.kernel_rules_cnt;
3606 }
3607 else if (data.attack_kern == ATTACK_KERN_COMBI)
3608 {
3609 keyspace *= data.combs_cnt;
3610 }
3611
3612 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);
3613 if (data.quiet == 0) log_info ("");
3614
3615 hc_signal (sigHandler_default);
3616
3617 return (keyspace);
3618 }
3619 }
3620
3621 time_t now = 0;
3622 time_t prev = 0;
3623
3624 u64 comp = 0;
3625 u64 cnt = 0;
3626 u64 cnt2 = 0;
3627
3628 while (!feof (fd))
3629 {
3630 load_segment (wl_data, fd);
3631
3632 comp += wl_data->cnt;
3633
3634 u32 i = 0;
3635
3636 while (i < wl_data->cnt)
3637 {
3638 u32 len;
3639 u32 off;
3640
3641 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3642
3643 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3644 {
3645 char rule_buf_out[BLOCK_SIZE] = { 0 };
3646
3647 int rule_len_out = -1;
3648
3649 if (len < BLOCK_SIZE)
3650 {
3651 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3652 }
3653
3654 if (rule_len_out < 0)
3655 {
3656 len = PW_MAX1;
3657 }
3658 else
3659 {
3660 len = rule_len_out;
3661 }
3662 }
3663
3664 if (len < PW_MAX1)
3665 {
3666 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3667 {
3668 cnt += data.kernel_rules_cnt;
3669 }
3670 else if (data.attack_kern == ATTACK_KERN_COMBI)
3671 {
3672 cnt += data.combs_cnt;
3673 }
3674
3675 d.cnt++;
3676 }
3677
3678 i += off;
3679
3680 cnt2++;
3681 }
3682
3683 time (&now);
3684
3685 if ((now - prev) == 0) continue;
3686
3687 float percent = (float) comp / (float) d.stat.st_size;
3688
3689 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);
3690
3691 time (&prev);
3692 }
3693
3694 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);
3695 if (data.quiet == 0) log_info ("");
3696
3697 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3698
3699 hc_signal (sigHandler_default);
3700
3701 return (cnt);
3702 }
3703
3704 static void *thread_monitor (void *p)
3705 {
3706 uint runtime_check = 0;
3707 uint remove_check = 0;
3708 uint status_check = 0;
3709 uint restore_check = 0;
3710
3711 uint restore_left = data.restore_timer;
3712 uint remove_left = data.remove_timer;
3713 uint status_left = data.status_timer;
3714
3715 #ifdef HAVE_HWMON
3716 uint hwmon_check = 0;
3717
3718 // these variables are mainly used for fan control (AMD only)
3719
3720 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3721
3722 // temperature controller "loopback" values
3723
3724 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3725 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3726
3727 #ifdef HAVE_ADL
3728 int temp_threshold = 1; // degrees celcius
3729
3730 int fan_speed_min = 15; // in percentage
3731 int fan_speed_max = 100;
3732 #endif // HAVE_ADL
3733
3734 time_t last_temp_check_time;
3735 #endif // HAVE_HWMON
3736
3737 uint sleep_time = 1;
3738
3739 if (data.runtime)
3740 {
3741 runtime_check = 1;
3742 }
3743
3744 if (data.restore_timer)
3745 {
3746 restore_check = 1;
3747 }
3748
3749 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3750 {
3751 remove_check = 1;
3752 }
3753
3754 if (data.status == 1)
3755 {
3756 status_check = 1;
3757 }
3758
3759 #ifdef HAVE_HWMON
3760 if (data.gpu_temp_disable == 0)
3761 {
3762 time (&last_temp_check_time);
3763
3764 hwmon_check = 1;
3765 }
3766 #endif
3767
3768 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3769 {
3770 #ifdef HAVE_HWMON
3771 if (hwmon_check == 0)
3772 #endif
3773 return (p);
3774 }
3775
3776 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3777 {
3778 hc_sleep (sleep_time);
3779
3780 if (data.devices_status != STATUS_RUNNING) continue;
3781
3782 #ifdef HAVE_HWMON
3783 if (hwmon_check == 1)
3784 {
3785 hc_thread_mutex_lock (mux_adl);
3786
3787 time_t temp_check_time;
3788
3789 time (&temp_check_time);
3790
3791 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3792
3793 if (Ta == 0) Ta = 1;
3794
3795 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3796 {
3797 hc_device_param_t *device_param = &data.devices_param[device_id];
3798
3799 if (device_param->skipped) continue;
3800
3801 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3802
3803 const int temperature = hm_get_temperature_with_device_id (device_id);
3804
3805 if (temperature > (int) data.gpu_temp_abort)
3806 {
3807 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3808
3809 if (data.devices_status != STATUS_QUIT) myabort ();
3810
3811 break;
3812 }
3813
3814 #ifdef HAVE_ADL
3815 const int gpu_temp_retain = data.gpu_temp_retain;
3816
3817 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3818 {
3819 if (data.hm_device[device_id].fan_supported == 1)
3820 {
3821 int temp_cur = temperature;
3822
3823 int temp_diff_new = gpu_temp_retain - temp_cur;
3824
3825 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3826
3827 // calculate Ta value (time difference in seconds between the last check and this check)
3828
3829 last_temp_check_time = temp_check_time;
3830
3831 float Kp = 1.8;
3832 float Ki = 0.005;
3833 float Kd = 6;
3834
3835 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3836
3837 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);
3838
3839 if (abs (fan_diff_required) >= temp_threshold)
3840 {
3841 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3842
3843 int fan_speed_level = fan_speed_cur;
3844
3845 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3846
3847 int fan_speed_new = fan_speed_level - fan_diff_required;
3848
3849 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3850 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3851
3852 if (fan_speed_new != fan_speed_cur)
3853 {
3854 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3855 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3856
3857 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3858 {
3859 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3860
3861 fan_speed_chgd[device_id] = 1;
3862 }
3863
3864 temp_diff_old[device_id] = temp_diff_new;
3865 }
3866 }
3867 }
3868 }
3869 #endif // HAVE_ADL
3870 }
3871
3872 hc_thread_mutex_unlock (mux_adl);
3873 }
3874 #endif // HAVE_HWMON
3875
3876 if (restore_check == 1)
3877 {
3878 restore_left--;
3879
3880 if (restore_left == 0)
3881 {
3882 if (data.restore_disable == 0) cycle_restore ();
3883
3884 restore_left = data.restore_timer;
3885 }
3886 }
3887
3888 if ((runtime_check == 1) && (data.runtime_start > 0))
3889 {
3890 time_t runtime_cur;
3891
3892 time (&runtime_cur);
3893
3894 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3895
3896 if (runtime_left <= 0)
3897 {
3898 if (data.benchmark == 0)
3899 {
3900 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3901 }
3902
3903 if (data.devices_status != STATUS_QUIT) myabort ();
3904 }
3905 }
3906
3907 if (remove_check == 1)
3908 {
3909 remove_left--;
3910
3911 if (remove_left == 0)
3912 {
3913 if (data.digests_saved != data.digests_done)
3914 {
3915 data.digests_saved = data.digests_done;
3916
3917 save_hash ();
3918 }
3919
3920 remove_left = data.remove_timer;
3921 }
3922 }
3923
3924 if (status_check == 1)
3925 {
3926 status_left--;
3927
3928 if (status_left == 0)
3929 {
3930 //hc_thread_mutex_lock (mux_display);
3931
3932 if (data.quiet == 0) clear_prompt ();
3933
3934 if (data.quiet == 0) log_info ("");
3935
3936 status_display ();
3937
3938 if (data.quiet == 0) log_info ("");
3939
3940 //hc_thread_mutex_unlock (mux_display);
3941
3942 status_left = data.status_timer;
3943 }
3944 }
3945 }
3946
3947 #ifdef HAVE_HWMON
3948 myfree (fan_speed_chgd);
3949
3950 myfree (temp_diff_old);
3951 myfree (temp_diff_sum);
3952 #endif
3953
3954 p = NULL;
3955
3956 return (p);
3957 }
3958
3959 static void *thread_outfile_remove (void *p)
3960 {
3961 // some hash-dependent constants
3962 char *outfile_dir = data.outfile_check_directory;
3963 uint dgst_size = data.dgst_size;
3964 uint isSalted = data.isSalted;
3965 uint esalt_size = data.esalt_size;
3966 uint hash_mode = data.hash_mode;
3967
3968 uint outfile_check_timer = data.outfile_check_timer;
3969
3970 char separator = data.separator;
3971
3972 // some hash-dependent functions
3973 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3974 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3975
3976 // buffers
3977 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3978
3979 hash_buf.digest = mymalloc (dgst_size);
3980
3981 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3982
3983 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3984
3985 uint digest_buf[64] = { 0 };
3986
3987 outfile_data_t *out_info = NULL;
3988
3989 char **out_files = NULL;
3990
3991 time_t folder_mtime = 0;
3992
3993 int out_cnt = 0;
3994
3995 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3996
3997 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3998 {
3999 hc_sleep (1);
4000
4001 if (data.devices_status != STATUS_RUNNING) continue;
4002
4003 check_left--;
4004
4005 if (check_left == 0)
4006 {
4007 struct stat outfile_check_stat;
4008
4009 if (stat (outfile_dir, &outfile_check_stat) == 0)
4010 {
4011 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4012
4013 if (is_dir == 1)
4014 {
4015 if (outfile_check_stat.st_mtime > folder_mtime)
4016 {
4017 char **out_files_new = scan_directory (outfile_dir);
4018
4019 int out_cnt_new = count_dictionaries (out_files_new);
4020
4021 outfile_data_t *out_info_new = NULL;
4022
4023 if (out_cnt_new > 0)
4024 {
4025 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4026
4027 for (int i = 0; i < out_cnt_new; i++)
4028 {
4029 out_info_new[i].file_name = out_files_new[i];
4030
4031 // check if there are files that we have seen/checked before (and not changed)
4032
4033 for (int j = 0; j < out_cnt; j++)
4034 {
4035 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4036 {
4037 struct stat outfile_stat;
4038
4039 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4040 {
4041 if (outfile_stat.st_ctime == out_info[j].ctime)
4042 {
4043 out_info_new[i].ctime = out_info[j].ctime;
4044 out_info_new[i].seek = out_info[j].seek;
4045 }
4046 }
4047 }
4048 }
4049 }
4050 }
4051
4052 local_free (out_info);
4053 local_free (out_files);
4054
4055 out_files = out_files_new;
4056 out_cnt = out_cnt_new;
4057 out_info = out_info_new;
4058
4059 folder_mtime = outfile_check_stat.st_mtime;
4060 }
4061
4062 for (int j = 0; j < out_cnt; j++)
4063 {
4064 FILE *fp = fopen (out_info[j].file_name, "rb");
4065
4066 if (fp != NULL)
4067 {
4068 //hc_thread_mutex_lock (mux_display);
4069
4070 #ifdef _POSIX
4071 struct stat outfile_stat;
4072
4073 fstat (fileno (fp), &outfile_stat);
4074 #endif
4075
4076 #ifdef _WIN
4077 struct stat64 outfile_stat;
4078
4079 _fstat64 (fileno (fp), &outfile_stat);
4080 #endif
4081
4082 if (outfile_stat.st_ctime > out_info[j].ctime)
4083 {
4084 out_info[j].ctime = outfile_stat.st_ctime;
4085 out_info[j].seek = 0;
4086 }
4087
4088 fseek (fp, out_info[j].seek, SEEK_SET);
4089
4090 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4091
4092 while (!feof (fp))
4093 {
4094 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4095
4096 if (ptr == NULL) break;
4097
4098 int line_len = strlen (line_buf);
4099
4100 if (line_len <= 0) continue;
4101
4102 int iter = MAX_CUT_TRIES;
4103
4104 for (uint i = line_len - 1; i && iter; i--, line_len--)
4105 {
4106 if (line_buf[i] != separator) continue;
4107
4108 int parser_status = PARSER_OK;
4109
4110 if ((hash_mode != 2500) && (hash_mode != 6800))
4111 {
4112 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4113 }
4114
4115 uint found = 0;
4116
4117 if (parser_status == PARSER_OK)
4118 {
4119 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4120 {
4121 if (data.salts_shown[salt_pos] == 1) continue;
4122
4123 salt_t *salt_buf = &data.salts_buf[salt_pos];
4124
4125 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4126 {
4127 uint idx = salt_buf->digests_offset + digest_pos;
4128
4129 if (data.digests_shown[idx] == 1) continue;
4130
4131 uint cracked = 0;
4132
4133 if (hash_mode == 6800)
4134 {
4135 if (i == salt_buf->salt_len)
4136 {
4137 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4138 }
4139 }
4140 else if (hash_mode == 2500)
4141 {
4142 // BSSID : MAC1 : MAC2 (:plain)
4143 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4144 {
4145 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4146
4147 if (!cracked) continue;
4148
4149 // now compare MAC1 and MAC2 too, since we have this additional info
4150 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4151 char *mac2_pos = mac1_pos + 12 + 1;
4152
4153 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4154 wpa_t *wpa = &wpas[salt_pos];
4155
4156 // compare hex string(s) vs binary MAC address(es)
4157
4158 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4159 {
4160 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4161 {
4162 cracked = 0;
4163
4164 break;
4165 }
4166 }
4167
4168 // early skip ;)
4169 if (!cracked) continue;
4170
4171 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4172 {
4173 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4174 {
4175 cracked = 0;
4176
4177 break;
4178 }
4179 }
4180 }
4181 }
4182 else
4183 {
4184 char *digests_buf_ptr = (char *) data.digests_buf;
4185
4186 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4187
4188 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4189 }
4190
4191 if (cracked == 1)
4192 {
4193 found = 1;
4194
4195 data.digests_shown[idx] = 1;
4196
4197 data.digests_done++;
4198
4199 salt_buf->digests_done++;
4200
4201 if (salt_buf->digests_done == salt_buf->digests_cnt)
4202 {
4203 data.salts_shown[salt_pos] = 1;
4204
4205 data.salts_done++;
4206
4207 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4208 }
4209 }
4210 }
4211
4212 if (data.devices_status == STATUS_CRACKED) break;
4213 }
4214 }
4215
4216 if (found) break;
4217
4218 if (data.devices_status == STATUS_CRACKED) break;
4219
4220 iter--;
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225
4226 myfree (line_buf);
4227
4228 out_info[j].seek = ftell (fp);
4229
4230 //hc_thread_mutex_unlock (mux_display);
4231
4232 fclose (fp);
4233 }
4234 }
4235 }
4236 }
4237
4238 check_left = outfile_check_timer;
4239 }
4240 }
4241
4242 if (esalt_size) local_free (hash_buf.esalt);
4243
4244 if (isSalted) local_free (hash_buf.salt);
4245
4246 local_free (hash_buf.digest);
4247
4248 local_free (out_info);
4249
4250 local_free (out_files);
4251
4252 p = NULL;
4253
4254 return (p);
4255 }
4256
4257 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4258 {
4259 if (device_param->pws_cnt < device_param->kernel_power)
4260 {
4261 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4262
4263 u8 *ptr = (u8 *) pw->i;
4264
4265 memcpy (ptr, pw_buf, pw_len);
4266
4267 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4268
4269 pw->pw_len = pw_len;
4270
4271 device_param->pws_cnt++;
4272 }
4273 else
4274 {
4275 fprintf (stderr, "BUG pw_add()!!\n");
4276
4277 return;
4278 }
4279 }
4280
4281 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4282 {
4283 hc_thread_mutex_lock (mux_dispatcher);
4284
4285 const u64 words_cur = data.words_cur;
4286 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4287
4288 device_param->words_off = words_cur;
4289
4290 const u64 words_left = words_base - words_cur;
4291
4292 if (allow_div)
4293 {
4294 if (data.kernel_power_all > words_left)
4295 {
4296 if (data.kernel_power_div == 0)
4297 {
4298 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4299 }
4300 }
4301
4302 if (data.kernel_power_div)
4303 {
4304 if (device_param->kernel_power == device_param->kernel_power_user)
4305 {
4306 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4307
4308 if (kernel_power_new < device_param->kernel_power)
4309 {
4310 device_param->kernel_power = kernel_power_new;
4311 }
4312 }
4313 }
4314 }
4315
4316 const uint kernel_power = device_param->kernel_power;
4317
4318 uint work = MIN (words_left, kernel_power);
4319
4320 work = MIN (work, max);
4321
4322 data.words_cur += work;
4323
4324 hc_thread_mutex_unlock (mux_dispatcher);
4325
4326 return work;
4327 }
4328
4329 static void *thread_calc_stdin (void *p)
4330 {
4331 hc_device_param_t *device_param = (hc_device_param_t *) p;
4332
4333 if (device_param->skipped) return NULL;
4334
4335 autotune (device_param);
4336
4337 char *buf = (char *) mymalloc (HCBUFSIZ);
4338
4339 const uint attack_kern = data.attack_kern;
4340
4341 const uint kernel_power = device_param->kernel_power;
4342
4343 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4344 {
4345 hc_thread_mutex_lock (mux_dispatcher);
4346
4347 if (feof (stdin) != 0)
4348 {
4349 hc_thread_mutex_unlock (mux_dispatcher);
4350
4351 break;
4352 }
4353
4354 uint words_cur = 0;
4355
4356 while (words_cur < kernel_power)
4357 {
4358 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4359
4360 if (line_buf == NULL) break;
4361
4362 uint line_len = in_superchop (line_buf);
4363
4364 line_len = convert_from_hex (line_buf, line_len);
4365
4366 // post-process rule engine
4367
4368 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4369 {
4370 char rule_buf_out[BLOCK_SIZE] = { 0 };
4371
4372 int rule_len_out = -1;
4373
4374 if (line_len < BLOCK_SIZE)
4375 {
4376 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4377 }
4378
4379 if (rule_len_out < 0) continue;
4380
4381 line_buf = rule_buf_out;
4382 line_len = rule_len_out;
4383 }
4384
4385 if (line_len > PW_MAX)
4386 {
4387 continue;
4388 }
4389
4390 if (attack_kern == ATTACK_KERN_STRAIGHT)
4391 {
4392 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4393 {
4394 hc_thread_mutex_lock (mux_counter);
4395
4396 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4397 {
4398 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4399 }
4400
4401 hc_thread_mutex_unlock (mux_counter);
4402
4403 continue;
4404 }
4405 }
4406 else if (attack_kern == ATTACK_KERN_COMBI)
4407 {
4408 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4409 // since we still need to combine the plains
4410
4411 if (line_len > data.pw_max)
4412 {
4413 hc_thread_mutex_lock (mux_counter);
4414
4415 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4416 {
4417 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4418 }
4419
4420 hc_thread_mutex_unlock (mux_counter);
4421
4422 continue;
4423 }
4424 }
4425
4426 pw_add (device_param, (u8 *) line_buf, line_len);
4427
4428 words_cur++;
4429
4430 if (data.devices_status == STATUS_CRACKED) break;
4431 if (data.devices_status == STATUS_ABORTED) break;
4432 if (data.devices_status == STATUS_QUIT) break;
4433 if (data.devices_status == STATUS_BYPASS) break;
4434 }
4435
4436 hc_thread_mutex_unlock (mux_dispatcher);
4437
4438 if (data.devices_status == STATUS_CRACKED) break;
4439 if (data.devices_status == STATUS_ABORTED) break;
4440 if (data.devices_status == STATUS_QUIT) break;
4441 if (data.devices_status == STATUS_BYPASS) break;
4442
4443 // flush
4444
4445 const uint pws_cnt = device_param->pws_cnt;
4446
4447 if (pws_cnt)
4448 {
4449 run_copy (device_param, pws_cnt);
4450
4451 run_cracker (device_param, pws_cnt);
4452
4453 device_param->pws_cnt = 0;
4454
4455 /*
4456 still required?
4457 if (attack_kern == ATTACK_KERN_STRAIGHT)
4458 {
4459 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4460 }
4461 else if (attack_kern == ATTACK_KERN_COMBI)
4462 {
4463 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4464 }
4465 */
4466 }
4467 }
4468
4469 device_param->kernel_accel = 0;
4470 device_param->kernel_loops = 0;
4471
4472 myfree (buf);
4473
4474 return NULL;
4475 }
4476
4477 static void *thread_calc (void *p)
4478 {
4479 hc_device_param_t *device_param = (hc_device_param_t *) p;
4480
4481 if (device_param->skipped) return NULL;
4482
4483 autotune (device_param);
4484
4485 const uint attack_mode = data.attack_mode;
4486 const uint attack_kern = data.attack_kern;
4487
4488 if (attack_mode == ATTACK_MODE_BF)
4489 {
4490 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4491 {
4492 const uint work = get_work (device_param, -1, true);
4493
4494 if (work == 0) break;
4495
4496 const u64 words_off = device_param->words_off;
4497 const u64 words_fin = words_off + work;
4498
4499 const uint pws_cnt = work;
4500
4501 device_param->pws_cnt = pws_cnt;
4502
4503 if (pws_cnt)
4504 {
4505 run_copy (device_param, pws_cnt);
4506
4507 run_cracker (device_param, pws_cnt);
4508
4509 device_param->pws_cnt = 0;
4510
4511 /*
4512 still required?
4513 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4514 */
4515 }
4516
4517 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4518
4519 if (data.devices_status == STATUS_CRACKED) break;
4520 if (data.devices_status == STATUS_ABORTED) break;
4521 if (data.devices_status == STATUS_QUIT) break;
4522 if (data.devices_status == STATUS_BYPASS) break;
4523
4524 if (data.benchmark == 1) break;
4525
4526 device_param->words_done = words_fin;
4527 }
4528 }
4529 else
4530 {
4531 const uint segment_size = data.segment_size;
4532
4533 char *dictfile = data.dictfile;
4534
4535 if (attack_mode == ATTACK_MODE_COMBI)
4536 {
4537 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4538 {
4539 dictfile = data.dictfile2;
4540 }
4541 }
4542
4543 FILE *fd = fopen (dictfile, "rb");
4544
4545 if (fd == NULL)
4546 {
4547 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4548
4549 return NULL;
4550 }
4551
4552 if (attack_mode == ATTACK_MODE_COMBI)
4553 {
4554 const uint combs_mode = data.combs_mode;
4555
4556 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4557 {
4558 const char *dictfilec = data.dictfile2;
4559
4560 FILE *combs_fp = fopen (dictfilec, "rb");
4561
4562 if (combs_fp == NULL)
4563 {
4564 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4565
4566 fclose (fd);
4567
4568 return NULL;
4569 }
4570
4571 device_param->combs_fp = combs_fp;
4572 }
4573 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4574 {
4575 const char *dictfilec = data.dictfile;
4576
4577 FILE *combs_fp = fopen (dictfilec, "rb");
4578
4579 if (combs_fp == NULL)
4580 {
4581 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4582
4583 fclose (fd);
4584
4585 return NULL;
4586 }
4587
4588 device_param->combs_fp = combs_fp;
4589 }
4590 }
4591
4592 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4593
4594 wl_data->buf = (char *) mymalloc (segment_size);
4595 wl_data->avail = segment_size;
4596 wl_data->incr = segment_size;
4597 wl_data->cnt = 0;
4598 wl_data->pos = 0;
4599
4600 u64 words_cur = 0;
4601
4602 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4603 {
4604 u64 words_off = 0;
4605 u64 words_fin = 0;
4606
4607 bool allow_div = true;
4608
4609 u64 max = -1;
4610
4611 while (max)
4612 {
4613 const uint work = get_work (device_param, max, allow_div);
4614
4615 allow_div = false;
4616
4617 if (work == 0) break;
4618
4619 words_off = device_param->words_off;
4620 words_fin = words_off + work;
4621
4622 char *line_buf;
4623 uint line_len;
4624
4625 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4626
4627 max = 0;
4628
4629 for ( ; words_cur < words_fin; words_cur++)
4630 {
4631 get_next_word (wl_data, fd, &line_buf, &line_len);
4632
4633 line_len = convert_from_hex (line_buf, line_len);
4634
4635 // post-process rule engine
4636
4637 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4638 {
4639 char rule_buf_out[BLOCK_SIZE] = { 0 };
4640
4641 int rule_len_out = -1;
4642
4643 if (line_len < BLOCK_SIZE)
4644 {
4645 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4646 }
4647
4648 if (rule_len_out < 0) continue;
4649
4650 line_buf = rule_buf_out;
4651 line_len = rule_len_out;
4652 }
4653
4654 if (attack_kern == ATTACK_KERN_STRAIGHT)
4655 {
4656 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4657 {
4658 max++;
4659
4660 hc_thread_mutex_lock (mux_counter);
4661
4662 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4663 {
4664 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4665 }
4666
4667 hc_thread_mutex_unlock (mux_counter);
4668
4669 continue;
4670 }
4671 }
4672 else if (attack_kern == ATTACK_KERN_COMBI)
4673 {
4674 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4675 // since we still need to combine the plains
4676
4677 if (line_len > data.pw_max)
4678 {
4679 max++;
4680
4681 hc_thread_mutex_lock (mux_counter);
4682
4683 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4684 {
4685 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4686 }
4687
4688 hc_thread_mutex_unlock (mux_counter);
4689
4690 continue;
4691 }
4692 }
4693
4694 pw_add (device_param, (u8 *) line_buf, line_len);
4695
4696 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4697
4698 if (data.devices_status == STATUS_CRACKED) break;
4699 if (data.devices_status == STATUS_ABORTED) break;
4700 if (data.devices_status == STATUS_QUIT) break;
4701 if (data.devices_status == STATUS_BYPASS) break;
4702 }
4703
4704 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4705
4706 if (data.devices_status == STATUS_CRACKED) break;
4707 if (data.devices_status == STATUS_ABORTED) break;
4708 if (data.devices_status == STATUS_QUIT) break;
4709 if (data.devices_status == STATUS_BYPASS) break;
4710 }
4711
4712 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4713
4714 if (data.devices_status == STATUS_CRACKED) break;
4715 if (data.devices_status == STATUS_ABORTED) break;
4716 if (data.devices_status == STATUS_QUIT) break;
4717 if (data.devices_status == STATUS_BYPASS) break;
4718
4719 //
4720 // flush
4721 //
4722
4723 const uint pws_cnt = device_param->pws_cnt;
4724
4725 if (pws_cnt)
4726 {
4727 run_copy (device_param, pws_cnt);
4728
4729 run_cracker (device_param, pws_cnt);
4730
4731 device_param->pws_cnt = 0;
4732
4733 /*
4734 still required?
4735 if (attack_kern == ATTACK_KERN_STRAIGHT)
4736 {
4737 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4738 }
4739 else if (attack_kern == ATTACK_KERN_COMBI)
4740 {
4741 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4742 }
4743 */
4744 }
4745
4746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4747
4748 if (data.devices_status == STATUS_CRACKED) break;
4749 if (data.devices_status == STATUS_ABORTED) break;
4750 if (data.devices_status == STATUS_QUIT) break;
4751 if (data.devices_status == STATUS_BYPASS) break;
4752
4753 if (words_fin == 0) break;
4754
4755 device_param->words_done = words_fin;
4756 }
4757
4758 if (attack_mode == ATTACK_MODE_COMBI)
4759 {
4760 fclose (device_param->combs_fp);
4761 }
4762
4763 free (wl_data->buf);
4764 free (wl_data);
4765
4766 fclose (fd);
4767 }
4768
4769 device_param->kernel_accel = 0;
4770 device_param->kernel_loops = 0;
4771
4772 return NULL;
4773 }
4774
4775 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4776 {
4777 if (!device_param)
4778 {
4779 log_error ("ERROR: %s : Invalid argument", __func__);
4780
4781 exit (-1);
4782 }
4783
4784 salt_t *salt_buf = &data.salts_buf[salt_pos];
4785
4786 device_param->kernel_params_buf32[24] = salt_pos;
4787 device_param->kernel_params_buf32[27] = 1;
4788 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4789 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4790 device_param->kernel_params_buf32[30] = 0;
4791 device_param->kernel_params_buf32[31] = 1;
4792
4793 char *dictfile_old = data.dictfile;
4794
4795 const char *weak_hash_check = "weak-hash-check";
4796
4797 data.dictfile = (char *) weak_hash_check;
4798
4799 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4800
4801 data.kernel_rules_buf[0].cmds[0] = 0;
4802
4803 /**
4804 * run the kernel
4805 */
4806
4807 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4808 {
4809 run_kernel (KERN_RUN_1, device_param, 1, false);
4810 }
4811 else
4812 {
4813 run_kernel (KERN_RUN_1, device_param, 1, false);
4814
4815 uint loop_step = 16;
4816
4817 const uint iter = salt_buf->salt_iter;
4818
4819 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4820 {
4821 uint loop_left = iter - loop_pos;
4822
4823 loop_left = MIN (loop_left, loop_step);
4824
4825 device_param->kernel_params_buf32[25] = loop_pos;
4826 device_param->kernel_params_buf32[26] = loop_left;
4827
4828 run_kernel (KERN_RUN_2, device_param, 1, false);
4829 }
4830
4831 run_kernel (KERN_RUN_3, device_param, 1, false);
4832 }
4833
4834 /**
4835 * result
4836 */
4837
4838 check_cracked (device_param, salt_pos);
4839
4840 /**
4841 * cleanup
4842 */
4843
4844 device_param->kernel_params_buf32[24] = 0;
4845 device_param->kernel_params_buf32[25] = 0;
4846 device_param->kernel_params_buf32[26] = 0;
4847 device_param->kernel_params_buf32[27] = 0;
4848 device_param->kernel_params_buf32[28] = 0;
4849 device_param->kernel_params_buf32[29] = 0;
4850 device_param->kernel_params_buf32[30] = 0;
4851 device_param->kernel_params_buf32[31] = 0;
4852
4853 data.dictfile = dictfile_old;
4854
4855 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4856 }
4857
4858 // hlfmt hashcat
4859
4860 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 if (data.username == 0)
4863 {
4864 *hashbuf_pos = line_buf;
4865 *hashbuf_len = line_len;
4866 }
4867 else
4868 {
4869 char *pos = line_buf;
4870 int len = line_len;
4871
4872 for (int i = 0; i < line_len; i++, pos++, len--)
4873 {
4874 if (line_buf[i] == data.separator)
4875 {
4876 pos++;
4877
4878 len--;
4879
4880 break;
4881 }
4882 }
4883
4884 *hashbuf_pos = pos;
4885 *hashbuf_len = len;
4886 }
4887 }
4888
4889 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4890 {
4891 char *pos = NULL;
4892 int len = 0;
4893
4894 int sep_cnt = 0;
4895
4896 for (int i = 0; i < line_len; i++)
4897 {
4898 if (line_buf[i] == data.separator)
4899 {
4900 sep_cnt++;
4901
4902 continue;
4903 }
4904
4905 if (sep_cnt == 0)
4906 {
4907 if (pos == NULL) pos = line_buf + i;
4908
4909 len++;
4910 }
4911 }
4912
4913 *userbuf_pos = pos;
4914 *userbuf_len = len;
4915 }
4916
4917 // hlfmt pwdump
4918
4919 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4920 {
4921 int sep_cnt = 0;
4922
4923 int sep2_len = 0;
4924 int sep3_len = 0;
4925
4926 for (int i = 0; i < line_len; i++)
4927 {
4928 if (line_buf[i] == ':')
4929 {
4930 sep_cnt++;
4931
4932 continue;
4933 }
4934
4935 if (sep_cnt == 2) sep2_len++;
4936 if (sep_cnt == 3) sep3_len++;
4937 }
4938
4939 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4940
4941 return 0;
4942 }
4943
4944 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4945 {
4946 char *pos = NULL;
4947 int len = 0;
4948
4949 int sep_cnt = 0;
4950
4951 for (int i = 0; i < line_len; i++)
4952 {
4953 if (line_buf[i] == ':')
4954 {
4955 sep_cnt++;
4956
4957 continue;
4958 }
4959
4960 if (data.hash_mode == 1000)
4961 {
4962 if (sep_cnt == 3)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969 else if (data.hash_mode == 3000)
4970 {
4971 if (sep_cnt == 2)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 }
4979
4980 *hashbuf_pos = pos;
4981 *hashbuf_len = len;
4982 }
4983
4984 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4985 {
4986 char *pos = NULL;
4987 int len = 0;
4988
4989 int sep_cnt = 0;
4990
4991 for (int i = 0; i < line_len; i++)
4992 {
4993 if (line_buf[i] == ':')
4994 {
4995 sep_cnt++;
4996
4997 continue;
4998 }
4999
5000 if (sep_cnt == 0)
5001 {
5002 if (pos == NULL) pos = line_buf + i;
5003
5004 len++;
5005 }
5006 }
5007
5008 *userbuf_pos = pos;
5009 *userbuf_len = len;
5010 }
5011
5012 // hlfmt passwd
5013
5014 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5015 {
5016 int sep_cnt = 0;
5017
5018 char sep5_first = 0;
5019 char sep6_first = 0;
5020
5021 for (int i = 0; i < line_len; i++)
5022 {
5023 if (line_buf[i] == ':')
5024 {
5025 sep_cnt++;
5026
5027 continue;
5028 }
5029
5030 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5031 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5032 }
5033
5034 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5035
5036 return 0;
5037 }
5038
5039 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 char *pos = NULL;
5042 int len = 0;
5043
5044 int sep_cnt = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == ':')
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (sep_cnt == 1)
5056 {
5057 if (pos == NULL) pos = line_buf + i;
5058
5059 len++;
5060 }
5061 }
5062
5063 *hashbuf_pos = pos;
5064 *hashbuf_len = len;
5065 }
5066
5067 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5068 {
5069 char *pos = NULL;
5070 int len = 0;
5071
5072 int sep_cnt = 0;
5073
5074 for (int i = 0; i < line_len; i++)
5075 {
5076 if (line_buf[i] == ':')
5077 {
5078 sep_cnt++;
5079
5080 continue;
5081 }
5082
5083 if (sep_cnt == 0)
5084 {
5085 if (pos == NULL) pos = line_buf + i;
5086
5087 len++;
5088 }
5089 }
5090
5091 *userbuf_pos = pos;
5092 *userbuf_len = len;
5093 }
5094
5095 // hlfmt shadow
5096
5097 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5098 {
5099 int sep_cnt = 0;
5100
5101 for (int i = 0; i < line_len; i++)
5102 {
5103 if (line_buf[i] == ':') sep_cnt++;
5104 }
5105
5106 if (sep_cnt == 8) return 1;
5107
5108 return 0;
5109 }
5110
5111 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5112 {
5113 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5114 }
5115
5116 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5117 {
5118 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5119 }
5120
5121 // hlfmt main
5122
5123 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5124 {
5125 switch (hashfile_format)
5126 {
5127 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5128 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5129 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 }
5132 }
5133
5134 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5135 {
5136 switch (hashfile_format)
5137 {
5138 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5139 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5140 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 }
5143 }
5144
5145 char *strhlfmt (const uint hashfile_format)
5146 {
5147 switch (hashfile_format)
5148 {
5149 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5150 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5151 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5152 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5153 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5154 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5155 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5156 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5157 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5158 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5159 }
5160
5161 return ((char *) "Unknown");
5162 }
5163
5164 static uint hlfmt_detect (FILE *fp, uint max_check)
5165 {
5166 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5167
5168 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5169 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5170
5171 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5172
5173 uint num_check = 0;
5174
5175 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5176
5177 while (!feof (fp))
5178 {
5179 int line_len = fgetl (fp, line_buf);
5180
5181 if (line_len == 0) continue;
5182
5183 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5184 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5185 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5186
5187 if (num_check == max_check) break;
5188
5189 num_check++;
5190 }
5191
5192 myfree (line_buf);
5193
5194 uint hashlist_format = HLFMT_HASHCAT;
5195
5196 for (int i = 1; i < HLFMTS_CNT; i++)
5197 {
5198 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5199
5200 hashlist_format = i;
5201 }
5202
5203 free (formats_cnt);
5204
5205 return hashlist_format;
5206 }
5207
5208 /**
5209 * some further helper function
5210 */
5211
5212 // wrapper around mymalloc for ADL
5213
5214 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5215 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5216 {
5217 return mymalloc (iSize);
5218 }
5219 #endif
5220
5221 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)
5222 {
5223 u64 collisions = 0;
5224
5225 const uint dgst_pos0 = data.dgst_pos0;
5226 const uint dgst_pos1 = data.dgst_pos1;
5227 const uint dgst_pos2 = data.dgst_pos2;
5228 const uint dgst_pos3 = data.dgst_pos3;
5229
5230 memset (bitmap_a, 0, bitmap_size);
5231 memset (bitmap_b, 0, bitmap_size);
5232 memset (bitmap_c, 0, bitmap_size);
5233 memset (bitmap_d, 0, bitmap_size);
5234
5235 for (uint i = 0; i < digests_cnt; i++)
5236 {
5237 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5238
5239 uint *digest_ptr = (uint *) digests_buf_ptr;
5240
5241 digests_buf_ptr += dgst_size;
5242
5243 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5244 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5245 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5246 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5247
5248 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5249 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5250 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5251 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5252
5253 if (bitmap_a[idx0] & val0) collisions++;
5254 if (bitmap_b[idx1] & val1) collisions++;
5255 if (bitmap_c[idx2] & val2) collisions++;
5256 if (bitmap_d[idx3] & val3) collisions++;
5257
5258 bitmap_a[idx0] |= val0;
5259 bitmap_b[idx1] |= val1;
5260 bitmap_c[idx2] |= val2;
5261 bitmap_d[idx3] |= val3;
5262
5263 if (collisions >= collisions_max) return 0x7fffffff;
5264 }
5265
5266 return collisions;
5267 }
5268
5269 /**
5270 * main
5271 */
5272
5273 int main (int argc, char **argv)
5274 {
5275 /**
5276 * To help users a bit
5277 */
5278
5279 char *compute = getenv ("COMPUTE");
5280
5281 if (compute)
5282 {
5283 static char display[100];
5284
5285 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5286
5287 putenv (display);
5288 }
5289 else
5290 {
5291 if (getenv ("DISPLAY") == NULL)
5292 putenv ((char *) "DISPLAY=:0");
5293 }
5294
5295 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5296 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5297
5298 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5299 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5300
5301 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5302 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5303
5304 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5305 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5306
5307 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5308 putenv ((char *) "POCL_KERNEL_CACHE=0");
5309
5310 umask (077);
5311
5312 /**
5313 * Real init
5314 */
5315
5316 memset (&data, 0, sizeof (hc_global_data_t));
5317
5318 time_t proc_start;
5319
5320 time (&proc_start);
5321
5322 data.proc_start = proc_start;
5323
5324 int myargc = argc;
5325 char **myargv = argv;
5326
5327 hc_thread_mutex_init (mux_dispatcher);
5328 hc_thread_mutex_init (mux_counter);
5329 hc_thread_mutex_init (mux_display);
5330 hc_thread_mutex_init (mux_adl);
5331
5332 /**
5333 * commandline parameters
5334 */
5335
5336 uint usage = USAGE;
5337 uint version = VERSION;
5338 uint quiet = QUIET;
5339 uint benchmark = BENCHMARK;
5340 uint show = SHOW;
5341 uint left = LEFT;
5342 uint username = USERNAME;
5343 uint remove = REMOVE;
5344 uint remove_timer = REMOVE_TIMER;
5345 u64 skip = SKIP;
5346 u64 limit = LIMIT;
5347 uint keyspace = KEYSPACE;
5348 uint potfile_disable = POTFILE_DISABLE;
5349 char *potfile_path = NULL;
5350 uint debug_mode = DEBUG_MODE;
5351 char *debug_file = NULL;
5352 char *induction_dir = NULL;
5353 char *outfile_check_dir = NULL;
5354 uint force = FORCE;
5355 uint runtime = RUNTIME;
5356 uint hash_mode = HASH_MODE;
5357 uint attack_mode = ATTACK_MODE;
5358 uint markov_disable = MARKOV_DISABLE;
5359 uint markov_classic = MARKOV_CLASSIC;
5360 uint markov_threshold = MARKOV_THRESHOLD;
5361 char *markov_hcstat = NULL;
5362 char *outfile = NULL;
5363 uint outfile_format = OUTFILE_FORMAT;
5364 uint outfile_autohex = OUTFILE_AUTOHEX;
5365 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5366 uint restore = RESTORE;
5367 uint restore_timer = RESTORE_TIMER;
5368 uint restore_disable = RESTORE_DISABLE;
5369 uint status = STATUS;
5370 uint status_timer = STATUS_TIMER;
5371 uint status_automat = STATUS_AUTOMAT;
5372 uint loopback = LOOPBACK;
5373 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5374 char *session = NULL;
5375 uint hex_charset = HEX_CHARSET;
5376 uint hex_salt = HEX_SALT;
5377 uint hex_wordlist = HEX_WORDLIST;
5378 uint rp_gen = RP_GEN;
5379 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5380 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5381 uint rp_gen_seed = RP_GEN_SEED;
5382 char *rule_buf_l = (char *) RULE_BUF_L;
5383 char *rule_buf_r = (char *) RULE_BUF_R;
5384 uint increment = INCREMENT;
5385 uint increment_min = INCREMENT_MIN;
5386 uint increment_max = INCREMENT_MAX;
5387 char *cpu_affinity = NULL;
5388 OCL_PTR *ocl = NULL;
5389 char *opencl_devices = NULL;
5390 char *opencl_platforms = NULL;
5391 char *opencl_device_types = NULL;
5392 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5393 char *truecrypt_keyfiles = NULL;
5394 char *veracrypt_keyfiles = NULL;
5395 uint veracrypt_pim = 0;
5396 uint workload_profile = WORKLOAD_PROFILE;
5397 uint kernel_accel = KERNEL_ACCEL;
5398 uint kernel_loops = KERNEL_LOOPS;
5399 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5400 #ifdef HAVE_HWMON
5401 uint gpu_temp_abort = GPU_TEMP_ABORT;
5402 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5403 #ifdef HAVE_ADL
5404 uint powertune_enable = POWERTUNE_ENABLE;
5405 #endif
5406 #endif
5407 uint logfile_disable = LOGFILE_DISABLE;
5408 uint segment_size = SEGMENT_SIZE;
5409 uint scrypt_tmto = SCRYPT_TMTO;
5410 char separator = SEPARATOR;
5411 uint bitmap_min = BITMAP_MIN;
5412 uint bitmap_max = BITMAP_MAX;
5413 char *custom_charset_1 = NULL;
5414 char *custom_charset_2 = NULL;
5415 char *custom_charset_3 = NULL;
5416 char *custom_charset_4 = NULL;
5417
5418 #define IDX_HELP 'h'
5419 #define IDX_VERSION 'V'
5420 #define IDX_VERSION_LOWER 'v'
5421 #define IDX_QUIET 0xff02
5422 #define IDX_SHOW 0xff03
5423 #define IDX_LEFT 0xff04
5424 #define IDX_REMOVE 0xff05
5425 #define IDX_REMOVE_TIMER 0xff37
5426 #define IDX_SKIP 's'
5427 #define IDX_LIMIT 'l'
5428 #define IDX_KEYSPACE 0xff35
5429 #define IDX_POTFILE_DISABLE 0xff06
5430 #define IDX_POTFILE_PATH 0xffe0
5431 #define IDX_DEBUG_MODE 0xff43
5432 #define IDX_DEBUG_FILE 0xff44
5433 #define IDX_INDUCTION_DIR 0xff46
5434 #define IDX_OUTFILE_CHECK_DIR 0xff47
5435 #define IDX_USERNAME 0xff07
5436 #define IDX_FORCE 0xff08
5437 #define IDX_RUNTIME 0xff09
5438 #define IDX_BENCHMARK 'b'
5439 #define IDX_HASH_MODE 'm'
5440 #define IDX_ATTACK_MODE 'a'
5441 #define IDX_RP_FILE 'r'
5442 #define IDX_RP_GEN 'g'
5443 #define IDX_RP_GEN_FUNC_MIN 0xff10
5444 #define IDX_RP_GEN_FUNC_MAX 0xff11
5445 #define IDX_RP_GEN_SEED 0xff34
5446 #define IDX_RULE_BUF_L 'j'
5447 #define IDX_RULE_BUF_R 'k'
5448 #define IDX_INCREMENT 'i'
5449 #define IDX_INCREMENT_MIN 0xff12
5450 #define IDX_INCREMENT_MAX 0xff13
5451 #define IDX_OUTFILE 'o'
5452 #define IDX_OUTFILE_FORMAT 0xff14
5453 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5454 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5455 #define IDX_RESTORE 0xff15
5456 #define IDX_RESTORE_DISABLE 0xff27
5457 #define IDX_STATUS 0xff17
5458 #define IDX_STATUS_TIMER 0xff18
5459 #define IDX_STATUS_AUTOMAT 0xff50
5460 #define IDX_LOOPBACK 0xff38
5461 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5462 #define IDX_SESSION 0xff19
5463 #define IDX_HEX_CHARSET 0xff20
5464 #define IDX_HEX_SALT 0xff21
5465 #define IDX_HEX_WORDLIST 0xff40
5466 #define IDX_MARKOV_DISABLE 0xff22
5467 #define IDX_MARKOV_CLASSIC 0xff23
5468 #define IDX_MARKOV_THRESHOLD 't'
5469 #define IDX_MARKOV_HCSTAT 0xff24
5470 #define IDX_CPU_AFFINITY 0xff25
5471 #define IDX_OPENCL_DEVICES 'd'
5472 #define IDX_OPENCL_PLATFORMS 0xff72
5473 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5474 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5475 #define IDX_WORKLOAD_PROFILE 'w'
5476 #define IDX_KERNEL_ACCEL 'n'
5477 #define IDX_KERNEL_LOOPS 'u'
5478 #define IDX_GPU_TEMP_DISABLE 0xff29
5479 #define IDX_GPU_TEMP_ABORT 0xff30
5480 #define IDX_GPU_TEMP_RETAIN 0xff31
5481 #define IDX_POWERTUNE_ENABLE 0xff41
5482 #define IDX_LOGFILE_DISABLE 0xff51
5483 #define IDX_TRUECRYPT_KEYFILES 0xff52
5484 #define IDX_VERACRYPT_KEYFILES 0xff53
5485 #define IDX_VERACRYPT_PIM 0xff54
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"restore", no_argument, 0, IDX_RESTORE},
5520 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5521 {"status", no_argument, 0, IDX_STATUS},
5522 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5523 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5524 {"loopback", no_argument, 0, IDX_LOOPBACK},
5525 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5526 {"session", required_argument, 0, IDX_SESSION},
5527 {"runtime", required_argument, 0, IDX_RUNTIME},
5528 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5529 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5530 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5531 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5532 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5533 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5534 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5535 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5536 {"rules-file", required_argument, 0, IDX_RP_FILE},
5537 {"outfile", required_argument, 0, IDX_OUTFILE},
5538 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5539 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5540 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5541 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5542 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5543 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5544 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5545 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5546 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5547 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5548 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5549 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5550 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5551 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5552 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5553 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5554 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5555 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5556 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5557 #ifdef HAVE_HWMON
5558 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5559 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5560 #ifdef HAVE_ADL
5561 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5562 #endif
5563 #endif // HAVE_HWMON
5564 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5565 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5566 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5567 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5568 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5569 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5570 {"seperator", required_argument, 0, IDX_SEPARATOR},
5571 {"separator", required_argument, 0, IDX_SEPARATOR},
5572 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5573 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5574 {"increment", no_argument, 0, IDX_INCREMENT},
5575 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5576 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5577 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5578 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5579 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5580 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5581 {0, 0, 0, 0}
5582 };
5583
5584 uint rp_files_cnt = 0;
5585
5586 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5587
5588 int option_index = 0;
5589 int c = -1;
5590
5591 optind = 1;
5592 optopt = 0;
5593
5594 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5595 {
5596 switch (c)
5597 {
5598 case IDX_HELP: usage = 1; break;
5599 case IDX_VERSION:
5600 case IDX_VERSION_LOWER: version = 1; break;
5601 case IDX_RESTORE: restore = 1; break;
5602 case IDX_SESSION: session = optarg; break;
5603 case IDX_SHOW: show = 1; break;
5604 case IDX_LEFT: left = 1; break;
5605 case '?': return (-1);
5606 }
5607 }
5608
5609 if (optopt != 0)
5610 {
5611 log_error ("ERROR: Invalid argument specified");
5612
5613 return (-1);
5614 }
5615
5616 /**
5617 * exit functions
5618 */
5619
5620 if (version)
5621 {
5622 log_info ("%s", VERSION_TAG);
5623
5624 return (0);
5625 }
5626
5627 if (usage)
5628 {
5629 usage_big_print (PROGNAME);
5630
5631 return (0);
5632 }
5633
5634 /**
5635 * session needs to be set, always!
5636 */
5637
5638 if (session == NULL) session = (char *) PROGNAME;
5639
5640 /**
5641 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5642 */
5643
5644 char *exec_path = get_exec_path ();
5645
5646 #ifdef LINUX
5647
5648 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5649 char *resolved_exec_path = realpath (exec_path, NULL);
5650
5651 char *install_dir = get_install_dir (resolved_exec_path);
5652 char *profile_dir = NULL;
5653 char *session_dir = NULL;
5654 char *shared_dir = NULL;
5655
5656 if (strcmp (install_dir, resolved_install_folder) == 0)
5657 {
5658 struct passwd *pw = getpwuid (getuid ());
5659
5660 const char *homedir = pw->pw_dir;
5661
5662 profile_dir = get_profile_dir (homedir);
5663 session_dir = get_session_dir (profile_dir);
5664 shared_dir = strdup (SHARED_FOLDER);
5665
5666 mkdir (profile_dir, 0700);
5667 mkdir (session_dir, 0700);
5668 }
5669 else
5670 {
5671 profile_dir = install_dir;
5672 session_dir = install_dir;
5673 shared_dir = install_dir;
5674 }
5675
5676 myfree (resolved_install_folder);
5677 myfree (resolved_exec_path);
5678
5679 #else
5680
5681 char *install_dir = get_install_dir (exec_path);
5682 char *profile_dir = install_dir;
5683 char *session_dir = install_dir;
5684 char *shared_dir = install_dir;
5685
5686 #endif
5687
5688 data.install_dir = install_dir;
5689 data.profile_dir = profile_dir;
5690 data.session_dir = session_dir;
5691 data.shared_dir = shared_dir;
5692
5693 myfree (exec_path);
5694
5695 /**
5696 * kernel cache, we need to make sure folder exist
5697 */
5698
5699 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5700
5701 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5702
5703 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5704
5705 mkdir (kernels_folder, 0700);
5706
5707 myfree (kernels_folder);
5708
5709 /**
5710 * session
5711 */
5712
5713 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5714
5715 data.session = session;
5716
5717 char *eff_restore_file = (char *) mymalloc (session_size);
5718 char *new_restore_file = (char *) mymalloc (session_size);
5719
5720 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5721 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5722
5723 data.eff_restore_file = eff_restore_file;
5724 data.new_restore_file = new_restore_file;
5725
5726 if (((show == 1) || (left == 1)) && (restore == 1))
5727 {
5728 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5729 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5730
5731 return (-1);
5732 }
5733
5734 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5735 if ((show == 1) || (left == 1))
5736 {
5737 restore_disable = 1;
5738
5739 restore = 0;
5740 }
5741
5742 data.restore_disable = restore_disable;
5743
5744 restore_data_t *rd = init_restore (argc, argv);
5745
5746 data.rd = rd;
5747
5748 /**
5749 * restore file
5750 */
5751
5752 if (restore == 1)
5753 {
5754 read_restore (eff_restore_file, rd);
5755
5756 if (rd->version_bin < RESTORE_MIN)
5757 {
5758 log_error ("ERROR: Incompatible restore-file version");
5759
5760 return (-1);
5761 }
5762
5763 myargc = rd->argc;
5764 myargv = rd->argv;
5765
5766 #ifdef _POSIX
5767 rd->pid = getpid ();
5768 #elif _WIN
5769 rd->pid = GetCurrentProcessId ();
5770 #endif
5771 }
5772
5773 uint hash_mode_chgd = 0;
5774 uint runtime_chgd = 0;
5775 uint kernel_loops_chgd = 0;
5776 uint kernel_accel_chgd = 0;
5777 uint attack_mode_chgd = 0;
5778 uint outfile_format_chgd = 0;
5779 uint rp_gen_seed_chgd = 0;
5780 uint remove_timer_chgd = 0;
5781 uint increment_min_chgd = 0;
5782 uint increment_max_chgd = 0;
5783 uint workload_profile_chgd = 0;
5784 uint opencl_vector_width_chgd = 0;
5785
5786 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5787 uint gpu_temp_retain_chgd = 0;
5788 uint gpu_temp_abort_chgd = 0;
5789 #endif
5790
5791 optind = 1;
5792 optopt = 0;
5793 option_index = 0;
5794
5795 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5796 {
5797 switch (c)
5798 {
5799 //case IDX_HELP: usage = 1; break;
5800 //case IDX_VERSION: version = 1; break;
5801 //case IDX_RESTORE: restore = 1; break;
5802 case IDX_QUIET: quiet = 1; break;
5803 //case IDX_SHOW: show = 1; break;
5804 case IDX_SHOW: break;
5805 //case IDX_LEFT: left = 1; break;
5806 case IDX_LEFT: break;
5807 case IDX_USERNAME: username = 1; break;
5808 case IDX_REMOVE: remove = 1; break;
5809 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5810 remove_timer_chgd = 1; break;
5811 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5812 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5813 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5814 case IDX_DEBUG_FILE: debug_file = optarg; break;
5815 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5816 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5817 case IDX_FORCE: force = 1; break;
5818 case IDX_SKIP: skip = atoll (optarg); break;
5819 case IDX_LIMIT: limit = atoll (optarg); break;
5820 case IDX_KEYSPACE: keyspace = 1; break;
5821 case IDX_BENCHMARK: benchmark = 1; break;
5822 case IDX_RESTORE: break;
5823 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5824 case IDX_STATUS: status = 1; break;
5825 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5826 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5827 case IDX_LOOPBACK: loopback = 1; break;
5828 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5829 //case IDX_SESSION: session = optarg; break;
5830 case IDX_SESSION: break;
5831 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5832 hash_mode_chgd = 1; break;
5833 case IDX_RUNTIME: runtime = atoi (optarg);
5834 runtime_chgd = 1; break;
5835 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5836 attack_mode_chgd = 1; break;
5837 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5838 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5839 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5840 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5841 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5842 rp_gen_seed_chgd = 1; break;
5843 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5844 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5845 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5846 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5847 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5848 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5849 case IDX_OUTFILE: outfile = optarg; break;
5850 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5851 outfile_format_chgd = 1; break;
5852 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5853 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5854 case IDX_HEX_CHARSET: hex_charset = 1; break;
5855 case IDX_HEX_SALT: hex_salt = 1; break;
5856 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5857 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5858 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5859 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5860 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5861 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5862 opencl_vector_width_chgd = 1; break;
5863 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5864 workload_profile_chgd = 1; break;
5865 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5866 kernel_accel_chgd = 1; break;
5867 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5868 kernel_loops_chgd = 1; break;
5869 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5870 #ifdef HAVE_HWMON
5871 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5872 #ifdef HAVE_ADL
5873 gpu_temp_abort_chgd = 1;
5874 #endif
5875 break;
5876 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5877 #ifdef HAVE_ADL
5878 gpu_temp_retain_chgd = 1;
5879 #endif
5880 break;
5881 #ifdef HAVE_ADL
5882 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5883 #endif
5884 #endif // HAVE_HWMON
5885 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5886 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5887 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5888 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5889 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5890 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5891 case IDX_SEPARATOR: separator = optarg[0]; break;
5892 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5893 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5894 case IDX_INCREMENT: increment = 1; break;
5895 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5896 increment_min_chgd = 1; break;
5897 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5898 increment_max_chgd = 1; break;
5899 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5900 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5901 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5902 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5903
5904 default:
5905 log_error ("ERROR: Invalid argument specified");
5906 return (-1);
5907 }
5908 }
5909
5910 if (optopt != 0)
5911 {
5912 log_error ("ERROR: Invalid argument specified");
5913
5914 return (-1);
5915 }
5916
5917 /**
5918 * Inform user things getting started,
5919 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5920 * - we do not need to check algorithm_pos
5921 */
5922
5923 if (quiet == 0)
5924 {
5925 if (benchmark == 1)
5926 {
5927 if (status_automat == 0)
5928 {
5929 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5930 log_info ("");
5931 }
5932 else
5933 {
5934 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5935 }
5936 }
5937 else if (restore == 1)
5938 {
5939 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5940 log_info ("");
5941 }
5942 else
5943 {
5944 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5945 log_info ("");
5946 }
5947 }
5948
5949 /**
5950 * sanity check
5951 */
5952
5953 if (attack_mode > 7)
5954 {
5955 log_error ("ERROR: Invalid attack-mode specified");
5956
5957 return (-1);
5958 }
5959
5960 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5961 {
5962 log_error ("ERROR: Invalid runtime specified");
5963
5964 return (-1);
5965 }
5966
5967 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5968 {
5969 log_error ("ERROR: Invalid hash-type specified");
5970
5971 return (-1);
5972 }
5973
5974 // renamed hash modes
5975
5976 if (hash_mode_chgd)
5977 {
5978 int n = -1;
5979
5980 switch (hash_mode)
5981 {
5982 case 123: n = 124;
5983 break;
5984 }
5985
5986 if (n >= 0)
5987 {
5988 log_error ("Old -m specified, use -m %d instead", n);
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (username == 1)
5995 {
5996 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5997 {
5998 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5999
6000 return (-1);
6001 }
6002 }
6003
6004 if (outfile_format > 16)
6005 {
6006 log_error ("ERROR: Invalid outfile-format specified");
6007
6008 return (-1);
6009 }
6010
6011 if (left == 1)
6012 {
6013 if (outfile_format_chgd == 1)
6014 {
6015 if (outfile_format > 1)
6016 {
6017 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6018
6019 return (-1);
6020 }
6021 }
6022 else
6023 {
6024 outfile_format = OUTFILE_FMT_HASH;
6025 }
6026 }
6027
6028 if (show == 1)
6029 {
6030 if (outfile_format_chgd == 1)
6031 {
6032 if ((outfile_format > 7) && (outfile_format < 16))
6033 {
6034 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6035
6036 return (-1);
6037 }
6038 }
6039 }
6040
6041 if (increment_min < INCREMENT_MIN)
6042 {
6043 log_error ("ERROR: Invalid increment-min specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_max > INCREMENT_MAX)
6049 {
6050 log_error ("ERROR: Invalid increment-max specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_min > increment_max)
6056 {
6057 log_error ("ERROR: Invalid increment-min specified");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6063 {
6064 log_error ("ERROR: increment is not allowed in attack-mode 0");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_min_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-min is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_max_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-max is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt && rp_gen)
6084 {
6085 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt || rp_gen)
6091 {
6092 if (attack_mode != ATTACK_MODE_STRAIGHT)
6093 {
6094 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (rp_gen_func_min > rp_gen_func_max)
6101 {
6102 log_error ("ERROR: Invalid rp-gen-func-min specified");
6103
6104 return (-1);
6105 }
6106
6107 if (kernel_accel_chgd == 1)
6108 {
6109 if (force == 0)
6110 {
6111 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6112 log_info ("Please consider using the option -w instead");
6113 log_info ("You can use --force to override this but do not post error reports if you do so");
6114 log_info ("");
6115
6116 return (-1);
6117 }
6118
6119 if (kernel_accel < 1)
6120 {
6121 log_error ("ERROR: Invalid kernel-accel specified");
6122
6123 return (-1);
6124 }
6125
6126 if (kernel_accel > 1024)
6127 {
6128 log_error ("ERROR: Invalid kernel-accel specified");
6129
6130 return (-1);
6131 }
6132 }
6133
6134 if (kernel_loops_chgd == 1)
6135 {
6136 if (force == 0)
6137 {
6138 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6139 log_info ("Please consider using the option -w instead");
6140 log_info ("You can use --force to override this but do not post error reports if you do so");
6141 log_info ("");
6142
6143 return (-1);
6144 }
6145
6146 if (kernel_loops < 1)
6147 {
6148 log_error ("ERROR: Invalid kernel-loops specified");
6149
6150 return (-1);
6151 }
6152
6153 if (kernel_loops > 1024)
6154 {
6155 log_error ("ERROR: Invalid kernel-loops specified");
6156
6157 return (-1);
6158 }
6159 }
6160
6161 if ((workload_profile < 1) || (workload_profile > 4))
6162 {
6163 log_error ("ERROR: workload-profile %i not available", workload_profile);
6164
6165 return (-1);
6166 }
6167
6168 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6169 {
6170 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6171
6172 return (-1);
6173 }
6174
6175 if (show == 1 || left == 1)
6176 {
6177 attack_mode = ATTACK_MODE_NONE;
6178
6179 if (remove == 1)
6180 {
6181 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6182
6183 return (-1);
6184 }
6185
6186 if (potfile_disable == 1)
6187 {
6188 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6189
6190 return (-1);
6191 }
6192 }
6193
6194 uint attack_kern = ATTACK_KERN_NONE;
6195
6196 switch (attack_mode)
6197 {
6198 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6199 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6200 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6201 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6202 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6203 }
6204
6205 if (benchmark == 0)
6206 {
6207 if (keyspace == 1)
6208 {
6209 int num_additional_params = 1;
6210
6211 if (attack_kern == ATTACK_KERN_COMBI)
6212 {
6213 num_additional_params = 2;
6214 }
6215
6216 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6217
6218 if (keyspace_wordlist_specified == 0) optind--;
6219 }
6220
6221 if (attack_kern == ATTACK_KERN_NONE)
6222 {
6223 if ((optind + 1) != myargc)
6224 {
6225 usage_mini_print (myargv[0]);
6226
6227 return (-1);
6228 }
6229 }
6230 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6231 {
6232 if ((optind + 1) > myargc)
6233 {
6234 usage_mini_print (myargv[0]);
6235
6236 return (-1);
6237 }
6238 }
6239 else if (attack_kern == ATTACK_KERN_COMBI)
6240 {
6241 if ((optind + 3) != myargc)
6242 {
6243 usage_mini_print (myargv[0]);
6244
6245 return (-1);
6246 }
6247 }
6248 else if (attack_kern == ATTACK_KERN_BF)
6249 {
6250 if ((optind + 1) > myargc)
6251 {
6252 usage_mini_print (myargv[0]);
6253
6254 return (-1);
6255 }
6256 }
6257 else
6258 {
6259 usage_mini_print (myargv[0]);
6260
6261 return (-1);
6262 }
6263 }
6264 else
6265 {
6266 if (myargv[optind] != 0)
6267 {
6268 log_error ("ERROR: Invalid argument for benchmark mode specified");
6269
6270 return (-1);
6271 }
6272
6273 if (attack_mode_chgd == 1)
6274 {
6275 if (attack_mode != ATTACK_MODE_BF)
6276 {
6277 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6278
6279 return (-1);
6280 }
6281 }
6282 }
6283
6284 if (skip != 0 && limit != 0)
6285 {
6286 limit += skip;
6287 }
6288
6289 if (keyspace == 1)
6290 {
6291 if (show == 1)
6292 {
6293 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6294
6295 return (-1);
6296 }
6297 else if (left == 1)
6298 {
6299 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6300
6301 return (-1);
6302 }
6303
6304 potfile_disable = 1;
6305
6306 restore_disable = 1;
6307
6308 restore = 0;
6309
6310 weak_hash_threshold = 0;
6311
6312 quiet = 1;
6313 }
6314
6315 if (remove_timer_chgd == 1)
6316 {
6317 if (remove == 0)
6318 {
6319 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6320
6321 return (-1);
6322 }
6323
6324 if (remove_timer < 1)
6325 {
6326 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6327
6328 return (-1);
6329 }
6330 }
6331
6332 if (loopback == 1)
6333 {
6334 if (attack_mode == ATTACK_MODE_STRAIGHT)
6335 {
6336 if ((rp_files_cnt == 0) && (rp_gen == 0))
6337 {
6338 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6339
6340 return (-1);
6341 }
6342 }
6343 else
6344 {
6345 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6346
6347 return (-1);
6348 }
6349 }
6350
6351 if (debug_mode > 0)
6352 {
6353 if (attack_mode != ATTACK_MODE_STRAIGHT)
6354 {
6355 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6356
6357 return (-1);
6358 }
6359
6360 if ((rp_files_cnt == 0) && (rp_gen == 0))
6361 {
6362 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6363
6364 return (-1);
6365 }
6366 }
6367
6368 if (debug_mode > 4)
6369 {
6370 log_error ("ERROR: Invalid debug-mode specified");
6371
6372 return (-1);
6373 }
6374
6375 if (debug_file != NULL)
6376 {
6377 if (debug_mode < 1)
6378 {
6379 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6380
6381 return (-1);
6382 }
6383 }
6384
6385 if (induction_dir != NULL)
6386 {
6387 if (attack_mode == ATTACK_MODE_BF)
6388 {
6389 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6390
6391 return (-1);
6392 }
6393 }
6394
6395 if (attack_mode != ATTACK_MODE_STRAIGHT)
6396 {
6397 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6398 {
6399 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6400
6401 return (-1);
6402 }
6403
6404 weak_hash_threshold = 0;
6405 }
6406
6407 /**
6408 * induction directory
6409 */
6410
6411 char *induction_directory = NULL;
6412
6413 if (attack_mode != ATTACK_MODE_BF)
6414 {
6415 if (induction_dir == NULL)
6416 {
6417 induction_directory = (char *) mymalloc (session_size);
6418
6419 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6420
6421 // create induction folder if it does not already exist
6422
6423 if (keyspace == 0)
6424 {
6425 if (rmdir (induction_directory) == -1)
6426 {
6427 if (errno == ENOENT)
6428 {
6429 // good, we can ignore
6430 }
6431 else if (errno == ENOTEMPTY)
6432 {
6433 char *induction_directory_mv = (char *) mymalloc (session_size);
6434
6435 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6436
6437 if (rename (induction_directory, induction_directory_mv) != 0)
6438 {
6439 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6440
6441 return (-1);
6442 }
6443 }
6444 else
6445 {
6446 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6447
6448 return (-1);
6449 }
6450 }
6451
6452 if (mkdir (induction_directory, 0700) == -1)
6453 {
6454 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6455
6456 return (-1);
6457 }
6458 }
6459 }
6460 else
6461 {
6462 induction_directory = induction_dir;
6463 }
6464 }
6465
6466 data.induction_directory = induction_directory;
6467
6468 /**
6469 * loopback
6470 */
6471
6472 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6473
6474 char *loopback_file = (char *) mymalloc (loopback_size);
6475
6476 /**
6477 * tuning db
6478 */
6479
6480 char tuning_db_file[256] = { 0 };
6481
6482 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6483
6484 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6485
6486 /**
6487 * outfile-check directory
6488 */
6489
6490 char *outfile_check_directory = NULL;
6491
6492 if (outfile_check_dir == NULL)
6493 {
6494 outfile_check_directory = (char *) mymalloc (session_size);
6495
6496 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6497 }
6498 else
6499 {
6500 outfile_check_directory = outfile_check_dir;
6501 }
6502
6503 data.outfile_check_directory = outfile_check_directory;
6504
6505 if (keyspace == 0)
6506 {
6507 struct stat outfile_check_stat;
6508
6509 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6510 {
6511 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6512
6513 if (is_dir == 0)
6514 {
6515 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6516
6517 return (-1);
6518 }
6519 }
6520 else if (outfile_check_dir == NULL)
6521 {
6522 if (mkdir (outfile_check_directory, 0700) == -1)
6523 {
6524 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6525
6526 return (-1);
6527 }
6528 }
6529 }
6530
6531 /**
6532 * special other stuff
6533 */
6534
6535 if (hash_mode == 9710)
6536 {
6537 outfile_format = 5;
6538 outfile_format_chgd = 1;
6539 }
6540
6541 if (hash_mode == 9810)
6542 {
6543 outfile_format = 5;
6544 outfile_format_chgd = 1;
6545 }
6546
6547 if (hash_mode == 10410)
6548 {
6549 outfile_format = 5;
6550 outfile_format_chgd = 1;
6551 }
6552
6553 /**
6554 * store stuff
6555 */
6556
6557 data.hash_mode = hash_mode;
6558 data.restore = restore;
6559 data.restore_timer = restore_timer;
6560 data.restore_disable = restore_disable;
6561 data.status = status;
6562 data.status_timer = status_timer;
6563 data.status_automat = status_automat;
6564 data.loopback = loopback;
6565 data.runtime = runtime;
6566 data.remove = remove;
6567 data.remove_timer = remove_timer;
6568 data.debug_mode = debug_mode;
6569 data.debug_file = debug_file;
6570 data.username = username;
6571 data.quiet = quiet;
6572 data.outfile = outfile;
6573 data.outfile_format = outfile_format;
6574 data.outfile_autohex = outfile_autohex;
6575 data.hex_charset = hex_charset;
6576 data.hex_salt = hex_salt;
6577 data.hex_wordlist = hex_wordlist;
6578 data.separator = separator;
6579 data.rp_files = rp_files;
6580 data.rp_files_cnt = rp_files_cnt;
6581 data.rp_gen = rp_gen;
6582 data.rp_gen_seed = rp_gen_seed;
6583 data.force = force;
6584 data.benchmark = benchmark;
6585 data.skip = skip;
6586 data.limit = limit;
6587 #ifdef HAVE_HWMON
6588 #ifdef HAVE_ADL
6589 data.powertune_enable = powertune_enable;
6590 #endif
6591 #endif
6592 data.logfile_disable = logfile_disable;
6593 data.truecrypt_keyfiles = truecrypt_keyfiles;
6594 data.veracrypt_keyfiles = veracrypt_keyfiles;
6595 data.veracrypt_pim = veracrypt_pim;
6596 data.scrypt_tmto = scrypt_tmto;
6597 data.workload_profile = workload_profile;
6598
6599 /**
6600 * cpu affinity
6601 */
6602
6603 if (cpu_affinity)
6604 {
6605 set_cpu_affinity (cpu_affinity);
6606 }
6607
6608 if (rp_gen_seed_chgd == 0)
6609 {
6610 srand (proc_start);
6611 }
6612 else
6613 {
6614 srand (rp_gen_seed);
6615 }
6616
6617 /**
6618 * logfile init
6619 */
6620
6621 if (logfile_disable == 0)
6622 {
6623 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6624
6625 char *logfile = (char *) mymalloc (logfile_size);
6626
6627 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6628
6629 data.logfile = logfile;
6630
6631 char *topid = logfile_generate_topid ();
6632
6633 data.topid = topid;
6634 }
6635
6636 // logfile_append() checks for logfile_disable internally to make it easier from here
6637
6638 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6639 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6640 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6641 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6643 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6644 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6645 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6646 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6647 #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));
6648
6649 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6650 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6651 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6652 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6653 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6654 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6655 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6656 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6657
6658 logfile_top_msg ("START");
6659
6660 logfile_top_uint (attack_mode);
6661 logfile_top_uint (attack_kern);
6662 logfile_top_uint (benchmark);
6663 logfile_top_uint (bitmap_min);
6664 logfile_top_uint (bitmap_max);
6665 logfile_top_uint (debug_mode);
6666 logfile_top_uint (force);
6667 logfile_top_uint (kernel_accel);
6668 logfile_top_uint (kernel_loops);
6669 logfile_top_uint (gpu_temp_disable);
6670 #ifdef HAVE_HWMON
6671 logfile_top_uint (gpu_temp_abort);
6672 logfile_top_uint (gpu_temp_retain);
6673 #endif
6674 logfile_top_uint (hash_mode);
6675 logfile_top_uint (hex_charset);
6676 logfile_top_uint (hex_salt);
6677 logfile_top_uint (hex_wordlist);
6678 logfile_top_uint (increment);
6679 logfile_top_uint (increment_max);
6680 logfile_top_uint (increment_min);
6681 logfile_top_uint (keyspace);
6682 logfile_top_uint (left);
6683 logfile_top_uint (logfile_disable);
6684 logfile_top_uint (loopback);
6685 logfile_top_uint (markov_classic);
6686 logfile_top_uint (markov_disable);
6687 logfile_top_uint (markov_threshold);
6688 logfile_top_uint (outfile_autohex);
6689 logfile_top_uint (outfile_check_timer);
6690 logfile_top_uint (outfile_format);
6691 logfile_top_uint (potfile_disable);
6692 logfile_top_string (potfile_path);
6693 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6694 logfile_top_uint (powertune_enable);
6695 #endif
6696 logfile_top_uint (scrypt_tmto);
6697 logfile_top_uint (quiet);
6698 logfile_top_uint (remove);
6699 logfile_top_uint (remove_timer);
6700 logfile_top_uint (restore);
6701 logfile_top_uint (restore_disable);
6702 logfile_top_uint (restore_timer);
6703 logfile_top_uint (rp_gen);
6704 logfile_top_uint (rp_gen_func_max);
6705 logfile_top_uint (rp_gen_func_min);
6706 logfile_top_uint (rp_gen_seed);
6707 logfile_top_uint (runtime);
6708 logfile_top_uint (segment_size);
6709 logfile_top_uint (show);
6710 logfile_top_uint (status);
6711 logfile_top_uint (status_automat);
6712 logfile_top_uint (status_timer);
6713 logfile_top_uint (usage);
6714 logfile_top_uint (username);
6715 logfile_top_uint (version);
6716 logfile_top_uint (weak_hash_threshold);
6717 logfile_top_uint (workload_profile);
6718 logfile_top_uint64 (limit);
6719 logfile_top_uint64 (skip);
6720 logfile_top_char (separator);
6721 logfile_top_string (cpu_affinity);
6722 logfile_top_string (custom_charset_1);
6723 logfile_top_string (custom_charset_2);
6724 logfile_top_string (custom_charset_3);
6725 logfile_top_string (custom_charset_4);
6726 logfile_top_string (debug_file);
6727 logfile_top_string (opencl_devices);
6728 logfile_top_string (opencl_platforms);
6729 logfile_top_string (opencl_device_types);
6730 logfile_top_uint (opencl_vector_width);
6731 logfile_top_string (induction_dir);
6732 logfile_top_string (markov_hcstat);
6733 logfile_top_string (outfile);
6734 logfile_top_string (outfile_check_dir);
6735 logfile_top_string (rule_buf_l);
6736 logfile_top_string (rule_buf_r);
6737 logfile_top_string (session);
6738 logfile_top_string (truecrypt_keyfiles);
6739 logfile_top_string (veracrypt_keyfiles);
6740 logfile_top_uint (veracrypt_pim);
6741
6742 /**
6743 * Init OpenCL library loader
6744 */
6745
6746 if (keyspace == 0)
6747 {
6748 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6749
6750 ocl_init (ocl);
6751
6752 data.ocl = ocl;
6753 }
6754
6755 /**
6756 * OpenCL platform selection
6757 */
6758
6759 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6760
6761 /**
6762 * OpenCL device selection
6763 */
6764
6765 u32 devices_filter = setup_devices_filter (opencl_devices);
6766
6767 /**
6768 * OpenCL device type selection
6769 */
6770
6771 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6772
6773 /**
6774 * benchmark
6775 */
6776
6777 if (benchmark == 1)
6778 {
6779 /**
6780 * disable useless stuff for benchmark
6781 */
6782
6783 status_timer = 0;
6784 restore_timer = 0;
6785 restore_disable = 1;
6786 potfile_disable = 1;
6787 weak_hash_threshold = 0;
6788 gpu_temp_disable = 1;
6789
6790 data.status_timer = status_timer;
6791 data.restore_timer = restore_timer;
6792 data.restore_disable = restore_disable;
6793
6794 /**
6795 * force attack mode to be bruteforce
6796 */
6797
6798 attack_mode = ATTACK_MODE_BF;
6799 attack_kern = ATTACK_KERN_BF;
6800
6801 if (workload_profile_chgd == 0)
6802 {
6803 workload_profile = 3;
6804
6805 data.workload_profile = workload_profile;
6806 }
6807 }
6808
6809 /**
6810 * config
6811 */
6812
6813 uint hash_type = 0;
6814 uint salt_type = 0;
6815 uint attack_exec = 0;
6816 uint opts_type = 0;
6817 uint kern_type = 0;
6818 uint dgst_size = 0;
6819 uint esalt_size = 0;
6820 uint opti_type = 0;
6821 uint dgst_pos0 = -1;
6822 uint dgst_pos1 = -1;
6823 uint dgst_pos2 = -1;
6824 uint dgst_pos3 = -1;
6825
6826 int (*parse_func) (char *, uint, hash_t *);
6827 int (*sort_by_digest) (const void *, const void *);
6828
6829 uint algorithm_pos = 0;
6830 uint algorithm_max = 1;
6831
6832 uint *algorithms = default_benchmark_algorithms;
6833
6834 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6835
6836 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6837 {
6838 /*
6839 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6840 * the following algos are skipped entirely
6841 */
6842
6843 if (algorithm_pos > 0)
6844 {
6845 local_free (rd);
6846
6847 rd = init_restore (argc, argv);
6848
6849 data.rd = rd;
6850 }
6851
6852 /**
6853 * update hash_mode in case of multihash benchmark
6854 */
6855
6856 if (benchmark == 1)
6857 {
6858 if (hash_mode_chgd == 0)
6859 {
6860 hash_mode = algorithms[algorithm_pos];
6861
6862 data.hash_mode = hash_mode;
6863 }
6864
6865 quiet = 1;
6866
6867 data.quiet = quiet;
6868 }
6869
6870 switch (hash_mode)
6871 {
6872 case 0: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_NONE;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_PT_ADD80
6877 | OPTS_TYPE_PT_ADDBITS14;
6878 kern_type = KERN_TYPE_MD5;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_MEET_IN_MIDDLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_NOT_SALTED
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 10: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_INTERN;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_ST_ADD80
6901 | OPTS_TYPE_ST_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_PWSLT;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = md5s_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_MEET_IN_MIDDLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_APPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 11: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_INTERN;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_PWSLT;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = joomla_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_MEET_IN_MIDDLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 12: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_ST_ADD80
6949 | OPTS_TYPE_ST_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_PWSLT;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = postgresql_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_MEET_IN_MIDDLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_APPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 0;
6963 dgst_pos1 = 3;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 20: hash_type = HASH_TYPE_MD5;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_LE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS14;
6974 kern_type = KERN_TYPE_MD5_SLTPW;
6975 dgst_size = DGST_SIZE_4_4;
6976 parse_func = md5s_parse_hash;
6977 sort_by_digest = sort_by_digest_4_4;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_PREPENDED_SALT
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 0;
6986 dgst_pos1 = 3;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 21: hash_type = HASH_TYPE_MD5;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_LE
6995 | OPTS_TYPE_PT_ADD80
6996 | OPTS_TYPE_PT_ADDBITS14;
6997 kern_type = KERN_TYPE_MD5_SLTPW;
6998 dgst_size = DGST_SIZE_4_4;
6999 parse_func = osc_parse_hash;
7000 sort_by_digest = sort_by_digest_4_4;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_PREPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 0;
7009 dgst_pos1 = 3;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 22: hash_type = HASH_TYPE_MD5;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_LE
7018 | OPTS_TYPE_PT_ADD80
7019 | OPTS_TYPE_PT_ADDBITS14;
7020 kern_type = KERN_TYPE_MD5_SLTPW;
7021 dgst_size = DGST_SIZE_4_4;
7022 parse_func = netscreen_parse_hash;
7023 sort_by_digest = sort_by_digest_4_4;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_PREPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 0;
7032 dgst_pos1 = 3;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 23: hash_type = HASH_TYPE_MD5;
7038 salt_type = SALT_TYPE_EMBEDDED;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_LE
7041 | OPTS_TYPE_PT_ADD80
7042 | OPTS_TYPE_PT_ADDBITS14;
7043 kern_type = KERN_TYPE_MD5_SLTPW;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = skype_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_PREPENDED_SALT
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 0;
7055 dgst_pos1 = 3;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 30: hash_type = HASH_TYPE_MD5;
7061 salt_type = SALT_TYPE_INTERN;
7062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7063 opts_type = OPTS_TYPE_PT_GENERATE_LE
7064 | OPTS_TYPE_PT_UNICODE
7065 | OPTS_TYPE_ST_ADD80
7066 | OPTS_TYPE_ST_ADDBITS14;
7067 kern_type = KERN_TYPE_MD5_PWUSLT;
7068 dgst_size = DGST_SIZE_4_4;
7069 parse_func = md5s_parse_hash;
7070 sort_by_digest = sort_by_digest_4_4;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_MEET_IN_MIDDLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_APPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 40: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_PT_ADD80
7090 | OPTS_TYPE_PT_ADDBITS14
7091 | OPTS_TYPE_PT_UNICODE;
7092 kern_type = KERN_TYPE_MD5_SLTPWU;
7093 dgst_size = DGST_SIZE_4_4;
7094 parse_func = md5s_parse_hash;
7095 sort_by_digest = sort_by_digest_4_4;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_EARLY_SKIP
7100 | OPTI_TYPE_NOT_ITERATED
7101 | OPTI_TYPE_PREPENDED_SALT
7102 | OPTI_TYPE_RAW_HASH;
7103 dgst_pos0 = 0;
7104 dgst_pos1 = 3;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 50: hash_type = HASH_TYPE_MD5;
7110 salt_type = SALT_TYPE_INTERN;
7111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7112 opts_type = OPTS_TYPE_PT_GENERATE_LE
7113 | OPTS_TYPE_ST_ADD80
7114 | OPTS_TYPE_ST_ADDBITS14;
7115 kern_type = KERN_TYPE_HMACMD5_PW;
7116 dgst_size = DGST_SIZE_4_4;
7117 parse_func = hmacmd5_parse_hash;
7118 sort_by_digest = sort_by_digest_4_4;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_NOT_ITERATED;
7121 dgst_pos0 = 0;
7122 dgst_pos1 = 3;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 60: hash_type = HASH_TYPE_MD5;
7128 salt_type = SALT_TYPE_INTERN;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_LE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS14;
7133 kern_type = KERN_TYPE_HMACMD5_SLT;
7134 dgst_size = DGST_SIZE_4_4;
7135 parse_func = hmacmd5_parse_hash;
7136 sort_by_digest = sort_by_digest_4_4;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_NOT_ITERATED;
7139 dgst_pos0 = 0;
7140 dgst_pos1 = 3;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 100: hash_type = HASH_TYPE_SHA1;
7146 salt_type = SALT_TYPE_NONE;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_BE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS15;
7151 kern_type = KERN_TYPE_SHA1;
7152 dgst_size = DGST_SIZE_4_5;
7153 parse_func = sha1_parse_hash;
7154 sort_by_digest = sort_by_digest_4_5;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_NOT_SALTED
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 101: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_NONE;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_PT_ADD80
7173 | OPTS_TYPE_PT_ADDBITS15;
7174 kern_type = KERN_TYPE_SHA1;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = sha1b64_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_NOT_SALTED
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 110: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_INTERN;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_ST_ADD80
7196 | OPTS_TYPE_ST_ADDBITS15;
7197 kern_type = KERN_TYPE_SHA1_PWSLT;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = sha1s_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_APPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 111: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_EMBEDDED;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_ST_ADD80
7219 | OPTS_TYPE_ST_ADDBITS15;
7220 kern_type = KERN_TYPE_SHA1_PWSLT;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = sha1b64s_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_APPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 112: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_ST_ADD80
7242 | OPTS_TYPE_ST_ADDBITS15
7243 | OPTS_TYPE_ST_HEX;
7244 kern_type = KERN_TYPE_SHA1_PWSLT;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = oracles_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_APPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 120: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_INTERN;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_ADD80
7266 | OPTS_TYPE_PT_ADDBITS15;
7267 kern_type = KERN_TYPE_SHA1_SLTPW;
7268 dgst_size = DGST_SIZE_4_5;
7269 parse_func = sha1s_parse_hash;
7270 sort_by_digest = sort_by_digest_4_5;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 121: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_INTERN;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15
7290 | OPTS_TYPE_ST_LOWER;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = smf_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 122: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15
7314 | OPTS_TYPE_ST_HEX;
7315 kern_type = KERN_TYPE_SHA1_SLTPW;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = osx1_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_PREPENDED_SALT
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 124: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_EMBEDDED;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_ADD80
7337 | OPTS_TYPE_PT_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1_SLTPW;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = djangosha1_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_PREPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 125: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_EMBEDDED;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_ADD80
7360 | OPTS_TYPE_PT_ADDBITS15
7361 | OPTS_TYPE_ST_HEX;
7362 kern_type = KERN_TYPE_SHA1_SLTPW;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = arubaos_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_PREPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 130: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_INTERN;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_UNICODE
7384 | OPTS_TYPE_ST_ADD80
7385 | OPTS_TYPE_ST_ADDBITS15;
7386 kern_type = KERN_TYPE_SHA1_PWUSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = sha1s_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 131: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_EMBEDDED;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_PT_UNICODE
7408 | OPTS_TYPE_PT_UPPER
7409 | OPTS_TYPE_ST_ADD80
7410 | OPTS_TYPE_ST_ADDBITS15
7411 | OPTS_TYPE_ST_HEX;
7412 kern_type = KERN_TYPE_SHA1_PWUSLT;
7413 dgst_size = DGST_SIZE_4_5;
7414 parse_func = mssql2000_parse_hash;
7415 sort_by_digest = sort_by_digest_4_5;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_EARLY_SKIP
7420 | OPTI_TYPE_NOT_ITERATED
7421 | OPTI_TYPE_APPENDED_SALT
7422 | OPTI_TYPE_RAW_HASH;
7423 dgst_pos0 = 3;
7424 dgst_pos1 = 4;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 1;
7427 break;
7428
7429 case 132: hash_type = HASH_TYPE_SHA1;
7430 salt_type = SALT_TYPE_EMBEDDED;
7431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_BE
7433 | OPTS_TYPE_PT_UNICODE
7434 | OPTS_TYPE_ST_ADD80
7435 | OPTS_TYPE_ST_ADDBITS15
7436 | OPTS_TYPE_ST_HEX;
7437 kern_type = KERN_TYPE_SHA1_PWUSLT;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = mssql2005_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_APPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 133: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_EMBEDDED;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_UNICODE
7459 | OPTS_TYPE_ST_ADD80
7460 | OPTS_TYPE_ST_ADDBITS15;
7461 kern_type = KERN_TYPE_SHA1_PWUSLT;
7462 dgst_size = DGST_SIZE_4_5;
7463 parse_func = peoplesoft_parse_hash;
7464 sort_by_digest = sort_by_digest_4_5;
7465 opti_type = OPTI_TYPE_ZERO_BYTE
7466 | OPTI_TYPE_PRECOMPUTE_INIT
7467 | OPTI_TYPE_PRECOMPUTE_MERKLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_APPENDED_SALT
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 3;
7473 dgst_pos1 = 4;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 140: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_INTERN;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_BE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS15
7484 | OPTS_TYPE_PT_UNICODE;
7485 kern_type = KERN_TYPE_SHA1_SLTPWU;
7486 dgst_size = DGST_SIZE_4_5;
7487 parse_func = sha1s_parse_hash;
7488 sort_by_digest = sort_by_digest_4_5;
7489 opti_type = OPTI_TYPE_ZERO_BYTE
7490 | OPTI_TYPE_PRECOMPUTE_INIT
7491 | OPTI_TYPE_PRECOMPUTE_MERKLE
7492 | OPTI_TYPE_EARLY_SKIP
7493 | OPTI_TYPE_NOT_ITERATED
7494 | OPTI_TYPE_PREPENDED_SALT
7495 | OPTI_TYPE_RAW_HASH;
7496 dgst_pos0 = 3;
7497 dgst_pos1 = 4;
7498 dgst_pos2 = 2;
7499 dgst_pos3 = 1;
7500 break;
7501
7502 case 141: hash_type = HASH_TYPE_SHA1;
7503 salt_type = SALT_TYPE_EMBEDDED;
7504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7505 opts_type = OPTS_TYPE_PT_GENERATE_BE
7506 | OPTS_TYPE_PT_ADD80
7507 | OPTS_TYPE_PT_ADDBITS15
7508 | OPTS_TYPE_PT_UNICODE
7509 | OPTS_TYPE_ST_BASE64;
7510 kern_type = KERN_TYPE_SHA1_SLTPWU;
7511 dgst_size = DGST_SIZE_4_5;
7512 parse_func = episerver_parse_hash;
7513 sort_by_digest = sort_by_digest_4_5;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_PREPENDED_SALT
7520 | OPTI_TYPE_RAW_HASH;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 4;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 1;
7525 break;
7526
7527 case 150: hash_type = HASH_TYPE_SHA1;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_ST_ADD80
7532 | OPTS_TYPE_ST_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA1_PW;
7534 dgst_size = DGST_SIZE_4_5;
7535 parse_func = hmacsha1_parse_hash;
7536 sort_by_digest = sort_by_digest_4_5;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 160: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_PT_ADD80
7550 | OPTS_TYPE_PT_ADDBITS15;
7551 kern_type = KERN_TYPE_HMACSHA1_SLT;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = hmacsha1_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_NOT_ITERATED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 190: hash_type = HASH_TYPE_SHA1;
7564 salt_type = SALT_TYPE_NONE;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7570 dgst_size = DGST_SIZE_4_5;
7571 parse_func = sha1linkedin_parse_hash;
7572 sort_by_digest = sort_by_digest_4_5;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED
7577 | OPTI_TYPE_NOT_SALTED;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 4;
7580 dgst_pos2 = 3;
7581 dgst_pos3 = 2;
7582 break;
7583
7584 case 200: hash_type = HASH_TYPE_MYSQL;
7585 salt_type = SALT_TYPE_NONE;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = 0;
7588 kern_type = KERN_TYPE_MYSQL;
7589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7590 parse_func = mysql323_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7592 opti_type = OPTI_TYPE_ZERO_BYTE;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 1;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 3;
7597 break;
7598
7599 case 300: hash_type = HASH_TYPE_SHA1;
7600 salt_type = SALT_TYPE_NONE;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_BE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS15;
7605 kern_type = KERN_TYPE_MYSQL41;
7606 dgst_size = DGST_SIZE_4_5;
7607 parse_func = sha1_parse_hash;
7608 sort_by_digest = sort_by_digest_4_5;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_NOT_SALTED;
7615 dgst_pos0 = 3;
7616 dgst_pos1 = 4;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 1;
7619 break;
7620
7621 case 400: hash_type = HASH_TYPE_MD5;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7625 kern_type = KERN_TYPE_PHPASS;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = phpass_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_SLOW_HASH_SIMD;
7631 dgst_pos0 = 0;
7632 dgst_pos1 = 1;
7633 dgst_pos2 = 2;
7634 dgst_pos3 = 3;
7635 break;
7636
7637 case 500: hash_type = HASH_TYPE_MD5;
7638 salt_type = SALT_TYPE_EMBEDDED;
7639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7641 kern_type = KERN_TYPE_MD5CRYPT;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = md5crypt_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE;
7646 dgst_pos0 = 0;
7647 dgst_pos1 = 1;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 3;
7650 break;
7651
7652 case 501: hash_type = HASH_TYPE_MD5;
7653 salt_type = SALT_TYPE_EMBEDDED;
7654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_LE
7656 | OPTS_TYPE_HASH_COPY;
7657 kern_type = KERN_TYPE_MD5CRYPT;
7658 dgst_size = DGST_SIZE_4_4;
7659 parse_func = juniper_parse_hash;
7660 sort_by_digest = sort_by_digest_4_4;
7661 opti_type = OPTI_TYPE_ZERO_BYTE;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 1;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 3;
7666 break;
7667
7668 case 900: hash_type = HASH_TYPE_MD4;
7669 salt_type = SALT_TYPE_NONE;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_LE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS14;
7674 kern_type = KERN_TYPE_MD4;
7675 dgst_size = DGST_SIZE_4_4;
7676 parse_func = md4_parse_hash;
7677 sort_by_digest = sort_by_digest_4_4;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_MEET_IN_MIDDLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_NOT_SALTED
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 0;
7687 dgst_pos1 = 3;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 1;
7690 break;
7691
7692 case 1000: hash_type = HASH_TYPE_MD4;
7693 salt_type = SALT_TYPE_NONE;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_LE
7696 | OPTS_TYPE_PT_ADD80
7697 | OPTS_TYPE_PT_ADDBITS14
7698 | OPTS_TYPE_PT_UNICODE;
7699 kern_type = KERN_TYPE_MD4_PWU;
7700 dgst_size = DGST_SIZE_4_4;
7701 parse_func = md4_parse_hash;
7702 sort_by_digest = sort_by_digest_4_4;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_MEET_IN_MIDDLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_NOT_SALTED
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 3;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 1100: hash_type = HASH_TYPE_MD4;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_LE
7721 | OPTS_TYPE_PT_ADD80
7722 | OPTS_TYPE_PT_ADDBITS14
7723 | OPTS_TYPE_PT_UNICODE
7724 | OPTS_TYPE_ST_ADD80
7725 | OPTS_TYPE_ST_UNICODE
7726 | OPTS_TYPE_ST_LOWER;
7727 kern_type = KERN_TYPE_MD44_PWUSLT;
7728 dgst_size = DGST_SIZE_4_4;
7729 parse_func = dcc_parse_hash;
7730 sort_by_digest = sort_by_digest_4_4;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED;
7736 dgst_pos0 = 0;
7737 dgst_pos1 = 3;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 1400: hash_type = HASH_TYPE_SHA256;
7743 salt_type = SALT_TYPE_NONE;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA256;
7749 dgst_size = DGST_SIZE_4_8;
7750 parse_func = sha256_parse_hash;
7751 sort_by_digest = sort_by_digest_4_8;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_NOT_SALTED
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1410: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_ST_ADD80
7770 | OPTS_TYPE_ST_ADDBITS15;
7771 kern_type = KERN_TYPE_SHA256_PWSLT;
7772 dgst_size = DGST_SIZE_4_8;
7773 parse_func = sha256s_parse_hash;
7774 sort_by_digest = sort_by_digest_4_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP
7779 | OPTI_TYPE_NOT_ITERATED
7780 | OPTI_TYPE_APPENDED_SALT
7781 | OPTI_TYPE_RAW_HASH;
7782 dgst_pos0 = 3;
7783 dgst_pos1 = 7;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 6;
7786 break;
7787
7788 case 1420: hash_type = HASH_TYPE_SHA256;
7789 salt_type = SALT_TYPE_INTERN;
7790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_BE
7792 | OPTS_TYPE_PT_ADD80
7793 | OPTS_TYPE_PT_ADDBITS15;
7794 kern_type = KERN_TYPE_SHA256_SLTPW;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = sha256s_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_PREPENDED_SALT
7804 | OPTI_TYPE_RAW_HASH;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 7;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 6;
7809 break;
7810
7811 case 1421: hash_type = HASH_TYPE_SHA256;
7812 salt_type = SALT_TYPE_EMBEDDED;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_ADD80
7816 | OPTS_TYPE_PT_ADDBITS15;
7817 kern_type = KERN_TYPE_SHA256_SLTPW;
7818 dgst_size = DGST_SIZE_4_8;
7819 parse_func = hmailserver_parse_hash;
7820 sort_by_digest = sort_by_digest_4_8;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 7;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 6;
7832 break;
7833
7834 case 1430: hash_type = HASH_TYPE_SHA256;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_UNICODE
7839 | OPTS_TYPE_ST_ADD80
7840 | OPTS_TYPE_ST_ADDBITS15;
7841 kern_type = KERN_TYPE_SHA256_PWUSLT;
7842 dgst_size = DGST_SIZE_4_8;
7843 parse_func = sha256s_parse_hash;
7844 sort_by_digest = sort_by_digest_4_8;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_APPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 7;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 6;
7856 break;
7857
7858 case 1440: hash_type = HASH_TYPE_SHA256;
7859 salt_type = SALT_TYPE_INTERN;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS15
7864 | OPTS_TYPE_PT_UNICODE;
7865 kern_type = KERN_TYPE_SHA256_SLTPWU;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = sha256s_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_EARLY_SKIP
7873 | OPTI_TYPE_NOT_ITERATED
7874 | OPTI_TYPE_PREPENDED_SALT
7875 | OPTI_TYPE_RAW_HASH;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 7;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 6;
7880 break;
7881
7882 case 1441: hash_type = HASH_TYPE_SHA256;
7883 salt_type = SALT_TYPE_EMBEDDED;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_PT_ADD80
7887 | OPTS_TYPE_PT_ADDBITS15
7888 | OPTS_TYPE_PT_UNICODE
7889 | OPTS_TYPE_ST_BASE64;
7890 kern_type = KERN_TYPE_SHA256_SLTPWU;
7891 dgst_size = DGST_SIZE_4_8;
7892 parse_func = episerver4_parse_hash;
7893 sort_by_digest = sort_by_digest_4_8;
7894 opti_type = OPTI_TYPE_ZERO_BYTE
7895 | OPTI_TYPE_PRECOMPUTE_INIT
7896 | OPTI_TYPE_PRECOMPUTE_MERKLE
7897 | OPTI_TYPE_EARLY_SKIP
7898 | OPTI_TYPE_NOT_ITERATED
7899 | OPTI_TYPE_PREPENDED_SALT
7900 | OPTI_TYPE_RAW_HASH;
7901 dgst_pos0 = 3;
7902 dgst_pos1 = 7;
7903 dgst_pos2 = 2;
7904 dgst_pos3 = 6;
7905 break;
7906
7907 case 1450: hash_type = HASH_TYPE_SHA256;
7908 salt_type = SALT_TYPE_INTERN;
7909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7910 opts_type = OPTS_TYPE_PT_GENERATE_BE
7911 | OPTS_TYPE_ST_ADD80;
7912 kern_type = KERN_TYPE_HMACSHA256_PW;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = hmacsha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_NOT_ITERATED;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1460: hash_type = HASH_TYPE_SHA256;
7925 salt_type = SALT_TYPE_INTERN;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_BE
7928 | OPTS_TYPE_PT_ADD80
7929 | OPTS_TYPE_PT_ADDBITS15;
7930 kern_type = KERN_TYPE_HMACSHA256_SLT;
7931 dgst_size = DGST_SIZE_4_8;
7932 parse_func = hmacsha256_parse_hash;
7933 sort_by_digest = sort_by_digest_4_8;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_NOT_ITERATED;
7936 dgst_pos0 = 3;
7937 dgst_pos1 = 7;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 6;
7940 break;
7941
7942 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7943 salt_type = SALT_TYPE_EMBEDDED;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_LE
7946 | OPTS_TYPE_PT_BITSLICE;
7947 kern_type = KERN_TYPE_DESCRYPT;
7948 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7949 parse_func = descrypt_parse_hash;
7950 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7951 opti_type = OPTI_TYPE_ZERO_BYTE
7952 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7953 dgst_pos0 = 0;
7954 dgst_pos1 = 1;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 3;
7957 break;
7958
7959 case 1600: hash_type = HASH_TYPE_MD5;
7960 salt_type = SALT_TYPE_EMBEDDED;
7961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7963 kern_type = KERN_TYPE_APR1CRYPT;
7964 dgst_size = DGST_SIZE_4_4;
7965 parse_func = md5apr1_parse_hash;
7966 sort_by_digest = sort_by_digest_4_4;
7967 opti_type = OPTI_TYPE_ZERO_BYTE;
7968 dgst_pos0 = 0;
7969 dgst_pos1 = 1;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 3;
7972 break;
7973
7974 case 1700: hash_type = HASH_TYPE_SHA512;
7975 salt_type = SALT_TYPE_NONE;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA512;
7981 dgst_size = DGST_SIZE_8_8;
7982 parse_func = sha512_parse_hash;
7983 sort_by_digest = sort_by_digest_8_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_NOT_SALTED
7990 | OPTI_TYPE_USES_BITS_64
7991 | OPTI_TYPE_RAW_HASH;
7992 dgst_pos0 = 14;
7993 dgst_pos1 = 15;
7994 dgst_pos2 = 6;
7995 dgst_pos3 = 7;
7996 break;
7997
7998 case 1710: hash_type = HASH_TYPE_SHA512;
7999 salt_type = SALT_TYPE_INTERN;
8000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8001 opts_type = OPTS_TYPE_PT_GENERATE_BE
8002 | OPTS_TYPE_ST_ADD80
8003 | OPTS_TYPE_ST_ADDBITS15;
8004 kern_type = KERN_TYPE_SHA512_PWSLT;
8005 dgst_size = DGST_SIZE_8_8;
8006 parse_func = sha512s_parse_hash;
8007 sort_by_digest = sort_by_digest_8_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP
8012 | OPTI_TYPE_NOT_ITERATED
8013 | OPTI_TYPE_APPENDED_SALT
8014 | OPTI_TYPE_USES_BITS_64
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 14;
8017 dgst_pos1 = 15;
8018 dgst_pos2 = 6;
8019 dgst_pos3 = 7;
8020 break;
8021
8022 case 1711: hash_type = HASH_TYPE_SHA512;
8023 salt_type = SALT_TYPE_EMBEDDED;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_ST_ADD80
8027 | OPTS_TYPE_ST_ADDBITS15;
8028 kern_type = KERN_TYPE_SHA512_PWSLT;
8029 dgst_size = DGST_SIZE_8_8;
8030 parse_func = sha512b64s_parse_hash;
8031 sort_by_digest = sort_by_digest_8_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_APPENDED_SALT
8038 | OPTI_TYPE_USES_BITS_64
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 14;
8041 dgst_pos1 = 15;
8042 dgst_pos2 = 6;
8043 dgst_pos3 = 7;
8044 break;
8045
8046 case 1720: hash_type = HASH_TYPE_SHA512;
8047 salt_type = SALT_TYPE_INTERN;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_ADD80
8051 | OPTS_TYPE_PT_ADDBITS15;
8052 kern_type = KERN_TYPE_SHA512_SLTPW;
8053 dgst_size = DGST_SIZE_8_8;
8054 parse_func = sha512s_parse_hash;
8055 sort_by_digest = sort_by_digest_8_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_PRECOMPUTE_MERKLE
8059 | OPTI_TYPE_EARLY_SKIP
8060 | OPTI_TYPE_NOT_ITERATED
8061 | OPTI_TYPE_PREPENDED_SALT
8062 | OPTI_TYPE_USES_BITS_64
8063 | OPTI_TYPE_RAW_HASH;
8064 dgst_pos0 = 14;
8065 dgst_pos1 = 15;
8066 dgst_pos2 = 6;
8067 dgst_pos3 = 7;
8068 break;
8069
8070 case 1722: hash_type = HASH_TYPE_SHA512;
8071 salt_type = SALT_TYPE_EMBEDDED;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_BE
8074 | OPTS_TYPE_PT_ADD80
8075 | OPTS_TYPE_PT_ADDBITS15
8076 | OPTS_TYPE_ST_HEX;
8077 kern_type = KERN_TYPE_SHA512_SLTPW;
8078 dgst_size = DGST_SIZE_8_8;
8079 parse_func = osx512_parse_hash;
8080 sort_by_digest = sort_by_digest_8_8;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP
8085 | OPTI_TYPE_NOT_ITERATED
8086 | OPTI_TYPE_PREPENDED_SALT
8087 | OPTI_TYPE_USES_BITS_64
8088 | OPTI_TYPE_RAW_HASH;
8089 dgst_pos0 = 14;
8090 dgst_pos1 = 15;
8091 dgst_pos2 = 6;
8092 dgst_pos3 = 7;
8093 break;
8094
8095 case 1730: hash_type = HASH_TYPE_SHA512;
8096 salt_type = SALT_TYPE_INTERN;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_BE
8099 | OPTS_TYPE_PT_UNICODE
8100 | OPTS_TYPE_ST_ADD80
8101 | OPTS_TYPE_ST_ADDBITS15;
8102 kern_type = KERN_TYPE_SHA512_PWSLTU;
8103 dgst_size = DGST_SIZE_8_8;
8104 parse_func = sha512s_parse_hash;
8105 sort_by_digest = sort_by_digest_8_8;
8106 opti_type = OPTI_TYPE_ZERO_BYTE
8107 | OPTI_TYPE_PRECOMPUTE_INIT
8108 | OPTI_TYPE_PRECOMPUTE_MERKLE
8109 | OPTI_TYPE_EARLY_SKIP
8110 | OPTI_TYPE_NOT_ITERATED
8111 | OPTI_TYPE_APPENDED_SALT
8112 | OPTI_TYPE_USES_BITS_64
8113 | OPTI_TYPE_RAW_HASH;
8114 dgst_pos0 = 14;
8115 dgst_pos1 = 15;
8116 dgst_pos2 = 6;
8117 dgst_pos3 = 7;
8118 break;
8119
8120 case 1731: hash_type = HASH_TYPE_SHA512;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_BE
8124 | OPTS_TYPE_PT_UNICODE
8125 | OPTS_TYPE_ST_ADD80
8126 | OPTS_TYPE_ST_ADDBITS15
8127 | OPTS_TYPE_ST_HEX;
8128 kern_type = KERN_TYPE_SHA512_PWSLTU;
8129 dgst_size = DGST_SIZE_8_8;
8130 parse_func = mssql2012_parse_hash;
8131 sort_by_digest = sort_by_digest_8_8;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_APPENDED_SALT
8138 | OPTI_TYPE_USES_BITS_64
8139 | OPTI_TYPE_RAW_HASH;
8140 dgst_pos0 = 14;
8141 dgst_pos1 = 15;
8142 dgst_pos2 = 6;
8143 dgst_pos3 = 7;
8144 break;
8145
8146 case 1740: hash_type = HASH_TYPE_SHA512;
8147 salt_type = SALT_TYPE_INTERN;
8148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149 opts_type = OPTS_TYPE_PT_GENERATE_BE
8150 | OPTS_TYPE_PT_ADD80
8151 | OPTS_TYPE_PT_ADDBITS15
8152 | OPTS_TYPE_PT_UNICODE;
8153 kern_type = KERN_TYPE_SHA512_SLTPWU;
8154 dgst_size = DGST_SIZE_8_8;
8155 parse_func = sha512s_parse_hash;
8156 sort_by_digest = sort_by_digest_8_8;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_ITERATED
8162 | OPTI_TYPE_PREPENDED_SALT
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_RAW_HASH;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1750: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_ST_ADD80;
8176 kern_type = KERN_TYPE_HMACSHA512_PW;
8177 dgst_size = DGST_SIZE_8_8;
8178 parse_func = hmacsha512_parse_hash;
8179 sort_by_digest = sort_by_digest_8_8;
8180 opti_type = OPTI_TYPE_ZERO_BYTE
8181 | OPTI_TYPE_USES_BITS_64
8182 | OPTI_TYPE_NOT_ITERATED;
8183 dgst_pos0 = 14;
8184 dgst_pos1 = 15;
8185 dgst_pos2 = 6;
8186 dgst_pos3 = 7;
8187 break;
8188
8189 case 1760: hash_type = HASH_TYPE_SHA512;
8190 salt_type = SALT_TYPE_INTERN;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_BE
8193 | OPTS_TYPE_PT_ADD80
8194 | OPTS_TYPE_PT_ADDBITS15;
8195 kern_type = KERN_TYPE_HMACSHA512_SLT;
8196 dgst_size = DGST_SIZE_8_8;
8197 parse_func = hmacsha512_parse_hash;
8198 sort_by_digest = sort_by_digest_8_8;
8199 opti_type = OPTI_TYPE_ZERO_BYTE
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_NOT_ITERATED;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1800: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8212 kern_type = KERN_TYPE_SHA512CRYPT;
8213 dgst_size = DGST_SIZE_8_8;
8214 parse_func = sha512crypt_parse_hash;
8215 sort_by_digest = sort_by_digest_8_8;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_USES_BITS_64;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 1;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 3;
8222 break;
8223
8224 case 2100: hash_type = HASH_TYPE_DCC2;
8225 salt_type = SALT_TYPE_EMBEDDED;
8226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8228 | OPTS_TYPE_ST_LOWER
8229 | OPTS_TYPE_ST_UNICODE;
8230 kern_type = KERN_TYPE_DCC2;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = dcc2_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_SLOW_HASH_SIMD;
8236 dgst_pos0 = 0;
8237 dgst_pos1 = 1;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 3;
8240 break;
8241
8242 case 2400: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_NONE;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8246 kern_type = KERN_TYPE_MD5PIX;
8247 dgst_size = DGST_SIZE_4_4;
8248 parse_func = md5pix_parse_hash;
8249 sort_by_digest = sort_by_digest_4_4;
8250 opti_type = OPTI_TYPE_ZERO_BYTE
8251 | OPTI_TYPE_PRECOMPUTE_INIT
8252 | OPTI_TYPE_PRECOMPUTE_MERKLE
8253 | OPTI_TYPE_EARLY_SKIP
8254 | OPTI_TYPE_NOT_ITERATED
8255 | OPTI_TYPE_NOT_SALTED;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2410: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8266 kern_type = KERN_TYPE_MD5ASA;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md5asa_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 3;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 1;
8279 break;
8280
8281 case 2500: hash_type = HASH_TYPE_WPA;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8285 kern_type = KERN_TYPE_WPA;
8286 dgst_size = DGST_SIZE_4_4;
8287 parse_func = wpa_parse_hash;
8288 sort_by_digest = sort_by_digest_4_4;
8289 opti_type = OPTI_TYPE_ZERO_BYTE
8290 | OPTI_TYPE_SLOW_HASH_SIMD;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 1;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 3;
8295 break;
8296
8297 case 2600: hash_type = HASH_TYPE_MD5;
8298 salt_type = SALT_TYPE_VIRTUAL;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_LE
8301 | OPTS_TYPE_PT_ADD80
8302 | OPTS_TYPE_PT_ADDBITS14
8303 | OPTS_TYPE_ST_ADD80;
8304 kern_type = KERN_TYPE_MD55_PWSLT1;
8305 dgst_size = DGST_SIZE_4_4;
8306 parse_func = md5md5_parse_hash;
8307 sort_by_digest = sort_by_digest_4_4;
8308 opti_type = OPTI_TYPE_ZERO_BYTE
8309 | OPTI_TYPE_PRECOMPUTE_INIT
8310 | OPTI_TYPE_PRECOMPUTE_MERKLE
8311 | OPTI_TYPE_EARLY_SKIP;
8312 dgst_pos0 = 0;
8313 dgst_pos1 = 3;
8314 dgst_pos2 = 2;
8315 dgst_pos3 = 1;
8316 break;
8317
8318 case 2611: hash_type = HASH_TYPE_MD5;
8319 salt_type = SALT_TYPE_INTERN;
8320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8321 opts_type = OPTS_TYPE_PT_GENERATE_LE
8322 | OPTS_TYPE_PT_ADD80
8323 | OPTS_TYPE_PT_ADDBITS14
8324 | OPTS_TYPE_ST_ADD80;
8325 kern_type = KERN_TYPE_MD55_PWSLT1;
8326 dgst_size = DGST_SIZE_4_4;
8327 parse_func = vb3_parse_hash;
8328 sort_by_digest = sort_by_digest_4_4;
8329 opti_type = OPTI_TYPE_ZERO_BYTE
8330 | OPTI_TYPE_PRECOMPUTE_INIT
8331 | OPTI_TYPE_PRECOMPUTE_MERKLE
8332 | OPTI_TYPE_EARLY_SKIP;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 3;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 1;
8337 break;
8338
8339 case 2612: hash_type = HASH_TYPE_MD5;
8340 salt_type = SALT_TYPE_EMBEDDED;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_LE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS14
8345 | OPTS_TYPE_ST_ADD80
8346 | OPTS_TYPE_ST_HEX;
8347 kern_type = KERN_TYPE_MD55_PWSLT1;
8348 dgst_size = DGST_SIZE_4_4;
8349 parse_func = phps_parse_hash;
8350 sort_by_digest = sort_by_digest_4_4;
8351 opti_type = OPTI_TYPE_ZERO_BYTE
8352 | OPTI_TYPE_PRECOMPUTE_INIT
8353 | OPTI_TYPE_PRECOMPUTE_MERKLE
8354 | OPTI_TYPE_EARLY_SKIP;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 2711: hash_type = HASH_TYPE_MD5;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_LE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS14
8367 | OPTS_TYPE_ST_ADD80;
8368 kern_type = KERN_TYPE_MD55_PWSLT2;
8369 dgst_size = DGST_SIZE_4_4;
8370 parse_func = vb30_parse_hash;
8371 sort_by_digest = sort_by_digest_4_4;
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_PRECOMPUTE_INIT
8374 | OPTI_TYPE_EARLY_SKIP;
8375 dgst_pos0 = 0;
8376 dgst_pos1 = 3;
8377 dgst_pos2 = 2;
8378 dgst_pos3 = 1;
8379 break;
8380
8381 case 2811: hash_type = HASH_TYPE_MD5;
8382 salt_type = SALT_TYPE_INTERN;
8383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_LE
8385 | OPTS_TYPE_PT_ADD80
8386 | OPTS_TYPE_PT_ADDBITS14;
8387 kern_type = KERN_TYPE_MD55_SLTPW;
8388 dgst_size = DGST_SIZE_4_4;
8389 parse_func = ipb2_parse_hash;
8390 sort_by_digest = sort_by_digest_4_4;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_EARLY_SKIP;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 3;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 1;
8398 break;
8399
8400 case 3000: hash_type = HASH_TYPE_LM;
8401 salt_type = SALT_TYPE_NONE;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_UPPER
8405 | OPTS_TYPE_PT_BITSLICE;
8406 kern_type = KERN_TYPE_LM;
8407 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8408 parse_func = lm_parse_hash;
8409 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 3100: hash_type = HASH_TYPE_ORACLEH;
8419 salt_type = SALT_TYPE_INTERN;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE
8422 | OPTS_TYPE_PT_UPPER
8423 | OPTS_TYPE_ST_UPPER;
8424 kern_type = KERN_TYPE_ORACLEH;
8425 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8426 parse_func = oracleh_parse_hash;
8427 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8428 opti_type = OPTI_TYPE_ZERO_BYTE;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 1;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 3;
8433 break;
8434
8435 case 3200: hash_type = HASH_TYPE_BCRYPT;
8436 salt_type = SALT_TYPE_EMBEDDED;
8437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE
8439 | OPTS_TYPE_ST_GENERATE_LE;
8440 kern_type = KERN_TYPE_BCRYPT;
8441 dgst_size = DGST_SIZE_4_6;
8442 parse_func = bcrypt_parse_hash;
8443 sort_by_digest = sort_by_digest_4_6;
8444 opti_type = OPTI_TYPE_ZERO_BYTE;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 1;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 3;
8449 break;
8450
8451 case 3710: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_INTERN;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14;
8457 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = md5s_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 3711: hash_type = HASH_TYPE_MD5;
8472 salt_type = SALT_TYPE_EMBEDDED;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE
8475 | OPTS_TYPE_PT_ADD80
8476 | OPTS_TYPE_PT_ADDBITS14;
8477 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8478 dgst_size = DGST_SIZE_4_4;
8479 parse_func = mediawiki_b_parse_hash;
8480 sort_by_digest = sort_by_digest_4_4;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP;
8485 dgst_pos0 = 0;
8486 dgst_pos1 = 3;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 1;
8489 break;
8490
8491 case 3800: hash_type = HASH_TYPE_MD5;
8492 salt_type = SALT_TYPE_INTERN;
8493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_LE
8495 | OPTS_TYPE_ST_ADDBITS14;
8496 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8497 dgst_size = DGST_SIZE_4_4;
8498 parse_func = md5s_parse_hash;
8499 sort_by_digest = sort_by_digest_4_4;
8500 opti_type = OPTI_TYPE_ZERO_BYTE
8501 | OPTI_TYPE_PRECOMPUTE_INIT
8502 | OPTI_TYPE_PRECOMPUTE_MERKLE
8503 | OPTI_TYPE_EARLY_SKIP
8504 | OPTI_TYPE_NOT_ITERATED
8505 | OPTI_TYPE_RAW_HASH;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 4300: hash_type = HASH_TYPE_MD5;
8513 salt_type = SALT_TYPE_VIRTUAL;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADD80
8517 | OPTS_TYPE_PT_ADDBITS14
8518 | OPTS_TYPE_ST_ADD80;
8519 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8520 dgst_size = DGST_SIZE_4_4;
8521 parse_func = md5md5_parse_hash;
8522 sort_by_digest = sort_by_digest_4_4;
8523 opti_type = OPTI_TYPE_ZERO_BYTE
8524 | OPTI_TYPE_PRECOMPUTE_INIT
8525 | OPTI_TYPE_PRECOMPUTE_MERKLE
8526 | OPTI_TYPE_EARLY_SKIP;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 3;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 1;
8531 break;
8532
8533
8534 case 4400: hash_type = HASH_TYPE_MD5;
8535 salt_type = SALT_TYPE_NONE;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_BE
8538 | OPTS_TYPE_PT_ADD80
8539 | OPTS_TYPE_PT_ADDBITS15;
8540 kern_type = KERN_TYPE_MD5_SHA1;
8541 dgst_size = DGST_SIZE_4_4;
8542 parse_func = md5_parse_hash;
8543 sort_by_digest = sort_by_digest_4_4;
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_PRECOMPUTE_INIT
8546 | OPTI_TYPE_PRECOMPUTE_MERKLE
8547 | OPTI_TYPE_EARLY_SKIP
8548 | OPTI_TYPE_NOT_ITERATED
8549 | OPTI_TYPE_NOT_SALTED
8550 | OPTI_TYPE_RAW_HASH;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 3;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 1;
8555 break;
8556
8557 case 4500: hash_type = HASH_TYPE_SHA1;
8558 salt_type = SALT_TYPE_NONE;
8559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_BE
8561 | OPTS_TYPE_PT_ADD80
8562 | OPTS_TYPE_PT_ADDBITS15;
8563 kern_type = KERN_TYPE_SHA11;
8564 dgst_size = DGST_SIZE_4_5;
8565 parse_func = sha1_parse_hash;
8566 sort_by_digest = sort_by_digest_4_5;
8567 opti_type = OPTI_TYPE_ZERO_BYTE
8568 | OPTI_TYPE_PRECOMPUTE_INIT
8569 | OPTI_TYPE_PRECOMPUTE_MERKLE
8570 | OPTI_TYPE_EARLY_SKIP
8571 | OPTI_TYPE_NOT_SALTED;
8572 dgst_pos0 = 3;
8573 dgst_pos1 = 4;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 1;
8576 break;
8577
8578 case 4700: hash_type = HASH_TYPE_SHA1;
8579 salt_type = SALT_TYPE_NONE;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE
8582 | OPTS_TYPE_PT_ADD80
8583 | OPTS_TYPE_PT_ADDBITS14;
8584 kern_type = KERN_TYPE_SHA1_MD5;
8585 dgst_size = DGST_SIZE_4_5;
8586 parse_func = sha1_parse_hash;
8587 sort_by_digest = sort_by_digest_4_5;
8588 opti_type = OPTI_TYPE_ZERO_BYTE
8589 | OPTI_TYPE_PRECOMPUTE_INIT
8590 | OPTI_TYPE_PRECOMPUTE_MERKLE
8591 | OPTI_TYPE_EARLY_SKIP
8592 | OPTI_TYPE_NOT_ITERATED
8593 | OPTI_TYPE_NOT_SALTED
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 3;
8596 dgst_pos1 = 4;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 1;
8599 break;
8600
8601 case 4800: hash_type = HASH_TYPE_MD5;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE
8605 | OPTS_TYPE_PT_ADDBITS14;
8606 kern_type = KERN_TYPE_MD5_CHAP;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = chap_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE
8611 | OPTI_TYPE_PRECOMPUTE_INIT
8612 | OPTI_TYPE_PRECOMPUTE_MERKLE
8613 | OPTI_TYPE_MEET_IN_MIDDLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_RAW_HASH;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 3;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 1;
8621 break;
8622
8623 case 4900: hash_type = HASH_TYPE_SHA1;
8624 salt_type = SALT_TYPE_INTERN;
8625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = sha1s_parse_hash;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_PRECOMPUTE_INIT
8633 | OPTI_TYPE_PRECOMPUTE_MERKLE
8634 | OPTI_TYPE_EARLY_SKIP;
8635 dgst_pos0 = 3;
8636 dgst_pos1 = 4;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 1;
8639 break;
8640
8641 case 5000: hash_type = HASH_TYPE_KECCAK;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE
8645 | OPTS_TYPE_PT_ADD01;
8646 kern_type = KERN_TYPE_KECCAK;
8647 dgst_size = DGST_SIZE_8_25;
8648 parse_func = keccak_parse_hash;
8649 sort_by_digest = sort_by_digest_8_25;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_USES_BITS_64
8652 | OPTI_TYPE_RAW_HASH;
8653 dgst_pos0 = 2;
8654 dgst_pos1 = 3;
8655 dgst_pos2 = 4;
8656 dgst_pos3 = 5;
8657 break;
8658
8659 case 5100: hash_type = HASH_TYPE_MD5H;
8660 salt_type = SALT_TYPE_NONE;
8661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_LE
8663 | OPTS_TYPE_PT_ADD80
8664 | OPTS_TYPE_PT_ADDBITS14;
8665 kern_type = KERN_TYPE_MD5H;
8666 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8667 parse_func = md5half_parse_hash;
8668 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8669 opti_type = OPTI_TYPE_ZERO_BYTE
8670 | OPTI_TYPE_RAW_HASH;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 5200: hash_type = HASH_TYPE_SHA256;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8681 kern_type = KERN_TYPE_PSAFE3;
8682 dgst_size = DGST_SIZE_4_8;
8683 parse_func = psafe3_parse_hash;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 5300: hash_type = HASH_TYPE_MD5;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE
8696 | OPTS_TYPE_ST_ADD80;
8697 kern_type = KERN_TYPE_IKEPSK_MD5;
8698 dgst_size = DGST_SIZE_4_4;
8699 parse_func = ikepsk_md5_parse_hash;
8700 sort_by_digest = sort_by_digest_4_4;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 3;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 1;
8706 break;
8707
8708 case 5400: hash_type = HASH_TYPE_SHA1;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_BE
8712 | OPTS_TYPE_ST_ADD80;
8713 kern_type = KERN_TYPE_IKEPSK_SHA1;
8714 dgst_size = DGST_SIZE_4_5;
8715 parse_func = ikepsk_sha1_parse_hash;
8716 sort_by_digest = sort_by_digest_4_5;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 3;
8719 dgst_pos1 = 4;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 5500: hash_type = HASH_TYPE_NETNTLM;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS14
8730 | OPTS_TYPE_PT_UNICODE
8731 | OPTS_TYPE_ST_HEX;
8732 kern_type = KERN_TYPE_NETNTLMv1;
8733 dgst_size = DGST_SIZE_4_4;
8734 parse_func = netntlmv1_parse_hash;
8735 sort_by_digest = sort_by_digest_4_4;
8736 opti_type = OPTI_TYPE_ZERO_BYTE
8737 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 5600: hash_type = HASH_TYPE_MD5;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14
8750 | OPTS_TYPE_PT_UNICODE;
8751 kern_type = KERN_TYPE_NETNTLMv2;
8752 dgst_size = DGST_SIZE_4_4;
8753 parse_func = netntlmv2_parse_hash;
8754 sort_by_digest = sort_by_digest_4_4;
8755 opti_type = OPTI_TYPE_ZERO_BYTE;
8756 dgst_pos0 = 0;
8757 dgst_pos1 = 3;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 1;
8760 break;
8761
8762 case 5700: hash_type = HASH_TYPE_SHA256;
8763 salt_type = SALT_TYPE_NONE;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_BE
8766 | OPTS_TYPE_PT_ADD80
8767 | OPTS_TYPE_PT_ADDBITS15;
8768 kern_type = KERN_TYPE_SHA256;
8769 dgst_size = DGST_SIZE_4_8;
8770 parse_func = cisco4_parse_hash;
8771 sort_by_digest = sort_by_digest_4_8;
8772 opti_type = OPTI_TYPE_ZERO_BYTE
8773 | OPTI_TYPE_PRECOMPUTE_INIT
8774 | OPTI_TYPE_PRECOMPUTE_MERKLE
8775 | OPTI_TYPE_EARLY_SKIP
8776 | OPTI_TYPE_NOT_ITERATED
8777 | OPTI_TYPE_NOT_SALTED
8778 | OPTI_TYPE_RAW_HASH;
8779 dgst_pos0 = 3;
8780 dgst_pos1 = 7;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 6;
8783 break;
8784
8785 case 5800: hash_type = HASH_TYPE_SHA1;
8786 salt_type = SALT_TYPE_INTERN;
8787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8789 | OPTS_TYPE_ST_ADD80;
8790 kern_type = KERN_TYPE_ANDROIDPIN;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = androidpin_parse_hash;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8802 salt_type = SALT_TYPE_NONE;
8803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE
8805 | OPTS_TYPE_PT_ADD80;
8806 kern_type = KERN_TYPE_RIPEMD160;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = ripemd160_parse_hash;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8818 salt_type = SALT_TYPE_NONE;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_BE
8821 | OPTS_TYPE_PT_ADD80;
8822 kern_type = KERN_TYPE_WHIRLPOOL;
8823 dgst_size = DGST_SIZE_4_16;
8824 parse_func = whirlpool_parse_hash;
8825 sort_by_digest = sort_by_digest_4_16;
8826 opti_type = OPTI_TYPE_ZERO_BYTE;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8837 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8838 dgst_size = DGST_SIZE_4_5;
8839 parse_func = truecrypt_parse_hash_2k;
8840 sort_by_digest = sort_by_digest_4_5;
8841 opti_type = OPTI_TYPE_ZERO_BYTE;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8849 salt_type = SALT_TYPE_EMBEDDED;
8850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8852 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8853 dgst_size = DGST_SIZE_4_5;
8854 parse_func = truecrypt_parse_hash_2k;
8855 sort_by_digest = sort_by_digest_4_5;
8856 opti_type = OPTI_TYPE_ZERO_BYTE;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8867 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8868 dgst_size = DGST_SIZE_4_5;
8869 parse_func = truecrypt_parse_hash_2k;
8870 sort_by_digest = sort_by_digest_4_5;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6221: hash_type = HASH_TYPE_SHA512;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8882 kern_type = KERN_TYPE_TCSHA512_XTS512;
8883 dgst_size = DGST_SIZE_8_8;
8884 parse_func = truecrypt_parse_hash_1k;
8885 sort_by_digest = sort_by_digest_8_8;
8886 opti_type = OPTI_TYPE_ZERO_BYTE
8887 | OPTI_TYPE_USES_BITS_64;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6222: hash_type = HASH_TYPE_SHA512;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8898 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8899 dgst_size = DGST_SIZE_8_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_8_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_USES_BITS_64;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6223: hash_type = HASH_TYPE_SHA512;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8914 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8915 dgst_size = DGST_SIZE_8_8;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_8_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE
8919 | OPTI_TYPE_USES_BITS_64;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8930 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8931 dgst_size = DGST_SIZE_4_8;
8932 parse_func = truecrypt_parse_hash_1k;
8933 sort_by_digest = sort_by_digest_4_8;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8945 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8946 dgst_size = DGST_SIZE_4_8;
8947 parse_func = truecrypt_parse_hash_1k;
8948 sort_by_digest = sort_by_digest_4_8;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8961 dgst_size = DGST_SIZE_4_8;
8962 parse_func = truecrypt_parse_hash_1k;
8963 sort_by_digest = sort_by_digest_4_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = truecrypt_parse_hash_1k;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8990 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8991 dgst_size = DGST_SIZE_4_5;
8992 parse_func = truecrypt_parse_hash_1k;
8993 sort_by_digest = sort_by_digest_4_5;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9002 salt_type = SALT_TYPE_EMBEDDED;
9003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9005 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9006 dgst_size = DGST_SIZE_4_5;
9007 parse_func = truecrypt_parse_hash_1k;
9008 sort_by_digest = sort_by_digest_4_5;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6300: hash_type = HASH_TYPE_MD5;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9020 kern_type = KERN_TYPE_MD5AIX;
9021 dgst_size = DGST_SIZE_4_4;
9022 parse_func = md5aix_parse_hash;
9023 sort_by_digest = sort_by_digest_4_4;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 6400: hash_type = HASH_TYPE_SHA256;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9035 kern_type = KERN_TYPE_SHA256AIX;
9036 dgst_size = DGST_SIZE_4_8;
9037 parse_func = sha256aix_parse_hash;
9038 sort_by_digest = sort_by_digest_4_8;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6500: hash_type = HASH_TYPE_SHA512;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_SHA512AIX;
9051 dgst_size = DGST_SIZE_8_8;
9052 parse_func = sha512aix_parse_hash;
9053 sort_by_digest = sort_by_digest_8_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE
9055 | OPTI_TYPE_USES_BITS_64;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 6600: hash_type = HASH_TYPE_AES;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9066 kern_type = KERN_TYPE_AGILEKEY;
9067 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9068 parse_func = agilekey_parse_hash;
9069 sort_by_digest = sort_by_digest_4_5;
9070 opti_type = OPTI_TYPE_ZERO_BYTE;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 6700: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9081 kern_type = KERN_TYPE_SHA1AIX;
9082 dgst_size = DGST_SIZE_4_5;
9083 parse_func = sha1aix_parse_hash;
9084 sort_by_digest = sort_by_digest_4_5;
9085 opti_type = OPTI_TYPE_ZERO_BYTE;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 6800: hash_type = HASH_TYPE_AES;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9096 kern_type = KERN_TYPE_LASTPASS;
9097 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9098 parse_func = lastpass_parse_hash;
9099 sort_by_digest = sort_by_digest_4_8;
9100 opti_type = OPTI_TYPE_ZERO_BYTE;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6900: hash_type = HASH_TYPE_GOST;
9108 salt_type = SALT_TYPE_NONE;
9109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_GOST;
9112 dgst_size = DGST_SIZE_4_8;
9113 parse_func = gost_parse_hash;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 7100: hash_type = HASH_TYPE_SHA512;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9126 kern_type = KERN_TYPE_PBKDF2_SHA512;
9127 dgst_size = DGST_SIZE_8_16;
9128 parse_func = sha512osx_parse_hash;
9129 sort_by_digest = sort_by_digest_8_16;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_USES_BITS_64
9132 | OPTI_TYPE_SLOW_HASH_SIMD;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 7200: hash_type = HASH_TYPE_SHA512;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9143 kern_type = KERN_TYPE_PBKDF2_SHA512;
9144 dgst_size = DGST_SIZE_8_16;
9145 parse_func = sha512grub_parse_hash;
9146 sort_by_digest = sort_by_digest_8_16;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_USES_BITS_64
9149 | OPTI_TYPE_SLOW_HASH_SIMD;
9150 dgst_pos0 = 0;
9151 dgst_pos1 = 1;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 3;
9154 break;
9155
9156 case 7300: hash_type = HASH_TYPE_SHA1;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_BE
9160 | OPTS_TYPE_ST_ADD80
9161 | OPTS_TYPE_ST_ADDBITS15;
9162 kern_type = KERN_TYPE_RAKP;
9163 dgst_size = DGST_SIZE_4_5;
9164 parse_func = rakp_parse_hash;
9165 sort_by_digest = sort_by_digest_4_5;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_NOT_ITERATED;
9168 dgst_pos0 = 3;
9169 dgst_pos1 = 4;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 1;
9172 break;
9173
9174 case 7400: hash_type = HASH_TYPE_SHA256;
9175 salt_type = SALT_TYPE_EMBEDDED;
9176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9178 kern_type = KERN_TYPE_SHA256CRYPT;
9179 dgst_size = DGST_SIZE_4_8;
9180 parse_func = sha256crypt_parse_hash;
9181 sort_by_digest = sort_by_digest_4_8;
9182 opti_type = OPTI_TYPE_ZERO_BYTE;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 7500: hash_type = HASH_TYPE_KRB5PA;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9193 kern_type = KERN_TYPE_KRB5PA;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = krb5pa_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_ZERO_BYTE
9198 | OPTI_TYPE_NOT_ITERATED;
9199 dgst_pos0 = 0;
9200 dgst_pos1 = 1;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 3;
9203 break;
9204
9205 case 7600: hash_type = HASH_TYPE_SHA1;
9206 salt_type = SALT_TYPE_INTERN;
9207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_BE
9209 | OPTS_TYPE_PT_ADD80
9210 | OPTS_TYPE_PT_ADDBITS15;
9211 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9212 dgst_size = DGST_SIZE_4_5;
9213 parse_func = redmine_parse_hash;
9214 sort_by_digest = sort_by_digest_4_5;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_PRECOMPUTE_INIT
9217 | OPTI_TYPE_EARLY_SKIP
9218 | OPTI_TYPE_NOT_ITERATED
9219 | OPTI_TYPE_PREPENDED_SALT;
9220 dgst_pos0 = 3;
9221 dgst_pos1 = 4;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 1;
9224 break;
9225
9226 case 7700: hash_type = HASH_TYPE_SAPB;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE
9230 | OPTS_TYPE_PT_UPPER
9231 | OPTS_TYPE_ST_UPPER;
9232 kern_type = KERN_TYPE_SAPB;
9233 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9234 parse_func = sapb_parse_hash;
9235 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9236 opti_type = OPTI_TYPE_ZERO_BYTE
9237 | OPTI_TYPE_PRECOMPUTE_INIT
9238 | OPTI_TYPE_NOT_ITERATED;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 1;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 3;
9243 break;
9244
9245 case 7800: hash_type = HASH_TYPE_SAPG;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_BE
9249 | OPTS_TYPE_ST_ADD80
9250 | OPTS_TYPE_ST_UPPER;
9251 kern_type = KERN_TYPE_SAPG;
9252 dgst_size = DGST_SIZE_4_5;
9253 parse_func = sapg_parse_hash;
9254 sort_by_digest = sort_by_digest_4_5;
9255 opti_type = OPTI_TYPE_ZERO_BYTE
9256 | OPTI_TYPE_PRECOMPUTE_INIT
9257 | OPTI_TYPE_NOT_ITERATED;
9258 dgst_pos0 = 3;
9259 dgst_pos1 = 4;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 1;
9262 break;
9263
9264 case 7900: hash_type = HASH_TYPE_SHA512;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9268 kern_type = KERN_TYPE_DRUPAL7;
9269 dgst_size = DGST_SIZE_8_8;
9270 parse_func = drupal7_parse_hash;
9271 sort_by_digest = sort_by_digest_8_8;
9272 opti_type = OPTI_TYPE_ZERO_BYTE
9273 | OPTI_TYPE_USES_BITS_64;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 8000: hash_type = HASH_TYPE_SHA256;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE
9284 | OPTS_TYPE_PT_UNICODE
9285 | OPTS_TYPE_ST_ADD80
9286 | OPTS_TYPE_ST_HEX;
9287 kern_type = KERN_TYPE_SYBASEASE;
9288 dgst_size = DGST_SIZE_4_8;
9289 parse_func = sybasease_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_PRECOMPUTE_INIT
9293 | OPTI_TYPE_EARLY_SKIP
9294 | OPTI_TYPE_NOT_ITERATED
9295 | OPTI_TYPE_RAW_HASH;
9296 dgst_pos0 = 3;
9297 dgst_pos1 = 7;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 6;
9300 break;
9301
9302 case 8100: hash_type = HASH_TYPE_SHA1;
9303 salt_type = SALT_TYPE_EMBEDDED;
9304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9306 kern_type = KERN_TYPE_NETSCALER;
9307 dgst_size = DGST_SIZE_4_5;
9308 parse_func = netscaler_parse_hash;
9309 sort_by_digest = sort_by_digest_4_5;
9310 opti_type = OPTI_TYPE_ZERO_BYTE
9311 | OPTI_TYPE_PRECOMPUTE_INIT
9312 | OPTI_TYPE_PRECOMPUTE_MERKLE
9313 | OPTI_TYPE_EARLY_SKIP
9314 | OPTI_TYPE_NOT_ITERATED
9315 | OPTI_TYPE_PREPENDED_SALT
9316 | OPTI_TYPE_RAW_HASH;
9317 dgst_pos0 = 3;
9318 dgst_pos1 = 4;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 1;
9321 break;
9322
9323 case 8200: hash_type = HASH_TYPE_SHA256;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9327 kern_type = KERN_TYPE_CLOUDKEY;
9328 dgst_size = DGST_SIZE_4_8;
9329 parse_func = cloudkey_parse_hash;
9330 sort_by_digest = sort_by_digest_4_8;
9331 opti_type = OPTI_TYPE_ZERO_BYTE;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 8300: hash_type = HASH_TYPE_SHA1;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_BE
9342 | OPTS_TYPE_ST_HEX
9343 | OPTS_TYPE_ST_ADD80;
9344 kern_type = KERN_TYPE_NSEC3;
9345 dgst_size = DGST_SIZE_4_5;
9346 parse_func = nsec3_parse_hash;
9347 sort_by_digest = sort_by_digest_4_5;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 3;
9350 dgst_pos1 = 4;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 1;
9353 break;
9354
9355 case 8400: hash_type = HASH_TYPE_SHA1;
9356 salt_type = SALT_TYPE_INTERN;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_BE
9359 | OPTS_TYPE_PT_ADD80
9360 | OPTS_TYPE_PT_ADDBITS15;
9361 kern_type = KERN_TYPE_WBB3;
9362 dgst_size = DGST_SIZE_4_5;
9363 parse_func = wbb3_parse_hash;
9364 sort_by_digest = sort_by_digest_4_5;
9365 opti_type = OPTI_TYPE_ZERO_BYTE
9366 | OPTI_TYPE_PRECOMPUTE_INIT
9367 | OPTI_TYPE_NOT_ITERATED;
9368 dgst_pos0 = 3;
9369 dgst_pos1 = 4;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 1;
9372 break;
9373
9374 case 8500: hash_type = HASH_TYPE_DESRACF;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE
9378 | OPTS_TYPE_ST_UPPER;
9379 kern_type = KERN_TYPE_RACF;
9380 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9381 parse_func = racf_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 8600: hash_type = HASH_TYPE_LOTUS5;
9392 salt_type = SALT_TYPE_NONE;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_LOTUS5;
9396 dgst_size = DGST_SIZE_4_4;
9397 parse_func = lotus5_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4;
9399 opti_type = OPTI_TYPE_EARLY_SKIP
9400 | OPTI_TYPE_NOT_ITERATED
9401 | OPTI_TYPE_NOT_SALTED
9402 | OPTI_TYPE_RAW_HASH;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 8700: hash_type = HASH_TYPE_LOTUS6;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_LOTUS6;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = lotus6_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_RAW_HASH;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_ANDROIDFDE;
9431 dgst_size = DGST_SIZE_4_4;
9432 parse_func = androidfde_parse_hash;
9433 sort_by_digest = sort_by_digest_4_4;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 8900: hash_type = HASH_TYPE_SCRYPT;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_SCRYPT;
9446 dgst_size = DGST_SIZE_4_8;
9447 parse_func = scrypt_parse_hash;
9448 sort_by_digest = sort_by_digest_4_8;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9000: hash_type = HASH_TYPE_SHA1;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE
9460 | OPTS_TYPE_ST_GENERATE_LE;
9461 kern_type = KERN_TYPE_PSAFE2;
9462 dgst_size = DGST_SIZE_4_5;
9463 parse_func = psafe2_parse_hash;
9464 sort_by_digest = sort_by_digest_4_5;
9465 opti_type = OPTI_TYPE_ZERO_BYTE;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 9100: hash_type = HASH_TYPE_LOTUS8;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9476 kern_type = KERN_TYPE_LOTUS8;
9477 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9478 parse_func = lotus8_parse_hash;
9479 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9480 opti_type = OPTI_TYPE_ZERO_BYTE;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 9200: hash_type = HASH_TYPE_SHA256;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9491 kern_type = KERN_TYPE_PBKDF2_SHA256;
9492 dgst_size = DGST_SIZE_4_32;
9493 parse_func = cisco8_parse_hash;
9494 sort_by_digest = sort_by_digest_4_32;
9495 opti_type = OPTI_TYPE_ZERO_BYTE
9496 | OPTI_TYPE_SLOW_HASH_SIMD;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9300: hash_type = HASH_TYPE_SCRYPT;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9507 kern_type = KERN_TYPE_SCRYPT;
9508 dgst_size = DGST_SIZE_4_8;
9509 parse_func = cisco9_parse_hash;
9510 sort_by_digest = sort_by_digest_4_8;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_OFFICE2007;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = office2007_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9537 kern_type = KERN_TYPE_OFFICE2010;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = office2010_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_OFFICE2013;
9553 dgst_size = DGST_SIZE_4_4;
9554 parse_func = office2013_parse_hash;
9555 sort_by_digest = sort_by_digest_4_4;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_PT_ADD80
9568 | OPTS_TYPE_PT_UNICODE;
9569 kern_type = KERN_TYPE_OLDOFFICE01;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = oldoffice01_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_PRECOMPUTE_INIT
9575 | OPTI_TYPE_NOT_ITERATED;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE
9586 | OPTS_TYPE_PT_ADD80;
9587 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9588 dgst_size = DGST_SIZE_4_4;
9589 parse_func = oldoffice01cm1_parse_hash;
9590 sort_by_digest = sort_by_digest_4_4;
9591 opti_type = OPTI_TYPE_ZERO_BYTE
9592 | OPTI_TYPE_PRECOMPUTE_INIT
9593 | OPTI_TYPE_NOT_ITERATED;
9594 dgst_pos0 = 0;
9595 dgst_pos1 = 1;
9596 dgst_pos2 = 2;
9597 dgst_pos3 = 3;
9598 break;
9599
9600 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9601 salt_type = SALT_TYPE_EMBEDDED;
9602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9603 opts_type = OPTS_TYPE_PT_GENERATE_LE
9604 | OPTS_TYPE_PT_ADD80
9605 | OPTS_TYPE_PT_UNICODE
9606 | OPTS_TYPE_PT_NEVERCRACK;
9607 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9608 dgst_size = DGST_SIZE_4_4;
9609 parse_func = oldoffice01cm2_parse_hash;
9610 sort_by_digest = sort_by_digest_4_4;
9611 opti_type = OPTI_TYPE_ZERO_BYTE
9612 | OPTI_TYPE_PRECOMPUTE_INIT
9613 | OPTI_TYPE_NOT_ITERATED;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_BE
9624 | OPTS_TYPE_PT_ADD80
9625 | OPTS_TYPE_PT_UNICODE;
9626 kern_type = KERN_TYPE_OLDOFFICE34;
9627 dgst_size = DGST_SIZE_4_4;
9628 parse_func = oldoffice34_parse_hash;
9629 sort_by_digest = sort_by_digest_4_4;
9630 opti_type = OPTI_TYPE_ZERO_BYTE
9631 | OPTI_TYPE_PRECOMPUTE_INIT
9632 | OPTI_TYPE_NOT_ITERATED;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9643 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9644 dgst_size = DGST_SIZE_4_4;
9645 parse_func = oldoffice34cm1_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4;
9647 opti_type = OPTI_TYPE_ZERO_BYTE
9648 | OPTI_TYPE_PRECOMPUTE_INIT
9649 | OPTI_TYPE_NOT_ITERATED;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_BE
9660 | OPTS_TYPE_PT_ADD80
9661 | OPTS_TYPE_PT_UNICODE
9662 | OPTS_TYPE_PT_NEVERCRACK;
9663 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9664 dgst_size = DGST_SIZE_4_4;
9665 parse_func = oldoffice34cm2_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_PRECOMPUTE_INIT
9669 | OPTI_TYPE_NOT_ITERATED;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 9900: hash_type = HASH_TYPE_MD5;
9677 salt_type = SALT_TYPE_NONE;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_RADMIN2;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = radmin2_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_PRECOMPUTE_INIT
9686 | OPTI_TYPE_EARLY_SKIP
9687 | OPTI_TYPE_NOT_ITERATED
9688 | OPTI_TYPE_NOT_SALTED;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 3;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 10000: hash_type = HASH_TYPE_SHA256;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9699 kern_type = KERN_TYPE_PBKDF2_SHA256;
9700 dgst_size = DGST_SIZE_4_32;
9701 parse_func = djangopbkdf2_parse_hash;
9702 sort_by_digest = sort_by_digest_4_32;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_SLOW_HASH_SIMD;
9705 dgst_pos0 = 0;
9706 dgst_pos1 = 1;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 3;
9709 break;
9710
9711 case 10100: hash_type = HASH_TYPE_SIPHASH;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9715 kern_type = KERN_TYPE_SIPHASH;
9716 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9717 parse_func = siphash_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_NOT_ITERATED
9721 | OPTI_TYPE_RAW_HASH;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 10200: hash_type = HASH_TYPE_MD5;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_LE
9732 | OPTS_TYPE_ST_ADD80
9733 | OPTS_TYPE_ST_ADDBITS14;
9734 kern_type = KERN_TYPE_HMACMD5_PW;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = crammd5_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 3;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 1;
9744 break;
9745
9746 case 10300: hash_type = HASH_TYPE_SHA1;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9750 kern_type = KERN_TYPE_SAPH_SHA1;
9751 dgst_size = DGST_SIZE_4_5;
9752 parse_func = saph_sha1_parse_hash;
9753 sort_by_digest = sort_by_digest_4_5;
9754 opti_type = OPTI_TYPE_ZERO_BYTE;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 10400: hash_type = HASH_TYPE_PDFU16;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9765 kern_type = KERN_TYPE_PDF11;
9766 dgst_size = DGST_SIZE_4_4;
9767 parse_func = pdf11_parse_hash;
9768 sort_by_digest = sort_by_digest_4_4;
9769 opti_type = OPTI_TYPE_ZERO_BYTE
9770 | OPTI_TYPE_NOT_ITERATED;
9771 dgst_pos0 = 0;
9772 dgst_pos1 = 1;
9773 dgst_pos2 = 2;
9774 dgst_pos3 = 3;
9775 break;
9776
9777 case 10410: hash_type = HASH_TYPE_PDFU16;
9778 salt_type = SALT_TYPE_EMBEDDED;
9779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9781 kern_type = KERN_TYPE_PDF11CM1;
9782 dgst_size = DGST_SIZE_4_4;
9783 parse_func = pdf11cm1_parse_hash;
9784 sort_by_digest = sort_by_digest_4_4;
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_NOT_ITERATED;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 10420: hash_type = HASH_TYPE_PDFU16;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9797 kern_type = KERN_TYPE_PDF11CM2;
9798 dgst_size = DGST_SIZE_4_4;
9799 parse_func = pdf11cm2_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4;
9801 opti_type = OPTI_TYPE_ZERO_BYTE
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 10500: hash_type = HASH_TYPE_PDFU16;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9813 kern_type = KERN_TYPE_PDF14;
9814 dgst_size = DGST_SIZE_4_4;
9815 parse_func = pdf14_parse_hash;
9816 sort_by_digest = sort_by_digest_4_4;
9817 opti_type = OPTI_TYPE_ZERO_BYTE
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 10600: hash_type = HASH_TYPE_SHA256;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_BE
9829 | OPTS_TYPE_ST_ADD80
9830 | OPTS_TYPE_ST_ADDBITS15
9831 | OPTS_TYPE_HASH_COPY;
9832 kern_type = KERN_TYPE_SHA256_PWSLT;
9833 dgst_size = DGST_SIZE_4_8;
9834 parse_func = pdf17l3_parse_hash;
9835 sort_by_digest = sort_by_digest_4_8;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_PRECOMPUTE_INIT
9838 | OPTI_TYPE_PRECOMPUTE_MERKLE
9839 | OPTI_TYPE_EARLY_SKIP
9840 | OPTI_TYPE_NOT_ITERATED
9841 | OPTI_TYPE_APPENDED_SALT
9842 | OPTI_TYPE_RAW_HASH;
9843 dgst_pos0 = 3;
9844 dgst_pos1 = 7;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 6;
9847 break;
9848
9849 case 10700: hash_type = HASH_TYPE_PDFU32;
9850 salt_type = SALT_TYPE_EMBEDDED;
9851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PDF17L8;
9855 dgst_size = DGST_SIZE_4_8;
9856 parse_func = pdf17l8_parse_hash;
9857 sort_by_digest = sort_by_digest_4_8;
9858 opti_type = OPTI_TYPE_ZERO_BYTE
9859 | OPTI_TYPE_NOT_ITERATED;
9860 dgst_pos0 = 0;
9861 dgst_pos1 = 1;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 3;
9864 break;
9865
9866 case 10800: hash_type = HASH_TYPE_SHA384;
9867 salt_type = SALT_TYPE_NONE;
9868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_BE
9870 | OPTS_TYPE_PT_ADD80
9871 | OPTS_TYPE_PT_ADDBITS15;
9872 kern_type = KERN_TYPE_SHA384;
9873 dgst_size = DGST_SIZE_8_8;
9874 parse_func = sha384_parse_hash;
9875 sort_by_digest = sort_by_digest_8_8;
9876 opti_type = OPTI_TYPE_ZERO_BYTE
9877 | OPTI_TYPE_PRECOMPUTE_INIT
9878 | OPTI_TYPE_PRECOMPUTE_MERKLE
9879 | OPTI_TYPE_EARLY_SKIP
9880 | OPTI_TYPE_NOT_ITERATED
9881 | OPTI_TYPE_NOT_SALTED
9882 | OPTI_TYPE_USES_BITS_64
9883 | OPTI_TYPE_RAW_HASH;
9884 dgst_pos0 = 6;
9885 dgst_pos1 = 7;
9886 dgst_pos2 = 4;
9887 dgst_pos3 = 5;
9888 break;
9889
9890 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE
9894 | OPTS_TYPE_ST_BASE64
9895 | OPTS_TYPE_HASH_COPY;
9896 kern_type = KERN_TYPE_PBKDF2_SHA256;
9897 dgst_size = DGST_SIZE_4_32;
9898 parse_func = pbkdf2_sha256_parse_hash;
9899 sort_by_digest = sort_by_digest_4_32;
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_SLOW_HASH_SIMD;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 11000: hash_type = HASH_TYPE_MD5;
9909 salt_type = SALT_TYPE_INTERN;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE
9912 | OPTS_TYPE_PT_ADD80;
9913 kern_type = KERN_TYPE_PRESTASHOP;
9914 dgst_size = DGST_SIZE_4_4;
9915 parse_func = prestashop_parse_hash;
9916 sort_by_digest = sort_by_digest_4_4;
9917 opti_type = OPTI_TYPE_ZERO_BYTE
9918 | OPTI_TYPE_PRECOMPUTE_INIT
9919 | OPTI_TYPE_NOT_ITERATED
9920 | OPTI_TYPE_PREPENDED_SALT;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 3;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 1;
9925 break;
9926
9927 case 11100: hash_type = HASH_TYPE_MD5;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_ST_ADD80;
9932 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = postgresql_auth_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE
9937 | OPTI_TYPE_PRECOMPUTE_INIT
9938 | OPTI_TYPE_PRECOMPUTE_MERKLE
9939 | OPTI_TYPE_EARLY_SKIP;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 3;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 1;
9944 break;
9945
9946 case 11200: hash_type = HASH_TYPE_SHA1;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_BE
9950 | OPTS_TYPE_PT_ADD80
9951 | OPTS_TYPE_ST_HEX;
9952 kern_type = KERN_TYPE_MYSQL_AUTH;
9953 dgst_size = DGST_SIZE_4_5;
9954 parse_func = mysql_auth_parse_hash;
9955 sort_by_digest = sort_by_digest_4_5;
9956 opti_type = OPTI_TYPE_ZERO_BYTE
9957 | OPTI_TYPE_EARLY_SKIP;
9958 dgst_pos0 = 3;
9959 dgst_pos1 = 4;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 1;
9962 break;
9963
9964 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9965 salt_type = SALT_TYPE_EMBEDDED;
9966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_ST_HEX
9969 | OPTS_TYPE_ST_ADD80;
9970 kern_type = KERN_TYPE_BITCOIN_WALLET;
9971 dgst_size = DGST_SIZE_4_4;
9972 parse_func = bitcoin_wallet_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11400: hash_type = HASH_TYPE_MD5;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_PT_ADD80
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_SIP_AUTH;
9988 dgst_size = DGST_SIZE_4_4;
9989 parse_func = sip_auth_parse_hash;
9990 sort_by_digest = sort_by_digest_4_4;
9991 opti_type = OPTI_TYPE_ZERO_BYTE;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 3;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 1;
9996 break;
9997
9998 case 11500: hash_type = HASH_TYPE_CRC32;
9999 salt_type = SALT_TYPE_INTERN;
10000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE
10002 | OPTS_TYPE_ST_GENERATE_LE
10003 | OPTS_TYPE_ST_HEX;
10004 kern_type = KERN_TYPE_CRC32;
10005 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10006 parse_func = crc32_parse_hash;
10007 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 11600: hash_type = HASH_TYPE_AES;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_NEVERCRACK;
10020 kern_type = KERN_TYPE_SEVEN_ZIP;
10021 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10022 parse_func = seven_zip_parse_hash;
10023 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10032 salt_type = SALT_TYPE_NONE;
10033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_PT_ADD01;
10036 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10037 dgst_size = DGST_SIZE_4_8;
10038 parse_func = gost2012sbog_256_parse_hash;
10039 sort_by_digest = sort_by_digest_4_8;
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10048 salt_type = SALT_TYPE_NONE;
10049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE
10051 | OPTS_TYPE_PT_ADD01;
10052 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10053 dgst_size = DGST_SIZE_4_16;
10054 parse_func = gost2012sbog_512_parse_hash;
10055 sort_by_digest = sort_by_digest_4_16;
10056 opti_type = OPTI_TYPE_ZERO_BYTE;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE
10067 | OPTS_TYPE_ST_BASE64
10068 | OPTS_TYPE_HASH_COPY;
10069 kern_type = KERN_TYPE_PBKDF2_MD5;
10070 dgst_size = DGST_SIZE_4_32;
10071 parse_func = pbkdf2_md5_parse_hash;
10072 sort_by_digest = sort_by_digest_4_32;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_SLOW_HASH_SIMD;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE
10085 | OPTS_TYPE_ST_BASE64
10086 | OPTS_TYPE_HASH_COPY;
10087 kern_type = KERN_TYPE_PBKDF2_SHA1;
10088 dgst_size = DGST_SIZE_4_32;
10089 parse_func = pbkdf2_sha1_parse_hash;
10090 sort_by_digest = sort_by_digest_4_32;
10091 opti_type = OPTI_TYPE_ZERO_BYTE
10092 | OPTI_TYPE_SLOW_HASH_SIMD;
10093 dgst_pos0 = 0;
10094 dgst_pos1 = 1;
10095 dgst_pos2 = 2;
10096 dgst_pos3 = 3;
10097 break;
10098
10099 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10100 salt_type = SALT_TYPE_EMBEDDED;
10101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10102 opts_type = OPTS_TYPE_PT_GENERATE_LE
10103 | OPTS_TYPE_ST_BASE64
10104 | OPTS_TYPE_HASH_COPY;
10105 kern_type = KERN_TYPE_PBKDF2_SHA512;
10106 dgst_size = DGST_SIZE_8_16;
10107 parse_func = pbkdf2_sha512_parse_hash;
10108 sort_by_digest = sort_by_digest_8_16;
10109 opti_type = OPTI_TYPE_ZERO_BYTE
10110 | OPTI_TYPE_USES_BITS_64
10111 | OPTI_TYPE_SLOW_HASH_SIMD;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10122 kern_type = KERN_TYPE_ECRYPTFS;
10123 dgst_size = DGST_SIZE_8_8;
10124 parse_func = ecryptfs_parse_hash;
10125 sort_by_digest = sort_by_digest_8_8;
10126 opti_type = OPTI_TYPE_ZERO_BYTE
10127 | OPTI_TYPE_USES_BITS_64;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12300: hash_type = HASH_TYPE_ORACLET;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10138 kern_type = KERN_TYPE_ORACLET;
10139 dgst_size = DGST_SIZE_8_16;
10140 parse_func = oraclet_parse_hash;
10141 sort_by_digest = sort_by_digest_8_16;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_USES_BITS_64;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10154 kern_type = KERN_TYPE_BSDICRYPT;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = bsdicrypt_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE
10159 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 12500: hash_type = HASH_TYPE_RAR3HP;
10167 salt_type = SALT_TYPE_EMBEDDED;
10168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10170 kern_type = KERN_TYPE_RAR3;
10171 dgst_size = DGST_SIZE_4_4;
10172 parse_func = rar3hp_parse_hash;
10173 sort_by_digest = sort_by_digest_4_4;
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 12600: hash_type = HASH_TYPE_SHA256;
10182 salt_type = SALT_TYPE_INTERN;
10183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_BE
10185 | OPTS_TYPE_PT_ADD80;
10186 kern_type = KERN_TYPE_CF10;
10187 dgst_size = DGST_SIZE_4_8;
10188 parse_func = cf10_parse_hash;
10189 sort_by_digest = sort_by_digest_4_8;
10190 opti_type = OPTI_TYPE_ZERO_BYTE
10191 | OPTI_TYPE_PRECOMPUTE_INIT
10192 | OPTI_TYPE_EARLY_SKIP
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 3;
10195 dgst_pos1 = 7;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 6;
10198 break;
10199
10200 case 12700: hash_type = HASH_TYPE_AES;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE
10204 | OPTS_TYPE_HASH_COPY;
10205 kern_type = KERN_TYPE_MYWALLET;
10206 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10207 parse_func = mywallet_parse_hash;
10208 sort_by_digest = sort_by_digest_4_5;
10209 opti_type = OPTI_TYPE_ZERO_BYTE;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10220 kern_type = KERN_TYPE_MS_DRSR;
10221 dgst_size = DGST_SIZE_4_8;
10222 parse_func = ms_drsr_parse_hash;
10223 sort_by_digest = sort_by_digest_4_8;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10236 dgst_size = DGST_SIZE_4_8;
10237 parse_func = androidfde_samsung_parse_hash;
10238 sort_by_digest = sort_by_digest_4_8;
10239 opti_type = OPTI_TYPE_ZERO_BYTE;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10247 salt_type = SALT_TYPE_EMBEDDED;
10248 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_RAR5;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = rar5_parse_hash;
10253 sort_by_digest = sort_by_digest_4_4;
10254 opti_type = OPTI_TYPE_ZERO_BYTE;
10255 dgst_pos0 = 0;
10256 dgst_pos1 = 1;
10257 dgst_pos2 = 2;
10258 dgst_pos3 = 3;
10259 break;
10260
10261 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10262 salt_type = SALT_TYPE_EMBEDDED;
10263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10264 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10265 kern_type = KERN_TYPE_KRB5TGS;
10266 dgst_size = DGST_SIZE_4_4;
10267 parse_func = krb5tgs_parse_hash;
10268 sort_by_digest = sort_by_digest_4_4;
10269 opti_type = OPTI_TYPE_ZERO_BYTE
10270 | OPTI_TYPE_NOT_ITERATED;
10271 dgst_pos0 = 0;
10272 dgst_pos1 = 1;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 3;
10275 break;
10276
10277 case 13200: hash_type = HASH_TYPE_AES;
10278 salt_type = SALT_TYPE_EMBEDDED;
10279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10281 kern_type = KERN_TYPE_AXCRYPT;
10282 dgst_size = DGST_SIZE_4_4;
10283 parse_func = axcrypt_parse_hash;
10284 sort_by_digest = sort_by_digest_4_4;
10285 opti_type = OPTI_TYPE_ZERO_BYTE;
10286 dgst_pos0 = 0;
10287 dgst_pos1 = 1;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 3;
10290 break;
10291
10292 case 13300: hash_type = HASH_TYPE_SHA1;
10293 salt_type = SALT_TYPE_NONE;
10294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_BE
10296 | OPTS_TYPE_PT_ADD80
10297 | OPTS_TYPE_PT_ADDBITS15;
10298 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10299 dgst_size = DGST_SIZE_4_5;
10300 parse_func = sha1axcrypt_parse_hash;
10301 sort_by_digest = sort_by_digest_4_5;
10302 opti_type = OPTI_TYPE_ZERO_BYTE
10303 | OPTI_TYPE_PRECOMPUTE_INIT
10304 | OPTI_TYPE_EARLY_SKIP
10305 | OPTI_TYPE_NOT_ITERATED
10306 | OPTI_TYPE_NOT_SALTED;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 4;
10309 dgst_pos2 = 3;
10310 dgst_pos3 = 2;
10311 break;
10312
10313 case 13400: hash_type = HASH_TYPE_AES;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10317 kern_type = KERN_TYPE_KEEPASS;
10318 dgst_size = DGST_SIZE_4_4;
10319 parse_func = keepass_parse_hash;
10320 sort_by_digest = sort_by_digest_4_4;
10321 opti_type = OPTI_TYPE_ZERO_BYTE;
10322 dgst_pos0 = 0;
10323 dgst_pos1 = 1;
10324 dgst_pos2 = 2;
10325 dgst_pos3 = 3;
10326 break;
10327
10328 case 13500: hash_type = HASH_TYPE_SHA1;
10329 salt_type = SALT_TYPE_EMBEDDED;
10330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10331 opts_type = OPTS_TYPE_PT_GENERATE_BE
10332 | OPTS_TYPE_PT_UNICODE
10333 | OPTS_TYPE_PT_ADD80;
10334 kern_type = KERN_TYPE_PSTOKEN;
10335 dgst_size = DGST_SIZE_4_5;
10336 parse_func = pstoken_parse_hash;
10337 sort_by_digest = sort_by_digest_4_5;
10338 opti_type = OPTI_TYPE_ZERO_BYTE
10339 | OPTI_TYPE_PRECOMPUTE_INIT
10340 | OPTI_TYPE_EARLY_SKIP
10341 | OPTI_TYPE_NOT_ITERATED
10342 | OPTI_TYPE_PREPENDED_SALT
10343 | OPTI_TYPE_RAW_HASH;
10344 dgst_pos0 = 3;
10345 dgst_pos1 = 4;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 1;
10348 break;
10349
10350 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10351 salt_type = SALT_TYPE_EMBEDDED;
10352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10354 kern_type = KERN_TYPE_ZIP2;
10355 dgst_size = DGST_SIZE_4_4;
10356 parse_func = zip2_parse_hash;
10357 sort_by_digest = sort_by_digest_4_4;
10358 opti_type = OPTI_TYPE_ZERO_BYTE;
10359 dgst_pos0 = 0;
10360 dgst_pos1 = 1;
10361 dgst_pos2 = 2;
10362 dgst_pos3 = 3;
10363 break;
10364
10365 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10366 salt_type = SALT_TYPE_EMBEDDED;
10367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10369 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10370 dgst_size = DGST_SIZE_4_5;
10371 parse_func = veracrypt_parse_hash_655331;
10372 sort_by_digest = sort_by_digest_4_5;
10373 opti_type = OPTI_TYPE_ZERO_BYTE;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10385 dgst_size = DGST_SIZE_4_5;
10386 parse_func = veracrypt_parse_hash_655331;
10387 sort_by_digest = sort_by_digest_4_5;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10400 dgst_size = DGST_SIZE_4_5;
10401 parse_func = veracrypt_parse_hash_655331;
10402 sort_by_digest = sort_by_digest_4_5;
10403 opti_type = OPTI_TYPE_ZERO_BYTE;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13721: hash_type = HASH_TYPE_SHA512;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10414 kern_type = KERN_TYPE_TCSHA512_XTS512;
10415 dgst_size = DGST_SIZE_8_8;
10416 parse_func = veracrypt_parse_hash_500000;
10417 sort_by_digest = sort_by_digest_8_8;
10418 opti_type = OPTI_TYPE_ZERO_BYTE
10419 | OPTI_TYPE_USES_BITS_64;
10420 dgst_pos0 = 0;
10421 dgst_pos1 = 1;
10422 dgst_pos2 = 2;
10423 dgst_pos3 = 3;
10424 break;
10425
10426 case 13722: hash_type = HASH_TYPE_SHA512;
10427 salt_type = SALT_TYPE_EMBEDDED;
10428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10430 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10431 dgst_size = DGST_SIZE_8_8;
10432 parse_func = veracrypt_parse_hash_500000;
10433 sort_by_digest = sort_by_digest_8_8;
10434 opti_type = OPTI_TYPE_ZERO_BYTE
10435 | OPTI_TYPE_USES_BITS_64;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 1;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 3;
10440 break;
10441
10442 case 13723: hash_type = HASH_TYPE_SHA512;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10446 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10447 dgst_size = DGST_SIZE_8_8;
10448 parse_func = veracrypt_parse_hash_500000;
10449 sort_by_digest = sort_by_digest_8_8;
10450 opti_type = OPTI_TYPE_ZERO_BYTE
10451 | OPTI_TYPE_USES_BITS_64;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10462 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10463 dgst_size = DGST_SIZE_4_8;
10464 parse_func = veracrypt_parse_hash_500000;
10465 sort_by_digest = sort_by_digest_4_8;
10466 opti_type = OPTI_TYPE_ZERO_BYTE;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10474 salt_type = SALT_TYPE_EMBEDDED;
10475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10477 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10478 dgst_size = DGST_SIZE_4_8;
10479 parse_func = veracrypt_parse_hash_500000;
10480 sort_by_digest = sort_by_digest_4_8;
10481 opti_type = OPTI_TYPE_ZERO_BYTE;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 1;
10484 dgst_pos2 = 2;
10485 dgst_pos3 = 3;
10486 break;
10487
10488 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10492 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10493 dgst_size = DGST_SIZE_4_8;
10494 parse_func = veracrypt_parse_hash_500000;
10495 sort_by_digest = sort_by_digest_4_8;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10504 salt_type = SALT_TYPE_EMBEDDED;
10505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10507 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10508 dgst_size = DGST_SIZE_4_5;
10509 parse_func = veracrypt_parse_hash_327661;
10510 sort_by_digest = sort_by_digest_4_5;
10511 opti_type = OPTI_TYPE_ZERO_BYTE;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 1;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 3;
10516 break;
10517
10518 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10519 salt_type = SALT_TYPE_EMBEDDED;
10520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10522 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10523 dgst_size = DGST_SIZE_4_5;
10524 parse_func = veracrypt_parse_hash_327661;
10525 sort_by_digest = sort_by_digest_4_5;
10526 opti_type = OPTI_TYPE_ZERO_BYTE;
10527 dgst_pos0 = 0;
10528 dgst_pos1 = 1;
10529 dgst_pos2 = 2;
10530 dgst_pos3 = 3;
10531 break;
10532
10533 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10534 salt_type = SALT_TYPE_EMBEDDED;
10535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10537 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10538 dgst_size = DGST_SIZE_4_5;
10539 parse_func = veracrypt_parse_hash_327661;
10540 sort_by_digest = sort_by_digest_4_5;
10541 opti_type = OPTI_TYPE_ZERO_BYTE;
10542 dgst_pos0 = 0;
10543 dgst_pos1 = 1;
10544 dgst_pos2 = 2;
10545 dgst_pos3 = 3;
10546 break;
10547
10548 case 13751: hash_type = HASH_TYPE_SHA256;
10549 salt_type = SALT_TYPE_EMBEDDED;
10550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10552 kern_type = KERN_TYPE_VCSHA256_XTS512;
10553 dgst_size = DGST_SIZE_4_8;
10554 parse_func = veracrypt_parse_hash_500000;
10555 sort_by_digest = sort_by_digest_4_8;
10556 opti_type = OPTI_TYPE_ZERO_BYTE;
10557 dgst_pos0 = 0;
10558 dgst_pos1 = 1;
10559 dgst_pos2 = 2;
10560 dgst_pos3 = 3;
10561 break;
10562
10563 case 13752: hash_type = HASH_TYPE_SHA256;
10564 salt_type = SALT_TYPE_EMBEDDED;
10565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10566 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10567 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10568 dgst_size = DGST_SIZE_4_8;
10569 parse_func = veracrypt_parse_hash_500000;
10570 sort_by_digest = sort_by_digest_4_8;
10571 opti_type = OPTI_TYPE_ZERO_BYTE;
10572 dgst_pos0 = 0;
10573 dgst_pos1 = 1;
10574 dgst_pos2 = 2;
10575 dgst_pos3 = 3;
10576 break;
10577
10578 case 13753: hash_type = HASH_TYPE_SHA256;
10579 salt_type = SALT_TYPE_EMBEDDED;
10580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10581 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10582 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10583 dgst_size = DGST_SIZE_4_8;
10584 parse_func = veracrypt_parse_hash_500000;
10585 sort_by_digest = sort_by_digest_4_8;
10586 opti_type = OPTI_TYPE_ZERO_BYTE;
10587 dgst_pos0 = 0;
10588 dgst_pos1 = 1;
10589 dgst_pos2 = 2;
10590 dgst_pos3 = 3;
10591 break;
10592
10593 case 13761: hash_type = HASH_TYPE_SHA256;
10594 salt_type = SALT_TYPE_EMBEDDED;
10595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10596 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10597 kern_type = KERN_TYPE_VCSHA256_XTS512;
10598 dgst_size = DGST_SIZE_4_8;
10599 parse_func = veracrypt_parse_hash_200000;
10600 sort_by_digest = sort_by_digest_4_8;
10601 opti_type = OPTI_TYPE_ZERO_BYTE;
10602 dgst_pos0 = 0;
10603 dgst_pos1 = 1;
10604 dgst_pos2 = 2;
10605 dgst_pos3 = 3;
10606 break;
10607
10608 case 13762: hash_type = HASH_TYPE_SHA256;
10609 salt_type = SALT_TYPE_EMBEDDED;
10610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10611 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10612 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10613 dgst_size = DGST_SIZE_4_8;
10614 parse_func = veracrypt_parse_hash_200000;
10615 sort_by_digest = sort_by_digest_4_8;
10616 opti_type = OPTI_TYPE_ZERO_BYTE;
10617 dgst_pos0 = 0;
10618 dgst_pos1 = 1;
10619 dgst_pos2 = 2;
10620 dgst_pos3 = 3;
10621 break;
10622
10623 case 13763: hash_type = HASH_TYPE_SHA256;
10624 salt_type = SALT_TYPE_EMBEDDED;
10625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10627 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10628 dgst_size = DGST_SIZE_4_8;
10629 parse_func = veracrypt_parse_hash_200000;
10630 sort_by_digest = sort_by_digest_4_8;
10631 opti_type = OPTI_TYPE_ZERO_BYTE;
10632 dgst_pos0 = 0;
10633 dgst_pos1 = 1;
10634 dgst_pos2 = 2;
10635 dgst_pos3 = 3;
10636 break;
10637
10638
10639 default: usage_mini_print (PROGNAME); return (-1);
10640 }
10641
10642 /**
10643 * parser
10644 */
10645
10646 data.parse_func = parse_func;
10647
10648 /**
10649 * misc stuff
10650 */
10651
10652 if (hex_salt)
10653 {
10654 if (salt_type == SALT_TYPE_INTERN)
10655 {
10656 opts_type |= OPTS_TYPE_ST_HEX;
10657 }
10658 else
10659 {
10660 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10661
10662 return (-1);
10663 }
10664 }
10665
10666 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10667 | (salt_type == SALT_TYPE_EXTERN)
10668 | (salt_type == SALT_TYPE_EMBEDDED)
10669 | (salt_type == SALT_TYPE_VIRTUAL));
10670
10671 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10672
10673 data.hash_type = hash_type;
10674 data.attack_mode = attack_mode;
10675 data.attack_kern = attack_kern;
10676 data.attack_exec = attack_exec;
10677 data.kern_type = kern_type;
10678 data.opts_type = opts_type;
10679 data.dgst_size = dgst_size;
10680 data.salt_type = salt_type;
10681 data.isSalted = isSalted;
10682 data.sort_by_digest = sort_by_digest;
10683 data.dgst_pos0 = dgst_pos0;
10684 data.dgst_pos1 = dgst_pos1;
10685 data.dgst_pos2 = dgst_pos2;
10686 data.dgst_pos3 = dgst_pos3;
10687
10688 esalt_size = 0;
10689
10690 switch (hash_mode)
10691 {
10692 case 2500: esalt_size = sizeof (wpa_t); break;
10693 case 5300: esalt_size = sizeof (ikepsk_t); break;
10694 case 5400: esalt_size = sizeof (ikepsk_t); break;
10695 case 5500: esalt_size = sizeof (netntlm_t); break;
10696 case 5600: esalt_size = sizeof (netntlm_t); break;
10697 case 6211: esalt_size = sizeof (tc_t); break;
10698 case 6212: esalt_size = sizeof (tc_t); break;
10699 case 6213: esalt_size = sizeof (tc_t); break;
10700 case 6221: esalt_size = sizeof (tc_t); break;
10701 case 6222: esalt_size = sizeof (tc_t); break;
10702 case 6223: esalt_size = sizeof (tc_t); break;
10703 case 6231: esalt_size = sizeof (tc_t); break;
10704 case 6232: esalt_size = sizeof (tc_t); break;
10705 case 6233: esalt_size = sizeof (tc_t); break;
10706 case 6241: esalt_size = sizeof (tc_t); break;
10707 case 6242: esalt_size = sizeof (tc_t); break;
10708 case 6243: esalt_size = sizeof (tc_t); break;
10709 case 6600: esalt_size = sizeof (agilekey_t); break;
10710 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10711 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10712 case 7300: esalt_size = sizeof (rakp_t); break;
10713 case 7500: esalt_size = sizeof (krb5pa_t); break;
10714 case 8200: esalt_size = sizeof (cloudkey_t); break;
10715 case 8800: esalt_size = sizeof (androidfde_t); break;
10716 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10717 case 9400: esalt_size = sizeof (office2007_t); break;
10718 case 9500: esalt_size = sizeof (office2010_t); break;
10719 case 9600: esalt_size = sizeof (office2013_t); break;
10720 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10721 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10722 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10723 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10724 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10725 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10726 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10727 case 10200: esalt_size = sizeof (cram_md5_t); break;
10728 case 10400: esalt_size = sizeof (pdf_t); break;
10729 case 10410: esalt_size = sizeof (pdf_t); break;
10730 case 10420: esalt_size = sizeof (pdf_t); break;
10731 case 10500: esalt_size = sizeof (pdf_t); break;
10732 case 10600: esalt_size = sizeof (pdf_t); break;
10733 case 10700: esalt_size = sizeof (pdf_t); break;
10734 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10735 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10736 case 11400: esalt_size = sizeof (sip_t); break;
10737 case 11600: esalt_size = sizeof (seven_zip_t); break;
10738 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10739 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10740 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10741 case 13000: esalt_size = sizeof (rar5_t); break;
10742 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10743 case 13400: esalt_size = sizeof (keepass_t); break;
10744 case 13500: esalt_size = sizeof (pstoken_t); break;
10745 case 13600: esalt_size = sizeof (zip2_t); break;
10746 case 13711: esalt_size = sizeof (tc_t); break;
10747 case 13712: esalt_size = sizeof (tc_t); break;
10748 case 13713: esalt_size = sizeof (tc_t); break;
10749 case 13721: esalt_size = sizeof (tc_t); break;
10750 case 13722: esalt_size = sizeof (tc_t); break;
10751 case 13723: esalt_size = sizeof (tc_t); break;
10752 case 13731: esalt_size = sizeof (tc_t); break;
10753 case 13732: esalt_size = sizeof (tc_t); break;
10754 case 13733: esalt_size = sizeof (tc_t); break;
10755 case 13741: esalt_size = sizeof (tc_t); break;
10756 case 13742: esalt_size = sizeof (tc_t); break;
10757 case 13743: esalt_size = sizeof (tc_t); break;
10758 case 13751: esalt_size = sizeof (tc_t); break;
10759 case 13752: esalt_size = sizeof (tc_t); break;
10760 case 13753: esalt_size = sizeof (tc_t); break;
10761 case 13761: esalt_size = sizeof (tc_t); break;
10762 case 13762: esalt_size = sizeof (tc_t); break;
10763 case 13763: esalt_size = sizeof (tc_t); break;
10764 }
10765
10766 data.esalt_size = esalt_size;
10767
10768 /**
10769 * choose dictionary parser
10770 */
10771
10772 if (hash_type == HASH_TYPE_LM)
10773 {
10774 get_next_word_func = get_next_word_lm;
10775 }
10776 else if (opts_type & OPTS_TYPE_PT_UPPER)
10777 {
10778 get_next_word_func = get_next_word_uc;
10779 }
10780 else
10781 {
10782 get_next_word_func = get_next_word_std;
10783 }
10784
10785 /**
10786 * dictstat
10787 */
10788
10789 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10790
10791 #ifdef _POSIX
10792 size_t dictstat_nmemb = 0;
10793 #endif
10794
10795 #ifdef _WIN
10796 uint dictstat_nmemb = 0;
10797 #endif
10798
10799 char dictstat[256] = { 0 };
10800
10801 FILE *dictstat_fp = NULL;
10802
10803 if (keyspace == 0)
10804 {
10805 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10806
10807 dictstat_fp = fopen (dictstat, "rb");
10808
10809 if (dictstat_fp)
10810 {
10811 #ifdef _POSIX
10812 struct stat tmpstat;
10813
10814 fstat (fileno (dictstat_fp), &tmpstat);
10815 #endif
10816
10817 #ifdef _WIN
10818 struct stat64 tmpstat;
10819
10820 _fstat64 (fileno (dictstat_fp), &tmpstat);
10821 #endif
10822
10823 if (tmpstat.st_mtime < COMPTIME)
10824 {
10825 /* with v0.15 the format changed so we have to ensure user is using a good version
10826 since there is no version-header in the dictstat file */
10827
10828 fclose (dictstat_fp);
10829
10830 unlink (dictstat);
10831 }
10832 else
10833 {
10834 while (!feof (dictstat_fp))
10835 {
10836 dictstat_t d;
10837
10838 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10839
10840 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10841
10842 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10843 {
10844 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10845
10846 return -1;
10847 }
10848 }
10849
10850 fclose (dictstat_fp);
10851 }
10852 }
10853 }
10854
10855 /**
10856 * potfile
10857 */
10858
10859 char potfile[256] = { 0 };
10860
10861 if (potfile_path == NULL)
10862 {
10863 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10864 }
10865 else
10866 {
10867 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10868 }
10869
10870 data.pot_fp = NULL;
10871
10872 FILE *out_fp = NULL;
10873 FILE *pot_fp = NULL;
10874
10875 if (show == 1 || left == 1)
10876 {
10877 pot_fp = fopen (potfile, "rb");
10878
10879 if (pot_fp == NULL)
10880 {
10881 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10882
10883 return (-1);
10884 }
10885
10886 if (outfile != NULL)
10887 {
10888 if ((out_fp = fopen (outfile, "ab")) == NULL)
10889 {
10890 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10891
10892 fclose (pot_fp);
10893
10894 return (-1);
10895 }
10896 }
10897 else
10898 {
10899 out_fp = stdout;
10900 }
10901 }
10902 else
10903 {
10904 if (potfile_disable == 0)
10905 {
10906 pot_fp = fopen (potfile, "ab");
10907
10908 if (pot_fp == NULL)
10909 {
10910 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10911
10912 return (-1);
10913 }
10914
10915 data.pot_fp = pot_fp;
10916 }
10917 }
10918
10919 pot_t *pot = NULL;
10920
10921 uint pot_cnt = 0;
10922 uint pot_avail = 0;
10923
10924 if (show == 1 || left == 1)
10925 {
10926 SUPPRESS_OUTPUT = 1;
10927
10928 pot_avail = count_lines (pot_fp);
10929
10930 rewind (pot_fp);
10931
10932 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10933
10934 uint pot_hashes_avail = 0;
10935
10936 uint line_num = 0;
10937
10938 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10939
10940 while (!feof (pot_fp))
10941 {
10942 line_num++;
10943
10944 int line_len = fgetl (pot_fp, line_buf);
10945
10946 if (line_len == 0) continue;
10947
10948 char *plain_buf = line_buf + line_len;
10949
10950 pot_t *pot_ptr = &pot[pot_cnt];
10951
10952 hash_t *hashes_buf = &pot_ptr->hash;
10953
10954 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10955 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10956
10957 if (pot_cnt == pot_hashes_avail)
10958 {
10959 uint pos = 0;
10960
10961 for (pos = 0; pos < INCR_POT; pos++)
10962 {
10963 if ((pot_cnt + pos) >= pot_avail) break;
10964
10965 pot_t *tmp_pot = &pot[pot_cnt + pos];
10966
10967 hash_t *tmp_hash = &tmp_pot->hash;
10968
10969 tmp_hash->digest = mymalloc (dgst_size);
10970
10971 if (isSalted)
10972 {
10973 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10974 }
10975
10976 if (esalt_size)
10977 {
10978 tmp_hash->esalt = mymalloc (esalt_size);
10979 }
10980
10981 pot_hashes_avail++;
10982 }
10983 }
10984
10985 int plain_len = 0;
10986
10987 int parser_status;
10988
10989 int iter = MAX_CUT_TRIES;
10990
10991 do
10992 {
10993 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10994 {
10995 if (line_buf[i] == ':')
10996 {
10997 line_len--;
10998
10999 break;
11000 }
11001 }
11002
11003 if (data.hash_mode != 2500)
11004 {
11005 parser_status = parse_func (line_buf, line_len, hashes_buf);
11006 }
11007 else
11008 {
11009 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11010
11011 if (line_len > max_salt_size)
11012 {
11013 parser_status = PARSER_GLOBAL_LENGTH;
11014 }
11015 else
11016 {
11017 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11018
11019 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11020
11021 hashes_buf->salt->salt_len = line_len;
11022
11023 parser_status = PARSER_OK;
11024 }
11025 }
11026
11027 // if NOT parsed without error, we add the ":" to the plain
11028
11029 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11030 {
11031 plain_len++;
11032 plain_buf--;
11033 }
11034
11035 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11036
11037 if (parser_status < PARSER_GLOBAL_ZERO)
11038 {
11039 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11040
11041 continue;
11042 }
11043
11044 if (plain_len >= 255) continue;
11045
11046 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11047
11048 pot_ptr->plain_len = plain_len;
11049
11050 pot_cnt++;
11051 }
11052
11053 myfree (line_buf);
11054
11055 fclose (pot_fp);
11056
11057 SUPPRESS_OUTPUT = 0;
11058
11059 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11060 }
11061
11062 /**
11063 * word len
11064 */
11065
11066 uint pw_min = PW_MIN;
11067 uint pw_max = PW_MAX;
11068
11069 switch (hash_mode)
11070 {
11071 case 125: if (pw_max > 32) pw_max = 32;
11072 break;
11073 case 400: if (pw_max > 40) pw_max = 40;
11074 break;
11075 case 500: if (pw_max > 16) pw_max = 16;
11076 break;
11077 case 1500: if (pw_max > 8) pw_max = 8;
11078 break;
11079 case 1600: if (pw_max > 16) pw_max = 16;
11080 break;
11081 case 1800: if (pw_max > 16) pw_max = 16;
11082 break;
11083 case 2100: if (pw_max > 16) pw_max = 16;
11084 break;
11085 case 2500: if (pw_min < 8) pw_min = 8;
11086 break;
11087 case 3000: if (pw_max > 7) pw_max = 7;
11088 break;
11089 case 5200: if (pw_max > 24) pw_max = 24;
11090 break;
11091 case 5800: if (pw_max > 16) pw_max = 16;
11092 break;
11093 case 6300: if (pw_max > 16) pw_max = 16;
11094 break;
11095 case 7400: if (pw_max > 16) pw_max = 16;
11096 break;
11097 case 7900: if (pw_max > 48) pw_max = 48;
11098 break;
11099 case 8500: if (pw_max > 8) pw_max = 8;
11100 break;
11101 case 8600: if (pw_max > 16) pw_max = 16;
11102 break;
11103 case 9710: pw_min = 5;
11104 pw_max = 5;
11105 break;
11106 case 9810: pw_min = 5;
11107 pw_max = 5;
11108 break;
11109 case 10410: pw_min = 5;
11110 pw_max = 5;
11111 break;
11112 case 10300: if (pw_max < 3) pw_min = 3;
11113 if (pw_max > 40) pw_max = 40;
11114 break;
11115 case 10500: if (pw_max < 3) pw_min = 3;
11116 if (pw_max > 40) pw_max = 40;
11117 break;
11118 case 10700: if (pw_max > 16) pw_max = 16;
11119 break;
11120 case 11300: if (pw_max > 40) pw_max = 40;
11121 break;
11122 case 11600: if (pw_max > 32) pw_max = 32;
11123 break;
11124 case 12500: if (pw_max > 20) pw_max = 20;
11125 break;
11126 case 12800: if (pw_max > 24) pw_max = 24;
11127 break;
11128 }
11129
11130 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11131 {
11132 switch (attack_kern)
11133 {
11134 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11135 break;
11136 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11137 break;
11138 }
11139 }
11140
11141 /**
11142 * charsets : keep them together for more easy maintainnce
11143 */
11144
11145 cs_t mp_sys[6] = { { { 0 }, 0 } };
11146 cs_t mp_usr[4] = { { { 0 }, 0 } };
11147
11148 mp_setup_sys (mp_sys);
11149
11150 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11151 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11152 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11153 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11154
11155 /**
11156 * load hashes, part I: find input mode, count hashes
11157 */
11158
11159 uint hashlist_mode = 0;
11160 uint hashlist_format = HLFMT_HASHCAT;
11161
11162 uint hashes_avail = 0;
11163
11164 if (benchmark == 0)
11165 {
11166 struct stat f;
11167
11168 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11169
11170 if ((hash_mode == 2500) ||
11171 (hash_mode == 5200) ||
11172 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11173 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11174 (hash_mode == 9000))
11175 {
11176 hashlist_mode = HL_MODE_ARG;
11177
11178 char *hashfile = myargv[optind];
11179
11180 data.hashfile = hashfile;
11181
11182 logfile_top_var_string ("target", hashfile);
11183 }
11184
11185 if (hashlist_mode == HL_MODE_ARG)
11186 {
11187 if (hash_mode == 2500)
11188 {
11189 struct stat st;
11190
11191 if (stat (data.hashfile, &st) == -1)
11192 {
11193 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11194
11195 return (-1);
11196 }
11197
11198 hashes_avail = st.st_size / sizeof (hccap_t);
11199 }
11200 else
11201 {
11202 hashes_avail = 1;
11203 }
11204 }
11205 else if (hashlist_mode == HL_MODE_FILE)
11206 {
11207 char *hashfile = myargv[optind];
11208
11209 data.hashfile = hashfile;
11210
11211 logfile_top_var_string ("target", hashfile);
11212
11213 FILE *fp = NULL;
11214
11215 if ((fp = fopen (hashfile, "rb")) == NULL)
11216 {
11217 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11218
11219 return (-1);
11220 }
11221
11222 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11223
11224 hashes_avail = count_lines (fp);
11225
11226 rewind (fp);
11227
11228 if (hashes_avail == 0)
11229 {
11230 log_error ("ERROR: hashfile is empty or corrupt");
11231
11232 fclose (fp);
11233
11234 return (-1);
11235 }
11236
11237 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11238
11239 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11240 {
11241 log_error ("ERROR: remove not supported in native hashfile-format mode");
11242
11243 fclose (fp);
11244
11245 return (-1);
11246 }
11247
11248 fclose (fp);
11249 }
11250 }
11251 else
11252 {
11253 hashlist_mode = HL_MODE_ARG;
11254
11255 hashes_avail = 1;
11256 }
11257
11258 if (hash_mode == 3000) hashes_avail *= 2;
11259
11260 data.hashlist_mode = hashlist_mode;
11261 data.hashlist_format = hashlist_format;
11262
11263 logfile_top_uint (hashlist_mode);
11264 logfile_top_uint (hashlist_format);
11265
11266 /**
11267 * load hashes, part II: allocate required memory, set pointers
11268 */
11269
11270 hash_t *hashes_buf = NULL;
11271 void *digests_buf = NULL;
11272 salt_t *salts_buf = NULL;
11273 void *esalts_buf = NULL;
11274
11275 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11276
11277 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11278
11279 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11280 {
11281 u32 hash_pos;
11282
11283 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11284 {
11285 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11286
11287 hashes_buf[hash_pos].hash_info = hash_info;
11288
11289 if (username && (remove || show || left))
11290 {
11291 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11292 }
11293
11294 if (benchmark)
11295 {
11296 hash_info->orighash = (char *) mymalloc (256);
11297 }
11298 }
11299 }
11300
11301 if (isSalted)
11302 {
11303 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11304
11305 if (esalt_size)
11306 {
11307 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11308 }
11309 }
11310 else
11311 {
11312 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11313 }
11314
11315 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11316 {
11317 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11318
11319 if (isSalted)
11320 {
11321 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11322
11323 if (esalt_size)
11324 {
11325 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11326 }
11327 }
11328 else
11329 {
11330 hashes_buf[hash_pos].salt = &salts_buf[0];
11331 }
11332 }
11333
11334 /**
11335 * load hashes, part III: parse hashes or generate them if benchmark
11336 */
11337
11338 uint hashes_cnt = 0;
11339
11340 if (benchmark == 0)
11341 {
11342 if (keyspace == 1)
11343 {
11344 // useless to read hash file for keyspace, cheat a little bit w/ optind
11345 }
11346 else if (hashes_avail == 0)
11347 {
11348 }
11349 else if (hashlist_mode == HL_MODE_ARG)
11350 {
11351 char *input_buf = myargv[optind];
11352
11353 uint input_len = strlen (input_buf);
11354
11355 logfile_top_var_string ("target", input_buf);
11356
11357 char *hash_buf = NULL;
11358 int hash_len = 0;
11359
11360 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11361
11362 bool hash_fmt_error = 0;
11363
11364 if (hash_len < 1) hash_fmt_error = 1;
11365 if (hash_buf == NULL) hash_fmt_error = 1;
11366
11367 if (hash_fmt_error)
11368 {
11369 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11370 }
11371 else
11372 {
11373 if (opts_type & OPTS_TYPE_HASH_COPY)
11374 {
11375 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11376
11377 hash_info_tmp->orighash = mystrdup (hash_buf);
11378 }
11379
11380 if (isSalted)
11381 {
11382 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11383 }
11384
11385 int parser_status = PARSER_OK;
11386
11387 if (hash_mode == 2500)
11388 {
11389 if (hash_len == 0)
11390 {
11391 log_error ("ERROR: hccap file not specified");
11392
11393 return (-1);
11394 }
11395
11396 hashlist_mode = HL_MODE_FILE;
11397
11398 data.hashlist_mode = hashlist_mode;
11399
11400 FILE *fp = fopen (hash_buf, "rb");
11401
11402 if (fp == NULL)
11403 {
11404 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11405
11406 return (-1);
11407 }
11408
11409 if (hashes_avail < 1)
11410 {
11411 log_error ("ERROR: hccap file is empty or corrupt");
11412
11413 fclose (fp);
11414
11415 return (-1);
11416 }
11417
11418 uint hccap_size = sizeof (hccap_t);
11419
11420 char *in = (char *) mymalloc (hccap_size);
11421
11422 while (!feof (fp))
11423 {
11424 int n = fread (in, hccap_size, 1, fp);
11425
11426 if (n != 1)
11427 {
11428 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11429
11430 break;
11431 }
11432
11433 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11434
11435 if (parser_status != PARSER_OK)
11436 {
11437 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11438
11439 continue;
11440 }
11441
11442 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11443
11444 if ((show == 1) || (left == 1))
11445 {
11446 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11447
11448 char *salt_ptr = (char *) tmp_salt->salt_buf;
11449
11450 int cur_pos = tmp_salt->salt_len;
11451 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11452
11453 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11454
11455 // do the appending task
11456
11457 snprintf (salt_ptr + cur_pos,
11458 rem_len,
11459 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11460 wpa->orig_mac1[0],
11461 wpa->orig_mac1[1],
11462 wpa->orig_mac1[2],
11463 wpa->orig_mac1[3],
11464 wpa->orig_mac1[4],
11465 wpa->orig_mac1[5],
11466 wpa->orig_mac2[0],
11467 wpa->orig_mac2[1],
11468 wpa->orig_mac2[2],
11469 wpa->orig_mac2[3],
11470 wpa->orig_mac2[4],
11471 wpa->orig_mac2[5]);
11472
11473 // memset () the remaining part of the salt
11474
11475 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11476 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11477
11478 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11479
11480 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11481 }
11482
11483 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);
11484 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);
11485
11486 hashes_cnt++;
11487 }
11488
11489 fclose (fp);
11490
11491 myfree (in);
11492 }
11493 else if (hash_mode == 3000)
11494 {
11495 if (hash_len == 32)
11496 {
11497 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11498
11499 hash_t *lm_hash_left = NULL;
11500
11501 if (parser_status == PARSER_OK)
11502 {
11503 lm_hash_left = &hashes_buf[hashes_cnt];
11504
11505 hashes_cnt++;
11506 }
11507 else
11508 {
11509 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11510 }
11511
11512 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11513
11514 hash_t *lm_hash_right = NULL;
11515
11516 if (parser_status == PARSER_OK)
11517 {
11518 lm_hash_right = &hashes_buf[hashes_cnt];
11519
11520 hashes_cnt++;
11521 }
11522 else
11523 {
11524 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11525 }
11526
11527 // show / left
11528
11529 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11530 {
11531 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);
11532 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);
11533 }
11534 }
11535 else
11536 {
11537 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11538
11539 if (parser_status == PARSER_OK)
11540 {
11541 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11542 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11543 }
11544
11545 if (parser_status == PARSER_OK)
11546 {
11547 hashes_cnt++;
11548 }
11549 else
11550 {
11551 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11552 }
11553 }
11554 }
11555 else
11556 {
11557 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11558
11559 if (parser_status == PARSER_OK)
11560 {
11561 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11562 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11563 }
11564
11565 if (parser_status == PARSER_OK)
11566 {
11567 hashes_cnt++;
11568 }
11569 else
11570 {
11571 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11572 }
11573 }
11574 }
11575 }
11576 else if (hashlist_mode == HL_MODE_FILE)
11577 {
11578 char *hashfile = data.hashfile;
11579
11580 FILE *fp;
11581
11582 if ((fp = fopen (hashfile, "rb")) == NULL)
11583 {
11584 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11585
11586 return (-1);
11587 }
11588
11589 uint line_num = 0;
11590
11591 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11592
11593 while (!feof (fp))
11594 {
11595 line_num++;
11596
11597 int line_len = fgetl (fp, line_buf);
11598
11599 if (line_len == 0) continue;
11600
11601 char *hash_buf = NULL;
11602 int hash_len = 0;
11603
11604 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11605
11606 bool hash_fmt_error = 0;
11607
11608 if (hash_len < 1) hash_fmt_error = 1;
11609 if (hash_buf == NULL) hash_fmt_error = 1;
11610
11611 if (hash_fmt_error)
11612 {
11613 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11614
11615 continue;
11616 }
11617
11618 if (username)
11619 {
11620 char *user_buf = NULL;
11621 int user_len = 0;
11622
11623 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11624
11625 if (remove || show)
11626 {
11627 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11628
11629 *user = (user_t *) mymalloc (sizeof (user_t));
11630
11631 user_t *user_ptr = *user;
11632
11633 if (user_buf != NULL)
11634 {
11635 user_ptr->user_name = mystrdup (user_buf);
11636 }
11637 else
11638 {
11639 user_ptr->user_name = mystrdup ("");
11640 }
11641
11642 user_ptr->user_len = user_len;
11643 }
11644 }
11645
11646 if (opts_type & OPTS_TYPE_HASH_COPY)
11647 {
11648 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11649
11650 hash_info_tmp->orighash = mystrdup (hash_buf);
11651 }
11652
11653 if (isSalted)
11654 {
11655 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11656 }
11657
11658 if (hash_mode == 3000)
11659 {
11660 if (hash_len == 32)
11661 {
11662 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11663
11664 if (parser_status < PARSER_GLOBAL_ZERO)
11665 {
11666 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11667
11668 continue;
11669 }
11670
11671 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11672
11673 hashes_cnt++;
11674
11675 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11676
11677 if (parser_status < PARSER_GLOBAL_ZERO)
11678 {
11679 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11680
11681 continue;
11682 }
11683
11684 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11685
11686 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);
11687
11688 hashes_cnt++;
11689
11690 // show / left
11691
11692 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);
11693 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);
11694 }
11695 else
11696 {
11697 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11698
11699 if (parser_status < PARSER_GLOBAL_ZERO)
11700 {
11701 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11702
11703 continue;
11704 }
11705
11706 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);
11707
11708 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11709 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11710
11711 hashes_cnt++;
11712 }
11713 }
11714 else
11715 {
11716 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11717
11718 if (parser_status < PARSER_GLOBAL_ZERO)
11719 {
11720 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11721
11722 continue;
11723 }
11724
11725 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);
11726
11727 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11728 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11729
11730 hashes_cnt++;
11731 }
11732 }
11733
11734 myfree (line_buf);
11735
11736 fclose (fp);
11737
11738 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11739
11740 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11741 }
11742 }
11743 else
11744 {
11745 if (isSalted)
11746 {
11747 hashes_buf[0].salt->salt_len = 8;
11748
11749 // special salt handling
11750
11751 switch (hash_mode)
11752 {
11753 case 1500: hashes_buf[0].salt->salt_len = 2;
11754 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11755 break;
11756 case 1731: hashes_buf[0].salt->salt_len = 4;
11757 break;
11758 case 2410: hashes_buf[0].salt->salt_len = 4;
11759 break;
11760 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11761 break;
11762 case 3100: hashes_buf[0].salt->salt_len = 1;
11763 break;
11764 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11765 break;
11766 case 5800: hashes_buf[0].salt->salt_len = 16;
11767 break;
11768 case 6800: hashes_buf[0].salt->salt_len = 32;
11769 break;
11770 case 8400: hashes_buf[0].salt->salt_len = 40;
11771 break;
11772 case 8800: hashes_buf[0].salt->salt_len = 16;
11773 break;
11774 case 8900: hashes_buf[0].salt->salt_len = 16;
11775 hashes_buf[0].salt->scrypt_N = 1024;
11776 hashes_buf[0].salt->scrypt_r = 1;
11777 hashes_buf[0].salt->scrypt_p = 1;
11778 break;
11779 case 9100: hashes_buf[0].salt->salt_len = 16;
11780 break;
11781 case 9300: hashes_buf[0].salt->salt_len = 14;
11782 hashes_buf[0].salt->scrypt_N = 16384;
11783 hashes_buf[0].salt->scrypt_r = 1;
11784 hashes_buf[0].salt->scrypt_p = 1;
11785 break;
11786 case 9400: hashes_buf[0].salt->salt_len = 16;
11787 break;
11788 case 9500: hashes_buf[0].salt->salt_len = 16;
11789 break;
11790 case 9600: hashes_buf[0].salt->salt_len = 16;
11791 break;
11792 case 9700: hashes_buf[0].salt->salt_len = 16;
11793 break;
11794 case 9710: hashes_buf[0].salt->salt_len = 16;
11795 break;
11796 case 9720: hashes_buf[0].salt->salt_len = 16;
11797 break;
11798 case 9800: hashes_buf[0].salt->salt_len = 16;
11799 break;
11800 case 9810: hashes_buf[0].salt->salt_len = 16;
11801 break;
11802 case 9820: hashes_buf[0].salt->salt_len = 16;
11803 break;
11804 case 10300: hashes_buf[0].salt->salt_len = 12;
11805 break;
11806 case 11500: hashes_buf[0].salt->salt_len = 4;
11807 break;
11808 case 11600: hashes_buf[0].salt->salt_len = 4;
11809 break;
11810 case 12400: hashes_buf[0].salt->salt_len = 4;
11811 break;
11812 case 12500: hashes_buf[0].salt->salt_len = 8;
11813 break;
11814 case 12600: hashes_buf[0].salt->salt_len = 64;
11815 break;
11816 }
11817
11818 // special esalt handling
11819
11820 switch (hash_mode)
11821 {
11822 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11823 break;
11824 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11825 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11826 break;
11827 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11828 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11829 break;
11830 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11831 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11832 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11833 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11834 break;
11835 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11836 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11837 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11838 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11839 break;
11840 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11841 break;
11842 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11843 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11844 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11845 break;
11846 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11847 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11848 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11849 break;
11850 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11851 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11852 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11853 break;
11854 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11855 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11856 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11857 break;
11858 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11859 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11860 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11861 break;
11862 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11863 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11864 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11865 break;
11866 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11867 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11868 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11869 break;
11870 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11871 break;
11872 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11873 break;
11874 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11875 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11876 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11877 break;
11878 }
11879 }
11880
11881 // set hashfile
11882
11883 switch (hash_mode)
11884 {
11885 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11886 break;
11887 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11888 break;
11889 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11890 break;
11891 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11892 break;
11893 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11894 break;
11895 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11896 break;
11897 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11898 break;
11899 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11900 break;
11901 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11902 break;
11903 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11904 break;
11905 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11906 break;
11907 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11908 break;
11909 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11910 break;
11911 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11912 break;
11913 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11914 break;
11915 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11916 break;
11917 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11918 break;
11919 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11920 break;
11921 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11924 break;
11925 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11926 break;
11927 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11928 break;
11929 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11930 break;
11931 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11932 break;
11933 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11934 break;
11935 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11936 break;
11937 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11938 break;
11939 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11940 break;
11941 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11942 break;
11943 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11944 break;
11945 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11946 break;
11947 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11948 break;
11949 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11950 break;
11951 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11952 break;
11953 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11954 break;
11955 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11956 break;
11957 }
11958
11959 // set default iterations
11960
11961 switch (hash_mode)
11962 {
11963 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11964 break;
11965 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11966 break;
11967 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11968 break;
11969 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11970 break;
11971 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11972 break;
11973 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11974 break;
11975 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11976 break;
11977 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11978 break;
11979 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11980 break;
11981 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11982 break;
11983 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11984 break;
11985 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11986 break;
11987 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11988 break;
11989 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11990 break;
11991 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11992 break;
11993 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11994 break;
11995 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11996 break;
11997 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11998 break;
11999 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12000 break;
12001 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12002 break;
12003 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12004 break;
12005 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12006 break;
12007 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12008 break;
12009 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12010 break;
12011 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12012 break;
12013 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12014 break;
12015 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12016 break;
12017 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12018 break;
12019 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12020 break;
12021 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12022 break;
12023 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12024 break;
12025 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12026 break;
12027 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12028 break;
12029 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12030 break;
12031 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12032 break;
12033 case 8900: hashes_buf[0].salt->salt_iter = 1;
12034 break;
12035 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12036 break;
12037 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12038 break;
12039 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12040 break;
12041 case 9300: hashes_buf[0].salt->salt_iter = 1;
12042 break;
12043 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12044 break;
12045 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12046 break;
12047 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12048 break;
12049 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12050 break;
12051 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12052 break;
12053 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12054 break;
12055 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12056 break;
12057 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12058 break;
12059 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12060 break;
12061 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12062 break;
12063 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12064 break;
12065 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12066 break;
12067 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12068 break;
12069 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12070 break;
12071 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12072 break;
12073 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12074 break;
12075 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12076 break;
12077 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12078 break;
12079 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12080 break;
12081 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12082 break;
12083 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12084 break;
12085 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12086 break;
12087 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12088 break;
12089 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12090 break;
12091 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12092 break;
12093 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12094 break;
12095 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12096 break;
12097 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12098 break;
12099 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12100 break;
12101 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12102 break;
12103 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12104 break;
12105 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12106 break;
12107 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12108 break;
12109 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12110 break;
12111 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12112 break;
12113 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12114 break;
12115 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12116 break;
12117 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12118 break;
12119 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12120 break;
12121 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12122 break;
12123 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12124 break;
12125 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12126 break;
12127 }
12128
12129 hashes_cnt = 1;
12130 }
12131
12132 if (show == 1 || left == 1)
12133 {
12134 for (uint i = 0; i < pot_cnt; i++)
12135 {
12136 pot_t *pot_ptr = &pot[i];
12137
12138 hash_t *hashes_buf = &pot_ptr->hash;
12139
12140 local_free (hashes_buf->digest);
12141
12142 if (isSalted)
12143 {
12144 local_free (hashes_buf->salt);
12145 }
12146 }
12147
12148 local_free (pot);
12149
12150 if (data.quiet == 0) log_info_nn ("");
12151
12152 return (0);
12153 }
12154
12155 if (keyspace == 0)
12156 {
12157 if (hashes_cnt == 0)
12158 {
12159 log_error ("ERROR: No hashes loaded");
12160
12161 return (-1);
12162 }
12163 }
12164
12165 /**
12166 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12167 */
12168
12169 if (data.outfile != NULL)
12170 {
12171 if (data.hashfile != NULL)
12172 {
12173 #ifdef _POSIX
12174 struct stat tmpstat_outfile;
12175 struct stat tmpstat_hashfile;
12176 #endif
12177
12178 #ifdef _WIN
12179 struct stat64 tmpstat_outfile;
12180 struct stat64 tmpstat_hashfile;
12181 #endif
12182
12183 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12184
12185 if (tmp_outfile_fp)
12186 {
12187 #ifdef _POSIX
12188 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12189 #endif
12190
12191 #ifdef _WIN
12192 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12193 #endif
12194
12195 fclose (tmp_outfile_fp);
12196 }
12197
12198 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12199
12200 if (tmp_hashfile_fp)
12201 {
12202 #ifdef _POSIX
12203 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12204 #endif
12205
12206 #ifdef _WIN
12207 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12208 #endif
12209
12210 fclose (tmp_hashfile_fp);
12211 }
12212
12213 if (tmp_outfile_fp && tmp_outfile_fp)
12214 {
12215 tmpstat_outfile.st_mode = 0;
12216 tmpstat_outfile.st_nlink = 0;
12217 tmpstat_outfile.st_uid = 0;
12218 tmpstat_outfile.st_gid = 0;
12219 tmpstat_outfile.st_rdev = 0;
12220 tmpstat_outfile.st_atime = 0;
12221
12222 tmpstat_hashfile.st_mode = 0;
12223 tmpstat_hashfile.st_nlink = 0;
12224 tmpstat_hashfile.st_uid = 0;
12225 tmpstat_hashfile.st_gid = 0;
12226 tmpstat_hashfile.st_rdev = 0;
12227 tmpstat_hashfile.st_atime = 0;
12228
12229 #ifdef _POSIX
12230 tmpstat_outfile.st_blksize = 0;
12231 tmpstat_outfile.st_blocks = 0;
12232
12233 tmpstat_hashfile.st_blksize = 0;
12234 tmpstat_hashfile.st_blocks = 0;
12235 #endif
12236
12237 #ifdef _POSIX
12238 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12239 {
12240 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12241
12242 return (-1);
12243 }
12244 #endif
12245
12246 #ifdef _WIN
12247 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12248 {
12249 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12250
12251 return (-1);
12252 }
12253 #endif
12254 }
12255 }
12256 }
12257
12258 /**
12259 * Remove duplicates
12260 */
12261
12262 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12263
12264 if (isSalted)
12265 {
12266 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12267 }
12268 else
12269 {
12270 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12271 }
12272
12273 uint hashes_cnt_orig = hashes_cnt;
12274
12275 hashes_cnt = 1;
12276
12277 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12278 {
12279 if (isSalted)
12280 {
12281 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12282 {
12283 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12284 }
12285 }
12286 else
12287 {
12288 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12289 }
12290
12291 if (hashes_pos > hashes_cnt)
12292 {
12293 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12294 }
12295
12296 hashes_cnt++;
12297 }
12298
12299 /**
12300 * Potfile removes
12301 */
12302
12303 uint potfile_remove_cracks = 0;
12304
12305 if (potfile_disable == 0)
12306 {
12307 hash_t hash_buf;
12308
12309 hash_buf.digest = mymalloc (dgst_size);
12310 hash_buf.salt = NULL;
12311 hash_buf.esalt = NULL;
12312 hash_buf.hash_info = NULL;
12313 hash_buf.cracked = 0;
12314
12315 if (isSalted)
12316 {
12317 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12318 }
12319
12320 if (esalt_size)
12321 {
12322 hash_buf.esalt = mymalloc (esalt_size);
12323 }
12324
12325 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12326
12327 // no solution for these special hash types (for instane because they use hashfile in output etc)
12328 if ((hash_mode != 5200) &&
12329 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12330 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12331 (hash_mode != 9000))
12332 {
12333 FILE *fp = fopen (potfile, "rb");
12334
12335 if (fp != NULL)
12336 {
12337 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12338
12339 // to be safe work with a copy (because of line_len loop, i etc)
12340 // moved up here because it's easier to handle continue case
12341 // it's just 64kb
12342
12343 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12344
12345 while (!feof (fp))
12346 {
12347 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12348
12349 if (ptr == NULL) break;
12350
12351 int line_len = strlen (line_buf);
12352
12353 if (line_len == 0) continue;
12354
12355 int iter = MAX_CUT_TRIES;
12356
12357 for (int i = line_len - 1; i && iter; i--, line_len--)
12358 {
12359 if (line_buf[i] != ':') continue;
12360
12361 if (isSalted)
12362 {
12363 memset (hash_buf.salt, 0, sizeof (salt_t));
12364 }
12365
12366 hash_t *found = NULL;
12367
12368 if (hash_mode == 6800)
12369 {
12370 if (i < 64) // 64 = 16 * uint in salt_buf[]
12371 {
12372 // manipulate salt_buf
12373 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12374
12375 hash_buf.salt->salt_len = i;
12376
12377 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12378 }
12379 }
12380 else if (hash_mode == 2500)
12381 {
12382 if (i < 64) // 64 = 16 * uint in salt_buf[]
12383 {
12384 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12385 // manipulate salt_buf
12386
12387 memcpy (line_buf_cpy, line_buf, i);
12388
12389 char *mac2_pos = strrchr (line_buf_cpy, ':');
12390
12391 if (mac2_pos == NULL) continue;
12392
12393 mac2_pos[0] = 0;
12394 mac2_pos++;
12395
12396 if (strlen (mac2_pos) != 12) continue;
12397
12398 char *mac1_pos = strrchr (line_buf_cpy, ':');
12399
12400 if (mac1_pos == NULL) continue;
12401
12402 mac1_pos[0] = 0;
12403 mac1_pos++;
12404
12405 if (strlen (mac1_pos) != 12) continue;
12406
12407 uint essid_length = mac1_pos - line_buf_cpy - 1;
12408
12409 // here we need the ESSID
12410 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12411
12412 hash_buf.salt->salt_len = essid_length;
12413
12414 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12415
12416 if (found)
12417 {
12418 wpa_t *wpa = (wpa_t *) found->esalt;
12419
12420 // compare hex string(s) vs binary MAC address(es)
12421
12422 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12423 {
12424 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12425 {
12426 found = NULL;
12427
12428 break;
12429 }
12430 }
12431
12432 // early skip ;)
12433 if (!found) continue;
12434
12435 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12436 {
12437 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12438 {
12439 found = NULL;
12440
12441 break;
12442 }
12443 }
12444 }
12445 }
12446 }
12447 else
12448 {
12449 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12450
12451 if (parser_status == PARSER_OK)
12452 {
12453 if (isSalted)
12454 {
12455 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12456 }
12457 else
12458 {
12459 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12460 }
12461 }
12462 }
12463
12464 if (found == NULL) continue;
12465
12466 if (!found->cracked) potfile_remove_cracks++;
12467
12468 found->cracked = 1;
12469
12470 if (found) break;
12471
12472 iter--;
12473 }
12474 }
12475
12476 myfree (line_buf_cpy);
12477
12478 myfree (line_buf);
12479
12480 fclose (fp);
12481 }
12482 }
12483
12484 if (esalt_size)
12485 {
12486 local_free (hash_buf.esalt);
12487 }
12488
12489 if (isSalted)
12490 {
12491 local_free (hash_buf.salt);
12492 }
12493
12494 local_free (hash_buf.digest);
12495 }
12496
12497 /**
12498 * Now generate all the buffers required for later
12499 */
12500
12501 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12502
12503 salt_t *salts_buf_new = NULL;
12504 void *esalts_buf_new = NULL;
12505
12506 if (isSalted)
12507 {
12508 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12509
12510 if (esalt_size)
12511 {
12512 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12513 }
12514 }
12515 else
12516 {
12517 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12518 }
12519
12520 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12521
12522 uint digests_cnt = hashes_cnt;
12523 uint digests_done = 0;
12524
12525 size_t size_digests = digests_cnt * dgst_size;
12526 size_t size_shown = digests_cnt * sizeof (uint);
12527
12528 uint *digests_shown = (uint *) mymalloc (size_shown);
12529 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12530
12531 uint salts_cnt = 0;
12532 uint salts_done = 0;
12533
12534 hashinfo_t **hash_info = NULL;
12535
12536 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12537 {
12538 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12539
12540 if (username && (remove || show))
12541 {
12542 uint user_pos;
12543
12544 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12545 {
12546 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12547
12548 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12549 }
12550 }
12551 }
12552
12553 uint *salts_shown = (uint *) mymalloc (size_shown);
12554
12555 salt_t *salt_buf;
12556
12557 {
12558 // copied from inner loop
12559
12560 salt_buf = &salts_buf_new[salts_cnt];
12561
12562 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12563
12564 if (esalt_size)
12565 {
12566 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12567 }
12568
12569 salt_buf->digests_cnt = 0;
12570 salt_buf->digests_done = 0;
12571 salt_buf->digests_offset = 0;
12572
12573 salts_cnt++;
12574 }
12575
12576 if (hashes_buf[0].cracked == 1)
12577 {
12578 digests_shown[0] = 1;
12579
12580 digests_done++;
12581
12582 salt_buf->digests_done++;
12583 }
12584
12585 salt_buf->digests_cnt++;
12586
12587 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12588
12589 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12590 {
12591 hash_info[0] = hashes_buf[0].hash_info;
12592 }
12593
12594 // copy from inner loop
12595
12596 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12597 {
12598 if (isSalted)
12599 {
12600 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12601 {
12602 salt_buf = &salts_buf_new[salts_cnt];
12603
12604 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12605
12606 if (esalt_size)
12607 {
12608 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12609 }
12610
12611 salt_buf->digests_cnt = 0;
12612 salt_buf->digests_done = 0;
12613 salt_buf->digests_offset = hashes_pos;
12614
12615 salts_cnt++;
12616 }
12617 }
12618
12619 if (hashes_buf[hashes_pos].cracked == 1)
12620 {
12621 digests_shown[hashes_pos] = 1;
12622
12623 digests_done++;
12624
12625 salt_buf->digests_done++;
12626 }
12627
12628 salt_buf->digests_cnt++;
12629
12630 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12631
12632 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12633 {
12634 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12635 }
12636 }
12637
12638 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12639 {
12640 salt_t *salt_buf = &salts_buf_new[salt_pos];
12641
12642 if (salt_buf->digests_done == salt_buf->digests_cnt)
12643 {
12644 salts_shown[salt_pos] = 1;
12645
12646 salts_done++;
12647 }
12648
12649 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12650 }
12651
12652 local_free (digests_buf);
12653 local_free (salts_buf);
12654 local_free (esalts_buf);
12655
12656 digests_buf = digests_buf_new;
12657 salts_buf = salts_buf_new;
12658 esalts_buf = esalts_buf_new;
12659
12660 local_free (hashes_buf);
12661
12662 /**
12663 * special modification not set from parser
12664 */
12665
12666 switch (hash_mode)
12667 {
12668 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12669 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12670 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12671 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12672 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12673 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12674 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12675 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12676 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12677 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12678 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12679 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12680 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12681 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12682 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12683 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12684 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12685 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12686 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12687 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12688 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12689 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12690 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12691 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12692 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12693 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12694 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12695 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12696 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12697 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12698 }
12699
12700 if (truecrypt_keyfiles)
12701 {
12702 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12703
12704 char *keyfiles = strdup (truecrypt_keyfiles);
12705
12706 char *keyfile = strtok (keyfiles, ",");
12707
12708 do
12709 {
12710 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12711
12712 } while ((keyfile = strtok (NULL, ",")) != NULL);
12713
12714 free (keyfiles);
12715 }
12716
12717 if (veracrypt_keyfiles)
12718 {
12719 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12720
12721 char *keyfiles = strdup (veracrypt_keyfiles);
12722
12723 char *keyfile = strtok (keyfiles, ",");
12724
12725 do
12726 {
12727 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12728
12729 } while ((keyfile = strtok (NULL, ",")) != NULL);
12730
12731 free (keyfiles);
12732 }
12733
12734 data.digests_cnt = digests_cnt;
12735 data.digests_done = digests_done;
12736 data.digests_buf = digests_buf;
12737 data.digests_shown = digests_shown;
12738 data.digests_shown_tmp = digests_shown_tmp;
12739
12740 data.salts_cnt = salts_cnt;
12741 data.salts_done = salts_done;
12742 data.salts_buf = salts_buf;
12743 data.salts_shown = salts_shown;
12744
12745 data.esalts_buf = esalts_buf;
12746 data.hash_info = hash_info;
12747
12748 /**
12749 * Automatic Optimizers
12750 */
12751
12752 if (salts_cnt == 1)
12753 opti_type |= OPTI_TYPE_SINGLE_SALT;
12754
12755 if (digests_cnt == 1)
12756 opti_type |= OPTI_TYPE_SINGLE_HASH;
12757
12758 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12759 opti_type |= OPTI_TYPE_NOT_ITERATED;
12760
12761 if (attack_mode == ATTACK_MODE_BF)
12762 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12763
12764 data.opti_type = opti_type;
12765
12766 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12767 {
12768 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12769 {
12770 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12771 {
12772 if (opts_type & OPTS_TYPE_ST_ADD80)
12773 {
12774 opts_type &= ~OPTS_TYPE_ST_ADD80;
12775 opts_type |= OPTS_TYPE_PT_ADD80;
12776 }
12777
12778 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12779 {
12780 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12781 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12782 }
12783
12784 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12785 {
12786 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12787 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12788 }
12789 }
12790 }
12791 }
12792
12793 /**
12794 * Some algorithm, like descrypt, can benefit from JIT compilation
12795 */
12796
12797 int force_jit_compilation = -1;
12798
12799 if (hash_mode == 8900)
12800 {
12801 force_jit_compilation = 8900;
12802 }
12803 else if (hash_mode == 9300)
12804 {
12805 force_jit_compilation = 8900;
12806 }
12807 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12808 {
12809 force_jit_compilation = 1500;
12810 }
12811
12812 /**
12813 * generate bitmap tables
12814 */
12815
12816 const uint bitmap_shift1 = 5;
12817 const uint bitmap_shift2 = 13;
12818
12819 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12820
12821 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12822 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12823 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12824 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12825 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12826 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12827 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12828 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12829
12830 uint bitmap_bits;
12831 uint bitmap_nums;
12832 uint bitmap_mask;
12833 uint bitmap_size;
12834
12835 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12836 {
12837 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12838
12839 bitmap_nums = 1 << bitmap_bits;
12840
12841 bitmap_mask = bitmap_nums - 1;
12842
12843 bitmap_size = bitmap_nums * sizeof (uint);
12844
12845 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12846
12847 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;
12848 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;
12849
12850 break;
12851 }
12852
12853 bitmap_nums = 1 << bitmap_bits;
12854
12855 bitmap_mask = bitmap_nums - 1;
12856
12857 bitmap_size = bitmap_nums * sizeof (uint);
12858
12859 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);
12860 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);
12861
12862 /**
12863 * prepare quick rule
12864 */
12865
12866 data.rule_buf_l = rule_buf_l;
12867 data.rule_buf_r = rule_buf_r;
12868
12869 int rule_len_l = (int) strlen (rule_buf_l);
12870 int rule_len_r = (int) strlen (rule_buf_r);
12871
12872 data.rule_len_l = rule_len_l;
12873 data.rule_len_r = rule_len_r;
12874
12875 /**
12876 * load rules
12877 */
12878
12879 uint *all_kernel_rules_cnt = NULL;
12880
12881 kernel_rule_t **all_kernel_rules_buf = NULL;
12882
12883 if (rp_files_cnt)
12884 {
12885 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12886
12887 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12888 }
12889
12890 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12891
12892 int rule_len = 0;
12893
12894 for (uint i = 0; i < rp_files_cnt; i++)
12895 {
12896 uint kernel_rules_avail = 0;
12897
12898 uint kernel_rules_cnt = 0;
12899
12900 kernel_rule_t *kernel_rules_buf = NULL;
12901
12902 char *rp_file = rp_files[i];
12903
12904 char in[BLOCK_SIZE] = { 0 };
12905 char out[BLOCK_SIZE] = { 0 };
12906
12907 FILE *fp = NULL;
12908
12909 uint rule_line = 0;
12910
12911 if ((fp = fopen (rp_file, "rb")) == NULL)
12912 {
12913 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12914
12915 return (-1);
12916 }
12917
12918 while (!feof (fp))
12919 {
12920 memset (rule_buf, 0, HCBUFSIZ);
12921
12922 rule_len = fgetl (fp, rule_buf);
12923
12924 rule_line++;
12925
12926 if (rule_len == 0) continue;
12927
12928 if (rule_buf[0] == '#') continue;
12929
12930 if (kernel_rules_avail == kernel_rules_cnt)
12931 {
12932 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12933
12934 kernel_rules_avail += INCR_RULES;
12935 }
12936
12937 memset (in, 0, BLOCK_SIZE);
12938 memset (out, 0, BLOCK_SIZE);
12939
12940 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12941
12942 if (result == -1)
12943 {
12944 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12945
12946 continue;
12947 }
12948
12949 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12950 {
12951 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12952
12953 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12954
12955 continue;
12956 }
12957
12958 /* its so slow
12959 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12960 {
12961 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12962
12963 continue;
12964 }
12965 */
12966
12967 kernel_rules_cnt++;
12968 }
12969
12970 fclose (fp);
12971
12972 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12973
12974 all_kernel_rules_buf[i] = kernel_rules_buf;
12975 }
12976
12977 /**
12978 * merge rules or automatic rule generator
12979 */
12980
12981 uint kernel_rules_cnt = 0;
12982
12983 kernel_rule_t *kernel_rules_buf = NULL;
12984
12985 if (attack_mode == ATTACK_MODE_STRAIGHT)
12986 {
12987 if (rp_files_cnt)
12988 {
12989 kernel_rules_cnt = 1;
12990
12991 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12992
12993 repeats[0] = kernel_rules_cnt;
12994
12995 for (uint i = 0; i < rp_files_cnt; i++)
12996 {
12997 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12998
12999 repeats[i + 1] = kernel_rules_cnt;
13000 }
13001
13002 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13003
13004 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13005
13006 for (uint i = 0; i < kernel_rules_cnt; i++)
13007 {
13008 uint out_pos = 0;
13009
13010 kernel_rule_t *out = &kernel_rules_buf[i];
13011
13012 for (uint j = 0; j < rp_files_cnt; j++)
13013 {
13014 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13015 uint in_pos;
13016
13017 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13018
13019 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13020 {
13021 if (out_pos == RULES_MAX - 1)
13022 {
13023 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13024
13025 break;
13026 }
13027
13028 out->cmds[out_pos] = in->cmds[in_pos];
13029 }
13030 }
13031 }
13032
13033 local_free (repeats);
13034 }
13035 else if (rp_gen)
13036 {
13037 uint kernel_rules_avail = 0;
13038
13039 while (kernel_rules_cnt < rp_gen)
13040 {
13041 if (kernel_rules_avail == kernel_rules_cnt)
13042 {
13043 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13044
13045 kernel_rules_avail += INCR_RULES;
13046 }
13047
13048 memset (rule_buf, 0, HCBUFSIZ);
13049
13050 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13051
13052 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13053
13054 kernel_rules_cnt++;
13055 }
13056 }
13057 }
13058
13059 myfree (rule_buf);
13060
13061 /**
13062 * generate NOP rules
13063 */
13064
13065 if (kernel_rules_cnt == 0)
13066 {
13067 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13068
13069 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13070
13071 kernel_rules_cnt++;
13072 }
13073
13074 data.kernel_rules_cnt = kernel_rules_cnt;
13075 data.kernel_rules_buf = kernel_rules_buf;
13076
13077 /**
13078 * OpenCL platforms: detect
13079 */
13080
13081 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13082 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13083
13084 cl_uint platforms_cnt = 0;
13085 cl_uint platform_devices_cnt = 0;
13086
13087 if (keyspace == 0)
13088 {
13089 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13090
13091 if (platforms_cnt == 0)
13092 {
13093 log_info ("");
13094 log_info ("ATTENTION! No OpenCL compatible platform found");
13095 log_info ("");
13096 log_info ("You're probably missing the OpenCL runtime installation");
13097 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13098 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13099 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13100 log_info ("");
13101
13102 return (-1);
13103 }
13104
13105 if (opencl_platforms_filter != (uint) -1)
13106 {
13107 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13108
13109 if (opencl_platforms_filter > platform_cnt_mask)
13110 {
13111 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13112
13113 return (-1);
13114 }
13115 }
13116 }
13117
13118 /**
13119 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13120 */
13121
13122 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13123 {
13124 cl_platform_id platform = platforms[platform_id];
13125
13126 char platform_vendor[INFOSZ] = { 0 };
13127
13128 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13129
13130 #ifdef HAVE_HWMON
13131 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13132 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13133 {
13134 // make sure that we do not directly control the fan for NVidia
13135
13136 gpu_temp_retain = 0;
13137
13138 data.gpu_temp_retain = gpu_temp_retain;
13139 }
13140 #endif // HAVE_NVML || HAVE_NVAPI
13141 #endif
13142 }
13143
13144 /**
13145 * OpenCL device types:
13146 * 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.
13147 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13148 */
13149
13150 if (opencl_device_types == NULL)
13151 {
13152 cl_device_type device_types_all = 0;
13153
13154 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13155 {
13156 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13157
13158 cl_platform_id platform = platforms[platform_id];
13159
13160 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13161
13162 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13163 {
13164 cl_device_id device = platform_devices[platform_devices_id];
13165
13166 cl_device_type device_type;
13167
13168 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13169
13170 device_types_all |= device_type;
13171 }
13172 }
13173
13174 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13175 {
13176 device_types_filter |= CL_DEVICE_TYPE_CPU;
13177 }
13178 }
13179
13180 /**
13181 * OpenCL devices: simply push all devices from all platforms into the same device array
13182 */
13183
13184 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13185
13186 data.devices_param = devices_param;
13187
13188 uint devices_cnt = 0;
13189
13190 uint devices_active = 0;
13191
13192 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13193 {
13194 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13195
13196 cl_platform_id platform = platforms[platform_id];
13197
13198 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13199
13200 char platform_vendor[INFOSZ] = { 0 };
13201
13202 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13203
13204 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13205 // this causes trouble with vendor id based macros
13206 // we'll assign generic to those without special optimization available
13207
13208 cl_uint vendor_id = 0;
13209
13210 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13211 {
13212 vendor_id = VENDOR_ID_AMD;
13213 }
13214 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13215 {
13216 vendor_id = VENDOR_ID_APPLE;
13217 }
13218 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13219 {
13220 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13221 }
13222 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13223 {
13224 vendor_id = VENDOR_ID_INTEL_SDK;
13225 }
13226 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13227 {
13228 vendor_id = VENDOR_ID_MESA;
13229 }
13230 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13231 {
13232 vendor_id = VENDOR_ID_NV;
13233 }
13234 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13235 {
13236 vendor_id = VENDOR_ID_POCL;
13237 }
13238 else
13239 {
13240 vendor_id = VENDOR_ID_GENERIC;
13241 }
13242
13243 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13244 {
13245 size_t param_value_size = 0;
13246
13247 const uint device_id = devices_cnt;
13248
13249 hc_device_param_t *device_param = &data.devices_param[device_id];
13250
13251 device_param->vendor_id = vendor_id;
13252
13253 device_param->device = platform_devices[platform_devices_id];
13254
13255 device_param->device_id = device_id;
13256
13257 device_param->platform_devices_id = platform_devices_id;
13258
13259 // device_type
13260
13261 cl_device_type device_type;
13262
13263 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13264
13265 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13266
13267 device_param->device_type = device_type;
13268
13269 // device_name
13270
13271 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13272
13273 char *device_name = (char *) mymalloc (param_value_size);
13274
13275 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13276
13277 device_param->device_name = device_name;
13278
13279 // tuning db
13280
13281 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13282
13283 // device_version
13284
13285 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13286
13287 char *device_version = (char *) mymalloc (param_value_size);
13288
13289 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13290
13291 device_param->device_version = device_version;
13292
13293 // device_opencl_version
13294
13295 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13296
13297 char *device_opencl_version = (char *) mymalloc (param_value_size);
13298
13299 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13300
13301 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13302
13303 myfree (device_opencl_version);
13304
13305 // vector_width
13306
13307 cl_uint vector_width;
13308
13309 if (opencl_vector_width_chgd == 0)
13310 {
13311 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13312 {
13313 if (opti_type & OPTI_TYPE_USES_BITS_64)
13314 {
13315 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13316 }
13317 else
13318 {
13319 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13320 }
13321 }
13322 else
13323 {
13324 vector_width = (cl_uint) tuningdb_entry->vector_width;
13325 }
13326 }
13327 else
13328 {
13329 vector_width = opencl_vector_width;
13330 }
13331
13332 if (vector_width > 16) vector_width = 16;
13333
13334 device_param->vector_width = vector_width;
13335
13336 // max_compute_units
13337
13338 cl_uint device_processors;
13339
13340 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13341
13342 device_param->device_processors = device_processors;
13343
13344 // device_maxmem_alloc
13345 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13346
13347 cl_ulong device_maxmem_alloc;
13348
13349 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13350
13351 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13352
13353 // device_global_mem
13354
13355 cl_ulong device_global_mem;
13356
13357 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13358
13359 device_param->device_global_mem = device_global_mem;
13360
13361 // max_work_group_size
13362
13363 size_t device_maxworkgroup_size;
13364
13365 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13366
13367 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13368
13369 // max_clock_frequency
13370
13371 cl_uint device_maxclock_frequency;
13372
13373 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13374
13375 device_param->device_maxclock_frequency = device_maxclock_frequency;
13376
13377 // device_endian_little
13378
13379 cl_bool device_endian_little;
13380
13381 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13382
13383 if (device_endian_little == CL_FALSE)
13384 {
13385 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13386
13387 device_param->skipped = 1;
13388 }
13389
13390 // device_available
13391
13392 cl_bool device_available;
13393
13394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13395
13396 if (device_available == CL_FALSE)
13397 {
13398 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13399
13400 device_param->skipped = 1;
13401 }
13402
13403 // device_compiler_available
13404
13405 cl_bool device_compiler_available;
13406
13407 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13408
13409 if (device_compiler_available == CL_FALSE)
13410 {
13411 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13412
13413 device_param->skipped = 1;
13414 }
13415
13416 // device_execution_capabilities
13417
13418 cl_device_exec_capabilities device_execution_capabilities;
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13421
13422 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13423 {
13424 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13425
13426 device_param->skipped = 1;
13427 }
13428
13429 // device_extensions
13430
13431 size_t device_extensions_size;
13432
13433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13434
13435 char *device_extensions = mymalloc (device_extensions_size + 1);
13436
13437 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13438
13439 if (strstr (device_extensions, "base_atomics") == 0)
13440 {
13441 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13442
13443 device_param->skipped = 1;
13444 }
13445
13446 if (strstr (device_extensions, "byte_addressable_store") == 0)
13447 {
13448 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13449
13450 device_param->skipped = 1;
13451 }
13452
13453 myfree (device_extensions);
13454
13455 // device_local_mem_size
13456
13457 cl_ulong device_local_mem_size;
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13460
13461 if (device_local_mem_size < 32768)
13462 {
13463 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13464
13465 device_param->skipped = 1;
13466 }
13467
13468
13469 // skipped
13470
13471 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13472 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13473
13474 // driver_version
13475
13476 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13477
13478 char *driver_version = (char *) mymalloc (param_value_size);
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13481
13482 device_param->driver_version = driver_version;
13483
13484 // device_name_chksum
13485
13486 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13487
13488 #if __x86_64__
13489 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13490 #else
13491 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13492 #endif
13493
13494 uint device_name_digest[4] = { 0 };
13495
13496 md5_64 ((uint *) device_name_chksum, device_name_digest);
13497
13498 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13499
13500 device_param->device_name_chksum = device_name_chksum;
13501
13502 // device_processor_cores
13503
13504 if (device_type & CL_DEVICE_TYPE_CPU)
13505 {
13506 cl_uint device_processor_cores = 1;
13507
13508 device_param->device_processor_cores = device_processor_cores;
13509 }
13510
13511 if (device_type & CL_DEVICE_TYPE_GPU)
13512 {
13513 if (vendor_id == VENDOR_ID_AMD)
13514 {
13515 cl_uint device_processor_cores = 0;
13516
13517 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13518
13519 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13520
13521 device_param->device_processor_cores = device_processor_cores;
13522 }
13523 else if (vendor_id == VENDOR_ID_NV)
13524 {
13525 cl_uint kernel_exec_timeout = 0;
13526
13527 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13528
13529 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13530
13531 device_param->kernel_exec_timeout = kernel_exec_timeout;
13532
13533 cl_uint device_processor_cores = 0;
13534
13535 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13536
13537 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13538
13539 device_param->device_processor_cores = device_processor_cores;
13540
13541 cl_uint sm_minor = 0;
13542 cl_uint sm_major = 0;
13543
13544 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13545 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13546
13547 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13548 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13549
13550 device_param->sm_minor = sm_minor;
13551 device_param->sm_major = sm_major;
13552 }
13553 else
13554 {
13555 cl_uint device_processor_cores = 1;
13556
13557 device_param->device_processor_cores = device_processor_cores;
13558 }
13559 }
13560
13561 // display results
13562
13563 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13564 {
13565 if (status_automat == 0)
13566 {
13567 if (device_param->skipped == 0)
13568 {
13569 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13570 device_id + 1,
13571 device_name,
13572 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13573 (unsigned int) (device_global_mem / 1024 / 1024),
13574 (unsigned int) (device_maxclock_frequency),
13575 (unsigned int) device_processors);
13576 }
13577 else
13578 {
13579 log_info ("Device #%u: %s, skipped",
13580 device_id + 1,
13581 device_name);
13582 }
13583 }
13584 }
13585
13586 // common driver check
13587
13588 if (device_param->skipped == 0)
13589 {
13590 if (device_type & CL_DEVICE_TYPE_GPU)
13591 {
13592 if (vendor_id == VENDOR_ID_AMD)
13593 {
13594 int catalyst_check = (force == 1) ? 0 : 1;
13595
13596 int catalyst_warn = 0;
13597
13598 int catalyst_broken = 0;
13599
13600 if (catalyst_check == 1)
13601 {
13602 catalyst_warn = 1;
13603
13604 // v14.9 and higher
13605 if (atoi (device_param->driver_version) >= 1573)
13606 {
13607 catalyst_warn = 0;
13608 }
13609
13610 catalyst_check = 0;
13611 }
13612
13613 if (catalyst_broken == 1)
13614 {
13615 log_info ("");
13616 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13617 log_info ("It will pass over cracked hashes and does not report them as cracked");
13618 log_info ("You are STRONGLY encouraged not to use it");
13619 log_info ("You can use --force to override this but do not post error reports if you do so");
13620 log_info ("");
13621
13622 return (-1);
13623 }
13624
13625 if (catalyst_warn == 1)
13626 {
13627 log_info ("");
13628 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13629 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13630 log_info ("See hashcat's homepage for official supported catalyst drivers");
13631 #ifdef _WIN
13632 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13633 #endif
13634 log_info ("You can use --force to override this but do not post error reports if you do so");
13635 log_info ("");
13636
13637 return (-1);
13638 }
13639 }
13640 else if (vendor_id == VENDOR_ID_NV)
13641 {
13642 if (device_param->kernel_exec_timeout != 0)
13643 {
13644 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);
13645 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13646 }
13647 }
13648 }
13649
13650 if (device_type & CL_DEVICE_TYPE_CPU)
13651 {
13652 if (vendor_id == VENDOR_ID_AMD)
13653 {
13654 if (force == 0)
13655 {
13656 log_info ("");
13657 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13658 log_info ("You are STRONGLY encouraged not to use it");
13659 log_info ("You can use --force to override this but do not post error reports if you do so");
13660 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13661 log_info ("");
13662
13663 return (-1);
13664 }
13665 }
13666 }
13667
13668 /**
13669 * kernel accel and loops tuning db adjustment
13670 */
13671
13672 device_param->kernel_accel_min = 1;
13673 device_param->kernel_accel_max = 1024;
13674
13675 device_param->kernel_loops_min = 1;
13676 device_param->kernel_loops_max = 1024;
13677
13678 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13679
13680 if (tuningdb_entry)
13681 {
13682 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13683 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13684
13685 if (_kernel_accel)
13686 {
13687 device_param->kernel_accel_min = _kernel_accel;
13688 device_param->kernel_accel_max = _kernel_accel;
13689 }
13690
13691 if (_kernel_loops)
13692 {
13693 if (workload_profile == 1)
13694 {
13695 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13696 }
13697 else if (workload_profile == 2)
13698 {
13699 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13700 }
13701
13702 device_param->kernel_loops_min = _kernel_loops;
13703 device_param->kernel_loops_max = _kernel_loops;
13704 }
13705 }
13706
13707 // commandline parameters overwrite tuningdb entries
13708
13709 if (kernel_accel)
13710 {
13711 device_param->kernel_accel_min = kernel_accel;
13712 device_param->kernel_accel_max = kernel_accel;
13713 }
13714
13715 if (kernel_loops)
13716 {
13717 device_param->kernel_loops_min = kernel_loops;
13718 device_param->kernel_loops_max = kernel_loops;
13719 }
13720
13721 /**
13722 * activate device
13723 */
13724
13725 devices_active++;
13726 }
13727
13728 // next please
13729
13730 devices_cnt++;
13731 }
13732 }
13733
13734 if (keyspace == 0 && devices_active == 0)
13735 {
13736 log_error ("ERROR: No devices found/left");
13737
13738 return (-1);
13739 }
13740
13741 // 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)
13742
13743 if (devices_filter != (uint) -1)
13744 {
13745 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13746
13747 if (devices_filter > devices_cnt_mask)
13748 {
13749 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13750
13751 return (-1);
13752 }
13753 }
13754
13755 data.devices_cnt = devices_cnt;
13756
13757 data.devices_active = devices_active;
13758
13759 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13760 {
13761 if (status_automat == 0)
13762 {
13763 log_info ("");
13764 }
13765 }
13766
13767 /**
13768 * HM devices: init
13769 */
13770
13771 #ifdef HAVE_HWMON
13772 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13773 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13774 #endif
13775
13776 #ifdef HAVE_ADL
13777 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13778 #endif
13779
13780 if (gpu_temp_disable == 0)
13781 {
13782 #if defined(WIN) && defined(HAVE_NVAPI)
13783 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13784
13785 if (nvapi_init (nvapi) == 0)
13786 data.hm_nv = nvapi;
13787
13788 if (data.hm_nv)
13789 {
13790 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13791 {
13792 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13793
13794 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13795
13796 int tmp_out = 0;
13797
13798 for (int i = 0; i < tmp_in; i++)
13799 {
13800 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13801 }
13802
13803 for (int i = 0; i < tmp_out; i++)
13804 {
13805 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13806
13807 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13808
13809 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;
13810 }
13811 }
13812 }
13813 #endif // WIN && HAVE_NVAPI
13814
13815 #if defined(LINUX) && defined(HAVE_NVML)
13816 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13817
13818 if (nvml_init (nvml) == 0)
13819 data.hm_nv = nvml;
13820
13821 if (data.hm_nv)
13822 {
13823 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13824 {
13825 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13826
13827 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13828
13829 int tmp_out = 0;
13830
13831 for (int i = 0; i < tmp_in; i++)
13832 {
13833 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13834 }
13835
13836 for (int i = 0; i < tmp_out; i++)
13837 {
13838 unsigned int speed;
13839
13840 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;
13841 }
13842 }
13843 }
13844 #endif // LINUX && HAVE_NVML
13845
13846 data.hm_amd = NULL;
13847
13848 #ifdef HAVE_ADL
13849 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13850
13851 if (adl_init (adl) == 0)
13852 data.hm_amd = adl;
13853
13854 if (data.hm_amd)
13855 {
13856 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13857 {
13858 // total number of adapters
13859
13860 int hm_adapters_num;
13861
13862 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13863
13864 // adapter info
13865
13866 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13867
13868 if (lpAdapterInfo == NULL) return (-1);
13869
13870 // get a list (of ids of) valid/usable adapters
13871
13872 int num_adl_adapters = 0;
13873
13874 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13875
13876 if (num_adl_adapters > 0)
13877 {
13878 hc_thread_mutex_lock (mux_adl);
13879
13880 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13881
13882 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13883
13884 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13885 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13886
13887 hc_thread_mutex_unlock (mux_adl);
13888 }
13889
13890 myfree (valid_adl_device_list);
13891 myfree (lpAdapterInfo);
13892 }
13893 }
13894 #endif // HAVE_ADL
13895
13896 if (data.hm_amd == NULL && data.hm_nv == NULL)
13897 {
13898 gpu_temp_disable = 1;
13899 }
13900 }
13901
13902 /**
13903 * OpenCL devices: allocate buffer for device specific information
13904 */
13905
13906 #ifdef HAVE_HWMON
13907 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13908
13909 #ifdef HAVE_ADL
13910 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13911
13912 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13913 #endif // ADL
13914 #endif
13915
13916 /**
13917 * enable custom signal handler(s)
13918 */
13919
13920 if (benchmark == 0)
13921 {
13922 hc_signal (sigHandler_default);
13923 }
13924 else
13925 {
13926 hc_signal (sigHandler_benchmark);
13927 }
13928
13929 /**
13930 * User-defined GPU temp handling
13931 */
13932
13933 #ifdef HAVE_HWMON
13934 if (gpu_temp_disable == 1)
13935 {
13936 gpu_temp_abort = 0;
13937 gpu_temp_retain = 0;
13938 }
13939
13940 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13941 {
13942 if (gpu_temp_abort < gpu_temp_retain)
13943 {
13944 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13945
13946 return (-1);
13947 }
13948 }
13949
13950 data.gpu_temp_disable = gpu_temp_disable;
13951 data.gpu_temp_abort = gpu_temp_abort;
13952 data.gpu_temp_retain = gpu_temp_retain;
13953 #endif
13954
13955 /**
13956 * inform the user
13957 */
13958
13959 if (data.quiet == 0)
13960 {
13961 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13962
13963 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);
13964
13965 if (attack_mode == ATTACK_MODE_STRAIGHT)
13966 {
13967 log_info ("Rules: %u", kernel_rules_cnt);
13968 }
13969
13970 if (opti_type)
13971 {
13972 log_info ("Applicable Optimizers:");
13973
13974 for (uint i = 0; i < 32; i++)
13975 {
13976 const uint opti_bit = 1u << i;
13977
13978 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13979 }
13980 }
13981
13982 /**
13983 * Watchdog and Temperature balance
13984 */
13985
13986 #ifdef HAVE_HWMON
13987 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13988 {
13989 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13990 }
13991
13992 if (gpu_temp_abort == 0)
13993 {
13994 log_info ("Watchdog: Temperature abort trigger disabled");
13995 }
13996 else
13997 {
13998 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13999 }
14000
14001 if (gpu_temp_retain == 0)
14002 {
14003 log_info ("Watchdog: Temperature retain trigger disabled");
14004 }
14005 else
14006 {
14007 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14008 }
14009
14010 if (data.quiet == 0) log_info ("");
14011 #endif
14012 }
14013
14014 /**
14015 * HM devices: copy
14016 */
14017
14018 if (gpu_temp_disable == 0)
14019 {
14020 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14021 {
14022 hc_device_param_t *device_param = &data.devices_param[device_id];
14023
14024 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14025
14026 if (device_param->skipped) continue;
14027
14028 const uint platform_devices_id = device_param->platform_devices_id;
14029
14030 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14031 if (device_param->vendor_id == VENDOR_ID_NV)
14032 {
14033 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14034 }
14035 #endif
14036
14037 #ifdef HAVE_ADL
14038 if (device_param->vendor_id == VENDOR_ID_AMD)
14039 {
14040 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14041 }
14042 #endif
14043 }
14044 }
14045
14046 /*
14047 * Temporary fix:
14048 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14049 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14050 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14051 * Driver / ADL bug?
14052 */
14053
14054 #ifdef HAVE_ADL
14055 if (powertune_enable == 1)
14056 {
14057 hc_thread_mutex_lock (mux_adl);
14058
14059 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14060 {
14061 hc_device_param_t *device_param = &data.devices_param[device_id];
14062
14063 if (device_param->skipped) continue;
14064
14065 if (data.hm_device[device_id].od_version == 6)
14066 {
14067 // set powertune value only
14068
14069 int powertune_supported = 0;
14070
14071 int ADL_rc = 0;
14072
14073 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14074 {
14075 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14076
14077 return (-1);
14078 }
14079
14080 if (powertune_supported != 0)
14081 {
14082 // powertune set
14083 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14084
14085 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14086 {
14087 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14088
14089 return (-1);
14090 }
14091
14092 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14093 {
14094 log_error ("ERROR: Failed to set new ADL PowerControl values");
14095
14096 return (-1);
14097 }
14098 }
14099 }
14100 }
14101
14102 hc_thread_mutex_unlock (mux_adl);
14103 }
14104 #endif // HAVE_ADK
14105 #endif // HAVE_HWMON
14106
14107 #ifdef DEBUG
14108 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14109 #endif
14110
14111 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14112
14113 uint kernel_power_all = 0;
14114
14115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14116 {
14117 /**
14118 * host buffer
14119 */
14120
14121 hc_device_param_t *device_param = &data.devices_param[device_id];
14122
14123 if (device_param->skipped) continue;
14124
14125 /**
14126 * device properties
14127 */
14128
14129 const char *device_name_chksum = device_param->device_name_chksum;
14130 const u32 device_processors = device_param->device_processors;
14131 const u32 device_processor_cores = device_param->device_processor_cores;
14132
14133 /**
14134 * create context for each device
14135 */
14136
14137 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14138
14139 /**
14140 * create command-queue
14141 */
14142
14143 // not supported with NV
14144 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14145
14146 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14147
14148 /**
14149 * kernel threads: some algorithms need a fixed kernel-threads count
14150 * because of shared memory usage or bitslice
14151 * there needs to be some upper limit, otherwise there's too much overhead
14152 */
14153
14154 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14155
14156 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14157 {
14158 kernel_threads = KERNEL_THREADS_MAX_CPU;
14159 }
14160
14161 if (hash_mode == 1500) kernel_threads = 64; // DES
14162 if (hash_mode == 3000) kernel_threads = 64; // DES
14163 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14164 if (hash_mode == 7500) kernel_threads = 64; // RC4
14165 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14166 if (hash_mode == 9700) kernel_threads = 64; // RC4
14167 if (hash_mode == 9710) kernel_threads = 64; // RC4
14168 if (hash_mode == 9800) kernel_threads = 64; // RC4
14169 if (hash_mode == 9810) kernel_threads = 64; // RC4
14170 if (hash_mode == 10400) kernel_threads = 64; // RC4
14171 if (hash_mode == 10410) kernel_threads = 64; // RC4
14172 if (hash_mode == 10500) kernel_threads = 64; // RC4
14173 if (hash_mode == 13100) kernel_threads = 64; // RC4
14174
14175 /**
14176 * create input buffers on device : calculate size of fixed memory buffers
14177 */
14178
14179 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14180 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14181
14182 device_param->size_root_css = size_root_css;
14183 device_param->size_markov_css = size_markov_css;
14184
14185 size_t size_results = sizeof (uint);
14186
14187 device_param->size_results = size_results;
14188
14189 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14190 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14191
14192 size_t size_plains = digests_cnt * sizeof (plain_t);
14193 size_t size_salts = salts_cnt * sizeof (salt_t);
14194 size_t size_esalts = salts_cnt * esalt_size;
14195
14196 device_param->size_plains = size_plains;
14197 device_param->size_digests = size_digests;
14198 device_param->size_shown = size_shown;
14199 device_param->size_salts = size_salts;
14200
14201 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14202 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14203 size_t size_tm = 32 * sizeof (bs_word_t);
14204
14205 // scryptV stuff
14206
14207 size_t size_scryptV = 1;
14208
14209 if ((hash_mode == 8900) || (hash_mode == 9300))
14210 {
14211 uint tmto_start = 0;
14212 uint tmto_stop = 10;
14213
14214 if (scrypt_tmto)
14215 {
14216 tmto_start = scrypt_tmto;
14217 }
14218 else
14219 {
14220 // in case the user did not specify the tmto manually
14221 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14222 // but set the lower end only in case the user has a device with too less memory
14223
14224 if (hash_mode == 8900)
14225 {
14226 if (device_param->vendor_id == VENDOR_ID_AMD)
14227 {
14228 tmto_start = 1;
14229 }
14230 else if (device_param->vendor_id == VENDOR_ID_NV)
14231 {
14232 tmto_start = 2;
14233 }
14234 }
14235 else if (hash_mode == 9300)
14236 {
14237 if (device_param->vendor_id == VENDOR_ID_AMD)
14238 {
14239 tmto_start = 2;
14240 }
14241 else if (device_param->vendor_id == VENDOR_ID_NV)
14242 {
14243 tmto_start = 2;
14244 }
14245 }
14246 }
14247
14248 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14249 {
14250 // TODO: in theory the following calculation needs to be done per salt, not global
14251 // we assume all hashes have the same scrypt settings
14252
14253 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14254
14255 size_scryptV /= 1 << tmto;
14256
14257 size_scryptV *= device_processors * device_processor_cores;
14258
14259 if (size_scryptV > device_param->device_maxmem_alloc)
14260 {
14261 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14262
14263 continue;
14264 }
14265
14266 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14267 {
14268 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14269 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14270 }
14271
14272 break;
14273 }
14274
14275 if (data.salts_buf[0].scrypt_phy == 0)
14276 {
14277 log_error ("ERROR: can't allocate enough device memory");
14278
14279 return -1;
14280 }
14281
14282 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14283 }
14284
14285 /**
14286 * some algorithms need a fixed kernel-loops count
14287 */
14288
14289 if (hash_mode == 1500)
14290 {
14291 const u32 kernel_loops_fixed = 1024;
14292
14293 device_param->kernel_loops_min = kernel_loops_fixed;
14294 device_param->kernel_loops_max = kernel_loops_fixed;
14295 }
14296
14297 if (hash_mode == 3000)
14298 {
14299 const u32 kernel_loops_fixed = 1024;
14300
14301 device_param->kernel_loops_min = kernel_loops_fixed;
14302 device_param->kernel_loops_max = kernel_loops_fixed;
14303 }
14304
14305 if (hash_mode == 8900)
14306 {
14307 const u32 kernel_loops_fixed = 1;
14308
14309 device_param->kernel_loops_min = kernel_loops_fixed;
14310 device_param->kernel_loops_max = kernel_loops_fixed;
14311 }
14312
14313 if (hash_mode == 9300)
14314 {
14315 const u32 kernel_loops_fixed = 1;
14316
14317 device_param->kernel_loops_min = kernel_loops_fixed;
14318 device_param->kernel_loops_max = kernel_loops_fixed;
14319 }
14320
14321 if (hash_mode == 12500)
14322 {
14323 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14324
14325 device_param->kernel_loops_min = kernel_loops_fixed;
14326 device_param->kernel_loops_max = kernel_loops_fixed;
14327 }
14328
14329 /**
14330 * some algorithms have a maximum kernel-loops count
14331 */
14332
14333 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14334 {
14335 u32 innerloop_cnt = 0;
14336
14337 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14338 {
14339 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14340 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14341 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14342 }
14343 else
14344 {
14345 innerloop_cnt = data.salts_buf[0].salt_iter;
14346 }
14347
14348 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14349 (innerloop_cnt <= device_param->kernel_loops_max))
14350 {
14351 device_param->kernel_loops_max = innerloop_cnt;
14352 }
14353 }
14354
14355 u32 kernel_accel_min = device_param->kernel_accel_min;
14356 u32 kernel_accel_max = device_param->kernel_accel_max;
14357
14358 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14359
14360 size_t size_pws = 4;
14361 size_t size_tmps = 4;
14362 size_t size_hooks = 4;
14363
14364 while (kernel_accel_max >= kernel_accel_min)
14365 {
14366 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14367
14368 // size_pws
14369
14370 size_pws = kernel_power_max * sizeof (pw_t);
14371
14372 // size_tmps
14373
14374 switch (hash_mode)
14375 {
14376 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14377 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14378 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14379 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14380 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14381 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14382 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14383 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14384 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14385 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14386 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14387 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14388 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14389 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14390 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14391 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14392 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14393 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14394 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14395 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14396 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14397 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14398 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14399 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14400 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14401 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14402 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14403 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14404 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14405 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14406 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14407 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14408 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14409 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14410 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14411 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14412 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14413 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14414 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14415 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14416 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14417 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14418 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14419 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14420 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14421 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14422 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14423 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14424 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14425 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14426 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14427 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14428 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14429 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14430 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14431 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14432 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14433 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14434 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14435 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14436 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14437 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14438 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14439 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14440 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14441 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14442 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14443 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14444 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14445 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14446 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14447 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14448 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14452 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14453 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14454 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14455 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14456 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14457 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14458 };
14459
14460 // size_hooks
14461
14462 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14463 {
14464 // none yet
14465 }
14466
14467 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14468 // if not, decrease amplifier and try again
14469
14470 int skip = 0;
14471
14472 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14473 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14474 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14475
14476 if (( bitmap_size
14477 + bitmap_size
14478 + bitmap_size
14479 + bitmap_size
14480 + bitmap_size
14481 + bitmap_size
14482 + bitmap_size
14483 + bitmap_size
14484 + size_bfs
14485 + size_combs
14486 + size_digests
14487 + size_esalts
14488 + size_hooks
14489 + size_markov_css
14490 + size_plains
14491 + size_pws
14492 + size_pws // not a bug
14493 + size_results
14494 + size_root_css
14495 + size_rules
14496 + size_rules_c
14497 + size_salts
14498 + size_scryptV
14499 + size_shown
14500 + size_tm
14501 + size_tmps) > device_param->device_global_mem) skip = 1;
14502
14503 if (skip == 1)
14504 {
14505 kernel_accel_max--;
14506
14507 continue;
14508 }
14509
14510 break;
14511 }
14512
14513 /*
14514 if (kernel_accel_max == 0)
14515 {
14516 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14517
14518 return -1;
14519 }
14520 */
14521
14522 device_param->kernel_accel_min = kernel_accel_min;
14523 device_param->kernel_accel_max = kernel_accel_max;
14524
14525 /*
14526 if (kernel_accel_max < kernel_accel)
14527 {
14528 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14529
14530 device_param->kernel_accel = kernel_accel_max;
14531 }
14532 */
14533
14534 device_param->size_bfs = size_bfs;
14535 device_param->size_combs = size_combs;
14536 device_param->size_rules = size_rules;
14537 device_param->size_rules_c = size_rules_c;
14538 device_param->size_pws = size_pws;
14539 device_param->size_tmps = size_tmps;
14540 device_param->size_hooks = size_hooks;
14541
14542 // do not confuse kernel_accel_max with kernel_accel here
14543
14544 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14545
14546 device_param->kernel_threads = kernel_threads;
14547 device_param->kernel_power_user = kernel_power;
14548
14549 kernel_power_all += kernel_power;
14550
14551 /**
14552 * default building options
14553 */
14554
14555 char build_opts[1024] = { 0 };
14556
14557 // we don't have sm_* on vendors not NV but it doesn't matter
14558
14559 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/OpenCL\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14560
14561 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14562 {
14563 // we do vectorizing much better than the auto-vectorizer
14564
14565 char build_opts_new[1024] = { 0 };
14566
14567 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14568
14569 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14570 }
14571
14572 #ifdef DEBUG
14573 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14574 #endif
14575
14576 /**
14577 * main kernel
14578 */
14579
14580 {
14581 /**
14582 * kernel source filename
14583 */
14584
14585 char source_file[256] = { 0 };
14586
14587 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14588
14589 struct stat sst;
14590
14591 if (stat (source_file, &sst) == -1)
14592 {
14593 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14594
14595 return -1;
14596 }
14597
14598 /**
14599 * kernel cached filename
14600 */
14601
14602 char cached_file[256] = { 0 };
14603
14604 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14605
14606 int cached = 1;
14607
14608 struct stat cst;
14609
14610 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14611 {
14612 cached = 0;
14613 }
14614
14615 /**
14616 * kernel compile or load
14617 */
14618
14619 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14620
14621 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14622
14623 if (force_jit_compilation == -1)
14624 {
14625 if (cached == 0)
14626 {
14627 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14628
14629 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14630
14631 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14632
14633 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14634
14635 #ifdef DEBUG
14636 size_t build_log_size = 0;
14637
14638 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14639
14640 if (build_log_size > 1)
14641 {
14642 char *build_log = (char *) malloc (build_log_size + 1);
14643
14644 memset (build_log, 0, build_log_size + 1);
14645
14646 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14647
14648 puts (build_log);
14649
14650 free (build_log);
14651 }
14652 #endif
14653
14654 if (rc != 0)
14655 {
14656 device_param->skipped = true;
14657
14658 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14659
14660 continue;
14661 }
14662
14663 size_t binary_size;
14664
14665 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14666
14667 u8 *binary = (u8 *) mymalloc (binary_size);
14668
14669 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14670
14671 writeProgramBin (cached_file, binary, binary_size);
14672
14673 local_free (binary);
14674 }
14675 else
14676 {
14677 #ifdef DEBUG
14678 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14679 #endif
14680
14681 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14682
14683 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14684
14685 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14686 }
14687 }
14688 else
14689 {
14690 #ifdef DEBUG
14691 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14692 #endif
14693
14694 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14695
14696 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14697
14698 char build_opts_update[1024] = { 0 };
14699
14700 if (force_jit_compilation == 1500)
14701 {
14702 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14703 }
14704 else if (force_jit_compilation == 8900)
14705 {
14706 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);
14707 }
14708 else
14709 {
14710 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14711 }
14712
14713 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14714
14715 #ifdef DEBUG
14716 size_t build_log_size = 0;
14717
14718 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14719
14720 if (build_log_size > 1)
14721 {
14722 char *build_log = (char *) malloc (build_log_size + 1);
14723
14724 memset (build_log, 0, build_log_size + 1);
14725
14726 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14727
14728 puts (build_log);
14729
14730 free (build_log);
14731 }
14732 #endif
14733
14734 if (rc != 0)
14735 {
14736 device_param->skipped = true;
14737
14738 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14739 }
14740 }
14741
14742 local_free (kernel_lengths);
14743 local_free (kernel_sources[0]);
14744 local_free (kernel_sources);
14745 }
14746
14747 /**
14748 * word generator kernel
14749 */
14750
14751 if (attack_mode != ATTACK_MODE_STRAIGHT)
14752 {
14753 /**
14754 * kernel mp source filename
14755 */
14756
14757 char source_file[256] = { 0 };
14758
14759 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14760
14761 struct stat sst;
14762
14763 if (stat (source_file, &sst) == -1)
14764 {
14765 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14766
14767 return -1;
14768 }
14769
14770 /**
14771 * kernel mp cached filename
14772 */
14773
14774 char cached_file[256] = { 0 };
14775
14776 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14777
14778 int cached = 1;
14779
14780 struct stat cst;
14781
14782 if (stat (cached_file, &cst) == -1)
14783 {
14784 cached = 0;
14785 }
14786
14787 /**
14788 * kernel compile or load
14789 */
14790
14791 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14792
14793 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14794
14795 if (cached == 0)
14796 {
14797 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14798 if (quiet == 0) log_info ("");
14799
14800 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14801
14802 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14803
14804 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14805
14806 if (rc != 0)
14807 {
14808 device_param->skipped = true;
14809
14810 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14811
14812 continue;
14813 }
14814
14815 size_t binary_size;
14816
14817 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14818
14819 u8 *binary = (u8 *) mymalloc (binary_size);
14820
14821 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14822
14823 writeProgramBin (cached_file, binary, binary_size);
14824
14825 local_free (binary);
14826 }
14827 else
14828 {
14829 #ifdef DEBUG
14830 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14831 #endif
14832
14833 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14834
14835 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14836
14837 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14838 }
14839
14840 local_free (kernel_lengths);
14841 local_free (kernel_sources[0]);
14842 local_free (kernel_sources);
14843 }
14844
14845 /**
14846 * amplifier kernel
14847 */
14848
14849 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14850 {
14851
14852 }
14853 else
14854 {
14855 /**
14856 * kernel amp source filename
14857 */
14858
14859 char source_file[256] = { 0 };
14860
14861 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14862
14863 struct stat sst;
14864
14865 if (stat (source_file, &sst) == -1)
14866 {
14867 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14868
14869 return -1;
14870 }
14871
14872 /**
14873 * kernel amp cached filename
14874 */
14875
14876 char cached_file[256] = { 0 };
14877
14878 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14879
14880 int cached = 1;
14881
14882 struct stat cst;
14883
14884 if (stat (cached_file, &cst) == -1)
14885 {
14886 cached = 0;
14887 }
14888
14889 /**
14890 * kernel compile or load
14891 */
14892
14893 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14894
14895 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14896
14897 if (cached == 0)
14898 {
14899 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14900 if (quiet == 0) log_info ("");
14901
14902 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14903
14904 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14905
14906 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14907
14908 if (rc != 0)
14909 {
14910 device_param->skipped = true;
14911
14912 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14913
14914 continue;
14915 }
14916
14917 size_t binary_size;
14918
14919 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14920
14921 u8 *binary = (u8 *) mymalloc (binary_size);
14922
14923 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14924
14925 writeProgramBin (cached_file, binary, binary_size);
14926
14927 local_free (binary);
14928 }
14929 else
14930 {
14931 #ifdef DEBUG
14932 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14933 #endif
14934
14935 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14936
14937 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14938
14939 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14940 }
14941
14942 local_free (kernel_lengths);
14943 local_free (kernel_sources[0]);
14944 local_free (kernel_sources);
14945 }
14946
14947 // some algorithm collide too fast, make that impossible
14948
14949 if (benchmark == 1)
14950 {
14951 ((uint *) digests_buf)[0] = -1;
14952 ((uint *) digests_buf)[1] = -1;
14953 ((uint *) digests_buf)[2] = -1;
14954 ((uint *) digests_buf)[3] = -1;
14955 }
14956
14957 /**
14958 * global buffers
14959 */
14960
14961 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14962 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14963 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14964 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14965 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14966 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14967 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14968 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14969 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14970 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14971 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14972 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14973 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14974 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14975 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14976 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14977 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14978 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14979
14980 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);
14981 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);
14982 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);
14983 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);
14984 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);
14985 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);
14986 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);
14987 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);
14988 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14989 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14990 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14991
14992 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14993 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14994 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14995 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14996 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14997 run_kernel_bzero (device_param, device_param->d_result, size_results);
14998
14999 /**
15000 * special buffers
15001 */
15002
15003 if (attack_kern == ATTACK_KERN_STRAIGHT)
15004 {
15005 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15006 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15007
15008 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15009
15010 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15011 }
15012 else if (attack_kern == ATTACK_KERN_COMBI)
15013 {
15014 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15015 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15016 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15017 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15018
15019 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15020 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15021 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15022 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15023 }
15024 else if (attack_kern == ATTACK_KERN_BF)
15025 {
15026 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15027 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15028 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15029 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15030 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15031
15032 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15033 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15034 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15035 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15036 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15037 }
15038
15039 if (size_esalts)
15040 {
15041 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15042
15043 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15044 }
15045
15046 /**
15047 * main host data
15048 */
15049
15050 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15051
15052 device_param->pws_buf = pws_buf;
15053
15054 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15055
15056 device_param->combs_buf = combs_buf;
15057
15058 void *hooks_buf = mymalloc (size_hooks);
15059
15060 device_param->hooks_buf = hooks_buf;
15061
15062 /**
15063 * kernel args
15064 */
15065
15066 device_param->kernel_params_buf32[21] = bitmap_mask;
15067 device_param->kernel_params_buf32[22] = bitmap_shift1;
15068 device_param->kernel_params_buf32[23] = bitmap_shift2;
15069 device_param->kernel_params_buf32[24] = 0; // salt_pos
15070 device_param->kernel_params_buf32[25] = 0; // loop_pos
15071 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15072 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15073 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15074 device_param->kernel_params_buf32[29] = 0; // digests_offset
15075 device_param->kernel_params_buf32[30] = 0; // combs_mode
15076 device_param->kernel_params_buf32[31] = 0; // gid_max
15077
15078 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15079 ? &device_param->d_pws_buf
15080 : &device_param->d_pws_amp_buf;
15081 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15082 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15083 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15084 device_param->kernel_params[ 4] = &device_param->d_tmps;
15085 device_param->kernel_params[ 5] = &device_param->d_hooks;
15086 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15087 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15088 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15089 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15090 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15091 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15092 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15093 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15094 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15095 device_param->kernel_params[15] = &device_param->d_digests_buf;
15096 device_param->kernel_params[16] = &device_param->d_digests_shown;
15097 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15098 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15099 device_param->kernel_params[19] = &device_param->d_result;
15100 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15101 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15102 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15103 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15104 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15105 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15106 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15107 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15108 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15109 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15110 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15111 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15112
15113 device_param->kernel_params_mp_buf64[3] = 0;
15114 device_param->kernel_params_mp_buf32[4] = 0;
15115 device_param->kernel_params_mp_buf32[5] = 0;
15116 device_param->kernel_params_mp_buf32[6] = 0;
15117 device_param->kernel_params_mp_buf32[7] = 0;
15118 device_param->kernel_params_mp_buf32[8] = 0;
15119
15120 device_param->kernel_params_mp[0] = NULL;
15121 device_param->kernel_params_mp[1] = NULL;
15122 device_param->kernel_params_mp[2] = NULL;
15123 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15124 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15125 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15126 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15127 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15128 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15129
15130 device_param->kernel_params_mp_l_buf64[3] = 0;
15131 device_param->kernel_params_mp_l_buf32[4] = 0;
15132 device_param->kernel_params_mp_l_buf32[5] = 0;
15133 device_param->kernel_params_mp_l_buf32[6] = 0;
15134 device_param->kernel_params_mp_l_buf32[7] = 0;
15135 device_param->kernel_params_mp_l_buf32[8] = 0;
15136 device_param->kernel_params_mp_l_buf32[9] = 0;
15137
15138 device_param->kernel_params_mp_l[0] = NULL;
15139 device_param->kernel_params_mp_l[1] = NULL;
15140 device_param->kernel_params_mp_l[2] = NULL;
15141 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15142 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15143 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15144 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15145 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15146 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15147 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15148
15149 device_param->kernel_params_mp_r_buf64[3] = 0;
15150 device_param->kernel_params_mp_r_buf32[4] = 0;
15151 device_param->kernel_params_mp_r_buf32[5] = 0;
15152 device_param->kernel_params_mp_r_buf32[6] = 0;
15153 device_param->kernel_params_mp_r_buf32[7] = 0;
15154 device_param->kernel_params_mp_r_buf32[8] = 0;
15155
15156 device_param->kernel_params_mp_r[0] = NULL;
15157 device_param->kernel_params_mp_r[1] = NULL;
15158 device_param->kernel_params_mp_r[2] = NULL;
15159 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15160 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15161 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15162 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15163 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15164 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15165
15166 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15167 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15168
15169 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15170 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15171 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15172 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15173 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15174 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15175 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15176
15177 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15178 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15179
15180 /**
15181 * kernel name
15182 */
15183
15184 size_t kernel_wgs_tmp;
15185
15186 char kernel_name[64] = { 0 };
15187
15188 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15189 {
15190 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15191 {
15192 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15193
15194 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15195
15196 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15197
15198 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15199
15200 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15201
15202 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15203 }
15204 else
15205 {
15206 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15207
15208 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15209
15210 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15211
15212 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15213
15214 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15215
15216 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15217 }
15218
15219 if (data.attack_mode == ATTACK_MODE_BF)
15220 {
15221 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15222 {
15223 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15224
15225 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15226
15227 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);
15228 }
15229 }
15230 }
15231 else
15232 {
15233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15234
15235 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15236
15237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15238
15239 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15240
15241 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15242
15243 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15244
15245 if (opts_type & OPTS_TYPE_HOOK12)
15246 {
15247 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15248
15249 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15250
15251 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);
15252 }
15253
15254 if (opts_type & OPTS_TYPE_HOOK23)
15255 {
15256 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15257
15258 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15259
15260 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);
15261 }
15262 }
15263
15264 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);
15265 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);
15266 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);
15267
15268 for (uint i = 0; i <= 20; i++)
15269 {
15270 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15271 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15272 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15273
15274 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15275 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15276 }
15277
15278 for (uint i = 21; i <= 31; i++)
15279 {
15280 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15281 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15282 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15283
15284 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15285 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15286 }
15287
15288 if (attack_mode == ATTACK_MODE_BF)
15289 {
15290 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15291 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15292
15293 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);
15294 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);
15295
15296 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15297 {
15298 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15299 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15300 }
15301 }
15302 else if (attack_mode == ATTACK_MODE_HYBRID1)
15303 {
15304 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15305
15306 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);
15307 }
15308 else if (attack_mode == ATTACK_MODE_HYBRID2)
15309 {
15310 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15311
15312 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);
15313 }
15314
15315 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15316 {
15317 // nothing to do
15318 }
15319 else
15320 {
15321 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15322
15323 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);
15324 }
15325
15326 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15327 {
15328 // nothing to do
15329 }
15330 else
15331 {
15332 for (uint i = 0; i < 5; i++)
15333 {
15334 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15335 }
15336
15337 for (uint i = 5; i < 7; i++)
15338 {
15339 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15340 }
15341 }
15342
15343 // maybe this has been updated by clGetKernelWorkGroupInfo()
15344 // value can only be decreased, so we don't need to reallocate buffers
15345
15346 device_param->kernel_threads = kernel_threads;
15347
15348 /**
15349 * Store initial fanspeed if gpu_temp_retain is enabled
15350 */
15351
15352 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15353 int gpu_temp_retain_set = 0;
15354
15355 if (gpu_temp_disable == 0)
15356 {
15357 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15358 {
15359 hc_thread_mutex_lock (mux_adl);
15360
15361 if (data.hm_device[device_id].fan_supported == 1)
15362 {
15363 if (gpu_temp_retain_chgd == 0)
15364 {
15365 uint cur_temp = 0;
15366 uint default_temp = 0;
15367
15368 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);
15369
15370 if (ADL_rc == ADL_OK)
15371 {
15372 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15373
15374 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15375
15376 // special case with multi gpu setups: always use minimum retain
15377
15378 if (gpu_temp_retain_set == 0)
15379 {
15380 gpu_temp_retain = gpu_temp_retain_target;
15381 gpu_temp_retain_set = 1;
15382 }
15383 else
15384 {
15385 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15386 }
15387
15388 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15389 }
15390 }
15391
15392 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15393
15394 temp_retain_fanspeed_value[device_id] = fan_speed;
15395
15396 if (fan_speed == -1)
15397 {
15398 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15399
15400 temp_retain_fanspeed_value[device_id] = 0;
15401 }
15402 }
15403
15404 hc_thread_mutex_unlock (mux_adl);
15405 }
15406 }
15407
15408 /**
15409 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15410 */
15411
15412 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15413 {
15414 hc_thread_mutex_lock (mux_adl);
15415
15416 if (data.hm_device[device_id].od_version == 6)
15417 {
15418 int ADL_rc;
15419
15420 // check powertune capabilities first, if not available then skip device
15421
15422 int powertune_supported = 0;
15423
15424 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15425 {
15426 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15427
15428 return (-1);
15429 }
15430
15431 if (powertune_supported != 0)
15432 {
15433 // powercontrol settings
15434
15435 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15436
15437 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15438 {
15439 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15440 }
15441
15442 if (ADL_rc != ADL_OK)
15443 {
15444 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15445
15446 return (-1);
15447 }
15448
15449 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15450 {
15451 log_error ("ERROR: Failed to set new ADL PowerControl values");
15452
15453 return (-1);
15454 }
15455
15456 // clocks
15457
15458 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15459
15460 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15461
15462 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)
15463 {
15464 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15465
15466 return (-1);
15467 }
15468
15469 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15470
15471 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15472
15473 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15474 {
15475 log_error ("ERROR: Failed to get ADL device capabilities");
15476
15477 return (-1);
15478 }
15479
15480 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15481 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15482
15483 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15484 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15485
15486 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15487 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15488
15489 // warning if profile has too low max values
15490
15491 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15492 {
15493 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15494 }
15495
15496 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15497 {
15498 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15499 }
15500
15501 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15502
15503 performance_state->iNumberOfPerformanceLevels = 2;
15504
15505 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15506 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15507 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15508 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15509
15510 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)
15511 {
15512 log_info ("ERROR: Failed to set ADL performance state");
15513
15514 return (-1);
15515 }
15516
15517 local_free (performance_state);
15518 }
15519 }
15520
15521 hc_thread_mutex_unlock (mux_adl);
15522 }
15523 #endif // HAVE_HWMON && HAVE_ADL
15524 }
15525
15526 data.kernel_power_all = kernel_power_all;
15527
15528 if (data.quiet == 0) log_info_nn ("");
15529
15530 /**
15531 * In benchmark-mode, inform user which algorithm is checked
15532 */
15533
15534 if (benchmark == 1)
15535 {
15536 if (status_automat == 0)
15537 {
15538 quiet = 0;
15539
15540 data.quiet = quiet;
15541
15542 char *hash_type = strhashtype (data.hash_mode); // not a bug
15543
15544 log_info ("Hashtype: %s", hash_type);
15545 log_info ("");
15546 }
15547 }
15548
15549 /**
15550 * keep track of the progress
15551 */
15552
15553 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15554 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15555 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15556
15557 /**
15558 * open filehandles
15559 */
15560
15561 #if _WIN
15562 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15563 {
15564 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15565
15566 return (-1);
15567 }
15568
15569 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15570 {
15571 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15572
15573 return (-1);
15574 }
15575
15576 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15577 {
15578 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15579
15580 return (-1);
15581 }
15582 #endif
15583
15584 /**
15585 * dictionary pad
15586 */
15587
15588 segment_size *= (1024 * 1024);
15589
15590 data.segment_size = segment_size;
15591
15592 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15593
15594 wl_data->buf = (char *) mymalloc (segment_size);
15595 wl_data->avail = segment_size;
15596 wl_data->incr = segment_size;
15597 wl_data->cnt = 0;
15598 wl_data->pos = 0;
15599
15600 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15601
15602 data.wordlist_mode = wordlist_mode;
15603
15604 cs_t *css_buf = NULL;
15605 uint css_cnt = 0;
15606 uint dictcnt = 0;
15607 uint maskcnt = 1;
15608 char **masks = NULL;
15609 char **dictfiles = NULL;
15610
15611 uint mask_from_file = 0;
15612
15613 if (attack_mode == ATTACK_MODE_STRAIGHT)
15614 {
15615 if (wordlist_mode == WL_MODE_FILE)
15616 {
15617 int wls_left = myargc - (optind + 1);
15618
15619 for (int i = 0; i < wls_left; i++)
15620 {
15621 char *l0_filename = myargv[optind + 1 + i];
15622
15623 struct stat l0_stat;
15624
15625 if (stat (l0_filename, &l0_stat) == -1)
15626 {
15627 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15628
15629 return (-1);
15630 }
15631
15632 uint is_dir = S_ISDIR (l0_stat.st_mode);
15633
15634 if (is_dir == 0)
15635 {
15636 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15637
15638 dictcnt++;
15639
15640 dictfiles[dictcnt - 1] = l0_filename;
15641 }
15642 else
15643 {
15644 // do not allow --keyspace w/ a directory
15645
15646 if (keyspace == 1)
15647 {
15648 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15649
15650 return (-1);
15651 }
15652
15653 char **dictionary_files = NULL;
15654
15655 dictionary_files = scan_directory (l0_filename);
15656
15657 if (dictionary_files != NULL)
15658 {
15659 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15660
15661 for (int d = 0; dictionary_files[d] != NULL; d++)
15662 {
15663 char *l1_filename = dictionary_files[d];
15664
15665 struct stat l1_stat;
15666
15667 if (stat (l1_filename, &l1_stat) == -1)
15668 {
15669 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15670
15671 return (-1);
15672 }
15673
15674 if (S_ISREG (l1_stat.st_mode))
15675 {
15676 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15677
15678 dictcnt++;
15679
15680 dictfiles[dictcnt - 1] = strdup (l1_filename);
15681 }
15682 }
15683 }
15684
15685 local_free (dictionary_files);
15686 }
15687 }
15688
15689 if (dictcnt < 1)
15690 {
15691 log_error ("ERROR: No usable dictionary file found.");
15692
15693 return (-1);
15694 }
15695 }
15696 else if (wordlist_mode == WL_MODE_STDIN)
15697 {
15698 dictcnt = 1;
15699 }
15700 }
15701 else if (attack_mode == ATTACK_MODE_COMBI)
15702 {
15703 // display
15704
15705 char *dictfile1 = myargv[optind + 1 + 0];
15706 char *dictfile2 = myargv[optind + 1 + 1];
15707
15708 // find the bigger dictionary and use as base
15709
15710 FILE *fp1 = NULL;
15711 FILE *fp2 = NULL;
15712
15713 struct stat tmp_stat;
15714
15715 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15716 {
15717 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15718
15719 return (-1);
15720 }
15721
15722 if (stat (dictfile1, &tmp_stat) == -1)
15723 {
15724 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15725
15726 fclose (fp1);
15727
15728 return (-1);
15729 }
15730
15731 if (S_ISDIR (tmp_stat.st_mode))
15732 {
15733 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15734
15735 fclose (fp1);
15736
15737 return (-1);
15738 }
15739
15740 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15741 {
15742 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15743
15744 fclose (fp1);
15745
15746 return (-1);
15747 }
15748
15749 if (stat (dictfile2, &tmp_stat) == -1)
15750 {
15751 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15752
15753 fclose (fp1);
15754 fclose (fp2);
15755
15756 return (-1);
15757 }
15758
15759 if (S_ISDIR (tmp_stat.st_mode))
15760 {
15761 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15762
15763 fclose (fp1);
15764 fclose (fp2);
15765
15766 return (-1);
15767 }
15768
15769 data.combs_cnt = 1;
15770
15771 data.quiet = 1;
15772
15773 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15774
15775 data.quiet = quiet;
15776
15777 if (words1_cnt == 0)
15778 {
15779 log_error ("ERROR: %s: empty file", dictfile1);
15780
15781 fclose (fp1);
15782 fclose (fp2);
15783
15784 return (-1);
15785 }
15786
15787 data.combs_cnt = 1;
15788
15789 data.quiet = 1;
15790
15791 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15792
15793 data.quiet = quiet;
15794
15795 if (words2_cnt == 0)
15796 {
15797 log_error ("ERROR: %s: empty file", dictfile2);
15798
15799 fclose (fp1);
15800 fclose (fp2);
15801
15802 return (-1);
15803 }
15804
15805 fclose (fp1);
15806 fclose (fp2);
15807
15808 data.dictfile = dictfile1;
15809 data.dictfile2 = dictfile2;
15810
15811 if (words1_cnt >= words2_cnt)
15812 {
15813 data.combs_cnt = words2_cnt;
15814 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15815
15816 dictfiles = &data.dictfile;
15817
15818 dictcnt = 1;
15819 }
15820 else
15821 {
15822 data.combs_cnt = words1_cnt;
15823 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15824
15825 dictfiles = &data.dictfile2;
15826
15827 dictcnt = 1;
15828
15829 // we also have to switch wordlist related rules!
15830
15831 char *tmpc = data.rule_buf_l;
15832
15833 data.rule_buf_l = data.rule_buf_r;
15834 data.rule_buf_r = tmpc;
15835
15836 int tmpi = data.rule_len_l;
15837
15838 data.rule_len_l = data.rule_len_r;
15839 data.rule_len_r = tmpi;
15840 }
15841 }
15842 else if (attack_mode == ATTACK_MODE_BF)
15843 {
15844 char *mask = NULL;
15845
15846 maskcnt = 0;
15847
15848 if (benchmark == 0)
15849 {
15850 mask = myargv[optind + 1];
15851
15852 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15853
15854 if ((optind + 2) <= myargc)
15855 {
15856 struct stat file_stat;
15857
15858 if (stat (mask, &file_stat) == -1)
15859 {
15860 maskcnt = 1;
15861
15862 masks[maskcnt - 1] = mystrdup (mask);
15863 }
15864 else
15865 {
15866 int wls_left = myargc - (optind + 1);
15867
15868 uint masks_avail = INCR_MASKS;
15869
15870 for (int i = 0; i < wls_left; i++)
15871 {
15872 if (i != 0)
15873 {
15874 mask = myargv[optind + 1 + i];
15875
15876 if (stat (mask, &file_stat) == -1)
15877 {
15878 log_error ("ERROR: %s: %s", mask, strerror (errno));
15879
15880 return (-1);
15881 }
15882 }
15883
15884 uint is_file = S_ISREG (file_stat.st_mode);
15885
15886 if (is_file == 1)
15887 {
15888 FILE *mask_fp;
15889
15890 if ((mask_fp = fopen (mask, "r")) == NULL)
15891 {
15892 log_error ("ERROR: %s: %s", mask, strerror (errno));
15893
15894 return (-1);
15895 }
15896
15897 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15898
15899 while (!feof (mask_fp))
15900 {
15901 memset (line_buf, 0, HCBUFSIZ);
15902
15903 int line_len = fgetl (mask_fp, line_buf);
15904
15905 if (line_len == 0) continue;
15906
15907 if (line_buf[0] == '#') continue;
15908
15909 if (masks_avail == maskcnt)
15910 {
15911 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15912
15913 masks_avail += INCR_MASKS;
15914 }
15915
15916 masks[maskcnt] = mystrdup (line_buf);
15917
15918 maskcnt++;
15919 }
15920
15921 myfree (line_buf);
15922
15923 fclose (mask_fp);
15924 }
15925 else
15926 {
15927 log_error ("ERROR: %s: unsupported file-type", mask);
15928
15929 return (-1);
15930 }
15931 }
15932
15933 mask_from_file = 1;
15934 }
15935 }
15936 else
15937 {
15938 custom_charset_1 = (char *) "?l?d?u";
15939 custom_charset_2 = (char *) "?l?d";
15940 custom_charset_3 = (char *) "?l?d*!$@_";
15941
15942 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15943 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15944 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15945
15946 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15947
15948 wordlist_mode = WL_MODE_MASK;
15949
15950 data.wordlist_mode = wordlist_mode;
15951
15952 increment = 1;
15953
15954 maskcnt = 1;
15955 }
15956 }
15957 else
15958 {
15959 /**
15960 * generate full masks and charsets
15961 */
15962
15963 masks = (char **) mymalloc (sizeof (char *));
15964
15965 switch (hash_mode)
15966 {
15967 case 1731: pw_min = 5;
15968 pw_max = 5;
15969 mask = mystrdup ("?b?b?b?b?b");
15970 break;
15971 case 12500: pw_min = 5;
15972 pw_max = 5;
15973 mask = mystrdup ("?b?b?b?b?b");
15974 break;
15975 default: pw_min = 7;
15976 pw_max = 7;
15977 mask = mystrdup ("?b?b?b?b?b?b?b");
15978 break;
15979 }
15980
15981 maskcnt = 1;
15982
15983 masks[maskcnt - 1] = mystrdup (mask);
15984
15985 wordlist_mode = WL_MODE_MASK;
15986
15987 data.wordlist_mode = wordlist_mode;
15988
15989 increment = 1;
15990 }
15991
15992 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15993
15994 if (increment)
15995 {
15996 if (increment_min > pw_min) pw_min = increment_min;
15997
15998 if (increment_max < pw_max) pw_max = increment_max;
15999 }
16000 }
16001 else if (attack_mode == ATTACK_MODE_HYBRID1)
16002 {
16003 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16004
16005 // display
16006
16007 char *mask = myargv[myargc - 1];
16008
16009 maskcnt = 0;
16010
16011 masks = (char **) mymalloc (1 * sizeof (char *));
16012
16013 // mod
16014
16015 struct stat file_stat;
16016
16017 if (stat (mask, &file_stat) == -1)
16018 {
16019 maskcnt = 1;
16020
16021 masks[maskcnt - 1] = mystrdup (mask);
16022 }
16023 else
16024 {
16025 uint is_file = S_ISREG (file_stat.st_mode);
16026
16027 if (is_file == 1)
16028 {
16029 FILE *mask_fp;
16030
16031 if ((mask_fp = fopen (mask, "r")) == NULL)
16032 {
16033 log_error ("ERROR: %s: %s", mask, strerror (errno));
16034
16035 return (-1);
16036 }
16037
16038 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16039
16040 uint masks_avail = 1;
16041
16042 while (!feof (mask_fp))
16043 {
16044 memset (line_buf, 0, HCBUFSIZ);
16045
16046 int line_len = fgetl (mask_fp, line_buf);
16047
16048 if (line_len == 0) continue;
16049
16050 if (line_buf[0] == '#') continue;
16051
16052 if (masks_avail == maskcnt)
16053 {
16054 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16055
16056 masks_avail += INCR_MASKS;
16057 }
16058
16059 masks[maskcnt] = mystrdup (line_buf);
16060
16061 maskcnt++;
16062 }
16063
16064 myfree (line_buf);
16065
16066 fclose (mask_fp);
16067
16068 mask_from_file = 1;
16069 }
16070 else
16071 {
16072 maskcnt = 1;
16073
16074 masks[maskcnt - 1] = mystrdup (mask);
16075 }
16076 }
16077
16078 // base
16079
16080 int wls_left = myargc - (optind + 2);
16081
16082 for (int i = 0; i < wls_left; i++)
16083 {
16084 char *filename = myargv[optind + 1 + i];
16085
16086 struct stat file_stat;
16087
16088 if (stat (filename, &file_stat) == -1)
16089 {
16090 log_error ("ERROR: %s: %s", filename, strerror (errno));
16091
16092 return (-1);
16093 }
16094
16095 uint is_dir = S_ISDIR (file_stat.st_mode);
16096
16097 if (is_dir == 0)
16098 {
16099 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16100
16101 dictcnt++;
16102
16103 dictfiles[dictcnt - 1] = filename;
16104 }
16105 else
16106 {
16107 // do not allow --keyspace w/ a directory
16108
16109 if (keyspace == 1)
16110 {
16111 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16112
16113 return (-1);
16114 }
16115
16116 char **dictionary_files = NULL;
16117
16118 dictionary_files = scan_directory (filename);
16119
16120 if (dictionary_files != NULL)
16121 {
16122 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16123
16124 for (int d = 0; dictionary_files[d] != NULL; d++)
16125 {
16126 char *l1_filename = dictionary_files[d];
16127
16128 struct stat l1_stat;
16129
16130 if (stat (l1_filename, &l1_stat) == -1)
16131 {
16132 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16133
16134 return (-1);
16135 }
16136
16137 if (S_ISREG (l1_stat.st_mode))
16138 {
16139 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16140
16141 dictcnt++;
16142
16143 dictfiles[dictcnt - 1] = strdup (l1_filename);
16144 }
16145 }
16146 }
16147
16148 local_free (dictionary_files);
16149 }
16150 }
16151
16152 if (dictcnt < 1)
16153 {
16154 log_error ("ERROR: No usable dictionary file found.");
16155
16156 return (-1);
16157 }
16158
16159 if (increment)
16160 {
16161 maskcnt = 0;
16162
16163 uint mask_min = increment_min; // we can't reject smaller masks here
16164 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16165
16166 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16167 {
16168 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16169
16170 if (cur_mask == NULL) break;
16171
16172 masks[maskcnt] = cur_mask;
16173
16174 maskcnt++;
16175
16176 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16177 }
16178 }
16179 }
16180 else if (attack_mode == ATTACK_MODE_HYBRID2)
16181 {
16182 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16183
16184 // display
16185
16186 char *mask = myargv[optind + 1 + 0];
16187
16188 maskcnt = 0;
16189
16190 masks = (char **) mymalloc (1 * sizeof (char *));
16191
16192 // mod
16193
16194 struct stat file_stat;
16195
16196 if (stat (mask, &file_stat) == -1)
16197 {
16198 maskcnt = 1;
16199
16200 masks[maskcnt - 1] = mystrdup (mask);
16201 }
16202 else
16203 {
16204 uint is_file = S_ISREG (file_stat.st_mode);
16205
16206 if (is_file == 1)
16207 {
16208 FILE *mask_fp;
16209
16210 if ((mask_fp = fopen (mask, "r")) == NULL)
16211 {
16212 log_error ("ERROR: %s: %s", mask, strerror (errno));
16213
16214 return (-1);
16215 }
16216
16217 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16218
16219 uint masks_avail = 1;
16220
16221 while (!feof (mask_fp))
16222 {
16223 memset (line_buf, 0, HCBUFSIZ);
16224
16225 int line_len = fgetl (mask_fp, line_buf);
16226
16227 if (line_len == 0) continue;
16228
16229 if (line_buf[0] == '#') continue;
16230
16231 if (masks_avail == maskcnt)
16232 {
16233 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16234
16235 masks_avail += INCR_MASKS;
16236 }
16237
16238 masks[maskcnt] = mystrdup (line_buf);
16239
16240 maskcnt++;
16241 }
16242
16243 myfree (line_buf);
16244
16245 fclose (mask_fp);
16246
16247 mask_from_file = 1;
16248 }
16249 else
16250 {
16251 maskcnt = 1;
16252
16253 masks[maskcnt - 1] = mystrdup (mask);
16254 }
16255 }
16256
16257 // base
16258
16259 int wls_left = myargc - (optind + 2);
16260
16261 for (int i = 0; i < wls_left; i++)
16262 {
16263 char *filename = myargv[optind + 2 + i];
16264
16265 struct stat file_stat;
16266
16267 if (stat (filename, &file_stat) == -1)
16268 {
16269 log_error ("ERROR: %s: %s", filename, strerror (errno));
16270
16271 return (-1);
16272 }
16273
16274 uint is_dir = S_ISDIR (file_stat.st_mode);
16275
16276 if (is_dir == 0)
16277 {
16278 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16279
16280 dictcnt++;
16281
16282 dictfiles[dictcnt - 1] = filename;
16283 }
16284 else
16285 {
16286 // do not allow --keyspace w/ a directory
16287
16288 if (keyspace == 1)
16289 {
16290 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16291
16292 return (-1);
16293 }
16294
16295 char **dictionary_files = NULL;
16296
16297 dictionary_files = scan_directory (filename);
16298
16299 if (dictionary_files != NULL)
16300 {
16301 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16302
16303 for (int d = 0; dictionary_files[d] != NULL; d++)
16304 {
16305 char *l1_filename = dictionary_files[d];
16306
16307 struct stat l1_stat;
16308
16309 if (stat (l1_filename, &l1_stat) == -1)
16310 {
16311 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16312
16313 return (-1);
16314 }
16315
16316 if (S_ISREG (l1_stat.st_mode))
16317 {
16318 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16319
16320 dictcnt++;
16321
16322 dictfiles[dictcnt - 1] = strdup (l1_filename);
16323 }
16324 }
16325 }
16326
16327 local_free (dictionary_files);
16328 }
16329 }
16330
16331 if (dictcnt < 1)
16332 {
16333 log_error ("ERROR: No usable dictionary file found.");
16334
16335 return (-1);
16336 }
16337
16338 if (increment)
16339 {
16340 maskcnt = 0;
16341
16342 uint mask_min = increment_min; // we can't reject smaller masks here
16343 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16344
16345 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16346 {
16347 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16348
16349 if (cur_mask == NULL) break;
16350
16351 masks[maskcnt] = cur_mask;
16352
16353 maskcnt++;
16354
16355 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16356 }
16357 }
16358 }
16359
16360 data.pw_min = pw_min;
16361 data.pw_max = pw_max;
16362
16363 /**
16364 * weak hash check
16365 */
16366
16367 if (weak_hash_threshold >= salts_cnt)
16368 {
16369 hc_device_param_t *device_param = NULL;
16370
16371 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16372 {
16373 device_param = &data.devices_param[device_id];
16374
16375 if (device_param->skipped) continue;
16376
16377 break;
16378 }
16379
16380 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16381
16382 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16383 {
16384 weak_hash_check (device_param, salt_pos);
16385 }
16386
16387 // Display hack, guarantee that there is at least one \r before real start
16388
16389 //if (data.quiet == 0) log_info ("");
16390 }
16391
16392 /**
16393 * status and monitor threads
16394 */
16395
16396 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16397
16398 hc_thread_t i_thread = 0;
16399
16400 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16401 {
16402 hc_thread_create (i_thread, thread_keypress, &benchmark);
16403 }
16404
16405 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16406
16407 uint ni_threads_cnt = 0;
16408
16409 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16410
16411 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16412
16413 ni_threads_cnt++;
16414
16415 /**
16416 * Outfile remove
16417 */
16418
16419 if (keyspace == 0)
16420 {
16421 if (outfile_check_timer != 0)
16422 {
16423 if (data.outfile_check_directory != NULL)
16424 {
16425 if ((hash_mode != 5200) &&
16426 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16427 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16428 (hash_mode != 9000))
16429 {
16430 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16431
16432 ni_threads_cnt++;
16433 }
16434 else
16435 {
16436 outfile_check_timer = 0;
16437 }
16438 }
16439 else
16440 {
16441 outfile_check_timer = 0;
16442 }
16443 }
16444 }
16445
16446 /**
16447 * Inform the user if we got some hashes remove because of the pot file remove feature
16448 */
16449
16450 if (data.quiet == 0)
16451 {
16452 if (potfile_remove_cracks > 0)
16453 {
16454 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16455 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16456 }
16457 }
16458
16459 data.outfile_check_timer = outfile_check_timer;
16460
16461 /**
16462 * main loop
16463 */
16464
16465 char **induction_dictionaries = NULL;
16466
16467 int induction_dictionaries_cnt = 0;
16468
16469 hcstat_table_t *root_table_buf = NULL;
16470 hcstat_table_t *markov_table_buf = NULL;
16471
16472 uint initial_restore_done = 0;
16473
16474 data.maskcnt = maskcnt;
16475
16476 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16477 {
16478 if (data.devices_status == STATUS_CRACKED) break;
16479
16480 data.devices_status = STATUS_INIT;
16481
16482 if (maskpos > rd->maskpos)
16483 {
16484 rd->dictpos = 0;
16485 }
16486
16487 rd->maskpos = maskpos;
16488 data.maskpos = maskpos;
16489
16490 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16491 {
16492 char *mask = masks[maskpos];
16493
16494 if (mask_from_file == 1)
16495 {
16496 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16497
16498 char *str_ptr;
16499 uint str_pos;
16500
16501 uint mask_offset = 0;
16502
16503 uint separator_cnt;
16504
16505 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16506 {
16507 str_ptr = strstr (mask + mask_offset, ",");
16508
16509 if (str_ptr == NULL) break;
16510
16511 str_pos = str_ptr - mask;
16512
16513 // escaped separator, i.e. "\,"
16514
16515 if (str_pos > 0)
16516 {
16517 if (mask[str_pos - 1] == '\\')
16518 {
16519 separator_cnt --;
16520
16521 mask_offset = str_pos + 1;
16522
16523 continue;
16524 }
16525 }
16526
16527 // reset the offset
16528
16529 mask_offset = 0;
16530
16531 mask[str_pos] = '\0';
16532
16533 switch (separator_cnt)
16534 {
16535 case 0:
16536 mp_reset_usr (mp_usr, 0);
16537
16538 custom_charset_1 = mask;
16539 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16540 break;
16541
16542 case 1:
16543 mp_reset_usr (mp_usr, 1);
16544
16545 custom_charset_2 = mask;
16546 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16547 break;
16548
16549 case 2:
16550 mp_reset_usr (mp_usr, 2);
16551
16552 custom_charset_3 = mask;
16553 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16554 break;
16555
16556 case 3:
16557 mp_reset_usr (mp_usr, 3);
16558
16559 custom_charset_4 = mask;
16560 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16561 break;
16562 }
16563
16564 mask = mask + str_pos + 1;
16565 }
16566 }
16567
16568 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16569 {
16570 if (maskpos > 0)
16571 {
16572 local_free (css_buf);
16573 local_free (data.root_css_buf);
16574 local_free (data.markov_css_buf);
16575
16576 local_free (masks[maskpos - 1]);
16577 }
16578
16579 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16580
16581 data.mask = mask;
16582 data.css_cnt = css_cnt;
16583 data.css_buf = css_buf;
16584
16585 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16586
16587 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16588
16589 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16590 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16591
16592 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16593
16594 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16595
16596 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16597 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16598
16599 data.root_css_buf = root_css_buf;
16600 data.markov_css_buf = markov_css_buf;
16601
16602 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16603
16604 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16605
16606 local_free (root_table_buf);
16607 local_free (markov_table_buf);
16608
16609 // args
16610
16611 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16612 {
16613 hc_device_param_t *device_param = &data.devices_param[device_id];
16614
16615 if (device_param->skipped) continue;
16616
16617 device_param->kernel_params_mp[0] = &device_param->d_combs;
16618 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16619 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16620
16621 device_param->kernel_params_mp_buf64[3] = 0;
16622 device_param->kernel_params_mp_buf32[4] = css_cnt;
16623 device_param->kernel_params_mp_buf32[5] = 0;
16624 device_param->kernel_params_mp_buf32[6] = 0;
16625 device_param->kernel_params_mp_buf32[7] = 0;
16626
16627 if (attack_mode == ATTACK_MODE_HYBRID1)
16628 {
16629 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16630 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16631 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16632 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16633 }
16634 else if (attack_mode == ATTACK_MODE_HYBRID2)
16635 {
16636 device_param->kernel_params_mp_buf32[5] = 0;
16637 device_param->kernel_params_mp_buf32[6] = 0;
16638 device_param->kernel_params_mp_buf32[7] = 0;
16639 }
16640
16641 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]);
16642 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]);
16643 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]);
16644
16645 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);
16646 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);
16647 }
16648 }
16649 else if (attack_mode == ATTACK_MODE_BF)
16650 {
16651 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16652
16653 if (increment)
16654 {
16655 for (uint i = 0; i < dictcnt; i++)
16656 {
16657 local_free (dictfiles[i]);
16658 }
16659
16660 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16661 {
16662 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16663
16664 if (l1_filename == NULL) break;
16665
16666 dictcnt++;
16667
16668 dictfiles[dictcnt - 1] = l1_filename;
16669 }
16670 }
16671 else
16672 {
16673 dictcnt++;
16674
16675 dictfiles[dictcnt - 1] = mask;
16676 }
16677
16678 if (dictcnt == 0)
16679 {
16680 log_error ("ERROR: Mask is too small");
16681
16682 return (-1);
16683 }
16684 }
16685 }
16686
16687 free (induction_dictionaries);
16688
16689 // induction_dictionaries_cnt = 0; // implied
16690
16691 if (attack_mode != ATTACK_MODE_BF)
16692 {
16693 if (keyspace == 0)
16694 {
16695 induction_dictionaries = scan_directory (induction_directory);
16696
16697 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16698 }
16699 }
16700
16701 if (induction_dictionaries_cnt)
16702 {
16703 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16704 }
16705
16706 /**
16707 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16708 */
16709 if (keyspace == 1)
16710 {
16711 if ((maskcnt > 1) || (dictcnt > 1))
16712 {
16713 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16714
16715 return (-1);
16716 }
16717 }
16718
16719 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16720 {
16721 char *subid = logfile_generate_subid ();
16722
16723 data.subid = subid;
16724
16725 logfile_sub_msg ("START");
16726
16727 data.devices_status = STATUS_INIT;
16728
16729 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16730 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16731 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16732
16733 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16734
16735 data.cpt_pos = 0;
16736
16737 data.cpt_start = time (NULL);
16738
16739 data.cpt_total = 0;
16740
16741 if (data.restore == 0)
16742 {
16743 rd->words_cur = skip;
16744
16745 skip = 0;
16746
16747 data.skip = 0;
16748 }
16749
16750 data.ms_paused = 0;
16751
16752 data.words_cur = rd->words_cur;
16753
16754 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16755 {
16756 hc_device_param_t *device_param = &data.devices_param[device_id];
16757
16758 if (device_param->skipped) continue;
16759
16760 device_param->speed_pos = 0;
16761
16762 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16763 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16764
16765 device_param->exec_pos = 0;
16766
16767 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16768
16769 device_param->kernel_power = device_param->kernel_power_user;
16770
16771 device_param->outerloop_pos = 0;
16772 device_param->outerloop_left = 0;
16773 device_param->innerloop_pos = 0;
16774 device_param->innerloop_left = 0;
16775
16776 // some more resets:
16777
16778 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16779
16780 device_param->pws_cnt = 0;
16781
16782 device_param->words_off = 0;
16783 device_param->words_done = 0;
16784 }
16785
16786 data.kernel_power_div = 0;
16787
16788 // figure out some workload
16789
16790 if (attack_mode == ATTACK_MODE_STRAIGHT)
16791 {
16792 if (data.wordlist_mode == WL_MODE_FILE)
16793 {
16794 char *dictfile = NULL;
16795
16796 if (induction_dictionaries_cnt)
16797 {
16798 dictfile = induction_dictionaries[0];
16799 }
16800 else
16801 {
16802 dictfile = dictfiles[dictpos];
16803 }
16804
16805 data.dictfile = dictfile;
16806
16807 logfile_sub_string (dictfile);
16808
16809 for (uint i = 0; i < rp_files_cnt; i++)
16810 {
16811 logfile_sub_var_string ("rulefile", rp_files[i]);
16812 }
16813
16814 FILE *fd2 = fopen (dictfile, "rb");
16815
16816 if (fd2 == NULL)
16817 {
16818 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16819
16820 return (-1);
16821 }
16822
16823 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16824
16825 fclose (fd2);
16826
16827 if (data.words_cnt == 0)
16828 {
16829 if (data.devices_status == STATUS_CRACKED) break;
16830 if (data.devices_status == STATUS_ABORTED) break;
16831
16832 dictpos++;
16833
16834 continue;
16835 }
16836 }
16837 }
16838 else if (attack_mode == ATTACK_MODE_COMBI)
16839 {
16840 char *dictfile = data.dictfile;
16841 char *dictfile2 = data.dictfile2;
16842
16843 logfile_sub_string (dictfile);
16844 logfile_sub_string (dictfile2);
16845
16846 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16847 {
16848 FILE *fd2 = fopen (dictfile, "rb");
16849
16850 if (fd2 == NULL)
16851 {
16852 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16853
16854 return (-1);
16855 }
16856
16857 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16858
16859 fclose (fd2);
16860 }
16861 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16862 {
16863 FILE *fd2 = fopen (dictfile2, "rb");
16864
16865 if (fd2 == NULL)
16866 {
16867 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16868
16869 return (-1);
16870 }
16871
16872 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16873
16874 fclose (fd2);
16875 }
16876
16877 if (data.words_cnt == 0)
16878 {
16879 if (data.devices_status == STATUS_CRACKED) break;
16880 if (data.devices_status == STATUS_ABORTED) break;
16881
16882 dictpos++;
16883
16884 continue;
16885 }
16886 }
16887 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16888 {
16889 char *dictfile = NULL;
16890
16891 if (induction_dictionaries_cnt)
16892 {
16893 dictfile = induction_dictionaries[0];
16894 }
16895 else
16896 {
16897 dictfile = dictfiles[dictpos];
16898 }
16899
16900 data.dictfile = dictfile;
16901
16902 char *mask = data.mask;
16903
16904 logfile_sub_string (dictfile);
16905 logfile_sub_string (mask);
16906
16907 FILE *fd2 = fopen (dictfile, "rb");
16908
16909 if (fd2 == NULL)
16910 {
16911 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16912
16913 return (-1);
16914 }
16915
16916 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16917
16918 fclose (fd2);
16919
16920 if (data.words_cnt == 0)
16921 {
16922 if (data.devices_status == STATUS_CRACKED) break;
16923 if (data.devices_status == STATUS_ABORTED) break;
16924
16925 dictpos++;
16926
16927 continue;
16928 }
16929 }
16930 else if (attack_mode == ATTACK_MODE_BF)
16931 {
16932 local_free (css_buf);
16933 local_free (data.root_css_buf);
16934 local_free (data.markov_css_buf);
16935
16936 char *mask = dictfiles[dictpos];
16937
16938 logfile_sub_string (mask);
16939
16940 // base
16941
16942 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16943
16944 if (opts_type & OPTS_TYPE_PT_UNICODE)
16945 {
16946 uint css_cnt_unicode = css_cnt * 2;
16947
16948 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16949
16950 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16951 {
16952 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16953
16954 css_buf_unicode[j + 1].cs_buf[0] = 0;
16955 css_buf_unicode[j + 1].cs_len = 1;
16956 }
16957
16958 free (css_buf);
16959
16960 css_buf = css_buf_unicode;
16961 css_cnt = css_cnt_unicode;
16962 }
16963
16964 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16965
16966 uint mask_min = pw_min;
16967 uint mask_max = pw_max;
16968
16969 if (opts_type & OPTS_TYPE_PT_UNICODE)
16970 {
16971 mask_min *= 2;
16972 mask_max *= 2;
16973 }
16974
16975 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16976 {
16977 if (css_cnt < mask_min)
16978 {
16979 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16980 }
16981
16982 if (css_cnt > mask_max)
16983 {
16984 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16985 }
16986
16987 // skip to next mask
16988
16989 dictpos++;
16990
16991 rd->dictpos = dictpos;
16992
16993 logfile_sub_msg ("STOP");
16994
16995 continue;
16996 }
16997
16998 uint save_css_cnt = css_cnt;
16999
17000 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17001 {
17002 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17003 {
17004 uint salt_len = (uint) data.salts_buf[0].salt_len;
17005 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17006
17007 uint css_cnt_salt = css_cnt + salt_len;
17008
17009 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17010
17011 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17012
17013 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17014 {
17015 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17016 css_buf_salt[j].cs_len = 1;
17017 }
17018
17019 free (css_buf);
17020
17021 css_buf = css_buf_salt;
17022 css_cnt = css_cnt_salt;
17023 }
17024 }
17025
17026 data.mask = mask;
17027 data.css_cnt = css_cnt;
17028 data.css_buf = css_buf;
17029
17030 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17031
17032 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17033
17034 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17035
17036 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17037 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17038
17039 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17040
17041 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17042
17043 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17044 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17045
17046 data.root_css_buf = root_css_buf;
17047 data.markov_css_buf = markov_css_buf;
17048
17049 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17050
17051 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17052
17053 local_free (root_table_buf);
17054 local_free (markov_table_buf);
17055
17056 // copy + args
17057
17058 uint css_cnt_l = css_cnt;
17059 uint css_cnt_r;
17060
17061 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17062 {
17063 if (save_css_cnt < 6)
17064 {
17065 css_cnt_r = 1;
17066 }
17067 else if (save_css_cnt == 6)
17068 {
17069 css_cnt_r = 2;
17070 }
17071 else
17072 {
17073 if (opts_type & OPTS_TYPE_PT_UNICODE)
17074 {
17075 if (save_css_cnt == 8 || save_css_cnt == 10)
17076 {
17077 css_cnt_r = 2;
17078 }
17079 else
17080 {
17081 css_cnt_r = 4;
17082 }
17083 }
17084 else
17085 {
17086 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17087 {
17088 css_cnt_r = 3;
17089 }
17090 else
17091 {
17092 css_cnt_r = 4;
17093 }
17094 }
17095 }
17096 }
17097 else
17098 {
17099 css_cnt_r = 1;
17100
17101 /* unfinished code?
17102 int sum = css_buf[css_cnt_r - 1].cs_len;
17103
17104 for (uint i = 1; i < 4 && i < css_cnt; i++)
17105 {
17106 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17107
17108 css_cnt_r++;
17109
17110 sum *= css_buf[css_cnt_r - 1].cs_len;
17111 }
17112 */
17113 }
17114
17115 css_cnt_l -= css_cnt_r;
17116
17117 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17118
17119 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17120 {
17121 hc_device_param_t *device_param = &data.devices_param[device_id];
17122
17123 if (device_param->skipped) continue;
17124
17125 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17126 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17127 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17128
17129 device_param->kernel_params_mp_l_buf64[3] = 0;
17130 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17131 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17132 device_param->kernel_params_mp_l_buf32[6] = 0;
17133 device_param->kernel_params_mp_l_buf32[7] = 0;
17134 device_param->kernel_params_mp_l_buf32[8] = 0;
17135
17136 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17137 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17138 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17139 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17140
17141 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17142 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17143 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17144
17145 device_param->kernel_params_mp_r_buf64[3] = 0;
17146 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17147 device_param->kernel_params_mp_r_buf32[5] = 0;
17148 device_param->kernel_params_mp_r_buf32[6] = 0;
17149 device_param->kernel_params_mp_r_buf32[7] = 0;
17150
17151 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]);
17152 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]);
17153 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]);
17154
17155 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]);
17156 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]);
17157 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]);
17158
17159 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);
17160 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);
17161 }
17162 }
17163
17164 u64 words_base = data.words_cnt;
17165
17166 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17167 {
17168 if (data.kernel_rules_cnt)
17169 {
17170 words_base /= data.kernel_rules_cnt;
17171 }
17172 }
17173 else if (data.attack_kern == ATTACK_KERN_COMBI)
17174 {
17175 if (data.combs_cnt)
17176 {
17177 words_base /= data.combs_cnt;
17178 }
17179 }
17180 else if (data.attack_kern == ATTACK_KERN_BF)
17181 {
17182 if (data.bfs_cnt)
17183 {
17184 words_base /= data.bfs_cnt;
17185 }
17186 }
17187
17188 data.words_base = words_base;
17189
17190 if (keyspace == 1)
17191 {
17192 log_info ("%llu", (unsigned long long int) words_base);
17193
17194 return (0);
17195 }
17196
17197 if (data.words_cur > data.words_base)
17198 {
17199 log_error ("ERROR: restore value greater keyspace");
17200
17201 return (-1);
17202 }
17203
17204 if (data.words_cur)
17205 {
17206 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17207 {
17208 for (uint i = 0; i < data.salts_cnt; i++)
17209 {
17210 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17211 }
17212 }
17213 else if (data.attack_kern == ATTACK_KERN_COMBI)
17214 {
17215 for (uint i = 0; i < data.salts_cnt; i++)
17216 {
17217 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17218 }
17219 }
17220 else if (data.attack_kern == ATTACK_KERN_BF)
17221 {
17222 for (uint i = 0; i < data.salts_cnt; i++)
17223 {
17224 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17225 }
17226 }
17227 }
17228
17229 /*
17230 * Inform user about possible slow speeds
17231 */
17232
17233 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17234 {
17235 if (data.words_base < kernel_power_all)
17236 {
17237 if (quiet == 0)
17238 {
17239 log_info ("ATTENTION!");
17240 log_info (" The wordlist or mask you are using is too small.");
17241 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17242 log_info (" The cracking speed will drop.");
17243 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17244 log_info ("");
17245 }
17246 }
17247 }
17248
17249 /*
17250 * Update loopback file
17251 */
17252
17253 if (loopback == 1)
17254 {
17255 time_t now;
17256
17257 time (&now);
17258
17259 uint random_num = get_random_num (0, 9999);
17260
17261 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17262
17263 data.loopback_file = loopback_file;
17264 }
17265
17266 /*
17267 * Update dictionary statistic
17268 */
17269
17270 if (keyspace == 0)
17271 {
17272 dictstat_fp = fopen (dictstat, "wb");
17273
17274 if (dictstat_fp)
17275 {
17276 lock_file (dictstat_fp);
17277
17278 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17279
17280 fclose (dictstat_fp);
17281 }
17282 }
17283
17284 data.devices_status = STATUS_RUNNING;
17285
17286 if (initial_restore_done == 0)
17287 {
17288 if (data.restore_disable == 0) cycle_restore ();
17289
17290 initial_restore_done = 1;
17291 }
17292
17293 hc_timer_set (&data.timer_running);
17294
17295 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17296 {
17297 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17298 {
17299 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17300 if (quiet == 0) fflush (stdout);
17301 }
17302 }
17303 else if (wordlist_mode == WL_MODE_STDIN)
17304 {
17305 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17306 if (data.quiet == 0) log_info ("");
17307 }
17308
17309 time_t runtime_start;
17310
17311 time (&runtime_start);
17312
17313 data.runtime_start = runtime_start;
17314
17315 /**
17316 * create cracker threads
17317 */
17318
17319 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17320
17321 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17322 {
17323 hc_device_param_t *device_param = &devices_param[device_id];
17324
17325 if (wordlist_mode == WL_MODE_STDIN)
17326 {
17327 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17328 }
17329 else
17330 {
17331 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17332 }
17333 }
17334
17335 // wait for crack threads to exit
17336
17337 hc_thread_wait (data.devices_cnt, c_threads);
17338
17339 local_free (c_threads);
17340
17341 data.restore = 0;
17342
17343 // finalize task
17344
17345 logfile_sub_var_uint ("status-after-work", data.devices_status);
17346
17347 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17348
17349 if (data.devices_status == STATUS_CRACKED) break;
17350 if (data.devices_status == STATUS_ABORTED) break;
17351
17352 if (data.devices_status == STATUS_BYPASS)
17353 {
17354 data.devices_status = STATUS_RUNNING;
17355 }
17356
17357 if (induction_dictionaries_cnt)
17358 {
17359 unlink (induction_dictionaries[0]);
17360 }
17361
17362 free (induction_dictionaries);
17363
17364 if (attack_mode != ATTACK_MODE_BF)
17365 {
17366 induction_dictionaries = scan_directory (induction_directory);
17367
17368 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17369 }
17370
17371 if (benchmark == 0)
17372 {
17373 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17374 {
17375 if (quiet == 0) clear_prompt ();
17376
17377 if (quiet == 0) log_info ("");
17378
17379 if (status == 1)
17380 {
17381 status_display ();
17382 }
17383 else
17384 {
17385 if (quiet == 0) status_display ();
17386 }
17387
17388 if (quiet == 0) log_info ("");
17389 }
17390 }
17391
17392 if (attack_mode == ATTACK_MODE_BF)
17393 {
17394 dictpos++;
17395
17396 rd->dictpos = dictpos;
17397 }
17398 else
17399 {
17400 if (induction_dictionaries_cnt)
17401 {
17402 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17403 }
17404 else
17405 {
17406 dictpos++;
17407
17408 rd->dictpos = dictpos;
17409 }
17410 }
17411
17412 time_t runtime_stop;
17413
17414 time (&runtime_stop);
17415
17416 data.runtime_stop = runtime_stop;
17417
17418 logfile_sub_uint (runtime_start);
17419 logfile_sub_uint (runtime_stop);
17420
17421 logfile_sub_msg ("STOP");
17422
17423 global_free (subid);
17424 }
17425
17426 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17427
17428 if (data.devices_status == STATUS_CRACKED) break;
17429 if (data.devices_status == STATUS_ABORTED) break;
17430 if (data.devices_status == STATUS_QUIT) break;
17431
17432 if (data.devices_status == STATUS_BYPASS)
17433 {
17434 data.devices_status = STATUS_RUNNING;
17435 }
17436 }
17437
17438 // 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
17439
17440 if (attack_mode == ATTACK_MODE_STRAIGHT)
17441 {
17442 if (data.wordlist_mode == WL_MODE_FILE)
17443 {
17444 if (data.dictfile == NULL)
17445 {
17446 if (dictfiles != NULL)
17447 {
17448 data.dictfile = dictfiles[0];
17449
17450 hc_timer_set (&data.timer_running);
17451 }
17452 }
17453 }
17454 }
17455 // NOTE: combi is okay because it is already set beforehand
17456 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17457 {
17458 if (data.dictfile == NULL)
17459 {
17460 if (dictfiles != NULL)
17461 {
17462 hc_timer_set (&data.timer_running);
17463
17464 data.dictfile = dictfiles[0];
17465 }
17466 }
17467 }
17468 else if (attack_mode == ATTACK_MODE_BF)
17469 {
17470 if (data.mask == NULL)
17471 {
17472 hc_timer_set (&data.timer_running);
17473
17474 data.mask = masks[0];
17475 }
17476 }
17477
17478 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17479 {
17480 data.devices_status = STATUS_EXHAUSTED;
17481 }
17482
17483 // if cracked / aborted remove last induction dictionary
17484
17485 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17486 {
17487 struct stat induct_stat;
17488
17489 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17490 {
17491 unlink (induction_dictionaries[file_pos]);
17492 }
17493 }
17494
17495 // wait for non-interactive threads
17496
17497 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17498 {
17499 hc_thread_wait (1, &ni_threads[thread_idx]);
17500 }
17501
17502 local_free (ni_threads);
17503
17504 // wait for interactive threads
17505
17506 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17507 {
17508 hc_thread_wait (1, &i_thread);
17509 }
17510
17511 // we dont need restore file anymore
17512 if (data.restore_disable == 0)
17513 {
17514 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17515 {
17516 unlink (eff_restore_file);
17517 unlink (new_restore_file);
17518 }
17519 else
17520 {
17521 cycle_restore ();
17522 }
17523 }
17524
17525 // finally save left hashes
17526
17527 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17528 {
17529 save_hash ();
17530 }
17531
17532 /**
17533 * Clean up
17534 */
17535
17536 if (benchmark == 1)
17537 {
17538 status_benchmark ();
17539
17540 if (status_automat == 0)
17541 {
17542 log_info ("");
17543 }
17544 }
17545 else
17546 {
17547 if (quiet == 0) clear_prompt ();
17548
17549 if (quiet == 0) log_info ("");
17550
17551 if (status == 1)
17552 {
17553 status_display ();
17554 }
17555 else
17556 {
17557 if (quiet == 0) status_display ();
17558 }
17559
17560 if (quiet == 0) log_info ("");
17561 }
17562
17563 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17564 {
17565 hc_device_param_t *device_param = &data.devices_param[device_id];
17566
17567 if (device_param->skipped) continue;
17568
17569 local_free (device_param->combs_buf);
17570
17571 local_free (device_param->hooks_buf);
17572
17573 local_free (device_param->device_name);
17574
17575 local_free (device_param->device_name_chksum);
17576
17577 local_free (device_param->device_version);
17578
17579 local_free (device_param->driver_version);
17580
17581 if (device_param->pws_buf) myfree (device_param->pws_buf);
17582 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17583 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17584 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17585 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17586 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17587 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17588 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17589 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17590 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17591 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17592 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17593 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17594 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17595 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17596 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17597 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17598 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17599 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17600 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17601 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17602 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17603 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17604 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17605 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17606 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17607 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17608 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17609 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17610
17611 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17612 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17613 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17614 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17615 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17616 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17617 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17618 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17619 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17620 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17621
17622 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17623 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17624 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17625
17626 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17627 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17628 }
17629
17630 // reset default fan speed
17631
17632 #ifdef HAVE_HWMON
17633 if (gpu_temp_disable == 0)
17634 {
17635 #ifdef HAVE_ADL
17636 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17637 {
17638 hc_thread_mutex_lock (mux_adl);
17639
17640 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17641 {
17642 hc_device_param_t *device_param = &data.devices_param[device_id];
17643
17644 if (device_param->skipped) continue;
17645
17646 if (data.hm_device[device_id].fan_supported == 1)
17647 {
17648 int fanspeed = temp_retain_fanspeed_value[device_id];
17649
17650 if (fanspeed == -1) continue;
17651
17652 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17653
17654 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17655 }
17656 }
17657
17658 hc_thread_mutex_unlock (mux_adl);
17659 }
17660 #endif // HAVE_ADL
17661 }
17662
17663 #ifdef HAVE_ADL
17664 // reset power tuning
17665
17666 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17667 {
17668 hc_thread_mutex_lock (mux_adl);
17669
17670 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17671 {
17672 hc_device_param_t *device_param = &data.devices_param[device_id];
17673
17674 if (device_param->skipped) continue;
17675
17676 if (data.hm_device[device_id].od_version == 6)
17677 {
17678 // check powertune capabilities first, if not available then skip device
17679
17680 int powertune_supported = 0;
17681
17682 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17683 {
17684 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17685
17686 return (-1);
17687 }
17688
17689 if (powertune_supported != 0)
17690 {
17691 // powercontrol settings
17692
17693 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)
17694 {
17695 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17696
17697 return (-1);
17698 }
17699
17700 // clocks
17701
17702 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17703
17704 performance_state->iNumberOfPerformanceLevels = 2;
17705
17706 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17707 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17708 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17709 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17710
17711 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)
17712 {
17713 log_info ("ERROR: Failed to restore ADL performance state");
17714
17715 return (-1);
17716 }
17717
17718 local_free (performance_state);
17719 }
17720 }
17721 }
17722
17723 hc_thread_mutex_unlock (mux_adl);
17724 }
17725 #endif // HAVE_ADL
17726
17727 if (gpu_temp_disable == 0)
17728 {
17729 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17730 if (data.hm_nv)
17731 {
17732 #if defined(LINUX) && defined(HAVE_NVML)
17733
17734 hm_NVML_nvmlShutdown (data.hm_nv);
17735
17736 nvml_close (data.hm_nv);
17737
17738 #elif defined(WIN) && (HAVE_NVAPI)
17739
17740 hm_NvAPI_Unload (data.hm_nv);
17741
17742 nvapi_close (data.hm_nv);
17743
17744 #endif
17745
17746 data.hm_nv = NULL;
17747 }
17748 #endif
17749
17750 #ifdef HAVE_ADL
17751 if (data.hm_amd)
17752 {
17753 hm_ADL_Main_Control_Destroy (data.hm_amd);
17754
17755 adl_close (data.hm_amd);
17756 data.hm_amd = NULL;
17757 }
17758 #endif
17759 }
17760 #endif // HAVE_HWMON
17761
17762 // free memory
17763
17764 local_free (masks);
17765
17766 local_free (dictstat_base);
17767
17768 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17769 {
17770 pot_t *pot_ptr = &pot[pot_pos];
17771
17772 hash_t *hash = &pot_ptr->hash;
17773
17774 local_free (hash->digest);
17775
17776 if (isSalted)
17777 {
17778 local_free (hash->salt);
17779 }
17780 }
17781
17782 local_free (pot);
17783
17784 local_free (all_kernel_rules_cnt);
17785 local_free (all_kernel_rules_buf);
17786
17787 local_free (wl_data->buf);
17788 local_free (wl_data);
17789
17790 local_free (bitmap_s1_a);
17791 local_free (bitmap_s1_b);
17792 local_free (bitmap_s1_c);
17793 local_free (bitmap_s1_d);
17794 local_free (bitmap_s2_a);
17795 local_free (bitmap_s2_b);
17796 local_free (bitmap_s2_c);
17797 local_free (bitmap_s2_d);
17798
17799 #ifdef HAVE_HWMON
17800 local_free (temp_retain_fanspeed_value);
17801 #ifdef HAVE_ADL
17802 local_free (od_clock_mem_status);
17803 local_free (od_power_control_status);
17804 #endif // ADL
17805 #endif
17806
17807 global_free (devices_param);
17808
17809 global_free (kernel_rules_buf);
17810
17811 global_free (root_css_buf);
17812 global_free (markov_css_buf);
17813
17814 global_free (digests_buf);
17815 global_free (digests_shown);
17816 global_free (digests_shown_tmp);
17817
17818 global_free (salts_buf);
17819 global_free (salts_shown);
17820
17821 global_free (esalts_buf);
17822
17823 global_free (words_progress_done);
17824 global_free (words_progress_rejected);
17825 global_free (words_progress_restored);
17826
17827 if (pot_fp) fclose (pot_fp);
17828
17829 if (data.devices_status == STATUS_QUIT) break;
17830 }
17831
17832 // destroy others mutex
17833
17834 hc_thread_mutex_delete (mux_dispatcher);
17835 hc_thread_mutex_delete (mux_counter);
17836 hc_thread_mutex_delete (mux_display);
17837 hc_thread_mutex_delete (mux_adl);
17838
17839 // free memory
17840
17841 local_free (eff_restore_file);
17842 local_free (new_restore_file);
17843
17844 local_free (rd);
17845
17846 // tuning db
17847
17848 tuning_db_destroy (tuning_db);
17849
17850 // loopback
17851
17852 local_free (loopback_file);
17853
17854 if (loopback == 1) unlink (loopback_file);
17855
17856 // induction directory
17857
17858 if (induction_dir == NULL)
17859 {
17860 if (attack_mode != ATTACK_MODE_BF)
17861 {
17862 if (rmdir (induction_directory) == -1)
17863 {
17864 if (errno == ENOENT)
17865 {
17866 // good, we can ignore
17867 }
17868 else if (errno == ENOTEMPTY)
17869 {
17870 // good, we can ignore
17871 }
17872 else
17873 {
17874 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17875
17876 return (-1);
17877 }
17878 }
17879
17880 local_free (induction_directory);
17881 }
17882 }
17883
17884 // outfile-check directory
17885
17886 if (outfile_check_dir == NULL)
17887 {
17888 if (rmdir (outfile_check_directory) == -1)
17889 {
17890 if (errno == ENOENT)
17891 {
17892 // good, we can ignore
17893 }
17894 else if (errno == ENOTEMPTY)
17895 {
17896 // good, we can ignore
17897 }
17898 else
17899 {
17900 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17901
17902 return (-1);
17903 }
17904 }
17905
17906 local_free (outfile_check_directory);
17907 }
17908
17909 time_t proc_stop;
17910
17911 time (&proc_stop);
17912
17913 logfile_top_uint (proc_start);
17914 logfile_top_uint (proc_stop);
17915
17916 logfile_top_msg ("STOP");
17917
17918 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17919 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17920
17921 if (data.ocl) ocl_close (data.ocl);
17922
17923 if (data.devices_status == STATUS_ABORTED) return 2;
17924 if (data.devices_status == STATUS_QUIT) return 2;
17925 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17926 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17927 if (data.devices_status == STATUS_CRACKED) return 0;
17928
17929 return -1;
17930 }
Hashcat additions to support pwdhash