projects / hashcat.git / blob
? search:


41c70d0cf284da27f6c64793123a05a316faff39
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2613 {
2614 int rc = -1;
2615
2616 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2617 {
2618 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2619
2620 const cl_uchar zero = 0;
2621
2622 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2623 }
2624
2625 if (rc != 0)
2626 {
2627 // NOTE: clEnqueueFillBuffer () always fails with -59
2628 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2629 // How's that possible, OpenCL 1.2 support is advertised??
2630 // We need to workaround...
2631
2632 #define FILLSZ 0x100000
2633
2634 char *tmp = (char *) mymalloc (FILLSZ);
2635
2636 for (size_t i = 0; i < size; i += FILLSZ)
2637 {
2638 const size_t left = size - i;
2639
2640 const size_t fillsz = MIN (FILLSZ, left);
2641
2642 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2643 }
2644
2645 myfree (tmp);
2646 }
2647 }
2648
2649 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2650 {
2651 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2652 {
2653 if (attack_mode == ATTACK_MODE_BF)
2654 {
2655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2656 {
2657 const uint size_tm = 32 * sizeof (bs_word_t);
2658
2659 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2660
2661 run_kernel_tm (device_param);
2662
2663 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2664 }
2665 }
2666
2667 if (highest_pw_len < 16)
2668 {
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2670 }
2671 else if (highest_pw_len < 32)
2672 {
2673 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2674 }
2675 else
2676 {
2677 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2678 }
2679 }
2680 else
2681 {
2682 run_kernel_amp (device_param, pws_cnt);
2683
2684 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2685
2686 if (opts_type & OPTS_TYPE_HOOK12)
2687 {
2688 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2689 }
2690
2691 uint iter = salt_buf->salt_iter;
2692
2693 uint loop_step = device_param->kernel_loops;
2694
2695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2696 {
2697 uint loop_left = iter - loop_pos;
2698
2699 loop_left = MIN (loop_left, loop_step);
2700
2701 device_param->kernel_params_buf32[25] = loop_pos;
2702 device_param->kernel_params_buf32[26] = loop_left;
2703
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705
2706 if (data.devices_status == STATUS_CRACKED) break;
2707 if (data.devices_status == STATUS_ABORTED) break;
2708 if (data.devices_status == STATUS_QUIT) break;
2709
2710 /**
2711 * speed
2712 */
2713
2714 const float iter_part = (float) (loop_pos + loop_left) / iter;
2715
2716 const u64 perf_sum_all = pws_cnt * iter_part;
2717
2718 double speed_ms;
2719
2720 hc_timer_get (device_param->timer_speed, speed_ms);
2721
2722 const u32 speed_pos = device_param->speed_pos;
2723
2724 device_param->speed_cnt[speed_pos] = perf_sum_all;
2725
2726 device_param->speed_ms[speed_pos] = speed_ms;
2727
2728 if (data.benchmark == 1)
2729 {
2730 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2731 }
2732 }
2733
2734 if (opts_type & OPTS_TYPE_HOOK23)
2735 {
2736 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2737
2738 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2739
2740 // do something with data
2741
2742 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2743 }
2744
2745 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2746 }
2747 }
2748
2749 static int run_rule_engine (const int rule_len, const char *rule_buf)
2750 {
2751 if (rule_len == 0)
2752 {
2753 return 0;
2754 }
2755 else if (rule_len == 1)
2756 {
2757 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2758 }
2759
2760 return 1;
2761 }
2762
2763 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2764 {
2765 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2766 {
2767 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_COMBI)
2770 {
2771 if (data.attack_mode == ATTACK_MODE_COMBI)
2772 {
2773 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2774 {
2775 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2776 {
2777 for (u32 i = 0; i < pws_cnt; i++)
2778 {
2779 const u32 pw_len = device_param->pws_buf[i].pw_len;
2780
2781 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2782
2783 ptr[pw_len] = 0x01;
2784 }
2785 }
2786 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2787 {
2788 for (u32 i = 0; i < pws_cnt; i++)
2789 {
2790 const u32 pw_len = device_param->pws_buf[i].pw_len;
2791
2792 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2793
2794 ptr[pw_len] = 0x80;
2795 }
2796 }
2797 }
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x01;
2810 }
2811 }
2812 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x80;
2821 }
2822 }
2823 }
2824
2825 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2826 }
2827 else if (data.attack_kern == ATTACK_KERN_BF)
2828 {
2829 const u64 off = device_param->words_off;
2830
2831 device_param->kernel_params_mp_l_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2834 }
2835 }
2836
2837 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2838 {
2839 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2840
2841 device_param->kernel_params_buf32[25] = 0;
2842 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2843 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2844
2845 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2846 {
2847 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2848 }
2849 else
2850 {
2851 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2852 }
2853
2854 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2855
2856 return exec_ms_prev;
2857 }
2858
2859 static void autotune (hc_device_param_t *device_param)
2860 {
2861 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2862
2863 const u32 kernel_accel_min = device_param->kernel_accel_min;
2864 const u32 kernel_accel_max = device_param->kernel_accel_max;
2865
2866 const u32 kernel_loops_min = device_param->kernel_loops_min;
2867 const u32 kernel_loops_max = device_param->kernel_loops_max;
2868
2869 u32 kernel_accel = kernel_accel_min;
2870 u32 kernel_loops = kernel_loops_min;
2871
2872 // in this case the user specified a fixed -u and -n on the commandline
2873 // no way to tune anything
2874 // but we need to run a few caching rounds
2875
2876 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2877 {
2878 try_run (device_param, kernel_accel, kernel_loops);
2879 try_run (device_param, kernel_accel, kernel_loops);
2880 try_run (device_param, kernel_accel, kernel_loops);
2881 try_run (device_param, kernel_accel, kernel_loops);
2882
2883 device_param->kernel_accel = kernel_accel;
2884 device_param->kernel_loops = kernel_loops;
2885
2886 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2887
2888 device_param->kernel_power = kernel_power;
2889
2890 return;
2891 }
2892
2893 // from here it's clear we are allowed to autotune
2894 // so let's init some fake words
2895
2896 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].i[0] = i;
2901 device_param->pws_buf[i].i[1] = 0x01234567;
2902 device_param->pws_buf[i].pw_len = 7;
2903 }
2904
2905 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2906
2907 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2908 {
2909 run_kernel_amp (device_param, kernel_power_max);
2910 }
2911
2912 #define VERIFIER_CNT 1
2913
2914 // first find out highest kernel-loops that stays below target_ms
2915
2916 if (kernel_loops_min < kernel_loops_max)
2917 {
2918 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2919 {
2920 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2921
2922 for (int i = 0; i < VERIFIER_CNT; i++)
2923 {
2924 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2925
2926 exec_ms = MIN (exec_ms, exec_ms_v);
2927 }
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931 }
2932
2933 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2934
2935 #define STEPS_CNT 10
2936
2937 if (kernel_accel_min < kernel_accel_max)
2938 {
2939 for (int i = 0; i < STEPS_CNT; i++)
2940 {
2941 const u32 kernel_accel_try = 1 << i;
2942
2943 if (kernel_accel_try < kernel_accel_min) continue;
2944 if (kernel_accel_try > kernel_accel_max) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms > target_ms) break;
2956
2957 kernel_accel = kernel_accel_try;
2958 }
2959 }
2960
2961 // at this point we want to know the actual runtime for the following reason:
2962 // we need a reference for the balancing loop following up, and this
2963 // the balancing loop can have an effect that the creates a new opportunity, for example:
2964 // if the target is 95 ms and the current runtime is 48ms the above loop
2965 // stopped the execution because the previous exec_ms was > 95ms
2966 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2967 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2968
2969 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2970
2971 for (int i = 0; i < VERIFIER_CNT; i++)
2972 {
2973 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2974
2975 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2976 }
2977
2978 u32 diff = kernel_loops - kernel_accel;
2979
2980 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2981 {
2982 for (u32 f = 2; f < 1024; f++)
2983 {
2984 const u32 kernel_accel_try = kernel_accel * f;
2985 const u32 kernel_loops_try = kernel_loops / f;
2986
2987 if (kernel_accel_try > kernel_accel_max) break;
2988 if (kernel_loops_try < kernel_loops_min) break;
2989
2990 u32 diff_new = kernel_loops_try - kernel_accel_try;
2991
2992 if (diff_new > diff) break;
2993
2994 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2995
2996 for (int i = 0; i < VERIFIER_CNT; i++)
2997 {
2998 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2999
3000 exec_ms = MIN (exec_ms, exec_ms_v);
3001 }
3002
3003 if (exec_ms < exec_ms_pre_final)
3004 {
3005 exec_ms_pre_final = exec_ms;
3006
3007 kernel_accel = kernel_accel_try;
3008 kernel_loops = kernel_loops_try;
3009 }
3010 }
3011 }
3012
3013 const double exec_left = target_ms / exec_ms_pre_final;
3014
3015 const double accel_left = kernel_accel_max / kernel_accel;
3016
3017 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3018
3019 if (exec_accel_min >= 1.0)
3020 {
3021 // this is safe to not overflow kernel_accel_max because of accel_left
3022
3023 kernel_accel = (double) kernel_accel * exec_accel_min;
3024 }
3025
3026 // reset them fake words
3027
3028 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3029
3030 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);
3031 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);
3032
3033 // reset timer
3034
3035 device_param->exec_pos = 0;
3036
3037 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3038
3039 // store
3040
3041 device_param->kernel_accel = kernel_accel;
3042 device_param->kernel_loops = kernel_loops;
3043
3044 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3045
3046 device_param->kernel_power = kernel_power;
3047
3048 #ifdef DEBUG
3049
3050 if (data.quiet == 0)
3051 {
3052 clear_prompt ();
3053
3054 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3055 "Device #%u: autotuned kernel-loops to %u\n",
3056 device_param->device_id + 1, kernel_accel,
3057 device_param->device_id + 1, kernel_loops);
3058
3059 fprintf (stdout, "%s", PROMPT);
3060
3061 fflush (stdout);
3062 }
3063
3064 #endif
3065 }
3066
3067 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3068 {
3069 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3070
3071 // init speed timer
3072
3073 uint speed_pos = device_param->speed_pos;
3074
3075 #ifdef _POSIX
3076 if (device_param->timer_speed.tv_sec == 0)
3077 {
3078 hc_timer_set (&device_param->timer_speed);
3079 }
3080 #endif
3081
3082 #ifdef _WIN
3083 if (device_param->timer_speed.QuadPart == 0)
3084 {
3085 hc_timer_set (&device_param->timer_speed);
3086 }
3087 #endif
3088
3089 // find higest password length, this is for optimization stuff
3090
3091 uint highest_pw_len = 0;
3092
3093 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3094 {
3095 }
3096 else if (data.attack_kern == ATTACK_KERN_COMBI)
3097 {
3098 }
3099 else if (data.attack_kern == ATTACK_KERN_BF)
3100 {
3101 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3102 + device_param->kernel_params_mp_l_buf32[5];
3103 }
3104
3105 // iteration type
3106
3107 uint innerloop_step = 0;
3108 uint innerloop_cnt = 0;
3109
3110 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3111 else innerloop_step = 1;
3112
3113 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3114 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3115 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3116
3117 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3118
3119 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3120 {
3121 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3122
3123 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3124
3125 if (data.devices_status == STATUS_CRACKED) break;
3126 if (data.devices_status == STATUS_ABORTED) break;
3127 if (data.devices_status == STATUS_QUIT) break;
3128 if (data.devices_status == STATUS_BYPASS) break;
3129
3130 salt_t *salt_buf = &data.salts_buf[salt_pos];
3131
3132 device_param->kernel_params_buf32[24] = salt_pos;
3133 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3134 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3135
3136 FILE *combs_fp = device_param->combs_fp;
3137
3138 if (data.attack_mode == ATTACK_MODE_COMBI)
3139 {
3140 rewind (combs_fp);
3141 }
3142
3143 // innerloops
3144
3145 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3146 {
3147 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3148
3149 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3150
3151 if (data.devices_status == STATUS_CRACKED) break;
3152 if (data.devices_status == STATUS_ABORTED) break;
3153 if (data.devices_status == STATUS_QUIT) break;
3154 if (data.devices_status == STATUS_BYPASS) break;
3155
3156 uint innerloop_left = innerloop_cnt - innerloop_pos;
3157
3158 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3159
3160 device_param->innerloop_pos = innerloop_pos;
3161 device_param->innerloop_left = innerloop_left;
3162
3163 device_param->kernel_params_buf32[27] = innerloop_left;
3164
3165 // i think we can get rid of this
3166 if (innerloop_left == 0)
3167 {
3168 puts ("bug, how should this happen????\n");
3169
3170 continue;
3171 }
3172
3173 if (data.salts_shown[salt_pos] == 1)
3174 {
3175 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3176
3177 continue;
3178 }
3179
3180 // initialize amplifiers
3181
3182 if (data.attack_mode == ATTACK_MODE_COMBI)
3183 {
3184 uint i = 0;
3185
3186 while (i < innerloop_left)
3187 {
3188 if (feof (combs_fp)) break;
3189
3190 int line_len = fgetl (combs_fp, line_buf);
3191
3192 if (line_len >= PW_MAX1) continue;
3193
3194 line_len = convert_from_hex (line_buf, line_len);
3195
3196 char *line_buf_new = line_buf;
3197
3198 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3199 {
3200 char rule_buf_out[BLOCK_SIZE] = { 0 };
3201
3202 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3203
3204 if (rule_len_out < 0)
3205 {
3206 data.words_progress_rejected[salt_pos] += pws_cnt;
3207
3208 continue;
3209 }
3210
3211 line_len = rule_len_out;
3212
3213 line_buf_new = rule_buf_out;
3214 }
3215
3216 line_len = MIN (line_len, PW_DICTMAX);
3217
3218 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3219
3220 memcpy (ptr, line_buf_new, line_len);
3221
3222 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3223
3224 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3225 {
3226 uppercase (ptr, line_len);
3227 }
3228
3229 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3230 {
3231 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3232 {
3233 ptr[line_len] = 0x80;
3234 }
3235
3236 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3237 {
3238 ptr[line_len] = 0x01;
3239 }
3240 }
3241
3242 device_param->combs_buf[i].pw_len = line_len;
3243
3244 i++;
3245 }
3246
3247 for (uint j = i; j < innerloop_left; j++)
3248 {
3249 device_param->combs_buf[j].i[0] = 0;
3250 device_param->combs_buf[j].i[1] = 0;
3251 device_param->combs_buf[j].i[2] = 0;
3252 device_param->combs_buf[j].i[3] = 0;
3253 device_param->combs_buf[j].i[4] = 0;
3254 device_param->combs_buf[j].i[5] = 0;
3255 device_param->combs_buf[j].i[6] = 0;
3256 device_param->combs_buf[j].i[7] = 0;
3257
3258 device_param->combs_buf[j].pw_len = 0;
3259 }
3260
3261 innerloop_left = i;
3262 }
3263 else if (data.attack_mode == ATTACK_MODE_BF)
3264 {
3265 u64 off = innerloop_pos;
3266
3267 device_param->kernel_params_mp_r_buf64[3] = off;
3268
3269 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3270 }
3271 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3272 {
3273 u64 off = innerloop_pos;
3274
3275 device_param->kernel_params_mp_buf64[3] = off;
3276
3277 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3278 }
3279 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3280 {
3281 u64 off = innerloop_pos;
3282
3283 device_param->kernel_params_mp_buf64[3] = off;
3284
3285 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3286 }
3287
3288 // copy amplifiers
3289
3290 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3291 {
3292 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);
3293 }
3294 else if (data.attack_mode == ATTACK_MODE_COMBI)
3295 {
3296 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);
3297 }
3298 else if (data.attack_mode == ATTACK_MODE_BF)
3299 {
3300 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);
3301 }
3302 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3303 {
3304 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);
3305 }
3306 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3307 {
3308 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);
3309 }
3310
3311 if (data.benchmark == 1)
3312 {
3313 hc_timer_set (&device_param->timer_speed);
3314 }
3315
3316 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3317
3318 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3319
3320 if (data.devices_status == STATUS_CRACKED) break;
3321 if (data.devices_status == STATUS_ABORTED) break;
3322 if (data.devices_status == STATUS_QUIT) break;
3323
3324 /**
3325 * result
3326 */
3327
3328 check_cracked (device_param, salt_pos);
3329
3330 /**
3331 * progress
3332 */
3333
3334 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3335
3336 hc_thread_mutex_lock (mux_counter);
3337
3338 data.words_progress_done[salt_pos] += perf_sum_all;
3339
3340 hc_thread_mutex_unlock (mux_counter);
3341
3342 /**
3343 * speed
3344 */
3345
3346 double speed_ms;
3347
3348 hc_timer_get (device_param->timer_speed, speed_ms);
3349
3350 hc_timer_set (&device_param->timer_speed);
3351
3352 // current speed
3353
3354 //hc_thread_mutex_lock (mux_display);
3355
3356 device_param->speed_cnt[speed_pos] = perf_sum_all;
3357
3358 device_param->speed_ms[speed_pos] = speed_ms;
3359
3360 //hc_thread_mutex_unlock (mux_display);
3361
3362 speed_pos++;
3363
3364 if (speed_pos == SPEED_CACHE)
3365 {
3366 speed_pos = 0;
3367 }
3368
3369 /**
3370 * benchmark
3371 */
3372
3373 if (data.benchmark == 1) break;
3374 }
3375 }
3376
3377 device_param->speed_pos = speed_pos;
3378
3379 myfree (line_buf);
3380 }
3381
3382 static void load_segment (wl_data_t *wl_data, FILE *fd)
3383 {
3384 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3385
3386 wl_data->pos = 0;
3387
3388 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3389
3390 wl_data->buf[wl_data->cnt] = 0;
3391
3392 if (wl_data->cnt == 0) return;
3393
3394 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3395
3396 while (!feof (fd))
3397 {
3398 if (wl_data->cnt == wl_data->avail)
3399 {
3400 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3401
3402 wl_data->avail += wl_data->incr;
3403 }
3404
3405 const int c = fgetc (fd);
3406
3407 if (c == EOF) break;
3408
3409 wl_data->buf[wl_data->cnt] = (char) c;
3410
3411 wl_data->cnt++;
3412
3413 if (c == '\n') break;
3414 }
3415
3416 // ensure stream ends with a newline
3417
3418 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3419 {
3420 wl_data->cnt++;
3421
3422 wl_data->buf[wl_data->cnt - 1] = '\n';
3423 }
3424
3425 return;
3426 }
3427
3428 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3429 {
3430 char *ptr = buf;
3431
3432 for (u32 i = 0; i < sz; i++, ptr++)
3433 {
3434 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3435
3436 if (i == 7)
3437 {
3438 *off = i;
3439 *len = i;
3440
3441 return;
3442 }
3443
3444 if (*ptr != '\n') continue;
3445
3446 *off = i + 1;
3447
3448 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3449
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 *off = sz;
3456 *len = sz;
3457 }
3458
3459 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3460 {
3461 char *ptr = buf;
3462
3463 for (u32 i = 0; i < sz; i++, ptr++)
3464 {
3465 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3466
3467 if (*ptr != '\n') continue;
3468
3469 *off = i + 1;
3470
3471 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3472
3473 *len = i;
3474
3475 return;
3476 }
3477
3478 *off = sz;
3479 *len = sz;
3480 }
3481
3482 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3483 {
3484 char *ptr = buf;
3485
3486 for (u32 i = 0; i < sz; i++, ptr++)
3487 {
3488 if (*ptr != '\n') continue;
3489
3490 *off = i + 1;
3491
3492 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3493
3494 *len = i;
3495
3496 return;
3497 }
3498
3499 *off = sz;
3500 *len = sz;
3501 }
3502
3503 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3504 {
3505 while (wl_data->pos < wl_data->cnt)
3506 {
3507 uint off;
3508 uint len;
3509
3510 char *ptr = wl_data->buf + wl_data->pos;
3511
3512 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3513
3514 wl_data->pos += off;
3515
3516 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3517 {
3518 char rule_buf_out[BLOCK_SIZE] = { 0 };
3519
3520 int rule_len_out = -1;
3521
3522 if (len < BLOCK_SIZE)
3523 {
3524 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3525 }
3526
3527 if (rule_len_out < 0)
3528 {
3529 continue;
3530 }
3531
3532 if (rule_len_out > PW_MAX)
3533 {
3534 continue;
3535 }
3536 }
3537 else
3538 {
3539 if (len > PW_MAX)
3540 {
3541 continue;
3542 }
3543 }
3544
3545 *out_buf = ptr;
3546 *out_len = len;
3547
3548 return;
3549 }
3550
3551 if (feof (fd))
3552 {
3553 fprintf (stderr, "BUG feof()!!\n");
3554
3555 return;
3556 }
3557
3558 load_segment (wl_data, fd);
3559
3560 get_next_word (wl_data, fd, out_buf, out_len);
3561 }
3562
3563 #ifdef _POSIX
3564 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3565 #endif
3566
3567 #ifdef _WIN
3568 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3569 #endif
3570 {
3571 hc_signal (NULL);
3572
3573 dictstat_t d;
3574
3575 d.cnt = 0;
3576
3577 #ifdef _POSIX
3578 fstat (fileno (fd), &d.stat);
3579 #endif
3580
3581 #ifdef _WIN
3582 _fstat64 (fileno (fd), &d.stat);
3583 #endif
3584
3585 d.stat.st_mode = 0;
3586 d.stat.st_nlink = 0;
3587 d.stat.st_uid = 0;
3588 d.stat.st_gid = 0;
3589 d.stat.st_rdev = 0;
3590 d.stat.st_atime = 0;
3591
3592 #ifdef _POSIX
3593 d.stat.st_blksize = 0;
3594 d.stat.st_blocks = 0;
3595 #endif
3596
3597 if (d.stat.st_size == 0) return 0;
3598
3599 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3600
3601 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3602 {
3603 if (d_cache)
3604 {
3605 u64 cnt = d_cache->cnt;
3606
3607 u64 keyspace = cnt;
3608
3609 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3610 {
3611 keyspace *= data.kernel_rules_cnt;
3612 }
3613 else if (data.attack_kern == ATTACK_KERN_COMBI)
3614 {
3615 keyspace *= data.combs_cnt;
3616 }
3617
3618 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);
3619 if (data.quiet == 0) log_info ("");
3620
3621 hc_signal (sigHandler_default);
3622
3623 return (keyspace);
3624 }
3625 }
3626
3627 time_t now = 0;
3628 time_t prev = 0;
3629
3630 u64 comp = 0;
3631 u64 cnt = 0;
3632 u64 cnt2 = 0;
3633
3634 while (!feof (fd))
3635 {
3636 load_segment (wl_data, fd);
3637
3638 comp += wl_data->cnt;
3639
3640 u32 i = 0;
3641
3642 while (i < wl_data->cnt)
3643 {
3644 u32 len;
3645 u32 off;
3646
3647 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3648
3649 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3650 {
3651 char rule_buf_out[BLOCK_SIZE] = { 0 };
3652
3653 int rule_len_out = -1;
3654
3655 if (len < BLOCK_SIZE)
3656 {
3657 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3658 }
3659
3660 if (rule_len_out < 0)
3661 {
3662 len = PW_MAX1;
3663 }
3664 else
3665 {
3666 len = rule_len_out;
3667 }
3668 }
3669
3670 if (len < PW_MAX1)
3671 {
3672 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3673 {
3674 cnt += data.kernel_rules_cnt;
3675 }
3676 else if (data.attack_kern == ATTACK_KERN_COMBI)
3677 {
3678 cnt += data.combs_cnt;
3679 }
3680
3681 d.cnt++;
3682 }
3683
3684 i += off;
3685
3686 cnt2++;
3687 }
3688
3689 time (&now);
3690
3691 if ((now - prev) == 0) continue;
3692
3693 float percent = (float) comp / (float) d.stat.st_size;
3694
3695 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);
3696
3697 time (&prev);
3698 }
3699
3700 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);
3701 if (data.quiet == 0) log_info ("");
3702
3703 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3704
3705 hc_signal (sigHandler_default);
3706
3707 return (cnt);
3708 }
3709
3710 static void *thread_monitor (void *p)
3711 {
3712 uint runtime_check = 0;
3713 uint remove_check = 0;
3714 uint status_check = 0;
3715 uint restore_check = 0;
3716
3717 uint restore_left = data.restore_timer;
3718 uint remove_left = data.remove_timer;
3719 uint status_left = data.status_timer;
3720
3721 #ifdef HAVE_HWMON
3722 uint hwmon_check = 0;
3723
3724 // these variables are mainly used for fan control (AMD only)
3725
3726 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3727
3728 // temperature controller "loopback" values
3729
3730 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3731 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3732
3733 #ifdef HAVE_ADL
3734 int temp_threshold = 1; // degrees celcius
3735
3736 int fan_speed_min = 15; // in percentage
3737 int fan_speed_max = 100;
3738 #endif // HAVE_ADL
3739
3740 time_t last_temp_check_time;
3741 #endif // HAVE_HWMON
3742
3743 uint sleep_time = 1;
3744
3745 if (data.runtime)
3746 {
3747 runtime_check = 1;
3748 }
3749
3750 if (data.restore_timer)
3751 {
3752 restore_check = 1;
3753 }
3754
3755 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3756 {
3757 remove_check = 1;
3758 }
3759
3760 if (data.status == 1)
3761 {
3762 status_check = 1;
3763 }
3764
3765 #ifdef HAVE_HWMON
3766 if (data.gpu_temp_disable == 0)
3767 {
3768 time (&last_temp_check_time);
3769
3770 hwmon_check = 1;
3771 }
3772 #endif
3773
3774 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3775 {
3776 #ifdef HAVE_HWMON
3777 if (hwmon_check == 0)
3778 #endif
3779 return (p);
3780 }
3781
3782 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3783 {
3784 hc_sleep (sleep_time);
3785
3786 if (data.devices_status != STATUS_RUNNING) continue;
3787
3788 #ifdef HAVE_HWMON
3789 if (hwmon_check == 1)
3790 {
3791 hc_thread_mutex_lock (mux_adl);
3792
3793 time_t temp_check_time;
3794
3795 time (&temp_check_time);
3796
3797 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3798
3799 if (Ta == 0) Ta = 1;
3800
3801 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3802 {
3803 hc_device_param_t *device_param = &data.devices_param[device_id];
3804
3805 if (device_param->skipped) continue;
3806
3807 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3808
3809 const int temperature = hm_get_temperature_with_device_id (device_id);
3810
3811 if (temperature > (int) data.gpu_temp_abort)
3812 {
3813 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3814
3815 if (data.devices_status != STATUS_QUIT) myabort ();
3816
3817 break;
3818 }
3819
3820 #ifdef HAVE_ADL
3821 const int gpu_temp_retain = data.gpu_temp_retain;
3822
3823 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3824 {
3825 if (data.hm_device[device_id].fan_supported == 1)
3826 {
3827 int temp_cur = temperature;
3828
3829 int temp_diff_new = gpu_temp_retain - temp_cur;
3830
3831 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3832
3833 // calculate Ta value (time difference in seconds between the last check and this check)
3834
3835 last_temp_check_time = temp_check_time;
3836
3837 float Kp = 1.8;
3838 float Ki = 0.005;
3839 float Kd = 6;
3840
3841 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3842
3843 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);
3844
3845 if (abs (fan_diff_required) >= temp_threshold)
3846 {
3847 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3848
3849 int fan_speed_level = fan_speed_cur;
3850
3851 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3852
3853 int fan_speed_new = fan_speed_level - fan_diff_required;
3854
3855 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3856 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3857
3858 if (fan_speed_new != fan_speed_cur)
3859 {
3860 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3861 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3862
3863 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3864 {
3865 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3866
3867 fan_speed_chgd[device_id] = 1;
3868 }
3869
3870 temp_diff_old[device_id] = temp_diff_new;
3871 }
3872 }
3873 }
3874 }
3875 #endif // HAVE_ADL
3876 }
3877
3878 hc_thread_mutex_unlock (mux_adl);
3879 }
3880 #endif // HAVE_HWMON
3881
3882 if (restore_check == 1)
3883 {
3884 restore_left--;
3885
3886 if (restore_left == 0)
3887 {
3888 if (data.restore_disable == 0) cycle_restore ();
3889
3890 restore_left = data.restore_timer;
3891 }
3892 }
3893
3894 if ((runtime_check == 1) && (data.runtime_start > 0))
3895 {
3896 time_t runtime_cur;
3897
3898 time (&runtime_cur);
3899
3900 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3901
3902 if (runtime_left <= 0)
3903 {
3904 if (data.benchmark == 0)
3905 {
3906 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3907 }
3908
3909 if (data.devices_status != STATUS_QUIT) myabort ();
3910 }
3911 }
3912
3913 if (remove_check == 1)
3914 {
3915 remove_left--;
3916
3917 if (remove_left == 0)
3918 {
3919 if (data.digests_saved != data.digests_done)
3920 {
3921 data.digests_saved = data.digests_done;
3922
3923 save_hash ();
3924 }
3925
3926 remove_left = data.remove_timer;
3927 }
3928 }
3929
3930 if (status_check == 1)
3931 {
3932 status_left--;
3933
3934 if (status_left == 0)
3935 {
3936 //hc_thread_mutex_lock (mux_display);
3937
3938 if (data.quiet == 0) clear_prompt ();
3939
3940 if (data.quiet == 0) log_info ("");
3941
3942 status_display ();
3943
3944 if (data.quiet == 0) log_info ("");
3945
3946 //hc_thread_mutex_unlock (mux_display);
3947
3948 status_left = data.status_timer;
3949 }
3950 }
3951 }
3952
3953 #ifdef HAVE_HWMON
3954 myfree (fan_speed_chgd);
3955
3956 myfree (temp_diff_old);
3957 myfree (temp_diff_sum);
3958 #endif
3959
3960 p = NULL;
3961
3962 return (p);
3963 }
3964
3965 static void *thread_outfile_remove (void *p)
3966 {
3967 // some hash-dependent constants
3968 char *outfile_dir = data.outfile_check_directory;
3969 uint dgst_size = data.dgst_size;
3970 uint isSalted = data.isSalted;
3971 uint esalt_size = data.esalt_size;
3972 uint hash_mode = data.hash_mode;
3973
3974 uint outfile_check_timer = data.outfile_check_timer;
3975
3976 char separator = data.separator;
3977
3978 // some hash-dependent functions
3979 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3980 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3981
3982 // buffers
3983 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3984
3985 hash_buf.digest = mymalloc (dgst_size);
3986
3987 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3988
3989 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3990
3991 uint digest_buf[64] = { 0 };
3992
3993 outfile_data_t *out_info = NULL;
3994
3995 char **out_files = NULL;
3996
3997 time_t folder_mtime = 0;
3998
3999 int out_cnt = 0;
4000
4001 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4002
4003 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4004 {
4005 hc_sleep (1);
4006
4007 if (data.devices_status != STATUS_RUNNING) continue;
4008
4009 check_left--;
4010
4011 if (check_left == 0)
4012 {
4013 struct stat outfile_check_stat;
4014
4015 if (stat (outfile_dir, &outfile_check_stat) == 0)
4016 {
4017 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4018
4019 if (is_dir == 1)
4020 {
4021 if (outfile_check_stat.st_mtime > folder_mtime)
4022 {
4023 char **out_files_new = scan_directory (outfile_dir);
4024
4025 int out_cnt_new = count_dictionaries (out_files_new);
4026
4027 outfile_data_t *out_info_new = NULL;
4028
4029 if (out_cnt_new > 0)
4030 {
4031 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4032
4033 for (int i = 0; i < out_cnt_new; i++)
4034 {
4035 out_info_new[i].file_name = out_files_new[i];
4036
4037 // check if there are files that we have seen/checked before (and not changed)
4038
4039 for (int j = 0; j < out_cnt; j++)
4040 {
4041 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4042 {
4043 struct stat outfile_stat;
4044
4045 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4046 {
4047 if (outfile_stat.st_ctime == out_info[j].ctime)
4048 {
4049 out_info_new[i].ctime = out_info[j].ctime;
4050 out_info_new[i].seek = out_info[j].seek;
4051 }
4052 }
4053 }
4054 }
4055 }
4056 }
4057
4058 local_free (out_info);
4059 local_free (out_files);
4060
4061 out_files = out_files_new;
4062 out_cnt = out_cnt_new;
4063 out_info = out_info_new;
4064
4065 folder_mtime = outfile_check_stat.st_mtime;
4066 }
4067
4068 for (int j = 0; j < out_cnt; j++)
4069 {
4070 FILE *fp = fopen (out_info[j].file_name, "rb");
4071
4072 if (fp != NULL)
4073 {
4074 //hc_thread_mutex_lock (mux_display);
4075
4076 #ifdef _POSIX
4077 struct stat outfile_stat;
4078
4079 fstat (fileno (fp), &outfile_stat);
4080 #endif
4081
4082 #ifdef _WIN
4083 struct stat64 outfile_stat;
4084
4085 _fstat64 (fileno (fp), &outfile_stat);
4086 #endif
4087
4088 if (outfile_stat.st_ctime > out_info[j].ctime)
4089 {
4090 out_info[j].ctime = outfile_stat.st_ctime;
4091 out_info[j].seek = 0;
4092 }
4093
4094 fseek (fp, out_info[j].seek, SEEK_SET);
4095
4096 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4097
4098 while (!feof (fp))
4099 {
4100 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4101
4102 if (ptr == NULL) break;
4103
4104 int line_len = strlen (line_buf);
4105
4106 if (line_len <= 0) continue;
4107
4108 int iter = MAX_CUT_TRIES;
4109
4110 for (uint i = line_len - 1; i && iter; i--, line_len--)
4111 {
4112 if (line_buf[i] != separator) continue;
4113
4114 int parser_status = PARSER_OK;
4115
4116 if ((hash_mode != 2500) && (hash_mode != 6800))
4117 {
4118 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4119 }
4120
4121 uint found = 0;
4122
4123 if (parser_status == PARSER_OK)
4124 {
4125 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4126 {
4127 if (data.salts_shown[salt_pos] == 1) continue;
4128
4129 salt_t *salt_buf = &data.salts_buf[salt_pos];
4130
4131 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4132 {
4133 uint idx = salt_buf->digests_offset + digest_pos;
4134
4135 if (data.digests_shown[idx] == 1) continue;
4136
4137 uint cracked = 0;
4138
4139 if (hash_mode == 6800)
4140 {
4141 if (i == salt_buf->salt_len)
4142 {
4143 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4144 }
4145 }
4146 else if (hash_mode == 2500)
4147 {
4148 // BSSID : MAC1 : MAC2 (:plain)
4149 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4150 {
4151 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4152
4153 if (!cracked) continue;
4154
4155 // now compare MAC1 and MAC2 too, since we have this additional info
4156 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4157 char *mac2_pos = mac1_pos + 12 + 1;
4158
4159 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4160 wpa_t *wpa = &wpas[salt_pos];
4161
4162 // compare hex string(s) vs binary MAC address(es)
4163
4164 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4165 {
4166 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4167 {
4168 cracked = 0;
4169
4170 break;
4171 }
4172 }
4173
4174 // early skip ;)
4175 if (!cracked) continue;
4176
4177 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4178 {
4179 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4180 {
4181 cracked = 0;
4182
4183 break;
4184 }
4185 }
4186 }
4187 }
4188 else
4189 {
4190 char *digests_buf_ptr = (char *) data.digests_buf;
4191
4192 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4193
4194 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4195 }
4196
4197 if (cracked == 1)
4198 {
4199 found = 1;
4200
4201 data.digests_shown[idx] = 1;
4202
4203 data.digests_done++;
4204
4205 salt_buf->digests_done++;
4206
4207 if (salt_buf->digests_done == salt_buf->digests_cnt)
4208 {
4209 data.salts_shown[salt_pos] = 1;
4210
4211 data.salts_done++;
4212
4213 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4214 }
4215 }
4216 }
4217
4218 if (data.devices_status == STATUS_CRACKED) break;
4219 }
4220 }
4221
4222 if (found) break;
4223
4224 if (data.devices_status == STATUS_CRACKED) break;
4225
4226 iter--;
4227 }
4228
4229 if (data.devices_status == STATUS_CRACKED) break;
4230 }
4231
4232 myfree (line_buf);
4233
4234 out_info[j].seek = ftell (fp);
4235
4236 //hc_thread_mutex_unlock (mux_display);
4237
4238 fclose (fp);
4239 }
4240 }
4241 }
4242 }
4243
4244 check_left = outfile_check_timer;
4245 }
4246 }
4247
4248 if (esalt_size) local_free (hash_buf.esalt);
4249
4250 if (isSalted) local_free (hash_buf.salt);
4251
4252 local_free (hash_buf.digest);
4253
4254 local_free (out_info);
4255
4256 local_free (out_files);
4257
4258 p = NULL;
4259
4260 return (p);
4261 }
4262
4263 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4264 {
4265 if (device_param->pws_cnt < device_param->kernel_power)
4266 {
4267 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4268
4269 u8 *ptr = (u8 *) pw->i;
4270
4271 memcpy (ptr, pw_buf, pw_len);
4272
4273 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4274
4275 pw->pw_len = pw_len;
4276
4277 device_param->pws_cnt++;
4278 }
4279 else
4280 {
4281 fprintf (stderr, "BUG pw_add()!!\n");
4282
4283 return;
4284 }
4285 }
4286
4287 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4288 {
4289 hc_thread_mutex_lock (mux_dispatcher);
4290
4291 const u64 words_cur = data.words_cur;
4292 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4293
4294 device_param->words_off = words_cur;
4295
4296 const u64 words_left = words_base - words_cur;
4297
4298 if (allow_div)
4299 {
4300 if (data.kernel_power_all > words_left)
4301 {
4302 if (data.kernel_power_div == 0)
4303 {
4304 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4305 }
4306 }
4307
4308 if (data.kernel_power_div)
4309 {
4310 if (device_param->kernel_power == device_param->kernel_power_user)
4311 {
4312 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4313
4314 if (kernel_power_new < device_param->kernel_power)
4315 {
4316 device_param->kernel_power = kernel_power_new;
4317 }
4318 }
4319 }
4320 }
4321
4322 const uint kernel_power = device_param->kernel_power;
4323
4324 uint work = MIN (words_left, kernel_power);
4325
4326 work = MIN (work, max);
4327
4328 data.words_cur += work;
4329
4330 hc_thread_mutex_unlock (mux_dispatcher);
4331
4332 return work;
4333 }
4334
4335 static void *thread_calc_stdin (void *p)
4336 {
4337 hc_device_param_t *device_param = (hc_device_param_t *) p;
4338
4339 if (device_param->skipped) return NULL;
4340
4341 autotune (device_param);
4342
4343 char *buf = (char *) mymalloc (HCBUFSIZ);
4344
4345 const uint attack_kern = data.attack_kern;
4346
4347 const uint kernel_power = device_param->kernel_power;
4348
4349 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4350 {
4351 hc_thread_mutex_lock (mux_dispatcher);
4352
4353 if (feof (stdin) != 0)
4354 {
4355 hc_thread_mutex_unlock (mux_dispatcher);
4356
4357 break;
4358 }
4359
4360 uint words_cur = 0;
4361
4362 while (words_cur < kernel_power)
4363 {
4364 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4365
4366 if (line_buf == NULL) break;
4367
4368 uint line_len = in_superchop (line_buf);
4369
4370 line_len = convert_from_hex (line_buf, line_len);
4371
4372 // post-process rule engine
4373
4374 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4375 {
4376 char rule_buf_out[BLOCK_SIZE] = { 0 };
4377
4378 int rule_len_out = -1;
4379
4380 if (line_len < BLOCK_SIZE)
4381 {
4382 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4383 }
4384
4385 if (rule_len_out < 0) continue;
4386
4387 line_buf = rule_buf_out;
4388 line_len = rule_len_out;
4389 }
4390
4391 if (line_len > PW_MAX)
4392 {
4393 continue;
4394 }
4395
4396 if (attack_kern == ATTACK_KERN_STRAIGHT)
4397 {
4398 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4399 {
4400 hc_thread_mutex_lock (mux_counter);
4401
4402 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4403 {
4404 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4405 }
4406
4407 hc_thread_mutex_unlock (mux_counter);
4408
4409 continue;
4410 }
4411 }
4412 else if (attack_kern == ATTACK_KERN_COMBI)
4413 {
4414 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4415 // since we still need to combine the plains
4416
4417 if (line_len > data.pw_max)
4418 {
4419 hc_thread_mutex_lock (mux_counter);
4420
4421 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4422 {
4423 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4424 }
4425
4426 hc_thread_mutex_unlock (mux_counter);
4427
4428 continue;
4429 }
4430 }
4431
4432 pw_add (device_param, (u8 *) line_buf, line_len);
4433
4434 words_cur++;
4435
4436 if (data.devices_status == STATUS_CRACKED) break;
4437 if (data.devices_status == STATUS_ABORTED) break;
4438 if (data.devices_status == STATUS_QUIT) break;
4439 if (data.devices_status == STATUS_BYPASS) break;
4440 }
4441
4442 hc_thread_mutex_unlock (mux_dispatcher);
4443
4444 if (data.devices_status == STATUS_CRACKED) break;
4445 if (data.devices_status == STATUS_ABORTED) break;
4446 if (data.devices_status == STATUS_QUIT) break;
4447 if (data.devices_status == STATUS_BYPASS) break;
4448
4449 // flush
4450
4451 const uint pws_cnt = device_param->pws_cnt;
4452
4453 if (pws_cnt)
4454 {
4455 run_copy (device_param, pws_cnt);
4456
4457 run_cracker (device_param, pws_cnt);
4458
4459 device_param->pws_cnt = 0;
4460
4461 /*
4462 still required?
4463 if (attack_kern == ATTACK_KERN_STRAIGHT)
4464 {
4465 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4466 }
4467 else if (attack_kern == ATTACK_KERN_COMBI)
4468 {
4469 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4470 }
4471 */
4472 }
4473 }
4474
4475 device_param->kernel_accel = 0;
4476 device_param->kernel_loops = 0;
4477
4478 myfree (buf);
4479
4480 return NULL;
4481 }
4482
4483 static void *thread_calc (void *p)
4484 {
4485 hc_device_param_t *device_param = (hc_device_param_t *) p;
4486
4487 if (device_param->skipped) return NULL;
4488
4489 autotune (device_param);
4490
4491 const uint attack_mode = data.attack_mode;
4492 const uint attack_kern = data.attack_kern;
4493
4494 if (attack_mode == ATTACK_MODE_BF)
4495 {
4496 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4497 {
4498 const uint work = get_work (device_param, -1, true);
4499
4500 if (work == 0) break;
4501
4502 const u64 words_off = device_param->words_off;
4503 const u64 words_fin = words_off + work;
4504
4505 const uint pws_cnt = work;
4506
4507 device_param->pws_cnt = pws_cnt;
4508
4509 if (pws_cnt)
4510 {
4511 run_copy (device_param, pws_cnt);
4512
4513 run_cracker (device_param, pws_cnt);
4514
4515 device_param->pws_cnt = 0;
4516
4517 /*
4518 still required?
4519 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4520 */
4521 }
4522
4523 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4524
4525 if (data.devices_status == STATUS_CRACKED) break;
4526 if (data.devices_status == STATUS_ABORTED) break;
4527 if (data.devices_status == STATUS_QUIT) break;
4528 if (data.devices_status == STATUS_BYPASS) break;
4529
4530 if (data.benchmark == 1) break;
4531
4532 device_param->words_done = words_fin;
4533 }
4534 }
4535 else
4536 {
4537 const uint segment_size = data.segment_size;
4538
4539 char *dictfile = data.dictfile;
4540
4541 if (attack_mode == ATTACK_MODE_COMBI)
4542 {
4543 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4544 {
4545 dictfile = data.dictfile2;
4546 }
4547 }
4548
4549 FILE *fd = fopen (dictfile, "rb");
4550
4551 if (fd == NULL)
4552 {
4553 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4554
4555 return NULL;
4556 }
4557
4558 if (attack_mode == ATTACK_MODE_COMBI)
4559 {
4560 const uint combs_mode = data.combs_mode;
4561
4562 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4563 {
4564 const char *dictfilec = data.dictfile2;
4565
4566 FILE *combs_fp = fopen (dictfilec, "rb");
4567
4568 if (combs_fp == NULL)
4569 {
4570 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4571
4572 fclose (fd);
4573
4574 return NULL;
4575 }
4576
4577 device_param->combs_fp = combs_fp;
4578 }
4579 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4580 {
4581 const char *dictfilec = data.dictfile;
4582
4583 FILE *combs_fp = fopen (dictfilec, "rb");
4584
4585 if (combs_fp == NULL)
4586 {
4587 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4588
4589 fclose (fd);
4590
4591 return NULL;
4592 }
4593
4594 device_param->combs_fp = combs_fp;
4595 }
4596 }
4597
4598 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4599
4600 wl_data->buf = (char *) mymalloc (segment_size);
4601 wl_data->avail = segment_size;
4602 wl_data->incr = segment_size;
4603 wl_data->cnt = 0;
4604 wl_data->pos = 0;
4605
4606 u64 words_cur = 0;
4607
4608 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4609 {
4610 u64 words_off = 0;
4611 u64 words_fin = 0;
4612
4613 bool allow_div = true;
4614
4615 u64 max = -1;
4616
4617 while (max)
4618 {
4619 const uint work = get_work (device_param, max, allow_div);
4620
4621 allow_div = false;
4622
4623 if (work == 0) break;
4624
4625 words_off = device_param->words_off;
4626 words_fin = words_off + work;
4627
4628 char *line_buf;
4629 uint line_len;
4630
4631 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4632
4633 max = 0;
4634
4635 for ( ; words_cur < words_fin; words_cur++)
4636 {
4637 get_next_word (wl_data, fd, &line_buf, &line_len);
4638
4639 line_len = convert_from_hex (line_buf, line_len);
4640
4641 // post-process rule engine
4642
4643 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4644 {
4645 char rule_buf_out[BLOCK_SIZE] = { 0 };
4646
4647 int rule_len_out = -1;
4648
4649 if (line_len < BLOCK_SIZE)
4650 {
4651 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4652 }
4653
4654 if (rule_len_out < 0) continue;
4655
4656 line_buf = rule_buf_out;
4657 line_len = rule_len_out;
4658 }
4659
4660 if (attack_kern == ATTACK_KERN_STRAIGHT)
4661 {
4662 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4663 {
4664 max++;
4665
4666 hc_thread_mutex_lock (mux_counter);
4667
4668 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4669 {
4670 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4671 }
4672
4673 hc_thread_mutex_unlock (mux_counter);
4674
4675 continue;
4676 }
4677 }
4678 else if (attack_kern == ATTACK_KERN_COMBI)
4679 {
4680 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4681 // since we still need to combine the plains
4682
4683 if (line_len > data.pw_max)
4684 {
4685 max++;
4686
4687 hc_thread_mutex_lock (mux_counter);
4688
4689 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4690 {
4691 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4692 }
4693
4694 hc_thread_mutex_unlock (mux_counter);
4695
4696 continue;
4697 }
4698 }
4699
4700 pw_add (device_param, (u8 *) line_buf, line_len);
4701
4702 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4703
4704 if (data.devices_status == STATUS_CRACKED) break;
4705 if (data.devices_status == STATUS_ABORTED) break;
4706 if (data.devices_status == STATUS_QUIT) break;
4707 if (data.devices_status == STATUS_BYPASS) break;
4708 }
4709
4710 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4711
4712 if (data.devices_status == STATUS_CRACKED) break;
4713 if (data.devices_status == STATUS_ABORTED) break;
4714 if (data.devices_status == STATUS_QUIT) break;
4715 if (data.devices_status == STATUS_BYPASS) break;
4716 }
4717
4718 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4719
4720 if (data.devices_status == STATUS_CRACKED) break;
4721 if (data.devices_status == STATUS_ABORTED) break;
4722 if (data.devices_status == STATUS_QUIT) break;
4723 if (data.devices_status == STATUS_BYPASS) break;
4724
4725 //
4726 // flush
4727 //
4728
4729 const uint pws_cnt = device_param->pws_cnt;
4730
4731 if (pws_cnt)
4732 {
4733 run_copy (device_param, pws_cnt);
4734
4735 run_cracker (device_param, pws_cnt);
4736
4737 device_param->pws_cnt = 0;
4738
4739 /*
4740 still required?
4741 if (attack_kern == ATTACK_KERN_STRAIGHT)
4742 {
4743 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4744 }
4745 else if (attack_kern == ATTACK_KERN_COMBI)
4746 {
4747 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4748 }
4749 */
4750 }
4751
4752 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4753
4754 if (data.devices_status == STATUS_CRACKED) break;
4755 if (data.devices_status == STATUS_ABORTED) break;
4756 if (data.devices_status == STATUS_QUIT) break;
4757 if (data.devices_status == STATUS_BYPASS) break;
4758
4759 if (words_fin == 0) break;
4760
4761 device_param->words_done = words_fin;
4762 }
4763
4764 if (attack_mode == ATTACK_MODE_COMBI)
4765 {
4766 fclose (device_param->combs_fp);
4767 }
4768
4769 free (wl_data->buf);
4770 free (wl_data);
4771
4772 fclose (fd);
4773 }
4774
4775 device_param->kernel_accel = 0;
4776 device_param->kernel_loops = 0;
4777
4778 return NULL;
4779 }
4780
4781 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4782 {
4783 if (!device_param)
4784 {
4785 log_error ("ERROR: %s : Invalid argument", __func__);
4786
4787 exit (-1);
4788 }
4789
4790 salt_t *salt_buf = &data.salts_buf[salt_pos];
4791
4792 device_param->kernel_params_buf32[24] = salt_pos;
4793 device_param->kernel_params_buf32[27] = 1;
4794 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4795 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4796 device_param->kernel_params_buf32[30] = 0;
4797 device_param->kernel_params_buf32[31] = 1;
4798
4799 char *dictfile_old = data.dictfile;
4800
4801 const char *weak_hash_check = "weak-hash-check";
4802
4803 data.dictfile = (char *) weak_hash_check;
4804
4805 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4806
4807 data.kernel_rules_buf[0].cmds[0] = 0;
4808
4809 /**
4810 * run the kernel
4811 */
4812
4813 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4814 {
4815 run_kernel (KERN_RUN_1, device_param, 1, false);
4816 }
4817 else
4818 {
4819 run_kernel (KERN_RUN_1, device_param, 1, false);
4820
4821 uint loop_step = 16;
4822
4823 const uint iter = salt_buf->salt_iter;
4824
4825 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4826 {
4827 uint loop_left = iter - loop_pos;
4828
4829 loop_left = MIN (loop_left, loop_step);
4830
4831 device_param->kernel_params_buf32[25] = loop_pos;
4832 device_param->kernel_params_buf32[26] = loop_left;
4833
4834 run_kernel (KERN_RUN_2, device_param, 1, false);
4835 }
4836
4837 run_kernel (KERN_RUN_3, device_param, 1, false);
4838 }
4839
4840 /**
4841 * result
4842 */
4843
4844 check_cracked (device_param, salt_pos);
4845
4846 /**
4847 * cleanup
4848 */
4849
4850 device_param->kernel_params_buf32[24] = 0;
4851 device_param->kernel_params_buf32[25] = 0;
4852 device_param->kernel_params_buf32[26] = 0;
4853 device_param->kernel_params_buf32[27] = 0;
4854 device_param->kernel_params_buf32[28] = 0;
4855 device_param->kernel_params_buf32[29] = 0;
4856 device_param->kernel_params_buf32[30] = 0;
4857 device_param->kernel_params_buf32[31] = 0;
4858
4859 data.dictfile = dictfile_old;
4860
4861 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4862 }
4863
4864 // hlfmt hashcat
4865
4866 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4867 {
4868 if (data.username == 0)
4869 {
4870 *hashbuf_pos = line_buf;
4871 *hashbuf_len = line_len;
4872 }
4873 else
4874 {
4875 char *pos = line_buf;
4876 int len = line_len;
4877
4878 for (int i = 0; i < line_len; i++, pos++, len--)
4879 {
4880 if (line_buf[i] == data.separator)
4881 {
4882 pos++;
4883
4884 len--;
4885
4886 break;
4887 }
4888 }
4889
4890 *hashbuf_pos = pos;
4891 *hashbuf_len = len;
4892 }
4893 }
4894
4895 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4896 {
4897 char *pos = NULL;
4898 int len = 0;
4899
4900 int sep_cnt = 0;
4901
4902 for (int i = 0; i < line_len; i++)
4903 {
4904 if (line_buf[i] == data.separator)
4905 {
4906 sep_cnt++;
4907
4908 continue;
4909 }
4910
4911 if (sep_cnt == 0)
4912 {
4913 if (pos == NULL) pos = line_buf + i;
4914
4915 len++;
4916 }
4917 }
4918
4919 *userbuf_pos = pos;
4920 *userbuf_len = len;
4921 }
4922
4923 // hlfmt pwdump
4924
4925 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4926 {
4927 int sep_cnt = 0;
4928
4929 int sep2_len = 0;
4930 int sep3_len = 0;
4931
4932 for (int i = 0; i < line_len; i++)
4933 {
4934 if (line_buf[i] == ':')
4935 {
4936 sep_cnt++;
4937
4938 continue;
4939 }
4940
4941 if (sep_cnt == 2) sep2_len++;
4942 if (sep_cnt == 3) sep3_len++;
4943 }
4944
4945 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4946
4947 return 0;
4948 }
4949
4950 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4951 {
4952 char *pos = NULL;
4953 int len = 0;
4954
4955 int sep_cnt = 0;
4956
4957 for (int i = 0; i < line_len; i++)
4958 {
4959 if (line_buf[i] == ':')
4960 {
4961 sep_cnt++;
4962
4963 continue;
4964 }
4965
4966 if (data.hash_mode == 1000)
4967 {
4968 if (sep_cnt == 3)
4969 {
4970 if (pos == NULL) pos = line_buf + i;
4971
4972 len++;
4973 }
4974 }
4975 else if (data.hash_mode == 3000)
4976 {
4977 if (sep_cnt == 2)
4978 {
4979 if (pos == NULL) pos = line_buf + i;
4980
4981 len++;
4982 }
4983 }
4984 }
4985
4986 *hashbuf_pos = pos;
4987 *hashbuf_len = len;
4988 }
4989
4990 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4991 {
4992 char *pos = NULL;
4993 int len = 0;
4994
4995 int sep_cnt = 0;
4996
4997 for (int i = 0; i < line_len; i++)
4998 {
4999 if (line_buf[i] == ':')
5000 {
5001 sep_cnt++;
5002
5003 continue;
5004 }
5005
5006 if (sep_cnt == 0)
5007 {
5008 if (pos == NULL) pos = line_buf + i;
5009
5010 len++;
5011 }
5012 }
5013
5014 *userbuf_pos = pos;
5015 *userbuf_len = len;
5016 }
5017
5018 // hlfmt passwd
5019
5020 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5021 {
5022 int sep_cnt = 0;
5023
5024 char sep5_first = 0;
5025 char sep6_first = 0;
5026
5027 for (int i = 0; i < line_len; i++)
5028 {
5029 if (line_buf[i] == ':')
5030 {
5031 sep_cnt++;
5032
5033 continue;
5034 }
5035
5036 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5037 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5038 }
5039
5040 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5041
5042 return 0;
5043 }
5044
5045 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5046 {
5047 char *pos = NULL;
5048 int len = 0;
5049
5050 int sep_cnt = 0;
5051
5052 for (int i = 0; i < line_len; i++)
5053 {
5054 if (line_buf[i] == ':')
5055 {
5056 sep_cnt++;
5057
5058 continue;
5059 }
5060
5061 if (sep_cnt == 1)
5062 {
5063 if (pos == NULL) pos = line_buf + i;
5064
5065 len++;
5066 }
5067 }
5068
5069 *hashbuf_pos = pos;
5070 *hashbuf_len = len;
5071 }
5072
5073 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5074 {
5075 char *pos = NULL;
5076 int len = 0;
5077
5078 int sep_cnt = 0;
5079
5080 for (int i = 0; i < line_len; i++)
5081 {
5082 if (line_buf[i] == ':')
5083 {
5084 sep_cnt++;
5085
5086 continue;
5087 }
5088
5089 if (sep_cnt == 0)
5090 {
5091 if (pos == NULL) pos = line_buf + i;
5092
5093 len++;
5094 }
5095 }
5096
5097 *userbuf_pos = pos;
5098 *userbuf_len = len;
5099 }
5100
5101 // hlfmt shadow
5102
5103 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5104 {
5105 int sep_cnt = 0;
5106
5107 for (int i = 0; i < line_len; i++)
5108 {
5109 if (line_buf[i] == ':') sep_cnt++;
5110 }
5111
5112 if (sep_cnt == 8) return 1;
5113
5114 return 0;
5115 }
5116
5117 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5118 {
5119 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5120 }
5121
5122 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5123 {
5124 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5125 }
5126
5127 // hlfmt main
5128
5129 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5130 {
5131 switch (hashfile_format)
5132 {
5133 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5134 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5135 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5136 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5137 }
5138 }
5139
5140 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5141 {
5142 switch (hashfile_format)
5143 {
5144 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5145 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5146 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5147 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5148 }
5149 }
5150
5151 char *strhlfmt (const uint hashfile_format)
5152 {
5153 switch (hashfile_format)
5154 {
5155 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5156 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5157 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5158 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5159 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5160 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5161 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5162 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5163 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5164 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5165 }
5166
5167 return ((char *) "Unknown");
5168 }
5169
5170 static uint hlfmt_detect (FILE *fp, uint max_check)
5171 {
5172 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5173
5174 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5175 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5176
5177 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5178
5179 uint num_check = 0;
5180
5181 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5182
5183 while (!feof (fp))
5184 {
5185 int line_len = fgetl (fp, line_buf);
5186
5187 if (line_len == 0) continue;
5188
5189 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5190 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5191 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5192
5193 if (num_check == max_check) break;
5194
5195 num_check++;
5196 }
5197
5198 myfree (line_buf);
5199
5200 uint hashlist_format = HLFMT_HASHCAT;
5201
5202 for (int i = 1; i < HLFMTS_CNT; i++)
5203 {
5204 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5205
5206 hashlist_format = i;
5207 }
5208
5209 free (formats_cnt);
5210
5211 return hashlist_format;
5212 }
5213
5214 /**
5215 * some further helper function
5216 */
5217
5218 // wrapper around mymalloc for ADL
5219
5220 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5221 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5222 {
5223 return mymalloc (iSize);
5224 }
5225 #endif
5226
5227 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)
5228 {
5229 u64 collisions = 0;
5230
5231 const uint dgst_pos0 = data.dgst_pos0;
5232 const uint dgst_pos1 = data.dgst_pos1;
5233 const uint dgst_pos2 = data.dgst_pos2;
5234 const uint dgst_pos3 = data.dgst_pos3;
5235
5236 memset (bitmap_a, 0, bitmap_size);
5237 memset (bitmap_b, 0, bitmap_size);
5238 memset (bitmap_c, 0, bitmap_size);
5239 memset (bitmap_d, 0, bitmap_size);
5240
5241 for (uint i = 0; i < digests_cnt; i++)
5242 {
5243 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5244
5245 uint *digest_ptr = (uint *) digests_buf_ptr;
5246
5247 digests_buf_ptr += dgst_size;
5248
5249 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5250 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5251 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5252 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5253
5254 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5255 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5256 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5257 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5258
5259 if (bitmap_a[idx0] & val0) collisions++;
5260 if (bitmap_b[idx1] & val1) collisions++;
5261 if (bitmap_c[idx2] & val2) collisions++;
5262 if (bitmap_d[idx3] & val3) collisions++;
5263
5264 bitmap_a[idx0] |= val0;
5265 bitmap_b[idx1] |= val1;
5266 bitmap_c[idx2] |= val2;
5267 bitmap_d[idx3] |= val3;
5268
5269 if (collisions >= collisions_max) return 0x7fffffff;
5270 }
5271
5272 return collisions;
5273 }
5274
5275 /**
5276 * main
5277 */
5278
5279 int main (int argc, char **argv)
5280 {
5281 /**
5282 * To help users a bit
5283 */
5284
5285 char *compute = getenv ("COMPUTE");
5286
5287 if (compute)
5288 {
5289 static char display[100];
5290
5291 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5292
5293 putenv (display);
5294 }
5295 else
5296 {
5297 if (getenv ("DISPLAY") == NULL)
5298 putenv ((char *) "DISPLAY=:0");
5299 }
5300
5301 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5302 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5303
5304 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5305 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5306
5307 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5308 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5309
5310 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5311 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5312
5313 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5314 putenv ((char *) "POCL_KERNEL_CACHE=0");
5315
5316 umask (077);
5317
5318 /**
5319 * Real init
5320 */
5321
5322 memset (&data, 0, sizeof (hc_global_data_t));
5323
5324 time_t proc_start;
5325
5326 time (&proc_start);
5327
5328 data.proc_start = proc_start;
5329
5330 int myargc = argc;
5331 char **myargv = argv;
5332
5333 hc_thread_mutex_init (mux_dispatcher);
5334 hc_thread_mutex_init (mux_counter);
5335 hc_thread_mutex_init (mux_display);
5336 hc_thread_mutex_init (mux_adl);
5337
5338 /**
5339 * commandline parameters
5340 */
5341
5342 uint usage = USAGE;
5343 uint version = VERSION;
5344 uint quiet = QUIET;
5345 uint benchmark = BENCHMARK;
5346 uint show = SHOW;
5347 uint left = LEFT;
5348 uint username = USERNAME;
5349 uint remove = REMOVE;
5350 uint remove_timer = REMOVE_TIMER;
5351 u64 skip = SKIP;
5352 u64 limit = LIMIT;
5353 uint keyspace = KEYSPACE;
5354 uint potfile_disable = POTFILE_DISABLE;
5355 char *potfile_path = NULL;
5356 uint debug_mode = DEBUG_MODE;
5357 char *debug_file = NULL;
5358 char *induction_dir = NULL;
5359 char *outfile_check_dir = NULL;
5360 uint force = FORCE;
5361 uint runtime = RUNTIME;
5362 uint hash_mode = HASH_MODE;
5363 uint attack_mode = ATTACK_MODE;
5364 uint markov_disable = MARKOV_DISABLE;
5365 uint markov_classic = MARKOV_CLASSIC;
5366 uint markov_threshold = MARKOV_THRESHOLD;
5367 char *markov_hcstat = NULL;
5368 char *outfile = NULL;
5369 uint outfile_format = OUTFILE_FORMAT;
5370 uint outfile_autohex = OUTFILE_AUTOHEX;
5371 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5372 uint restore = RESTORE;
5373 uint restore_timer = RESTORE_TIMER;
5374 uint restore_disable = RESTORE_DISABLE;
5375 uint status = STATUS;
5376 uint status_timer = STATUS_TIMER;
5377 uint status_automat = STATUS_AUTOMAT;
5378 uint loopback = LOOPBACK;
5379 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5380 char *session = NULL;
5381 uint hex_charset = HEX_CHARSET;
5382 uint hex_salt = HEX_SALT;
5383 uint hex_wordlist = HEX_WORDLIST;
5384 uint rp_gen = RP_GEN;
5385 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5386 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5387 uint rp_gen_seed = RP_GEN_SEED;
5388 char *rule_buf_l = (char *) RULE_BUF_L;
5389 char *rule_buf_r = (char *) RULE_BUF_R;
5390 uint increment = INCREMENT;
5391 uint increment_min = INCREMENT_MIN;
5392 uint increment_max = INCREMENT_MAX;
5393 char *cpu_affinity = NULL;
5394 OCL_PTR *ocl = NULL;
5395 char *opencl_devices = NULL;
5396 char *opencl_platforms = NULL;
5397 char *opencl_device_types = NULL;
5398 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5399 char *truecrypt_keyfiles = NULL;
5400 char *veracrypt_keyfiles = NULL;
5401 uint veracrypt_pim = 0;
5402 uint workload_profile = WORKLOAD_PROFILE;
5403 uint kernel_accel = KERNEL_ACCEL;
5404 uint kernel_loops = KERNEL_LOOPS;
5405 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5406 #ifdef HAVE_HWMON
5407 uint gpu_temp_abort = GPU_TEMP_ABORT;
5408 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5409 #ifdef HAVE_ADL
5410 uint powertune_enable = POWERTUNE_ENABLE;
5411 #endif
5412 #endif
5413 uint logfile_disable = LOGFILE_DISABLE;
5414 uint segment_size = SEGMENT_SIZE;
5415 uint scrypt_tmto = SCRYPT_TMTO;
5416 char separator = SEPARATOR;
5417 uint bitmap_min = BITMAP_MIN;
5418 uint bitmap_max = BITMAP_MAX;
5419 char *custom_charset_1 = NULL;
5420 char *custom_charset_2 = NULL;
5421 char *custom_charset_3 = NULL;
5422 char *custom_charset_4 = NULL;
5423
5424 #define IDX_HELP 'h'
5425 #define IDX_VERSION 'V'
5426 #define IDX_VERSION_LOWER 'v'
5427 #define IDX_QUIET 0xff02
5428 #define IDX_SHOW 0xff03
5429 #define IDX_LEFT 0xff04
5430 #define IDX_REMOVE 0xff05
5431 #define IDX_REMOVE_TIMER 0xff37
5432 #define IDX_SKIP 's'
5433 #define IDX_LIMIT 'l'
5434 #define IDX_KEYSPACE 0xff35
5435 #define IDX_POTFILE_DISABLE 0xff06
5436 #define IDX_POTFILE_PATH 0xffe0
5437 #define IDX_DEBUG_MODE 0xff43
5438 #define IDX_DEBUG_FILE 0xff44
5439 #define IDX_INDUCTION_DIR 0xff46
5440 #define IDX_OUTFILE_CHECK_DIR 0xff47
5441 #define IDX_USERNAME 0xff07
5442 #define IDX_FORCE 0xff08
5443 #define IDX_RUNTIME 0xff09
5444 #define IDX_BENCHMARK 'b'
5445 #define IDX_HASH_MODE 'm'
5446 #define IDX_ATTACK_MODE 'a'
5447 #define IDX_RP_FILE 'r'
5448 #define IDX_RP_GEN 'g'
5449 #define IDX_RP_GEN_FUNC_MIN 0xff10
5450 #define IDX_RP_GEN_FUNC_MAX 0xff11
5451 #define IDX_RP_GEN_SEED 0xff34
5452 #define IDX_RULE_BUF_L 'j'
5453 #define IDX_RULE_BUF_R 'k'
5454 #define IDX_INCREMENT 'i'
5455 #define IDX_INCREMENT_MIN 0xff12
5456 #define IDX_INCREMENT_MAX 0xff13
5457 #define IDX_OUTFILE 'o'
5458 #define IDX_OUTFILE_FORMAT 0xff14
5459 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5460 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5461 #define IDX_RESTORE 0xff15
5462 #define IDX_RESTORE_DISABLE 0xff27
5463 #define IDX_STATUS 0xff17
5464 #define IDX_STATUS_TIMER 0xff18
5465 #define IDX_STATUS_AUTOMAT 0xff50
5466 #define IDX_LOOPBACK 0xff38
5467 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5468 #define IDX_SESSION 0xff19
5469 #define IDX_HEX_CHARSET 0xff20
5470 #define IDX_HEX_SALT 0xff21
5471 #define IDX_HEX_WORDLIST 0xff40
5472 #define IDX_MARKOV_DISABLE 0xff22
5473 #define IDX_MARKOV_CLASSIC 0xff23
5474 #define IDX_MARKOV_THRESHOLD 't'
5475 #define IDX_MARKOV_HCSTAT 0xff24
5476 #define IDX_CPU_AFFINITY 0xff25
5477 #define IDX_OPENCL_DEVICES 'd'
5478 #define IDX_OPENCL_PLATFORMS 0xff72
5479 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5480 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5481 #define IDX_WORKLOAD_PROFILE 'w'
5482 #define IDX_KERNEL_ACCEL 'n'
5483 #define IDX_KERNEL_LOOPS 'u'
5484 #define IDX_GPU_TEMP_DISABLE 0xff29
5485 #define IDX_GPU_TEMP_ABORT 0xff30
5486 #define IDX_GPU_TEMP_RETAIN 0xff31
5487 #define IDX_POWERTUNE_ENABLE 0xff41
5488 #define IDX_LOGFILE_DISABLE 0xff51
5489 #define IDX_TRUECRYPT_KEYFILES 0xff52
5490 #define IDX_VERACRYPT_KEYFILES 0xff53
5491 #define IDX_VERACRYPT_PIM 0xff54
5492 #define IDX_SCRYPT_TMTO 0xff61
5493 #define IDX_SEGMENT_SIZE 'c'
5494 #define IDX_SEPARATOR 'p'
5495 #define IDX_BITMAP_MIN 0xff70
5496 #define IDX_BITMAP_MAX 0xff71
5497 #define IDX_CUSTOM_CHARSET_1 '1'
5498 #define IDX_CUSTOM_CHARSET_2 '2'
5499 #define IDX_CUSTOM_CHARSET_3 '3'
5500 #define IDX_CUSTOM_CHARSET_4 '4'
5501
5502 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5503
5504 struct option long_options[] =
5505 {
5506 {"help", no_argument, 0, IDX_HELP},
5507 {"version", no_argument, 0, IDX_VERSION},
5508 {"quiet", no_argument, 0, IDX_QUIET},
5509 {"show", no_argument, 0, IDX_SHOW},
5510 {"left", no_argument, 0, IDX_LEFT},
5511 {"username", no_argument, 0, IDX_USERNAME},
5512 {"remove", no_argument, 0, IDX_REMOVE},
5513 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5514 {"skip", required_argument, 0, IDX_SKIP},
5515 {"limit", required_argument, 0, IDX_LIMIT},
5516 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5517 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5518 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5519 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5520 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5521 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5522 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5523 {"force", no_argument, 0, IDX_FORCE},
5524 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5525 {"restore", no_argument, 0, IDX_RESTORE},
5526 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5527 {"status", no_argument, 0, IDX_STATUS},
5528 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5529 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5530 {"loopback", no_argument, 0, IDX_LOOPBACK},
5531 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5532 {"session", required_argument, 0, IDX_SESSION},
5533 {"runtime", required_argument, 0, IDX_RUNTIME},
5534 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5535 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5536 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5537 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5538 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5539 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5540 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5541 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5542 {"rules-file", required_argument, 0, IDX_RP_FILE},
5543 {"outfile", required_argument, 0, IDX_OUTFILE},
5544 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5545 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5546 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5547 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5548 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5549 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5550 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5551 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5552 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5553 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5554 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5555 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5556 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5557 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5558 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5559 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5560 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5561 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5562 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5563 #ifdef HAVE_HWMON
5564 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5565 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5566 #ifdef HAVE_ADL
5567 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5568 #endif
5569 #endif // HAVE_HWMON
5570 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5571 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5572 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5573 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5574 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5575 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5576 {"seperator", required_argument, 0, IDX_SEPARATOR},
5577 {"separator", required_argument, 0, IDX_SEPARATOR},
5578 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5579 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5580 {"increment", no_argument, 0, IDX_INCREMENT},
5581 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5582 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5583 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5584 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5585 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5586 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5587 {0, 0, 0, 0}
5588 };
5589
5590 uint rp_files_cnt = 0;
5591
5592 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5593
5594 int option_index = 0;
5595 int c = -1;
5596
5597 optind = 1;
5598 optopt = 0;
5599
5600 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5601 {
5602 switch (c)
5603 {
5604 case IDX_HELP: usage = 1; break;
5605 case IDX_VERSION:
5606 case IDX_VERSION_LOWER: version = 1; break;
5607 case IDX_RESTORE: restore = 1; break;
5608 case IDX_SESSION: session = optarg; break;
5609 case IDX_SHOW: show = 1; break;
5610 case IDX_LEFT: left = 1; break;
5611 case '?': return (-1);
5612 }
5613 }
5614
5615 if (optopt != 0)
5616 {
5617 log_error ("ERROR: Invalid argument specified");
5618
5619 return (-1);
5620 }
5621
5622 /**
5623 * exit functions
5624 */
5625
5626 if (version)
5627 {
5628 log_info ("%s", VERSION_TAG);
5629
5630 return (0);
5631 }
5632
5633 if (usage)
5634 {
5635 usage_big_print (PROGNAME);
5636
5637 return (0);
5638 }
5639
5640 /**
5641 * session needs to be set, always!
5642 */
5643
5644 if (session == NULL) session = (char *) PROGNAME;
5645
5646 /**
5647 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5648 */
5649
5650 char *exec_path = get_exec_path ();
5651
5652 #ifdef LINUX
5653
5654 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5655 char *resolved_exec_path = realpath (exec_path, NULL);
5656
5657 char *install_dir = get_install_dir (resolved_exec_path);
5658 char *profile_dir = NULL;
5659 char *session_dir = NULL;
5660 char *shared_dir = NULL;
5661
5662 if (strcmp (install_dir, resolved_install_folder) == 0)
5663 {
5664 struct passwd *pw = getpwuid (getuid ());
5665
5666 const char *homedir = pw->pw_dir;
5667
5668 profile_dir = get_profile_dir (homedir);
5669 session_dir = get_session_dir (profile_dir);
5670 shared_dir = strdup (SHARED_FOLDER);
5671
5672 mkdir (profile_dir, 0700);
5673 mkdir (session_dir, 0700);
5674 }
5675 else
5676 {
5677 profile_dir = install_dir;
5678 session_dir = install_dir;
5679 shared_dir = install_dir;
5680 }
5681
5682 myfree (resolved_install_folder);
5683 myfree (resolved_exec_path);
5684
5685 #else
5686
5687 char *install_dir = get_install_dir (exec_path);
5688 char *profile_dir = install_dir;
5689 char *session_dir = install_dir;
5690 char *shared_dir = install_dir;
5691
5692 #endif
5693
5694 data.install_dir = install_dir;
5695 data.profile_dir = profile_dir;
5696 data.session_dir = session_dir;
5697 data.shared_dir = shared_dir;
5698
5699 myfree (exec_path);
5700
5701 /**
5702 * kernel cache, we need to make sure folder exist
5703 */
5704
5705 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5706
5707 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5708
5709 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5710
5711 mkdir (kernels_folder, 0700);
5712
5713 myfree (kernels_folder);
5714
5715 /**
5716 * session
5717 */
5718
5719 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5720
5721 data.session = session;
5722
5723 char *eff_restore_file = (char *) mymalloc (session_size);
5724 char *new_restore_file = (char *) mymalloc (session_size);
5725
5726 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5727 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5728
5729 data.eff_restore_file = eff_restore_file;
5730 data.new_restore_file = new_restore_file;
5731
5732 if (((show == 1) || (left == 1)) && (restore == 1))
5733 {
5734 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5735 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5736
5737 return (-1);
5738 }
5739
5740 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5741 if ((show == 1) || (left == 1))
5742 {
5743 restore_disable = 1;
5744
5745 restore = 0;
5746 }
5747
5748 data.restore_disable = restore_disable;
5749
5750 restore_data_t *rd = init_restore (argc, argv);
5751
5752 data.rd = rd;
5753
5754 /**
5755 * restore file
5756 */
5757
5758 if (restore == 1)
5759 {
5760 read_restore (eff_restore_file, rd);
5761
5762 if (rd->version_bin < RESTORE_MIN)
5763 {
5764 log_error ("ERROR: Incompatible restore-file version");
5765
5766 return (-1);
5767 }
5768
5769 myargc = rd->argc;
5770 myargv = rd->argv;
5771
5772 #ifdef _POSIX
5773 rd->pid = getpid ();
5774 #elif _WIN
5775 rd->pid = GetCurrentProcessId ();
5776 #endif
5777 }
5778
5779 uint hash_mode_chgd = 0;
5780 uint runtime_chgd = 0;
5781 uint kernel_loops_chgd = 0;
5782 uint kernel_accel_chgd = 0;
5783 uint attack_mode_chgd = 0;
5784 uint outfile_format_chgd = 0;
5785 uint rp_gen_seed_chgd = 0;
5786 uint remove_timer_chgd = 0;
5787 uint increment_min_chgd = 0;
5788 uint increment_max_chgd = 0;
5789 uint workload_profile_chgd = 0;
5790 uint opencl_vector_width_chgd = 0;
5791
5792 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5793 uint gpu_temp_retain_chgd = 0;
5794 uint gpu_temp_abort_chgd = 0;
5795 #endif
5796
5797 optind = 1;
5798 optopt = 0;
5799 option_index = 0;
5800
5801 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5802 {
5803 switch (c)
5804 {
5805 //case IDX_HELP: usage = 1; break;
5806 //case IDX_VERSION: version = 1; break;
5807 //case IDX_RESTORE: restore = 1; break;
5808 case IDX_QUIET: quiet = 1; break;
5809 //case IDX_SHOW: show = 1; break;
5810 case IDX_SHOW: break;
5811 //case IDX_LEFT: left = 1; break;
5812 case IDX_LEFT: break;
5813 case IDX_USERNAME: username = 1; break;
5814 case IDX_REMOVE: remove = 1; break;
5815 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5816 remove_timer_chgd = 1; break;
5817 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5818 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5819 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5820 case IDX_DEBUG_FILE: debug_file = optarg; break;
5821 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5822 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5823 case IDX_FORCE: force = 1; break;
5824 case IDX_SKIP: skip = atoll (optarg); break;
5825 case IDX_LIMIT: limit = atoll (optarg); break;
5826 case IDX_KEYSPACE: keyspace = 1; break;
5827 case IDX_BENCHMARK: benchmark = 1; break;
5828 case IDX_RESTORE: break;
5829 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5830 case IDX_STATUS: status = 1; break;
5831 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5832 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5833 case IDX_LOOPBACK: loopback = 1; break;
5834 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5835 //case IDX_SESSION: session = optarg; break;
5836 case IDX_SESSION: break;
5837 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5838 hash_mode_chgd = 1; break;
5839 case IDX_RUNTIME: runtime = atoi (optarg);
5840 runtime_chgd = 1; break;
5841 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5842 attack_mode_chgd = 1; break;
5843 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5844 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5845 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5846 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5847 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5848 rp_gen_seed_chgd = 1; break;
5849 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5850 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5851 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5852 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5853 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5854 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5855 case IDX_OUTFILE: outfile = optarg; break;
5856 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5857 outfile_format_chgd = 1; break;
5858 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5859 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5860 case IDX_HEX_CHARSET: hex_charset = 1; break;
5861 case IDX_HEX_SALT: hex_salt = 1; break;
5862 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5863 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5864 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5865 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5866 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5867 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5868 opencl_vector_width_chgd = 1; break;
5869 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5870 workload_profile_chgd = 1; break;
5871 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5872 kernel_accel_chgd = 1; break;
5873 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5874 kernel_loops_chgd = 1; break;
5875 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5876 #ifdef HAVE_HWMON
5877 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5878 #ifdef HAVE_ADL
5879 gpu_temp_abort_chgd = 1;
5880 #endif
5881 break;
5882 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5883 #ifdef HAVE_ADL
5884 gpu_temp_retain_chgd = 1;
5885 #endif
5886 break;
5887 #ifdef HAVE_ADL
5888 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5889 #endif
5890 #endif // HAVE_HWMON
5891 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5892 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5893 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5894 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5895 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5896 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5897 case IDX_SEPARATOR: separator = optarg[0]; break;
5898 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5899 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5900 case IDX_INCREMENT: increment = 1; break;
5901 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5902 increment_min_chgd = 1; break;
5903 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5904 increment_max_chgd = 1; break;
5905 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5906 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5907 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5908 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5909
5910 default:
5911 log_error ("ERROR: Invalid argument specified");
5912 return (-1);
5913 }
5914 }
5915
5916 if (optopt != 0)
5917 {
5918 log_error ("ERROR: Invalid argument specified");
5919
5920 return (-1);
5921 }
5922
5923 /**
5924 * Inform user things getting started,
5925 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5926 * - we do not need to check algorithm_pos
5927 */
5928
5929 if (quiet == 0)
5930 {
5931 if (benchmark == 1)
5932 {
5933 if (status_automat == 0)
5934 {
5935 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5936 log_info ("");
5937 }
5938 else
5939 {
5940 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5941 }
5942 }
5943 else if (restore == 1)
5944 {
5945 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5946 log_info ("");
5947 }
5948 else
5949 {
5950 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5951 log_info ("");
5952 }
5953 }
5954
5955 /**
5956 * sanity check
5957 */
5958
5959 if (attack_mode > 7)
5960 {
5961 log_error ("ERROR: Invalid attack-mode specified");
5962
5963 return (-1);
5964 }
5965
5966 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5967 {
5968 log_error ("ERROR: Invalid runtime specified");
5969
5970 return (-1);
5971 }
5972
5973 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5974 {
5975 log_error ("ERROR: Invalid hash-type specified");
5976
5977 return (-1);
5978 }
5979
5980 // renamed hash modes
5981
5982 if (hash_mode_chgd)
5983 {
5984 int n = -1;
5985
5986 switch (hash_mode)
5987 {
5988 case 123: n = 124;
5989 break;
5990 }
5991
5992 if (n >= 0)
5993 {
5994 log_error ("Old -m specified, use -m %d instead", n);
5995
5996 return (-1);
5997 }
5998 }
5999
6000 if (username == 1)
6001 {
6002 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6003 {
6004 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6005
6006 return (-1);
6007 }
6008 }
6009
6010 if (outfile_format > 16)
6011 {
6012 log_error ("ERROR: Invalid outfile-format specified");
6013
6014 return (-1);
6015 }
6016
6017 if (left == 1)
6018 {
6019 if (outfile_format_chgd == 1)
6020 {
6021 if (outfile_format > 1)
6022 {
6023 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6024
6025 return (-1);
6026 }
6027 }
6028 else
6029 {
6030 outfile_format = OUTFILE_FMT_HASH;
6031 }
6032 }
6033
6034 if (show == 1)
6035 {
6036 if (outfile_format_chgd == 1)
6037 {
6038 if ((outfile_format > 7) && (outfile_format < 16))
6039 {
6040 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6041
6042 return (-1);
6043 }
6044 }
6045 }
6046
6047 if (increment_min < INCREMENT_MIN)
6048 {
6049 log_error ("ERROR: Invalid increment-min specified");
6050
6051 return (-1);
6052 }
6053
6054 if (increment_max > INCREMENT_MAX)
6055 {
6056 log_error ("ERROR: Invalid increment-max specified");
6057
6058 return (-1);
6059 }
6060
6061 if (increment_min > increment_max)
6062 {
6063 log_error ("ERROR: Invalid increment-min specified");
6064
6065 return (-1);
6066 }
6067
6068 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6069 {
6070 log_error ("ERROR: increment is not allowed in attack-mode 0");
6071
6072 return (-1);
6073 }
6074
6075 if ((increment == 0) && (increment_min_chgd == 1))
6076 {
6077 log_error ("ERROR: increment-min is only supported together with increment switch");
6078
6079 return (-1);
6080 }
6081
6082 if ((increment == 0) && (increment_max_chgd == 1))
6083 {
6084 log_error ("ERROR: increment-max is only supported together with increment switch");
6085
6086 return (-1);
6087 }
6088
6089 if (rp_files_cnt && rp_gen)
6090 {
6091 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6092
6093 return (-1);
6094 }
6095
6096 if (rp_files_cnt || rp_gen)
6097 {
6098 if (attack_mode != ATTACK_MODE_STRAIGHT)
6099 {
6100 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6101
6102 return (-1);
6103 }
6104 }
6105
6106 if (rp_gen_func_min > rp_gen_func_max)
6107 {
6108 log_error ("ERROR: Invalid rp-gen-func-min specified");
6109
6110 return (-1);
6111 }
6112
6113 if (kernel_accel_chgd == 1)
6114 {
6115 if (force == 0)
6116 {
6117 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6118 log_info ("Please consider using the option -w instead");
6119 log_info ("You can use --force to override this but do not post error reports if you do so");
6120 log_info ("");
6121
6122 return (-1);
6123 }
6124
6125 if (kernel_accel < 1)
6126 {
6127 log_error ("ERROR: Invalid kernel-accel specified");
6128
6129 return (-1);
6130 }
6131
6132 if (kernel_accel > 1024)
6133 {
6134 log_error ("ERROR: Invalid kernel-accel specified");
6135
6136 return (-1);
6137 }
6138 }
6139
6140 if (kernel_loops_chgd == 1)
6141 {
6142 if (force == 0)
6143 {
6144 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6145 log_info ("Please consider using the option -w instead");
6146 log_info ("You can use --force to override this but do not post error reports if you do so");
6147 log_info ("");
6148
6149 return (-1);
6150 }
6151
6152 if (kernel_loops < 1)
6153 {
6154 log_error ("ERROR: Invalid kernel-loops specified");
6155
6156 return (-1);
6157 }
6158
6159 if (kernel_loops > 1024)
6160 {
6161 log_error ("ERROR: Invalid kernel-loops specified");
6162
6163 return (-1);
6164 }
6165 }
6166
6167 if ((workload_profile < 1) || (workload_profile > 4))
6168 {
6169 log_error ("ERROR: workload-profile %i not available", workload_profile);
6170
6171 return (-1);
6172 }
6173
6174 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6175 {
6176 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6177
6178 return (-1);
6179 }
6180
6181 if (show == 1 || left == 1)
6182 {
6183 attack_mode = ATTACK_MODE_NONE;
6184
6185 if (remove == 1)
6186 {
6187 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6188
6189 return (-1);
6190 }
6191
6192 if (potfile_disable == 1)
6193 {
6194 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6195
6196 return (-1);
6197 }
6198 }
6199
6200 uint attack_kern = ATTACK_KERN_NONE;
6201
6202 switch (attack_mode)
6203 {
6204 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6205 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6206 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6207 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6208 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6209 }
6210
6211 if (benchmark == 0)
6212 {
6213 if (keyspace == 1)
6214 {
6215 int num_additional_params = 1;
6216
6217 if (attack_kern == ATTACK_KERN_COMBI)
6218 {
6219 num_additional_params = 2;
6220 }
6221
6222 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6223
6224 if (keyspace_wordlist_specified == 0) optind--;
6225 }
6226
6227 if (attack_kern == ATTACK_KERN_NONE)
6228 {
6229 if ((optind + 1) != myargc)
6230 {
6231 usage_mini_print (myargv[0]);
6232
6233 return (-1);
6234 }
6235 }
6236 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6237 {
6238 if ((optind + 1) > myargc)
6239 {
6240 usage_mini_print (myargv[0]);
6241
6242 return (-1);
6243 }
6244 }
6245 else if (attack_kern == ATTACK_KERN_COMBI)
6246 {
6247 if ((optind + 3) != myargc)
6248 {
6249 usage_mini_print (myargv[0]);
6250
6251 return (-1);
6252 }
6253 }
6254 else if (attack_kern == ATTACK_KERN_BF)
6255 {
6256 if ((optind + 1) > myargc)
6257 {
6258 usage_mini_print (myargv[0]);
6259
6260 return (-1);
6261 }
6262 }
6263 else
6264 {
6265 usage_mini_print (myargv[0]);
6266
6267 return (-1);
6268 }
6269 }
6270 else
6271 {
6272 if (myargv[optind] != 0)
6273 {
6274 log_error ("ERROR: Invalid argument for benchmark mode specified");
6275
6276 return (-1);
6277 }
6278
6279 if (attack_mode_chgd == 1)
6280 {
6281 if (attack_mode != ATTACK_MODE_BF)
6282 {
6283 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6284
6285 return (-1);
6286 }
6287 }
6288 }
6289
6290 if (skip != 0 && limit != 0)
6291 {
6292 limit += skip;
6293 }
6294
6295 if (keyspace == 1)
6296 {
6297 if (show == 1)
6298 {
6299 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6300
6301 return (-1);
6302 }
6303 else if (left == 1)
6304 {
6305 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6306
6307 return (-1);
6308 }
6309
6310 potfile_disable = 1;
6311
6312 restore_disable = 1;
6313
6314 restore = 0;
6315
6316 weak_hash_threshold = 0;
6317
6318 quiet = 1;
6319 }
6320
6321 if (remove_timer_chgd == 1)
6322 {
6323 if (remove == 0)
6324 {
6325 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6326
6327 return (-1);
6328 }
6329
6330 if (remove_timer < 1)
6331 {
6332 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6333
6334 return (-1);
6335 }
6336 }
6337
6338 if (loopback == 1)
6339 {
6340 if (attack_mode == ATTACK_MODE_STRAIGHT)
6341 {
6342 if ((rp_files_cnt == 0) && (rp_gen == 0))
6343 {
6344 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6345
6346 return (-1);
6347 }
6348 }
6349 else
6350 {
6351 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6352
6353 return (-1);
6354 }
6355 }
6356
6357 if (debug_mode > 0)
6358 {
6359 if (attack_mode != ATTACK_MODE_STRAIGHT)
6360 {
6361 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6362
6363 return (-1);
6364 }
6365
6366 if ((rp_files_cnt == 0) && (rp_gen == 0))
6367 {
6368 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6369
6370 return (-1);
6371 }
6372 }
6373
6374 if (debug_mode > 4)
6375 {
6376 log_error ("ERROR: Invalid debug-mode specified");
6377
6378 return (-1);
6379 }
6380
6381 if (debug_file != NULL)
6382 {
6383 if (debug_mode < 1)
6384 {
6385 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6386
6387 return (-1);
6388 }
6389 }
6390
6391 if (induction_dir != NULL)
6392 {
6393 if (attack_mode == ATTACK_MODE_BF)
6394 {
6395 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6396
6397 return (-1);
6398 }
6399 }
6400
6401 if (attack_mode != ATTACK_MODE_STRAIGHT)
6402 {
6403 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6404 {
6405 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6406
6407 return (-1);
6408 }
6409
6410 weak_hash_threshold = 0;
6411 }
6412
6413 /**
6414 * induction directory
6415 */
6416
6417 char *induction_directory = NULL;
6418
6419 if (attack_mode != ATTACK_MODE_BF)
6420 {
6421 if (induction_dir == NULL)
6422 {
6423 induction_directory = (char *) mymalloc (session_size);
6424
6425 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6426
6427 // create induction folder if it does not already exist
6428
6429 if (keyspace == 0)
6430 {
6431 if (rmdir (induction_directory) == -1)
6432 {
6433 if (errno == ENOENT)
6434 {
6435 // good, we can ignore
6436 }
6437 else if (errno == ENOTEMPTY)
6438 {
6439 char *induction_directory_mv = (char *) mymalloc (session_size);
6440
6441 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6442
6443 if (rename (induction_directory, induction_directory_mv) != 0)
6444 {
6445 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6446
6447 return (-1);
6448 }
6449 }
6450 else
6451 {
6452 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6453
6454 return (-1);
6455 }
6456 }
6457
6458 if (mkdir (induction_directory, 0700) == -1)
6459 {
6460 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6461
6462 return (-1);
6463 }
6464 }
6465 }
6466 else
6467 {
6468 induction_directory = induction_dir;
6469 }
6470 }
6471
6472 data.induction_directory = induction_directory;
6473
6474 /**
6475 * loopback
6476 */
6477
6478 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6479
6480 char *loopback_file = (char *) mymalloc (loopback_size);
6481
6482 /**
6483 * tuning db
6484 */
6485
6486 char tuning_db_file[256] = { 0 };
6487
6488 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6489
6490 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6491
6492 /**
6493 * outfile-check directory
6494 */
6495
6496 char *outfile_check_directory = NULL;
6497
6498 if (outfile_check_dir == NULL)
6499 {
6500 outfile_check_directory = (char *) mymalloc (session_size);
6501
6502 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6503 }
6504 else
6505 {
6506 outfile_check_directory = outfile_check_dir;
6507 }
6508
6509 data.outfile_check_directory = outfile_check_directory;
6510
6511 if (keyspace == 0)
6512 {
6513 struct stat outfile_check_stat;
6514
6515 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6516 {
6517 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6518
6519 if (is_dir == 0)
6520 {
6521 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6522
6523 return (-1);
6524 }
6525 }
6526 else if (outfile_check_dir == NULL)
6527 {
6528 if (mkdir (outfile_check_directory, 0700) == -1)
6529 {
6530 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6531
6532 return (-1);
6533 }
6534 }
6535 }
6536
6537 /**
6538 * special other stuff
6539 */
6540
6541 if (hash_mode == 9710)
6542 {
6543 outfile_format = 5;
6544 outfile_format_chgd = 1;
6545 }
6546
6547 if (hash_mode == 9810)
6548 {
6549 outfile_format = 5;
6550 outfile_format_chgd = 1;
6551 }
6552
6553 if (hash_mode == 10410)
6554 {
6555 outfile_format = 5;
6556 outfile_format_chgd = 1;
6557 }
6558
6559 /**
6560 * store stuff
6561 */
6562
6563 data.hash_mode = hash_mode;
6564 data.restore = restore;
6565 data.restore_timer = restore_timer;
6566 data.restore_disable = restore_disable;
6567 data.status = status;
6568 data.status_timer = status_timer;
6569 data.status_automat = status_automat;
6570 data.loopback = loopback;
6571 data.runtime = runtime;
6572 data.remove = remove;
6573 data.remove_timer = remove_timer;
6574 data.debug_mode = debug_mode;
6575 data.debug_file = debug_file;
6576 data.username = username;
6577 data.quiet = quiet;
6578 data.outfile = outfile;
6579 data.outfile_format = outfile_format;
6580 data.outfile_autohex = outfile_autohex;
6581 data.hex_charset = hex_charset;
6582 data.hex_salt = hex_salt;
6583 data.hex_wordlist = hex_wordlist;
6584 data.separator = separator;
6585 data.rp_files = rp_files;
6586 data.rp_files_cnt = rp_files_cnt;
6587 data.rp_gen = rp_gen;
6588 data.rp_gen_seed = rp_gen_seed;
6589 data.force = force;
6590 data.benchmark = benchmark;
6591 data.skip = skip;
6592 data.limit = limit;
6593 #ifdef HAVE_HWMON
6594 #ifdef HAVE_ADL
6595 data.powertune_enable = powertune_enable;
6596 #endif
6597 #endif
6598 data.logfile_disable = logfile_disable;
6599 data.truecrypt_keyfiles = truecrypt_keyfiles;
6600 data.veracrypt_keyfiles = veracrypt_keyfiles;
6601 data.veracrypt_pim = veracrypt_pim;
6602 data.scrypt_tmto = scrypt_tmto;
6603 data.workload_profile = workload_profile;
6604
6605 /**
6606 * cpu affinity
6607 */
6608
6609 if (cpu_affinity)
6610 {
6611 set_cpu_affinity (cpu_affinity);
6612 }
6613
6614 if (rp_gen_seed_chgd == 0)
6615 {
6616 srand (proc_start);
6617 }
6618 else
6619 {
6620 srand (rp_gen_seed);
6621 }
6622
6623 /**
6624 * logfile init
6625 */
6626
6627 if (logfile_disable == 0)
6628 {
6629 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6630
6631 char *logfile = (char *) mymalloc (logfile_size);
6632
6633 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6634
6635 data.logfile = logfile;
6636
6637 char *topid = logfile_generate_topid ();
6638
6639 data.topid = topid;
6640 }
6641
6642 // logfile_append() checks for logfile_disable internally to make it easier from here
6643
6644 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6645 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6646 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6647 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6648 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6649 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6650 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6651 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6652 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6653 #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));
6654
6655 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6656 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6657 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6658 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6659 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6660 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6661 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6662 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6663
6664 logfile_top_msg ("START");
6665
6666 logfile_top_uint (attack_mode);
6667 logfile_top_uint (attack_kern);
6668 logfile_top_uint (benchmark);
6669 logfile_top_uint (bitmap_min);
6670 logfile_top_uint (bitmap_max);
6671 logfile_top_uint (debug_mode);
6672 logfile_top_uint (force);
6673 logfile_top_uint (kernel_accel);
6674 logfile_top_uint (kernel_loops);
6675 logfile_top_uint (gpu_temp_disable);
6676 #ifdef HAVE_HWMON
6677 logfile_top_uint (gpu_temp_abort);
6678 logfile_top_uint (gpu_temp_retain);
6679 #endif
6680 logfile_top_uint (hash_mode);
6681 logfile_top_uint (hex_charset);
6682 logfile_top_uint (hex_salt);
6683 logfile_top_uint (hex_wordlist);
6684 logfile_top_uint (increment);
6685 logfile_top_uint (increment_max);
6686 logfile_top_uint (increment_min);
6687 logfile_top_uint (keyspace);
6688 logfile_top_uint (left);
6689 logfile_top_uint (logfile_disable);
6690 logfile_top_uint (loopback);
6691 logfile_top_uint (markov_classic);
6692 logfile_top_uint (markov_disable);
6693 logfile_top_uint (markov_threshold);
6694 logfile_top_uint (outfile_autohex);
6695 logfile_top_uint (outfile_check_timer);
6696 logfile_top_uint (outfile_format);
6697 logfile_top_uint (potfile_disable);
6698 logfile_top_string (potfile_path);
6699 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6700 logfile_top_uint (powertune_enable);
6701 #endif
6702 logfile_top_uint (scrypt_tmto);
6703 logfile_top_uint (quiet);
6704 logfile_top_uint (remove);
6705 logfile_top_uint (remove_timer);
6706 logfile_top_uint (restore);
6707 logfile_top_uint (restore_disable);
6708 logfile_top_uint (restore_timer);
6709 logfile_top_uint (rp_gen);
6710 logfile_top_uint (rp_gen_func_max);
6711 logfile_top_uint (rp_gen_func_min);
6712 logfile_top_uint (rp_gen_seed);
6713 logfile_top_uint (runtime);
6714 logfile_top_uint (segment_size);
6715 logfile_top_uint (show);
6716 logfile_top_uint (status);
6717 logfile_top_uint (status_automat);
6718 logfile_top_uint (status_timer);
6719 logfile_top_uint (usage);
6720 logfile_top_uint (username);
6721 logfile_top_uint (version);
6722 logfile_top_uint (weak_hash_threshold);
6723 logfile_top_uint (workload_profile);
6724 logfile_top_uint64 (limit);
6725 logfile_top_uint64 (skip);
6726 logfile_top_char (separator);
6727 logfile_top_string (cpu_affinity);
6728 logfile_top_string (custom_charset_1);
6729 logfile_top_string (custom_charset_2);
6730 logfile_top_string (custom_charset_3);
6731 logfile_top_string (custom_charset_4);
6732 logfile_top_string (debug_file);
6733 logfile_top_string (opencl_devices);
6734 logfile_top_string (opencl_platforms);
6735 logfile_top_string (opencl_device_types);
6736 logfile_top_uint (opencl_vector_width);
6737 logfile_top_string (induction_dir);
6738 logfile_top_string (markov_hcstat);
6739 logfile_top_string (outfile);
6740 logfile_top_string (outfile_check_dir);
6741 logfile_top_string (rule_buf_l);
6742 logfile_top_string (rule_buf_r);
6743 logfile_top_string (session);
6744 logfile_top_string (truecrypt_keyfiles);
6745 logfile_top_string (veracrypt_keyfiles);
6746 logfile_top_uint (veracrypt_pim);
6747
6748 /**
6749 * Init OpenCL library loader
6750 */
6751
6752 if (keyspace == 0)
6753 {
6754 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6755
6756 ocl_init (ocl);
6757
6758 data.ocl = ocl;
6759 }
6760
6761 /**
6762 * OpenCL platform selection
6763 */
6764
6765 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6766
6767 /**
6768 * OpenCL device selection
6769 */
6770
6771 u32 devices_filter = setup_devices_filter (opencl_devices);
6772
6773 /**
6774 * OpenCL device type selection
6775 */
6776
6777 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6778
6779 /**
6780 * benchmark
6781 */
6782
6783 if (benchmark == 1)
6784 {
6785 /**
6786 * disable useless stuff for benchmark
6787 */
6788
6789 status_timer = 0;
6790 restore_timer = 0;
6791 restore_disable = 1;
6792 potfile_disable = 1;
6793 weak_hash_threshold = 0;
6794 gpu_temp_disable = 1;
6795
6796 data.status_timer = status_timer;
6797 data.restore_timer = restore_timer;
6798 data.restore_disable = restore_disable;
6799
6800 /**
6801 * force attack mode to be bruteforce
6802 */
6803
6804 attack_mode = ATTACK_MODE_BF;
6805 attack_kern = ATTACK_KERN_BF;
6806
6807 if (workload_profile_chgd == 0)
6808 {
6809 workload_profile = 3;
6810
6811 data.workload_profile = workload_profile;
6812 }
6813 }
6814
6815 /**
6816 * config
6817 */
6818
6819 uint hash_type = 0;
6820 uint salt_type = 0;
6821 uint attack_exec = 0;
6822 uint opts_type = 0;
6823 uint kern_type = 0;
6824 uint dgst_size = 0;
6825 uint esalt_size = 0;
6826 uint opti_type = 0;
6827 uint dgst_pos0 = -1;
6828 uint dgst_pos1 = -1;
6829 uint dgst_pos2 = -1;
6830 uint dgst_pos3 = -1;
6831
6832 int (*parse_func) (char *, uint, hash_t *);
6833 int (*sort_by_digest) (const void *, const void *);
6834
6835 uint algorithm_pos = 0;
6836 uint algorithm_max = 1;
6837
6838 uint *algorithms = default_benchmark_algorithms;
6839
6840 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6841
6842 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6843 {
6844 /*
6845 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6846 * the following algos are skipped entirely
6847 */
6848
6849 if (algorithm_pos > 0)
6850 {
6851 local_free (rd);
6852
6853 rd = init_restore (argc, argv);
6854
6855 data.rd = rd;
6856 }
6857
6858 /**
6859 * update hash_mode in case of multihash benchmark
6860 */
6861
6862 if (benchmark == 1)
6863 {
6864 if (hash_mode_chgd == 0)
6865 {
6866 hash_mode = algorithms[algorithm_pos];
6867
6868 data.hash_mode = hash_mode;
6869 }
6870
6871 quiet = 1;
6872
6873 data.quiet = quiet;
6874 }
6875
6876 switch (hash_mode)
6877 {
6878 case 0: hash_type = HASH_TYPE_MD5;
6879 salt_type = SALT_TYPE_NONE;
6880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6881 opts_type = OPTS_TYPE_PT_GENERATE_LE
6882 | OPTS_TYPE_PT_ADD80
6883 | OPTS_TYPE_PT_ADDBITS14;
6884 kern_type = KERN_TYPE_MD5;
6885 dgst_size = DGST_SIZE_4_4;
6886 parse_func = md5_parse_hash;
6887 sort_by_digest = sort_by_digest_4_4;
6888 opti_type = OPTI_TYPE_ZERO_BYTE
6889 | OPTI_TYPE_PRECOMPUTE_INIT
6890 | OPTI_TYPE_PRECOMPUTE_MERKLE
6891 | OPTI_TYPE_MEET_IN_MIDDLE
6892 | OPTI_TYPE_EARLY_SKIP
6893 | OPTI_TYPE_NOT_ITERATED
6894 | OPTI_TYPE_NOT_SALTED
6895 | OPTI_TYPE_RAW_HASH;
6896 dgst_pos0 = 0;
6897 dgst_pos1 = 3;
6898 dgst_pos2 = 2;
6899 dgst_pos3 = 1;
6900 break;
6901
6902 case 10: hash_type = HASH_TYPE_MD5;
6903 salt_type = SALT_TYPE_INTERN;
6904 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6905 opts_type = OPTS_TYPE_PT_GENERATE_LE
6906 | OPTS_TYPE_ST_ADD80
6907 | OPTS_TYPE_ST_ADDBITS14;
6908 kern_type = KERN_TYPE_MD5_PWSLT;
6909 dgst_size = DGST_SIZE_4_4;
6910 parse_func = md5s_parse_hash;
6911 sort_by_digest = sort_by_digest_4_4;
6912 opti_type = OPTI_TYPE_ZERO_BYTE
6913 | OPTI_TYPE_PRECOMPUTE_INIT
6914 | OPTI_TYPE_PRECOMPUTE_MERKLE
6915 | OPTI_TYPE_MEET_IN_MIDDLE
6916 | OPTI_TYPE_EARLY_SKIP
6917 | OPTI_TYPE_NOT_ITERATED
6918 | OPTI_TYPE_APPENDED_SALT
6919 | OPTI_TYPE_RAW_HASH;
6920 dgst_pos0 = 0;
6921 dgst_pos1 = 3;
6922 dgst_pos2 = 2;
6923 dgst_pos3 = 1;
6924 break;
6925
6926 case 11: hash_type = HASH_TYPE_MD5;
6927 salt_type = SALT_TYPE_INTERN;
6928 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6929 opts_type = OPTS_TYPE_PT_GENERATE_LE
6930 | OPTS_TYPE_ST_ADD80
6931 | OPTS_TYPE_ST_ADDBITS14;
6932 kern_type = KERN_TYPE_MD5_PWSLT;
6933 dgst_size = DGST_SIZE_4_4;
6934 parse_func = joomla_parse_hash;
6935 sort_by_digest = sort_by_digest_4_4;
6936 opti_type = OPTI_TYPE_ZERO_BYTE
6937 | OPTI_TYPE_PRECOMPUTE_INIT
6938 | OPTI_TYPE_PRECOMPUTE_MERKLE
6939 | OPTI_TYPE_MEET_IN_MIDDLE
6940 | OPTI_TYPE_EARLY_SKIP
6941 | OPTI_TYPE_NOT_ITERATED
6942 | OPTI_TYPE_APPENDED_SALT
6943 | OPTI_TYPE_RAW_HASH;
6944 dgst_pos0 = 0;
6945 dgst_pos1 = 3;
6946 dgst_pos2 = 2;
6947 dgst_pos3 = 1;
6948 break;
6949
6950 case 12: hash_type = HASH_TYPE_MD5;
6951 salt_type = SALT_TYPE_INTERN;
6952 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6953 opts_type = OPTS_TYPE_PT_GENERATE_LE
6954 | OPTS_TYPE_ST_ADD80
6955 | OPTS_TYPE_ST_ADDBITS14;
6956 kern_type = KERN_TYPE_MD5_PWSLT;
6957 dgst_size = DGST_SIZE_4_4;
6958 parse_func = postgresql_parse_hash;
6959 sort_by_digest = sort_by_digest_4_4;
6960 opti_type = OPTI_TYPE_ZERO_BYTE
6961 | OPTI_TYPE_PRECOMPUTE_INIT
6962 | OPTI_TYPE_PRECOMPUTE_MERKLE
6963 | OPTI_TYPE_MEET_IN_MIDDLE
6964 | OPTI_TYPE_EARLY_SKIP
6965 | OPTI_TYPE_NOT_ITERATED
6966 | OPTI_TYPE_APPENDED_SALT
6967 | OPTI_TYPE_RAW_HASH;
6968 dgst_pos0 = 0;
6969 dgst_pos1 = 3;
6970 dgst_pos2 = 2;
6971 dgst_pos3 = 1;
6972 break;
6973
6974 case 20: hash_type = HASH_TYPE_MD5;
6975 salt_type = SALT_TYPE_INTERN;
6976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6977 opts_type = OPTS_TYPE_PT_GENERATE_LE
6978 | OPTS_TYPE_PT_ADD80
6979 | OPTS_TYPE_PT_ADDBITS14;
6980 kern_type = KERN_TYPE_MD5_SLTPW;
6981 dgst_size = DGST_SIZE_4_4;
6982 parse_func = md5s_parse_hash;
6983 sort_by_digest = sort_by_digest_4_4;
6984 opti_type = OPTI_TYPE_ZERO_BYTE
6985 | OPTI_TYPE_PRECOMPUTE_INIT
6986 | OPTI_TYPE_PRECOMPUTE_MERKLE
6987 | OPTI_TYPE_EARLY_SKIP
6988 | OPTI_TYPE_NOT_ITERATED
6989 | OPTI_TYPE_PREPENDED_SALT
6990 | OPTI_TYPE_RAW_HASH;
6991 dgst_pos0 = 0;
6992 dgst_pos1 = 3;
6993 dgst_pos2 = 2;
6994 dgst_pos3 = 1;
6995 break;
6996
6997 case 21: hash_type = HASH_TYPE_MD5;
6998 salt_type = SALT_TYPE_INTERN;
6999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7000 opts_type = OPTS_TYPE_PT_GENERATE_LE
7001 | OPTS_TYPE_PT_ADD80
7002 | OPTS_TYPE_PT_ADDBITS14;
7003 kern_type = KERN_TYPE_MD5_SLTPW;
7004 dgst_size = DGST_SIZE_4_4;
7005 parse_func = osc_parse_hash;
7006 sort_by_digest = sort_by_digest_4_4;
7007 opti_type = OPTI_TYPE_ZERO_BYTE
7008 | OPTI_TYPE_PRECOMPUTE_INIT
7009 | OPTI_TYPE_PRECOMPUTE_MERKLE
7010 | OPTI_TYPE_EARLY_SKIP
7011 | OPTI_TYPE_NOT_ITERATED
7012 | OPTI_TYPE_PREPENDED_SALT
7013 | OPTI_TYPE_RAW_HASH;
7014 dgst_pos0 = 0;
7015 dgst_pos1 = 3;
7016 dgst_pos2 = 2;
7017 dgst_pos3 = 1;
7018 break;
7019
7020 case 22: hash_type = HASH_TYPE_MD5;
7021 salt_type = SALT_TYPE_EMBEDDED;
7022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7023 opts_type = OPTS_TYPE_PT_GENERATE_LE
7024 | OPTS_TYPE_PT_ADD80
7025 | OPTS_TYPE_PT_ADDBITS14;
7026 kern_type = KERN_TYPE_MD5_SLTPW;
7027 dgst_size = DGST_SIZE_4_4;
7028 parse_func = netscreen_parse_hash;
7029 sort_by_digest = sort_by_digest_4_4;
7030 opti_type = OPTI_TYPE_ZERO_BYTE
7031 | OPTI_TYPE_PRECOMPUTE_INIT
7032 | OPTI_TYPE_PRECOMPUTE_MERKLE
7033 | OPTI_TYPE_EARLY_SKIP
7034 | OPTI_TYPE_NOT_ITERATED
7035 | OPTI_TYPE_PREPENDED_SALT
7036 | OPTI_TYPE_RAW_HASH;
7037 dgst_pos0 = 0;
7038 dgst_pos1 = 3;
7039 dgst_pos2 = 2;
7040 dgst_pos3 = 1;
7041 break;
7042
7043 case 23: hash_type = HASH_TYPE_MD5;
7044 salt_type = SALT_TYPE_EMBEDDED;
7045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7046 opts_type = OPTS_TYPE_PT_GENERATE_LE
7047 | OPTS_TYPE_PT_ADD80
7048 | OPTS_TYPE_PT_ADDBITS14;
7049 kern_type = KERN_TYPE_MD5_SLTPW;
7050 dgst_size = DGST_SIZE_4_4;
7051 parse_func = skype_parse_hash;
7052 sort_by_digest = sort_by_digest_4_4;
7053 opti_type = OPTI_TYPE_ZERO_BYTE
7054 | OPTI_TYPE_PRECOMPUTE_INIT
7055 | OPTI_TYPE_PRECOMPUTE_MERKLE
7056 | OPTI_TYPE_EARLY_SKIP
7057 | OPTI_TYPE_NOT_ITERATED
7058 | OPTI_TYPE_PREPENDED_SALT
7059 | OPTI_TYPE_RAW_HASH;
7060 dgst_pos0 = 0;
7061 dgst_pos1 = 3;
7062 dgst_pos2 = 2;
7063 dgst_pos3 = 1;
7064 break;
7065
7066 case 30: hash_type = HASH_TYPE_MD5;
7067 salt_type = SALT_TYPE_INTERN;
7068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7069 opts_type = OPTS_TYPE_PT_GENERATE_LE
7070 | OPTS_TYPE_PT_UNICODE
7071 | OPTS_TYPE_ST_ADD80
7072 | OPTS_TYPE_ST_ADDBITS14;
7073 kern_type = KERN_TYPE_MD5_PWUSLT;
7074 dgst_size = DGST_SIZE_4_4;
7075 parse_func = md5s_parse_hash;
7076 sort_by_digest = sort_by_digest_4_4;
7077 opti_type = OPTI_TYPE_ZERO_BYTE
7078 | OPTI_TYPE_PRECOMPUTE_INIT
7079 | OPTI_TYPE_PRECOMPUTE_MERKLE
7080 | OPTI_TYPE_MEET_IN_MIDDLE
7081 | OPTI_TYPE_EARLY_SKIP
7082 | OPTI_TYPE_NOT_ITERATED
7083 | OPTI_TYPE_APPENDED_SALT
7084 | OPTI_TYPE_RAW_HASH;
7085 dgst_pos0 = 0;
7086 dgst_pos1 = 3;
7087 dgst_pos2 = 2;
7088 dgst_pos3 = 1;
7089 break;
7090
7091 case 40: hash_type = HASH_TYPE_MD5;
7092 salt_type = SALT_TYPE_INTERN;
7093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7094 opts_type = OPTS_TYPE_PT_GENERATE_LE
7095 | OPTS_TYPE_PT_ADD80
7096 | OPTS_TYPE_PT_ADDBITS14
7097 | OPTS_TYPE_PT_UNICODE;
7098 kern_type = KERN_TYPE_MD5_SLTPWU;
7099 dgst_size = DGST_SIZE_4_4;
7100 parse_func = md5s_parse_hash;
7101 sort_by_digest = sort_by_digest_4_4;
7102 opti_type = OPTI_TYPE_ZERO_BYTE
7103 | OPTI_TYPE_PRECOMPUTE_INIT
7104 | OPTI_TYPE_PRECOMPUTE_MERKLE
7105 | OPTI_TYPE_EARLY_SKIP
7106 | OPTI_TYPE_NOT_ITERATED
7107 | OPTI_TYPE_PREPENDED_SALT
7108 | OPTI_TYPE_RAW_HASH;
7109 dgst_pos0 = 0;
7110 dgst_pos1 = 3;
7111 dgst_pos2 = 2;
7112 dgst_pos3 = 1;
7113 break;
7114
7115 case 50: hash_type = HASH_TYPE_MD5;
7116 salt_type = SALT_TYPE_INTERN;
7117 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7118 opts_type = OPTS_TYPE_PT_GENERATE_LE
7119 | OPTS_TYPE_ST_ADD80
7120 | OPTS_TYPE_ST_ADDBITS14;
7121 kern_type = KERN_TYPE_HMACMD5_PW;
7122 dgst_size = DGST_SIZE_4_4;
7123 parse_func = hmacmd5_parse_hash;
7124 sort_by_digest = sort_by_digest_4_4;
7125 opti_type = OPTI_TYPE_ZERO_BYTE
7126 | OPTI_TYPE_NOT_ITERATED;
7127 dgst_pos0 = 0;
7128 dgst_pos1 = 3;
7129 dgst_pos2 = 2;
7130 dgst_pos3 = 1;
7131 break;
7132
7133 case 60: hash_type = HASH_TYPE_MD5;
7134 salt_type = SALT_TYPE_INTERN;
7135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7136 opts_type = OPTS_TYPE_PT_GENERATE_LE
7137 | OPTS_TYPE_PT_ADD80
7138 | OPTS_TYPE_PT_ADDBITS14;
7139 kern_type = KERN_TYPE_HMACMD5_SLT;
7140 dgst_size = DGST_SIZE_4_4;
7141 parse_func = hmacmd5_parse_hash;
7142 sort_by_digest = sort_by_digest_4_4;
7143 opti_type = OPTI_TYPE_ZERO_BYTE
7144 | OPTI_TYPE_NOT_ITERATED;
7145 dgst_pos0 = 0;
7146 dgst_pos1 = 3;
7147 dgst_pos2 = 2;
7148 dgst_pos3 = 1;
7149 break;
7150
7151 case 100: hash_type = HASH_TYPE_SHA1;
7152 salt_type = SALT_TYPE_NONE;
7153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7154 opts_type = OPTS_TYPE_PT_GENERATE_BE
7155 | OPTS_TYPE_PT_ADD80
7156 | OPTS_TYPE_PT_ADDBITS15;
7157 kern_type = KERN_TYPE_SHA1;
7158 dgst_size = DGST_SIZE_4_5;
7159 parse_func = sha1_parse_hash;
7160 sort_by_digest = sort_by_digest_4_5;
7161 opti_type = OPTI_TYPE_ZERO_BYTE
7162 | OPTI_TYPE_PRECOMPUTE_INIT
7163 | OPTI_TYPE_PRECOMPUTE_MERKLE
7164 | OPTI_TYPE_EARLY_SKIP
7165 | OPTI_TYPE_NOT_ITERATED
7166 | OPTI_TYPE_NOT_SALTED
7167 | OPTI_TYPE_RAW_HASH;
7168 dgst_pos0 = 3;
7169 dgst_pos1 = 4;
7170 dgst_pos2 = 2;
7171 dgst_pos3 = 1;
7172 break;
7173
7174 case 101: hash_type = HASH_TYPE_SHA1;
7175 salt_type = SALT_TYPE_NONE;
7176 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7177 opts_type = OPTS_TYPE_PT_GENERATE_BE
7178 | OPTS_TYPE_PT_ADD80
7179 | OPTS_TYPE_PT_ADDBITS15;
7180 kern_type = KERN_TYPE_SHA1;
7181 dgst_size = DGST_SIZE_4_5;
7182 parse_func = sha1b64_parse_hash;
7183 sort_by_digest = sort_by_digest_4_5;
7184 opti_type = OPTI_TYPE_ZERO_BYTE
7185 | OPTI_TYPE_PRECOMPUTE_INIT
7186 | OPTI_TYPE_PRECOMPUTE_MERKLE
7187 | OPTI_TYPE_EARLY_SKIP
7188 | OPTI_TYPE_NOT_ITERATED
7189 | OPTI_TYPE_NOT_SALTED
7190 | OPTI_TYPE_RAW_HASH;
7191 dgst_pos0 = 3;
7192 dgst_pos1 = 4;
7193 dgst_pos2 = 2;
7194 dgst_pos3 = 1;
7195 break;
7196
7197 case 110: hash_type = HASH_TYPE_SHA1;
7198 salt_type = SALT_TYPE_INTERN;
7199 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7200 opts_type = OPTS_TYPE_PT_GENERATE_BE
7201 | OPTS_TYPE_ST_ADD80
7202 | OPTS_TYPE_ST_ADDBITS15;
7203 kern_type = KERN_TYPE_SHA1_PWSLT;
7204 dgst_size = DGST_SIZE_4_5;
7205 parse_func = sha1s_parse_hash;
7206 sort_by_digest = sort_by_digest_4_5;
7207 opti_type = OPTI_TYPE_ZERO_BYTE
7208 | OPTI_TYPE_PRECOMPUTE_INIT
7209 | OPTI_TYPE_PRECOMPUTE_MERKLE
7210 | OPTI_TYPE_EARLY_SKIP
7211 | OPTI_TYPE_NOT_ITERATED
7212 | OPTI_TYPE_APPENDED_SALT
7213 | OPTI_TYPE_RAW_HASH;
7214 dgst_pos0 = 3;
7215 dgst_pos1 = 4;
7216 dgst_pos2 = 2;
7217 dgst_pos3 = 1;
7218 break;
7219
7220 case 111: hash_type = HASH_TYPE_SHA1;
7221 salt_type = SALT_TYPE_EMBEDDED;
7222 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7223 opts_type = OPTS_TYPE_PT_GENERATE_BE
7224 | OPTS_TYPE_ST_ADD80
7225 | OPTS_TYPE_ST_ADDBITS15;
7226 kern_type = KERN_TYPE_SHA1_PWSLT;
7227 dgst_size = DGST_SIZE_4_5;
7228 parse_func = sha1b64s_parse_hash;
7229 sort_by_digest = sort_by_digest_4_5;
7230 opti_type = OPTI_TYPE_ZERO_BYTE
7231 | OPTI_TYPE_PRECOMPUTE_INIT
7232 | OPTI_TYPE_PRECOMPUTE_MERKLE
7233 | OPTI_TYPE_EARLY_SKIP
7234 | OPTI_TYPE_NOT_ITERATED
7235 | OPTI_TYPE_APPENDED_SALT
7236 | OPTI_TYPE_RAW_HASH;
7237 dgst_pos0 = 3;
7238 dgst_pos1 = 4;
7239 dgst_pos2 = 2;
7240 dgst_pos3 = 1;
7241 break;
7242
7243 case 112: hash_type = HASH_TYPE_SHA1;
7244 salt_type = SALT_TYPE_INTERN;
7245 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7246 opts_type = OPTS_TYPE_PT_GENERATE_BE
7247 | OPTS_TYPE_ST_ADD80
7248 | OPTS_TYPE_ST_ADDBITS15
7249 | OPTS_TYPE_ST_HEX;
7250 kern_type = KERN_TYPE_SHA1_PWSLT;
7251 dgst_size = DGST_SIZE_4_5;
7252 parse_func = oracles_parse_hash;
7253 sort_by_digest = sort_by_digest_4_5;
7254 opti_type = OPTI_TYPE_ZERO_BYTE
7255 | OPTI_TYPE_PRECOMPUTE_INIT
7256 | OPTI_TYPE_PRECOMPUTE_MERKLE
7257 | OPTI_TYPE_EARLY_SKIP
7258 | OPTI_TYPE_NOT_ITERATED
7259 | OPTI_TYPE_APPENDED_SALT
7260 | OPTI_TYPE_RAW_HASH;
7261 dgst_pos0 = 3;
7262 dgst_pos1 = 4;
7263 dgst_pos2 = 2;
7264 dgst_pos3 = 1;
7265 break;
7266
7267 case 120: hash_type = HASH_TYPE_SHA1;
7268 salt_type = SALT_TYPE_INTERN;
7269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7270 opts_type = OPTS_TYPE_PT_GENERATE_BE
7271 | OPTS_TYPE_PT_ADD80
7272 | OPTS_TYPE_PT_ADDBITS15;
7273 kern_type = KERN_TYPE_SHA1_SLTPW;
7274 dgst_size = DGST_SIZE_4_5;
7275 parse_func = sha1s_parse_hash;
7276 sort_by_digest = sort_by_digest_4_5;
7277 opti_type = OPTI_TYPE_ZERO_BYTE
7278 | OPTI_TYPE_PRECOMPUTE_INIT
7279 | OPTI_TYPE_PRECOMPUTE_MERKLE
7280 | OPTI_TYPE_EARLY_SKIP
7281 | OPTI_TYPE_NOT_ITERATED
7282 | OPTI_TYPE_PREPENDED_SALT
7283 | OPTI_TYPE_RAW_HASH;
7284 dgst_pos0 = 3;
7285 dgst_pos1 = 4;
7286 dgst_pos2 = 2;
7287 dgst_pos3 = 1;
7288 break;
7289
7290 case 121: hash_type = HASH_TYPE_SHA1;
7291 salt_type = SALT_TYPE_INTERN;
7292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7293 opts_type = OPTS_TYPE_PT_GENERATE_BE
7294 | OPTS_TYPE_PT_ADD80
7295 | OPTS_TYPE_PT_ADDBITS15
7296 | OPTS_TYPE_ST_LOWER;
7297 kern_type = KERN_TYPE_SHA1_SLTPW;
7298 dgst_size = DGST_SIZE_4_5;
7299 parse_func = smf_parse_hash;
7300 sort_by_digest = sort_by_digest_4_5;
7301 opti_type = OPTI_TYPE_ZERO_BYTE
7302 | OPTI_TYPE_PRECOMPUTE_INIT
7303 | OPTI_TYPE_PRECOMPUTE_MERKLE
7304 | OPTI_TYPE_EARLY_SKIP
7305 | OPTI_TYPE_NOT_ITERATED
7306 | OPTI_TYPE_PREPENDED_SALT
7307 | OPTI_TYPE_RAW_HASH;
7308 dgst_pos0 = 3;
7309 dgst_pos1 = 4;
7310 dgst_pos2 = 2;
7311 dgst_pos3 = 1;
7312 break;
7313
7314 case 122: hash_type = HASH_TYPE_SHA1;
7315 salt_type = SALT_TYPE_EMBEDDED;
7316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7317 opts_type = OPTS_TYPE_PT_GENERATE_BE
7318 | OPTS_TYPE_PT_ADD80
7319 | OPTS_TYPE_PT_ADDBITS15
7320 | OPTS_TYPE_ST_HEX;
7321 kern_type = KERN_TYPE_SHA1_SLTPW;
7322 dgst_size = DGST_SIZE_4_5;
7323 parse_func = osx1_parse_hash;
7324 sort_by_digest = sort_by_digest_4_5;
7325 opti_type = OPTI_TYPE_ZERO_BYTE
7326 | OPTI_TYPE_PRECOMPUTE_INIT
7327 | OPTI_TYPE_PRECOMPUTE_MERKLE
7328 | OPTI_TYPE_EARLY_SKIP
7329 | OPTI_TYPE_NOT_ITERATED
7330 | OPTI_TYPE_PREPENDED_SALT
7331 | OPTI_TYPE_RAW_HASH;
7332 dgst_pos0 = 3;
7333 dgst_pos1 = 4;
7334 dgst_pos2 = 2;
7335 dgst_pos3 = 1;
7336 break;
7337
7338 case 124: hash_type = HASH_TYPE_SHA1;
7339 salt_type = SALT_TYPE_EMBEDDED;
7340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7341 opts_type = OPTS_TYPE_PT_GENERATE_BE
7342 | OPTS_TYPE_PT_ADD80
7343 | OPTS_TYPE_PT_ADDBITS15;
7344 kern_type = KERN_TYPE_SHA1_SLTPW;
7345 dgst_size = DGST_SIZE_4_5;
7346 parse_func = djangosha1_parse_hash;
7347 sort_by_digest = sort_by_digest_4_5;
7348 opti_type = OPTI_TYPE_ZERO_BYTE
7349 | OPTI_TYPE_PRECOMPUTE_INIT
7350 | OPTI_TYPE_PRECOMPUTE_MERKLE
7351 | OPTI_TYPE_EARLY_SKIP
7352 | OPTI_TYPE_NOT_ITERATED
7353 | OPTI_TYPE_PREPENDED_SALT
7354 | OPTI_TYPE_RAW_HASH;
7355 dgst_pos0 = 3;
7356 dgst_pos1 = 4;
7357 dgst_pos2 = 2;
7358 dgst_pos3 = 1;
7359 break;
7360
7361 case 125: hash_type = HASH_TYPE_SHA1;
7362 salt_type = SALT_TYPE_EMBEDDED;
7363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7364 opts_type = OPTS_TYPE_PT_GENERATE_BE
7365 | OPTS_TYPE_PT_ADD80
7366 | OPTS_TYPE_PT_ADDBITS15
7367 | OPTS_TYPE_ST_HEX;
7368 kern_type = KERN_TYPE_SHA1_SLTPW;
7369 dgst_size = DGST_SIZE_4_5;
7370 parse_func = arubaos_parse_hash;
7371 sort_by_digest = sort_by_digest_4_5;
7372 opti_type = OPTI_TYPE_ZERO_BYTE
7373 | OPTI_TYPE_PRECOMPUTE_INIT
7374 | OPTI_TYPE_PRECOMPUTE_MERKLE
7375 | OPTI_TYPE_EARLY_SKIP
7376 | OPTI_TYPE_NOT_ITERATED
7377 | OPTI_TYPE_PREPENDED_SALT
7378 | OPTI_TYPE_RAW_HASH;
7379 dgst_pos0 = 3;
7380 dgst_pos1 = 4;
7381 dgst_pos2 = 2;
7382 dgst_pos3 = 1;
7383 break;
7384
7385 case 130: hash_type = HASH_TYPE_SHA1;
7386 salt_type = SALT_TYPE_INTERN;
7387 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7388 opts_type = OPTS_TYPE_PT_GENERATE_BE
7389 | OPTS_TYPE_PT_UNICODE
7390 | OPTS_TYPE_ST_ADD80
7391 | OPTS_TYPE_ST_ADDBITS15;
7392 kern_type = KERN_TYPE_SHA1_PWUSLT;
7393 dgst_size = DGST_SIZE_4_5;
7394 parse_func = sha1s_parse_hash;
7395 sort_by_digest = sort_by_digest_4_5;
7396 opti_type = OPTI_TYPE_ZERO_BYTE
7397 | OPTI_TYPE_PRECOMPUTE_INIT
7398 | OPTI_TYPE_PRECOMPUTE_MERKLE
7399 | OPTI_TYPE_EARLY_SKIP
7400 | OPTI_TYPE_NOT_ITERATED
7401 | OPTI_TYPE_APPENDED_SALT
7402 | OPTI_TYPE_RAW_HASH;
7403 dgst_pos0 = 3;
7404 dgst_pos1 = 4;
7405 dgst_pos2 = 2;
7406 dgst_pos3 = 1;
7407 break;
7408
7409 case 131: hash_type = HASH_TYPE_SHA1;
7410 salt_type = SALT_TYPE_EMBEDDED;
7411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7412 opts_type = OPTS_TYPE_PT_GENERATE_BE
7413 | OPTS_TYPE_PT_UNICODE
7414 | OPTS_TYPE_PT_UPPER
7415 | OPTS_TYPE_ST_ADD80
7416 | OPTS_TYPE_ST_ADDBITS15
7417 | OPTS_TYPE_ST_HEX;
7418 kern_type = KERN_TYPE_SHA1_PWUSLT;
7419 dgst_size = DGST_SIZE_4_5;
7420 parse_func = mssql2000_parse_hash;
7421 sort_by_digest = sort_by_digest_4_5;
7422 opti_type = OPTI_TYPE_ZERO_BYTE
7423 | OPTI_TYPE_PRECOMPUTE_INIT
7424 | OPTI_TYPE_PRECOMPUTE_MERKLE
7425 | OPTI_TYPE_EARLY_SKIP
7426 | OPTI_TYPE_NOT_ITERATED
7427 | OPTI_TYPE_APPENDED_SALT
7428 | OPTI_TYPE_RAW_HASH;
7429 dgst_pos0 = 3;
7430 dgst_pos1 = 4;
7431 dgst_pos2 = 2;
7432 dgst_pos3 = 1;
7433 break;
7434
7435 case 132: hash_type = HASH_TYPE_SHA1;
7436 salt_type = SALT_TYPE_EMBEDDED;
7437 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7438 opts_type = OPTS_TYPE_PT_GENERATE_BE
7439 | OPTS_TYPE_PT_UNICODE
7440 | OPTS_TYPE_ST_ADD80
7441 | OPTS_TYPE_ST_ADDBITS15
7442 | OPTS_TYPE_ST_HEX;
7443 kern_type = KERN_TYPE_SHA1_PWUSLT;
7444 dgst_size = DGST_SIZE_4_5;
7445 parse_func = mssql2005_parse_hash;
7446 sort_by_digest = sort_by_digest_4_5;
7447 opti_type = OPTI_TYPE_ZERO_BYTE
7448 | OPTI_TYPE_PRECOMPUTE_INIT
7449 | OPTI_TYPE_PRECOMPUTE_MERKLE
7450 | OPTI_TYPE_EARLY_SKIP
7451 | OPTI_TYPE_NOT_ITERATED
7452 | OPTI_TYPE_APPENDED_SALT
7453 | OPTI_TYPE_RAW_HASH;
7454 dgst_pos0 = 3;
7455 dgst_pos1 = 4;
7456 dgst_pos2 = 2;
7457 dgst_pos3 = 1;
7458 break;
7459
7460 case 133: hash_type = HASH_TYPE_SHA1;
7461 salt_type = SALT_TYPE_EMBEDDED;
7462 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7463 opts_type = OPTS_TYPE_PT_GENERATE_BE
7464 | OPTS_TYPE_PT_UNICODE
7465 | OPTS_TYPE_ST_ADD80
7466 | OPTS_TYPE_ST_ADDBITS15;
7467 kern_type = KERN_TYPE_SHA1_PWUSLT;
7468 dgst_size = DGST_SIZE_4_5;
7469 parse_func = peoplesoft_parse_hash;
7470 sort_by_digest = sort_by_digest_4_5;
7471 opti_type = OPTI_TYPE_ZERO_BYTE
7472 | OPTI_TYPE_PRECOMPUTE_INIT
7473 | OPTI_TYPE_PRECOMPUTE_MERKLE
7474 | OPTI_TYPE_EARLY_SKIP
7475 | OPTI_TYPE_NOT_ITERATED
7476 | OPTI_TYPE_APPENDED_SALT
7477 | OPTI_TYPE_RAW_HASH;
7478 dgst_pos0 = 3;
7479 dgst_pos1 = 4;
7480 dgst_pos2 = 2;
7481 dgst_pos3 = 1;
7482 break;
7483
7484 case 140: hash_type = HASH_TYPE_SHA1;
7485 salt_type = SALT_TYPE_INTERN;
7486 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7487 opts_type = OPTS_TYPE_PT_GENERATE_BE
7488 | OPTS_TYPE_PT_ADD80
7489 | OPTS_TYPE_PT_ADDBITS15
7490 | OPTS_TYPE_PT_UNICODE;
7491 kern_type = KERN_TYPE_SHA1_SLTPWU;
7492 dgst_size = DGST_SIZE_4_5;
7493 parse_func = sha1s_parse_hash;
7494 sort_by_digest = sort_by_digest_4_5;
7495 opti_type = OPTI_TYPE_ZERO_BYTE
7496 | OPTI_TYPE_PRECOMPUTE_INIT
7497 | OPTI_TYPE_PRECOMPUTE_MERKLE
7498 | OPTI_TYPE_EARLY_SKIP
7499 | OPTI_TYPE_NOT_ITERATED
7500 | OPTI_TYPE_PREPENDED_SALT
7501 | OPTI_TYPE_RAW_HASH;
7502 dgst_pos0 = 3;
7503 dgst_pos1 = 4;
7504 dgst_pos2 = 2;
7505 dgst_pos3 = 1;
7506 break;
7507
7508 case 141: hash_type = HASH_TYPE_SHA1;
7509 salt_type = SALT_TYPE_EMBEDDED;
7510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7511 opts_type = OPTS_TYPE_PT_GENERATE_BE
7512 | OPTS_TYPE_PT_ADD80
7513 | OPTS_TYPE_PT_ADDBITS15
7514 | OPTS_TYPE_PT_UNICODE
7515 | OPTS_TYPE_ST_BASE64;
7516 kern_type = KERN_TYPE_SHA1_SLTPWU;
7517 dgst_size = DGST_SIZE_4_5;
7518 parse_func = episerver_parse_hash;
7519 sort_by_digest = sort_by_digest_4_5;
7520 opti_type = OPTI_TYPE_ZERO_BYTE
7521 | OPTI_TYPE_PRECOMPUTE_INIT
7522 | OPTI_TYPE_PRECOMPUTE_MERKLE
7523 | OPTI_TYPE_EARLY_SKIP
7524 | OPTI_TYPE_NOT_ITERATED
7525 | OPTI_TYPE_PREPENDED_SALT
7526 | OPTI_TYPE_RAW_HASH;
7527 dgst_pos0 = 3;
7528 dgst_pos1 = 4;
7529 dgst_pos2 = 2;
7530 dgst_pos3 = 1;
7531 break;
7532
7533 case 150: hash_type = HASH_TYPE_SHA1;
7534 salt_type = SALT_TYPE_INTERN;
7535 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7536 opts_type = OPTS_TYPE_PT_GENERATE_BE
7537 | OPTS_TYPE_ST_ADD80
7538 | OPTS_TYPE_ST_ADDBITS15;
7539 kern_type = KERN_TYPE_HMACSHA1_PW;
7540 dgst_size = DGST_SIZE_4_5;
7541 parse_func = hmacsha1_parse_hash;
7542 sort_by_digest = sort_by_digest_4_5;
7543 opti_type = OPTI_TYPE_ZERO_BYTE
7544 | OPTI_TYPE_NOT_ITERATED;
7545 dgst_pos0 = 3;
7546 dgst_pos1 = 4;
7547 dgst_pos2 = 2;
7548 dgst_pos3 = 1;
7549 break;
7550
7551 case 160: hash_type = HASH_TYPE_SHA1;
7552 salt_type = SALT_TYPE_INTERN;
7553 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7554 opts_type = OPTS_TYPE_PT_GENERATE_BE
7555 | OPTS_TYPE_PT_ADD80
7556 | OPTS_TYPE_PT_ADDBITS15;
7557 kern_type = KERN_TYPE_HMACSHA1_SLT;
7558 dgst_size = DGST_SIZE_4_5;
7559 parse_func = hmacsha1_parse_hash;
7560 sort_by_digest = sort_by_digest_4_5;
7561 opti_type = OPTI_TYPE_ZERO_BYTE
7562 | OPTI_TYPE_NOT_ITERATED;
7563 dgst_pos0 = 3;
7564 dgst_pos1 = 4;
7565 dgst_pos2 = 2;
7566 dgst_pos3 = 1;
7567 break;
7568
7569 case 190: hash_type = HASH_TYPE_SHA1;
7570 salt_type = SALT_TYPE_NONE;
7571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7572 opts_type = OPTS_TYPE_PT_GENERATE_BE
7573 | OPTS_TYPE_PT_ADD80
7574 | OPTS_TYPE_PT_ADDBITS15;
7575 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7576 dgst_size = DGST_SIZE_4_5;
7577 parse_func = sha1linkedin_parse_hash;
7578 sort_by_digest = sort_by_digest_4_5;
7579 opti_type = OPTI_TYPE_ZERO_BYTE
7580 | OPTI_TYPE_PRECOMPUTE_INIT
7581 | OPTI_TYPE_EARLY_SKIP
7582 | OPTI_TYPE_NOT_ITERATED
7583 | OPTI_TYPE_NOT_SALTED;
7584 dgst_pos0 = 0;
7585 dgst_pos1 = 4;
7586 dgst_pos2 = 3;
7587 dgst_pos3 = 2;
7588 break;
7589
7590 case 200: hash_type = HASH_TYPE_MYSQL;
7591 salt_type = SALT_TYPE_NONE;
7592 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7593 opts_type = 0;
7594 kern_type = KERN_TYPE_MYSQL;
7595 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7596 parse_func = mysql323_parse_hash;
7597 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7598 opti_type = OPTI_TYPE_ZERO_BYTE;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 1;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 3;
7603 break;
7604
7605 case 300: hash_type = HASH_TYPE_SHA1;
7606 salt_type = SALT_TYPE_NONE;
7607 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_BE
7609 | OPTS_TYPE_PT_ADD80
7610 | OPTS_TYPE_PT_ADDBITS15;
7611 kern_type = KERN_TYPE_MYSQL41;
7612 dgst_size = DGST_SIZE_4_5;
7613 parse_func = sha1_parse_hash;
7614 sort_by_digest = sort_by_digest_4_5;
7615 opti_type = OPTI_TYPE_ZERO_BYTE
7616 | OPTI_TYPE_PRECOMPUTE_INIT
7617 | OPTI_TYPE_PRECOMPUTE_MERKLE
7618 | OPTI_TYPE_EARLY_SKIP
7619 | OPTI_TYPE_NOT_ITERATED
7620 | OPTI_TYPE_NOT_SALTED;
7621 dgst_pos0 = 3;
7622 dgst_pos1 = 4;
7623 dgst_pos2 = 2;
7624 dgst_pos3 = 1;
7625 break;
7626
7627 case 400: hash_type = HASH_TYPE_MD5;
7628 salt_type = SALT_TYPE_EMBEDDED;
7629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7631 kern_type = KERN_TYPE_PHPASS;
7632 dgst_size = DGST_SIZE_4_4;
7633 parse_func = phpass_parse_hash;
7634 sort_by_digest = sort_by_digest_4_4;
7635 opti_type = OPTI_TYPE_ZERO_BYTE
7636 | OPTI_TYPE_SLOW_HASH_SIMD;
7637 dgst_pos0 = 0;
7638 dgst_pos1 = 1;
7639 dgst_pos2 = 2;
7640 dgst_pos3 = 3;
7641 break;
7642
7643 case 500: hash_type = HASH_TYPE_MD5;
7644 salt_type = SALT_TYPE_EMBEDDED;
7645 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7646 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7647 kern_type = KERN_TYPE_MD5CRYPT;
7648 dgst_size = DGST_SIZE_4_4;
7649 parse_func = md5crypt_parse_hash;
7650 sort_by_digest = sort_by_digest_4_4;
7651 opti_type = OPTI_TYPE_ZERO_BYTE;
7652 dgst_pos0 = 0;
7653 dgst_pos1 = 1;
7654 dgst_pos2 = 2;
7655 dgst_pos3 = 3;
7656 break;
7657
7658 case 501: hash_type = HASH_TYPE_MD5;
7659 salt_type = SALT_TYPE_EMBEDDED;
7660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7661 opts_type = OPTS_TYPE_PT_GENERATE_LE
7662 | OPTS_TYPE_HASH_COPY;
7663 kern_type = KERN_TYPE_MD5CRYPT;
7664 dgst_size = DGST_SIZE_4_4;
7665 parse_func = juniper_parse_hash;
7666 sort_by_digest = sort_by_digest_4_4;
7667 opti_type = OPTI_TYPE_ZERO_BYTE;
7668 dgst_pos0 = 0;
7669 dgst_pos1 = 1;
7670 dgst_pos2 = 2;
7671 dgst_pos3 = 3;
7672 break;
7673
7674 case 900: hash_type = HASH_TYPE_MD4;
7675 salt_type = SALT_TYPE_NONE;
7676 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7677 opts_type = OPTS_TYPE_PT_GENERATE_LE
7678 | OPTS_TYPE_PT_ADD80
7679 | OPTS_TYPE_PT_ADDBITS14;
7680 kern_type = KERN_TYPE_MD4;
7681 dgst_size = DGST_SIZE_4_4;
7682 parse_func = md4_parse_hash;
7683 sort_by_digest = sort_by_digest_4_4;
7684 opti_type = OPTI_TYPE_ZERO_BYTE
7685 | OPTI_TYPE_PRECOMPUTE_INIT
7686 | OPTI_TYPE_PRECOMPUTE_MERKLE
7687 | OPTI_TYPE_MEET_IN_MIDDLE
7688 | OPTI_TYPE_EARLY_SKIP
7689 | OPTI_TYPE_NOT_ITERATED
7690 | OPTI_TYPE_NOT_SALTED
7691 | OPTI_TYPE_RAW_HASH;
7692 dgst_pos0 = 0;
7693 dgst_pos1 = 3;
7694 dgst_pos2 = 2;
7695 dgst_pos3 = 1;
7696 break;
7697
7698 case 1000: hash_type = HASH_TYPE_MD4;
7699 salt_type = SALT_TYPE_NONE;
7700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7701 opts_type = OPTS_TYPE_PT_GENERATE_LE
7702 | OPTS_TYPE_PT_ADD80
7703 | OPTS_TYPE_PT_ADDBITS14
7704 | OPTS_TYPE_PT_UNICODE;
7705 kern_type = KERN_TYPE_MD4_PWU;
7706 dgst_size = DGST_SIZE_4_4;
7707 parse_func = md4_parse_hash;
7708 sort_by_digest = sort_by_digest_4_4;
7709 opti_type = OPTI_TYPE_ZERO_BYTE
7710 | OPTI_TYPE_PRECOMPUTE_INIT
7711 | OPTI_TYPE_PRECOMPUTE_MERKLE
7712 | OPTI_TYPE_MEET_IN_MIDDLE
7713 | OPTI_TYPE_EARLY_SKIP
7714 | OPTI_TYPE_NOT_ITERATED
7715 | OPTI_TYPE_NOT_SALTED
7716 | OPTI_TYPE_RAW_HASH;
7717 dgst_pos0 = 0;
7718 dgst_pos1 = 3;
7719 dgst_pos2 = 2;
7720 dgst_pos3 = 1;
7721 break;
7722
7723 case 1100: hash_type = HASH_TYPE_MD4;
7724 salt_type = SALT_TYPE_INTERN;
7725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7726 opts_type = OPTS_TYPE_PT_GENERATE_LE
7727 | OPTS_TYPE_PT_ADD80
7728 | OPTS_TYPE_PT_ADDBITS14
7729 | OPTS_TYPE_PT_UNICODE
7730 | OPTS_TYPE_ST_ADD80
7731 | OPTS_TYPE_ST_UNICODE
7732 | OPTS_TYPE_ST_LOWER;
7733 kern_type = KERN_TYPE_MD44_PWUSLT;
7734 dgst_size = DGST_SIZE_4_4;
7735 parse_func = dcc_parse_hash;
7736 sort_by_digest = sort_by_digest_4_4;
7737 opti_type = OPTI_TYPE_ZERO_BYTE
7738 | OPTI_TYPE_PRECOMPUTE_INIT
7739 | OPTI_TYPE_PRECOMPUTE_MERKLE
7740 | OPTI_TYPE_EARLY_SKIP
7741 | OPTI_TYPE_NOT_ITERATED;
7742 dgst_pos0 = 0;
7743 dgst_pos1 = 3;
7744 dgst_pos2 = 2;
7745 dgst_pos3 = 1;
7746 break;
7747
7748 case 1400: hash_type = HASH_TYPE_SHA256;
7749 salt_type = SALT_TYPE_NONE;
7750 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7751 opts_type = OPTS_TYPE_PT_GENERATE_BE
7752 | OPTS_TYPE_PT_ADD80
7753 | OPTS_TYPE_PT_ADDBITS15;
7754 kern_type = KERN_TYPE_SHA256;
7755 dgst_size = DGST_SIZE_4_8;
7756 parse_func = sha256_parse_hash;
7757 sort_by_digest = sort_by_digest_4_8;
7758 opti_type = OPTI_TYPE_ZERO_BYTE
7759 | OPTI_TYPE_PRECOMPUTE_INIT
7760 | OPTI_TYPE_PRECOMPUTE_MERKLE
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_NOT_SALTED
7764 | OPTI_TYPE_RAW_HASH;
7765 dgst_pos0 = 3;
7766 dgst_pos1 = 7;
7767 dgst_pos2 = 2;
7768 dgst_pos3 = 6;
7769 break;
7770
7771 case 1410: hash_type = HASH_TYPE_SHA256;
7772 salt_type = SALT_TYPE_INTERN;
7773 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7774 opts_type = OPTS_TYPE_PT_GENERATE_BE
7775 | OPTS_TYPE_ST_ADD80
7776 | OPTS_TYPE_ST_ADDBITS15;
7777 kern_type = KERN_TYPE_SHA256_PWSLT;
7778 dgst_size = DGST_SIZE_4_8;
7779 parse_func = sha256s_parse_hash;
7780 sort_by_digest = sort_by_digest_4_8;
7781 opti_type = OPTI_TYPE_ZERO_BYTE
7782 | OPTI_TYPE_PRECOMPUTE_INIT
7783 | OPTI_TYPE_PRECOMPUTE_MERKLE
7784 | OPTI_TYPE_EARLY_SKIP
7785 | OPTI_TYPE_NOT_ITERATED
7786 | OPTI_TYPE_APPENDED_SALT
7787 | OPTI_TYPE_RAW_HASH;
7788 dgst_pos0 = 3;
7789 dgst_pos1 = 7;
7790 dgst_pos2 = 2;
7791 dgst_pos3 = 6;
7792 break;
7793
7794 case 1420: hash_type = HASH_TYPE_SHA256;
7795 salt_type = SALT_TYPE_INTERN;
7796 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7797 opts_type = OPTS_TYPE_PT_GENERATE_BE
7798 | OPTS_TYPE_PT_ADD80
7799 | OPTS_TYPE_PT_ADDBITS15;
7800 kern_type = KERN_TYPE_SHA256_SLTPW;
7801 dgst_size = DGST_SIZE_4_8;
7802 parse_func = sha256s_parse_hash;
7803 sort_by_digest = sort_by_digest_4_8;
7804 opti_type = OPTI_TYPE_ZERO_BYTE
7805 | OPTI_TYPE_PRECOMPUTE_INIT
7806 | OPTI_TYPE_PRECOMPUTE_MERKLE
7807 | OPTI_TYPE_EARLY_SKIP
7808 | OPTI_TYPE_NOT_ITERATED
7809 | OPTI_TYPE_PREPENDED_SALT
7810 | OPTI_TYPE_RAW_HASH;
7811 dgst_pos0 = 3;
7812 dgst_pos1 = 7;
7813 dgst_pos2 = 2;
7814 dgst_pos3 = 6;
7815 break;
7816
7817 case 1421: hash_type = HASH_TYPE_SHA256;
7818 salt_type = SALT_TYPE_EMBEDDED;
7819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7820 opts_type = OPTS_TYPE_PT_GENERATE_BE
7821 | OPTS_TYPE_PT_ADD80
7822 | OPTS_TYPE_PT_ADDBITS15;
7823 kern_type = KERN_TYPE_SHA256_SLTPW;
7824 dgst_size = DGST_SIZE_4_8;
7825 parse_func = hmailserver_parse_hash;
7826 sort_by_digest = sort_by_digest_4_8;
7827 opti_type = OPTI_TYPE_ZERO_BYTE
7828 | OPTI_TYPE_PRECOMPUTE_INIT
7829 | OPTI_TYPE_PRECOMPUTE_MERKLE
7830 | OPTI_TYPE_EARLY_SKIP
7831 | OPTI_TYPE_NOT_ITERATED
7832 | OPTI_TYPE_PREPENDED_SALT
7833 | OPTI_TYPE_RAW_HASH;
7834 dgst_pos0 = 3;
7835 dgst_pos1 = 7;
7836 dgst_pos2 = 2;
7837 dgst_pos3 = 6;
7838 break;
7839
7840 case 1430: hash_type = HASH_TYPE_SHA256;
7841 salt_type = SALT_TYPE_INTERN;
7842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7843 opts_type = OPTS_TYPE_PT_GENERATE_BE
7844 | OPTS_TYPE_PT_UNICODE
7845 | OPTS_TYPE_ST_ADD80
7846 | OPTS_TYPE_ST_ADDBITS15;
7847 kern_type = KERN_TYPE_SHA256_PWUSLT;
7848 dgst_size = DGST_SIZE_4_8;
7849 parse_func = sha256s_parse_hash;
7850 sort_by_digest = sort_by_digest_4_8;
7851 opti_type = OPTI_TYPE_ZERO_BYTE
7852 | OPTI_TYPE_PRECOMPUTE_INIT
7853 | OPTI_TYPE_PRECOMPUTE_MERKLE
7854 | OPTI_TYPE_EARLY_SKIP
7855 | OPTI_TYPE_NOT_ITERATED
7856 | OPTI_TYPE_APPENDED_SALT
7857 | OPTI_TYPE_RAW_HASH;
7858 dgst_pos0 = 3;
7859 dgst_pos1 = 7;
7860 dgst_pos2 = 2;
7861 dgst_pos3 = 6;
7862 break;
7863
7864 case 1440: hash_type = HASH_TYPE_SHA256;
7865 salt_type = SALT_TYPE_INTERN;
7866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7867 opts_type = OPTS_TYPE_PT_GENERATE_BE
7868 | OPTS_TYPE_PT_ADD80
7869 | OPTS_TYPE_PT_ADDBITS15
7870 | OPTS_TYPE_PT_UNICODE;
7871 kern_type = KERN_TYPE_SHA256_SLTPWU;
7872 dgst_size = DGST_SIZE_4_8;
7873 parse_func = sha256s_parse_hash;
7874 sort_by_digest = sort_by_digest_4_8;
7875 opti_type = OPTI_TYPE_ZERO_BYTE
7876 | OPTI_TYPE_PRECOMPUTE_INIT
7877 | OPTI_TYPE_PRECOMPUTE_MERKLE
7878 | OPTI_TYPE_EARLY_SKIP
7879 | OPTI_TYPE_NOT_ITERATED
7880 | OPTI_TYPE_PREPENDED_SALT
7881 | OPTI_TYPE_RAW_HASH;
7882 dgst_pos0 = 3;
7883 dgst_pos1 = 7;
7884 dgst_pos2 = 2;
7885 dgst_pos3 = 6;
7886 break;
7887
7888 case 1441: hash_type = HASH_TYPE_SHA256;
7889 salt_type = SALT_TYPE_EMBEDDED;
7890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7891 opts_type = OPTS_TYPE_PT_GENERATE_BE
7892 | OPTS_TYPE_PT_ADD80
7893 | OPTS_TYPE_PT_ADDBITS15
7894 | OPTS_TYPE_PT_UNICODE
7895 | OPTS_TYPE_ST_BASE64;
7896 kern_type = KERN_TYPE_SHA256_SLTPWU;
7897 dgst_size = DGST_SIZE_4_8;
7898 parse_func = episerver4_parse_hash;
7899 sort_by_digest = sort_by_digest_4_8;
7900 opti_type = OPTI_TYPE_ZERO_BYTE
7901 | OPTI_TYPE_PRECOMPUTE_INIT
7902 | OPTI_TYPE_PRECOMPUTE_MERKLE
7903 | OPTI_TYPE_EARLY_SKIP
7904 | OPTI_TYPE_NOT_ITERATED
7905 | OPTI_TYPE_PREPENDED_SALT
7906 | OPTI_TYPE_RAW_HASH;
7907 dgst_pos0 = 3;
7908 dgst_pos1 = 7;
7909 dgst_pos2 = 2;
7910 dgst_pos3 = 6;
7911 break;
7912
7913 case 1450: hash_type = HASH_TYPE_SHA256;
7914 salt_type = SALT_TYPE_INTERN;
7915 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7916 opts_type = OPTS_TYPE_PT_GENERATE_BE
7917 | OPTS_TYPE_ST_ADD80;
7918 kern_type = KERN_TYPE_HMACSHA256_PW;
7919 dgst_size = DGST_SIZE_4_8;
7920 parse_func = hmacsha256_parse_hash;
7921 sort_by_digest = sort_by_digest_4_8;
7922 opti_type = OPTI_TYPE_ZERO_BYTE
7923 | OPTI_TYPE_NOT_ITERATED;
7924 dgst_pos0 = 3;
7925 dgst_pos1 = 7;
7926 dgst_pos2 = 2;
7927 dgst_pos3 = 6;
7928 break;
7929
7930 case 1460: hash_type = HASH_TYPE_SHA256;
7931 salt_type = SALT_TYPE_INTERN;
7932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7933 opts_type = OPTS_TYPE_PT_GENERATE_BE
7934 | OPTS_TYPE_PT_ADD80
7935 | OPTS_TYPE_PT_ADDBITS15;
7936 kern_type = KERN_TYPE_HMACSHA256_SLT;
7937 dgst_size = DGST_SIZE_4_8;
7938 parse_func = hmacsha256_parse_hash;
7939 sort_by_digest = sort_by_digest_4_8;
7940 opti_type = OPTI_TYPE_ZERO_BYTE
7941 | OPTI_TYPE_NOT_ITERATED;
7942 dgst_pos0 = 3;
7943 dgst_pos1 = 7;
7944 dgst_pos2 = 2;
7945 dgst_pos3 = 6;
7946 break;
7947
7948 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7949 salt_type = SALT_TYPE_EMBEDDED;
7950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7951 opts_type = OPTS_TYPE_PT_GENERATE_LE
7952 | OPTS_TYPE_PT_BITSLICE;
7953 kern_type = KERN_TYPE_DESCRYPT;
7954 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7955 parse_func = descrypt_parse_hash;
7956 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7957 opti_type = OPTI_TYPE_ZERO_BYTE
7958 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7959 dgst_pos0 = 0;
7960 dgst_pos1 = 1;
7961 dgst_pos2 = 2;
7962 dgst_pos3 = 3;
7963 break;
7964
7965 case 1600: hash_type = HASH_TYPE_MD5;
7966 salt_type = SALT_TYPE_EMBEDDED;
7967 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7968 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7969 kern_type = KERN_TYPE_APR1CRYPT;
7970 dgst_size = DGST_SIZE_4_4;
7971 parse_func = md5apr1_parse_hash;
7972 sort_by_digest = sort_by_digest_4_4;
7973 opti_type = OPTI_TYPE_ZERO_BYTE;
7974 dgst_pos0 = 0;
7975 dgst_pos1 = 1;
7976 dgst_pos2 = 2;
7977 dgst_pos3 = 3;
7978 break;
7979
7980 case 1700: hash_type = HASH_TYPE_SHA512;
7981 salt_type = SALT_TYPE_NONE;
7982 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7983 opts_type = OPTS_TYPE_PT_GENERATE_BE
7984 | OPTS_TYPE_PT_ADD80
7985 | OPTS_TYPE_PT_ADDBITS15;
7986 kern_type = KERN_TYPE_SHA512;
7987 dgst_size = DGST_SIZE_8_8;
7988 parse_func = sha512_parse_hash;
7989 sort_by_digest = sort_by_digest_8_8;
7990 opti_type = OPTI_TYPE_ZERO_BYTE
7991 | OPTI_TYPE_PRECOMPUTE_INIT
7992 | OPTI_TYPE_PRECOMPUTE_MERKLE
7993 | OPTI_TYPE_EARLY_SKIP
7994 | OPTI_TYPE_NOT_ITERATED
7995 | OPTI_TYPE_NOT_SALTED
7996 | OPTI_TYPE_USES_BITS_64
7997 | OPTI_TYPE_RAW_HASH;
7998 dgst_pos0 = 14;
7999 dgst_pos1 = 15;
8000 dgst_pos2 = 6;
8001 dgst_pos3 = 7;
8002 break;
8003
8004 case 1710: hash_type = HASH_TYPE_SHA512;
8005 salt_type = SALT_TYPE_INTERN;
8006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8007 opts_type = OPTS_TYPE_PT_GENERATE_BE
8008 | OPTS_TYPE_ST_ADD80
8009 | OPTS_TYPE_ST_ADDBITS15;
8010 kern_type = KERN_TYPE_SHA512_PWSLT;
8011 dgst_size = DGST_SIZE_8_8;
8012 parse_func = sha512s_parse_hash;
8013 sort_by_digest = sort_by_digest_8_8;
8014 opti_type = OPTI_TYPE_ZERO_BYTE
8015 | OPTI_TYPE_PRECOMPUTE_INIT
8016 | OPTI_TYPE_PRECOMPUTE_MERKLE
8017 | OPTI_TYPE_EARLY_SKIP
8018 | OPTI_TYPE_NOT_ITERATED
8019 | OPTI_TYPE_APPENDED_SALT
8020 | OPTI_TYPE_USES_BITS_64
8021 | OPTI_TYPE_RAW_HASH;
8022 dgst_pos0 = 14;
8023 dgst_pos1 = 15;
8024 dgst_pos2 = 6;
8025 dgst_pos3 = 7;
8026 break;
8027
8028 case 1711: hash_type = HASH_TYPE_SHA512;
8029 salt_type = SALT_TYPE_EMBEDDED;
8030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8031 opts_type = OPTS_TYPE_PT_GENERATE_BE
8032 | OPTS_TYPE_ST_ADD80
8033 | OPTS_TYPE_ST_ADDBITS15;
8034 kern_type = KERN_TYPE_SHA512_PWSLT;
8035 dgst_size = DGST_SIZE_8_8;
8036 parse_func = sha512b64s_parse_hash;
8037 sort_by_digest = sort_by_digest_8_8;
8038 opti_type = OPTI_TYPE_ZERO_BYTE
8039 | OPTI_TYPE_PRECOMPUTE_INIT
8040 | OPTI_TYPE_PRECOMPUTE_MERKLE
8041 | OPTI_TYPE_EARLY_SKIP
8042 | OPTI_TYPE_NOT_ITERATED
8043 | OPTI_TYPE_APPENDED_SALT
8044 | OPTI_TYPE_USES_BITS_64
8045 | OPTI_TYPE_RAW_HASH;
8046 dgst_pos0 = 14;
8047 dgst_pos1 = 15;
8048 dgst_pos2 = 6;
8049 dgst_pos3 = 7;
8050 break;
8051
8052 case 1720: hash_type = HASH_TYPE_SHA512;
8053 salt_type = SALT_TYPE_INTERN;
8054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8055 opts_type = OPTS_TYPE_PT_GENERATE_BE
8056 | OPTS_TYPE_PT_ADD80
8057 | OPTS_TYPE_PT_ADDBITS15;
8058 kern_type = KERN_TYPE_SHA512_SLTPW;
8059 dgst_size = DGST_SIZE_8_8;
8060 parse_func = sha512s_parse_hash;
8061 sort_by_digest = sort_by_digest_8_8;
8062 opti_type = OPTI_TYPE_ZERO_BYTE
8063 | OPTI_TYPE_PRECOMPUTE_INIT
8064 | OPTI_TYPE_PRECOMPUTE_MERKLE
8065 | OPTI_TYPE_EARLY_SKIP
8066 | OPTI_TYPE_NOT_ITERATED
8067 | OPTI_TYPE_PREPENDED_SALT
8068 | OPTI_TYPE_USES_BITS_64
8069 | OPTI_TYPE_RAW_HASH;
8070 dgst_pos0 = 14;
8071 dgst_pos1 = 15;
8072 dgst_pos2 = 6;
8073 dgst_pos3 = 7;
8074 break;
8075
8076 case 1722: hash_type = HASH_TYPE_SHA512;
8077 salt_type = SALT_TYPE_EMBEDDED;
8078 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8079 opts_type = OPTS_TYPE_PT_GENERATE_BE
8080 | OPTS_TYPE_PT_ADD80
8081 | OPTS_TYPE_PT_ADDBITS15
8082 | OPTS_TYPE_ST_HEX;
8083 kern_type = KERN_TYPE_SHA512_SLTPW;
8084 dgst_size = DGST_SIZE_8_8;
8085 parse_func = osx512_parse_hash;
8086 sort_by_digest = sort_by_digest_8_8;
8087 opti_type = OPTI_TYPE_ZERO_BYTE
8088 | OPTI_TYPE_PRECOMPUTE_INIT
8089 | OPTI_TYPE_PRECOMPUTE_MERKLE
8090 | OPTI_TYPE_EARLY_SKIP
8091 | OPTI_TYPE_NOT_ITERATED
8092 | OPTI_TYPE_PREPENDED_SALT
8093 | OPTI_TYPE_USES_BITS_64
8094 | OPTI_TYPE_RAW_HASH;
8095 dgst_pos0 = 14;
8096 dgst_pos1 = 15;
8097 dgst_pos2 = 6;
8098 dgst_pos3 = 7;
8099 break;
8100
8101 case 1730: hash_type = HASH_TYPE_SHA512;
8102 salt_type = SALT_TYPE_INTERN;
8103 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8104 opts_type = OPTS_TYPE_PT_GENERATE_BE
8105 | OPTS_TYPE_PT_UNICODE
8106 | OPTS_TYPE_ST_ADD80
8107 | OPTS_TYPE_ST_ADDBITS15;
8108 kern_type = KERN_TYPE_SHA512_PWSLTU;
8109 dgst_size = DGST_SIZE_8_8;
8110 parse_func = sha512s_parse_hash;
8111 sort_by_digest = sort_by_digest_8_8;
8112 opti_type = OPTI_TYPE_ZERO_BYTE
8113 | OPTI_TYPE_PRECOMPUTE_INIT
8114 | OPTI_TYPE_PRECOMPUTE_MERKLE
8115 | OPTI_TYPE_EARLY_SKIP
8116 | OPTI_TYPE_NOT_ITERATED
8117 | OPTI_TYPE_APPENDED_SALT
8118 | OPTI_TYPE_USES_BITS_64
8119 | OPTI_TYPE_RAW_HASH;
8120 dgst_pos0 = 14;
8121 dgst_pos1 = 15;
8122 dgst_pos2 = 6;
8123 dgst_pos3 = 7;
8124 break;
8125
8126 case 1731: hash_type = HASH_TYPE_SHA512;
8127 salt_type = SALT_TYPE_EMBEDDED;
8128 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8129 opts_type = OPTS_TYPE_PT_GENERATE_BE
8130 | OPTS_TYPE_PT_UNICODE
8131 | OPTS_TYPE_ST_ADD80
8132 | OPTS_TYPE_ST_ADDBITS15
8133 | OPTS_TYPE_ST_HEX;
8134 kern_type = KERN_TYPE_SHA512_PWSLTU;
8135 dgst_size = DGST_SIZE_8_8;
8136 parse_func = mssql2012_parse_hash;
8137 sort_by_digest = sort_by_digest_8_8;
8138 opti_type = OPTI_TYPE_ZERO_BYTE
8139 | OPTI_TYPE_PRECOMPUTE_INIT
8140 | OPTI_TYPE_PRECOMPUTE_MERKLE
8141 | OPTI_TYPE_EARLY_SKIP
8142 | OPTI_TYPE_NOT_ITERATED
8143 | OPTI_TYPE_APPENDED_SALT
8144 | OPTI_TYPE_USES_BITS_64
8145 | OPTI_TYPE_RAW_HASH;
8146 dgst_pos0 = 14;
8147 dgst_pos1 = 15;
8148 dgst_pos2 = 6;
8149 dgst_pos3 = 7;
8150 break;
8151
8152 case 1740: hash_type = HASH_TYPE_SHA512;
8153 salt_type = SALT_TYPE_INTERN;
8154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8155 opts_type = OPTS_TYPE_PT_GENERATE_BE
8156 | OPTS_TYPE_PT_ADD80
8157 | OPTS_TYPE_PT_ADDBITS15
8158 | OPTS_TYPE_PT_UNICODE;
8159 kern_type = KERN_TYPE_SHA512_SLTPWU;
8160 dgst_size = DGST_SIZE_8_8;
8161 parse_func = sha512s_parse_hash;
8162 sort_by_digest = sort_by_digest_8_8;
8163 opti_type = OPTI_TYPE_ZERO_BYTE
8164 | OPTI_TYPE_PRECOMPUTE_INIT
8165 | OPTI_TYPE_PRECOMPUTE_MERKLE
8166 | OPTI_TYPE_EARLY_SKIP
8167 | OPTI_TYPE_NOT_ITERATED
8168 | OPTI_TYPE_PREPENDED_SALT
8169 | OPTI_TYPE_USES_BITS_64
8170 | OPTI_TYPE_RAW_HASH;
8171 dgst_pos0 = 14;
8172 dgst_pos1 = 15;
8173 dgst_pos2 = 6;
8174 dgst_pos3 = 7;
8175 break;
8176
8177 case 1750: hash_type = HASH_TYPE_SHA512;
8178 salt_type = SALT_TYPE_INTERN;
8179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8180 opts_type = OPTS_TYPE_PT_GENERATE_BE
8181 | OPTS_TYPE_ST_ADD80;
8182 kern_type = KERN_TYPE_HMACSHA512_PW;
8183 dgst_size = DGST_SIZE_8_8;
8184 parse_func = hmacsha512_parse_hash;
8185 sort_by_digest = sort_by_digest_8_8;
8186 opti_type = OPTI_TYPE_ZERO_BYTE
8187 | OPTI_TYPE_USES_BITS_64
8188 | OPTI_TYPE_NOT_ITERATED;
8189 dgst_pos0 = 14;
8190 dgst_pos1 = 15;
8191 dgst_pos2 = 6;
8192 dgst_pos3 = 7;
8193 break;
8194
8195 case 1760: hash_type = HASH_TYPE_SHA512;
8196 salt_type = SALT_TYPE_INTERN;
8197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8198 opts_type = OPTS_TYPE_PT_GENERATE_BE
8199 | OPTS_TYPE_PT_ADD80
8200 | OPTS_TYPE_PT_ADDBITS15;
8201 kern_type = KERN_TYPE_HMACSHA512_SLT;
8202 dgst_size = DGST_SIZE_8_8;
8203 parse_func = hmacsha512_parse_hash;
8204 sort_by_digest = sort_by_digest_8_8;
8205 opti_type = OPTI_TYPE_ZERO_BYTE
8206 | OPTI_TYPE_USES_BITS_64
8207 | OPTI_TYPE_NOT_ITERATED;
8208 dgst_pos0 = 14;
8209 dgst_pos1 = 15;
8210 dgst_pos2 = 6;
8211 dgst_pos3 = 7;
8212 break;
8213
8214 case 1800: hash_type = HASH_TYPE_SHA512;
8215 salt_type = SALT_TYPE_EMBEDDED;
8216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8217 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8218 kern_type = KERN_TYPE_SHA512CRYPT;
8219 dgst_size = DGST_SIZE_8_8;
8220 parse_func = sha512crypt_parse_hash;
8221 sort_by_digest = sort_by_digest_8_8;
8222 opti_type = OPTI_TYPE_ZERO_BYTE
8223 | OPTI_TYPE_USES_BITS_64;
8224 dgst_pos0 = 0;
8225 dgst_pos1 = 1;
8226 dgst_pos2 = 2;
8227 dgst_pos3 = 3;
8228 break;
8229
8230 case 2100: hash_type = HASH_TYPE_DCC2;
8231 salt_type = SALT_TYPE_EMBEDDED;
8232 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8234 | OPTS_TYPE_ST_LOWER
8235 | OPTS_TYPE_ST_UNICODE;
8236 kern_type = KERN_TYPE_DCC2;
8237 dgst_size = DGST_SIZE_4_4;
8238 parse_func = dcc2_parse_hash;
8239 sort_by_digest = sort_by_digest_4_4;
8240 opti_type = OPTI_TYPE_ZERO_BYTE
8241 | OPTI_TYPE_SLOW_HASH_SIMD;
8242 dgst_pos0 = 0;
8243 dgst_pos1 = 1;
8244 dgst_pos2 = 2;
8245 dgst_pos3 = 3;
8246 break;
8247
8248 case 2400: hash_type = HASH_TYPE_MD5;
8249 salt_type = SALT_TYPE_NONE;
8250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8252 kern_type = KERN_TYPE_MD5PIX;
8253 dgst_size = DGST_SIZE_4_4;
8254 parse_func = md5pix_parse_hash;
8255 sort_by_digest = sort_by_digest_4_4;
8256 opti_type = OPTI_TYPE_ZERO_BYTE
8257 | OPTI_TYPE_PRECOMPUTE_INIT
8258 | OPTI_TYPE_PRECOMPUTE_MERKLE
8259 | OPTI_TYPE_EARLY_SKIP
8260 | OPTI_TYPE_NOT_ITERATED
8261 | OPTI_TYPE_NOT_SALTED;
8262 dgst_pos0 = 0;
8263 dgst_pos1 = 3;
8264 dgst_pos2 = 2;
8265 dgst_pos3 = 1;
8266 break;
8267
8268 case 2410: hash_type = HASH_TYPE_MD5;
8269 salt_type = SALT_TYPE_INTERN;
8270 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8271 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8272 kern_type = KERN_TYPE_MD5ASA;
8273 dgst_size = DGST_SIZE_4_4;
8274 parse_func = md5asa_parse_hash;
8275 sort_by_digest = sort_by_digest_4_4;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_PRECOMPUTE_INIT
8278 | OPTI_TYPE_PRECOMPUTE_MERKLE
8279 | OPTI_TYPE_EARLY_SKIP
8280 | OPTI_TYPE_NOT_ITERATED;
8281 dgst_pos0 = 0;
8282 dgst_pos1 = 3;
8283 dgst_pos2 = 2;
8284 dgst_pos3 = 1;
8285 break;
8286
8287 case 2500: hash_type = HASH_TYPE_WPA;
8288 salt_type = SALT_TYPE_EMBEDDED;
8289 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8290 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8291 kern_type = KERN_TYPE_WPA;
8292 dgst_size = DGST_SIZE_4_4;
8293 parse_func = wpa_parse_hash;
8294 sort_by_digest = sort_by_digest_4_4;
8295 opti_type = OPTI_TYPE_ZERO_BYTE
8296 | OPTI_TYPE_SLOW_HASH_SIMD;
8297 dgst_pos0 = 0;
8298 dgst_pos1 = 1;
8299 dgst_pos2 = 2;
8300 dgst_pos3 = 3;
8301 break;
8302
8303 case 2600: hash_type = HASH_TYPE_MD5;
8304 salt_type = SALT_TYPE_VIRTUAL;
8305 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8306 opts_type = OPTS_TYPE_PT_GENERATE_LE
8307 | OPTS_TYPE_PT_ADD80
8308 | OPTS_TYPE_PT_ADDBITS14
8309 | OPTS_TYPE_ST_ADD80;
8310 kern_type = KERN_TYPE_MD55_PWSLT1;
8311 dgst_size = DGST_SIZE_4_4;
8312 parse_func = md5md5_parse_hash;
8313 sort_by_digest = sort_by_digest_4_4;
8314 opti_type = OPTI_TYPE_ZERO_BYTE
8315 | OPTI_TYPE_PRECOMPUTE_INIT
8316 | OPTI_TYPE_PRECOMPUTE_MERKLE
8317 | OPTI_TYPE_EARLY_SKIP;
8318 dgst_pos0 = 0;
8319 dgst_pos1 = 3;
8320 dgst_pos2 = 2;
8321 dgst_pos3 = 1;
8322 break;
8323
8324 case 2611: hash_type = HASH_TYPE_MD5;
8325 salt_type = SALT_TYPE_INTERN;
8326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8327 opts_type = OPTS_TYPE_PT_GENERATE_LE
8328 | OPTS_TYPE_PT_ADD80
8329 | OPTS_TYPE_PT_ADDBITS14
8330 | OPTS_TYPE_ST_ADD80;
8331 kern_type = KERN_TYPE_MD55_PWSLT1;
8332 dgst_size = DGST_SIZE_4_4;
8333 parse_func = vb3_parse_hash;
8334 sort_by_digest = sort_by_digest_4_4;
8335 opti_type = OPTI_TYPE_ZERO_BYTE
8336 | OPTI_TYPE_PRECOMPUTE_INIT
8337 | OPTI_TYPE_PRECOMPUTE_MERKLE
8338 | OPTI_TYPE_EARLY_SKIP;
8339 dgst_pos0 = 0;
8340 dgst_pos1 = 3;
8341 dgst_pos2 = 2;
8342 dgst_pos3 = 1;
8343 break;
8344
8345 case 2612: hash_type = HASH_TYPE_MD5;
8346 salt_type = SALT_TYPE_EMBEDDED;
8347 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8348 opts_type = OPTS_TYPE_PT_GENERATE_LE
8349 | OPTS_TYPE_PT_ADD80
8350 | OPTS_TYPE_PT_ADDBITS14
8351 | OPTS_TYPE_ST_ADD80
8352 | OPTS_TYPE_ST_HEX;
8353 kern_type = KERN_TYPE_MD55_PWSLT1;
8354 dgst_size = DGST_SIZE_4_4;
8355 parse_func = phps_parse_hash;
8356 sort_by_digest = sort_by_digest_4_4;
8357 opti_type = OPTI_TYPE_ZERO_BYTE
8358 | OPTI_TYPE_PRECOMPUTE_INIT
8359 | OPTI_TYPE_PRECOMPUTE_MERKLE
8360 | OPTI_TYPE_EARLY_SKIP;
8361 dgst_pos0 = 0;
8362 dgst_pos1 = 3;
8363 dgst_pos2 = 2;
8364 dgst_pos3 = 1;
8365 break;
8366
8367 case 2711: hash_type = HASH_TYPE_MD5;
8368 salt_type = SALT_TYPE_INTERN;
8369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8370 opts_type = OPTS_TYPE_PT_GENERATE_LE
8371 | OPTS_TYPE_PT_ADD80
8372 | OPTS_TYPE_PT_ADDBITS14
8373 | OPTS_TYPE_ST_ADD80;
8374 kern_type = KERN_TYPE_MD55_PWSLT2;
8375 dgst_size = DGST_SIZE_4_4;
8376 parse_func = vb30_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4;
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_PRECOMPUTE_INIT
8380 | OPTI_TYPE_EARLY_SKIP;
8381 dgst_pos0 = 0;
8382 dgst_pos1 = 3;
8383 dgst_pos2 = 2;
8384 dgst_pos3 = 1;
8385 break;
8386
8387 case 2811: hash_type = HASH_TYPE_MD5;
8388 salt_type = SALT_TYPE_INTERN;
8389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8390 opts_type = OPTS_TYPE_PT_GENERATE_LE
8391 | OPTS_TYPE_PT_ADD80
8392 | OPTS_TYPE_PT_ADDBITS14;
8393 kern_type = KERN_TYPE_MD55_SLTPW;
8394 dgst_size = DGST_SIZE_4_4;
8395 parse_func = ipb2_parse_hash;
8396 sort_by_digest = sort_by_digest_4_4;
8397 opti_type = OPTI_TYPE_ZERO_BYTE
8398 | OPTI_TYPE_PRECOMPUTE_INIT
8399 | OPTI_TYPE_EARLY_SKIP;
8400 dgst_pos0 = 0;
8401 dgst_pos1 = 3;
8402 dgst_pos2 = 2;
8403 dgst_pos3 = 1;
8404 break;
8405
8406 case 3000: hash_type = HASH_TYPE_LM;
8407 salt_type = SALT_TYPE_NONE;
8408 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8409 opts_type = OPTS_TYPE_PT_GENERATE_LE
8410 | OPTS_TYPE_PT_UPPER
8411 | OPTS_TYPE_PT_BITSLICE;
8412 kern_type = KERN_TYPE_LM;
8413 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8414 parse_func = lm_parse_hash;
8415 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8416 opti_type = OPTI_TYPE_ZERO_BYTE
8417 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8418 dgst_pos0 = 0;
8419 dgst_pos1 = 1;
8420 dgst_pos2 = 2;
8421 dgst_pos3 = 3;
8422 break;
8423
8424 case 3100: hash_type = HASH_TYPE_ORACLEH;
8425 salt_type = SALT_TYPE_INTERN;
8426 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8427 opts_type = OPTS_TYPE_PT_GENERATE_LE
8428 | OPTS_TYPE_PT_UPPER
8429 | OPTS_TYPE_ST_UPPER;
8430 kern_type = KERN_TYPE_ORACLEH;
8431 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8432 parse_func = oracleh_parse_hash;
8433 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8434 opti_type = OPTI_TYPE_ZERO_BYTE;
8435 dgst_pos0 = 0;
8436 dgst_pos1 = 1;
8437 dgst_pos2 = 2;
8438 dgst_pos3 = 3;
8439 break;
8440
8441 case 3200: hash_type = HASH_TYPE_BCRYPT;
8442 salt_type = SALT_TYPE_EMBEDDED;
8443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8444 opts_type = OPTS_TYPE_PT_GENERATE_LE
8445 | OPTS_TYPE_ST_GENERATE_LE;
8446 kern_type = KERN_TYPE_BCRYPT;
8447 dgst_size = DGST_SIZE_4_6;
8448 parse_func = bcrypt_parse_hash;
8449 sort_by_digest = sort_by_digest_4_6;
8450 opti_type = OPTI_TYPE_ZERO_BYTE;
8451 dgst_pos0 = 0;
8452 dgst_pos1 = 1;
8453 dgst_pos2 = 2;
8454 dgst_pos3 = 3;
8455 break;
8456
8457 case 3710: hash_type = HASH_TYPE_MD5;
8458 salt_type = SALT_TYPE_INTERN;
8459 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8460 opts_type = OPTS_TYPE_PT_GENERATE_LE
8461 | OPTS_TYPE_PT_ADD80
8462 | OPTS_TYPE_PT_ADDBITS14;
8463 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8464 dgst_size = DGST_SIZE_4_4;
8465 parse_func = md5s_parse_hash;
8466 sort_by_digest = sort_by_digest_4_4;
8467 opti_type = OPTI_TYPE_ZERO_BYTE
8468 | OPTI_TYPE_PRECOMPUTE_INIT
8469 | OPTI_TYPE_PRECOMPUTE_MERKLE
8470 | OPTI_TYPE_EARLY_SKIP;
8471 dgst_pos0 = 0;
8472 dgst_pos1 = 3;
8473 dgst_pos2 = 2;
8474 dgst_pos3 = 1;
8475 break;
8476
8477 case 3711: hash_type = HASH_TYPE_MD5;
8478 salt_type = SALT_TYPE_EMBEDDED;
8479 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8480 opts_type = OPTS_TYPE_PT_GENERATE_LE
8481 | OPTS_TYPE_PT_ADD80
8482 | OPTS_TYPE_PT_ADDBITS14;
8483 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8484 dgst_size = DGST_SIZE_4_4;
8485 parse_func = mediawiki_b_parse_hash;
8486 sort_by_digest = sort_by_digest_4_4;
8487 opti_type = OPTI_TYPE_ZERO_BYTE
8488 | OPTI_TYPE_PRECOMPUTE_INIT
8489 | OPTI_TYPE_PRECOMPUTE_MERKLE
8490 | OPTI_TYPE_EARLY_SKIP;
8491 dgst_pos0 = 0;
8492 dgst_pos1 = 3;
8493 dgst_pos2 = 2;
8494 dgst_pos3 = 1;
8495 break;
8496
8497 case 3800: hash_type = HASH_TYPE_MD5;
8498 salt_type = SALT_TYPE_INTERN;
8499 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8500 opts_type = OPTS_TYPE_PT_GENERATE_LE
8501 | OPTS_TYPE_ST_ADDBITS14;
8502 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8503 dgst_size = DGST_SIZE_4_4;
8504 parse_func = md5s_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP
8510 | OPTI_TYPE_NOT_ITERATED
8511 | OPTI_TYPE_RAW_HASH;
8512 dgst_pos0 = 0;
8513 dgst_pos1 = 3;
8514 dgst_pos2 = 2;
8515 dgst_pos3 = 1;
8516 break;
8517
8518 case 4300: hash_type = HASH_TYPE_MD5;
8519 salt_type = SALT_TYPE_VIRTUAL;
8520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8521 opts_type = OPTS_TYPE_PT_GENERATE_LE
8522 | OPTS_TYPE_PT_ADD80
8523 | OPTS_TYPE_PT_ADDBITS14
8524 | OPTS_TYPE_ST_ADD80;
8525 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8526 dgst_size = DGST_SIZE_4_4;
8527 parse_func = md5md5_parse_hash;
8528 sort_by_digest = sort_by_digest_4_4;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP;
8533 dgst_pos0 = 0;
8534 dgst_pos1 = 3;
8535 dgst_pos2 = 2;
8536 dgst_pos3 = 1;
8537 break;
8538
8539
8540 case 4400: hash_type = HASH_TYPE_MD5;
8541 salt_type = SALT_TYPE_NONE;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_BE
8544 | OPTS_TYPE_PT_ADD80
8545 | OPTS_TYPE_PT_ADDBITS15;
8546 kern_type = KERN_TYPE_MD5_SHA1;
8547 dgst_size = DGST_SIZE_4_4;
8548 parse_func = md5_parse_hash;
8549 sort_by_digest = sort_by_digest_4_4;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_PRECOMPUTE_INIT
8552 | OPTI_TYPE_PRECOMPUTE_MERKLE
8553 | OPTI_TYPE_EARLY_SKIP
8554 | OPTI_TYPE_NOT_ITERATED
8555 | OPTI_TYPE_NOT_SALTED
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 0;
8558 dgst_pos1 = 3;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 4500: hash_type = HASH_TYPE_SHA1;
8564 salt_type = SALT_TYPE_NONE;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_BE
8567 | OPTS_TYPE_PT_ADD80
8568 | OPTS_TYPE_PT_ADDBITS15;
8569 kern_type = KERN_TYPE_SHA11;
8570 dgst_size = DGST_SIZE_4_5;
8571 parse_func = sha1_parse_hash;
8572 sort_by_digest = sort_by_digest_4_5;
8573 opti_type = OPTI_TYPE_ZERO_BYTE
8574 | OPTI_TYPE_PRECOMPUTE_INIT
8575 | OPTI_TYPE_PRECOMPUTE_MERKLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_SALTED;
8578 dgst_pos0 = 3;
8579 dgst_pos1 = 4;
8580 dgst_pos2 = 2;
8581 dgst_pos3 = 1;
8582 break;
8583
8584 case 4700: hash_type = HASH_TYPE_SHA1;
8585 salt_type = SALT_TYPE_NONE;
8586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8587 opts_type = OPTS_TYPE_PT_GENERATE_LE
8588 | OPTS_TYPE_PT_ADD80
8589 | OPTS_TYPE_PT_ADDBITS14;
8590 kern_type = KERN_TYPE_SHA1_MD5;
8591 dgst_size = DGST_SIZE_4_5;
8592 parse_func = sha1_parse_hash;
8593 sort_by_digest = sort_by_digest_4_5;
8594 opti_type = OPTI_TYPE_ZERO_BYTE
8595 | OPTI_TYPE_PRECOMPUTE_INIT
8596 | OPTI_TYPE_PRECOMPUTE_MERKLE
8597 | OPTI_TYPE_EARLY_SKIP
8598 | OPTI_TYPE_NOT_ITERATED
8599 | OPTI_TYPE_NOT_SALTED
8600 | OPTI_TYPE_RAW_HASH;
8601 dgst_pos0 = 3;
8602 dgst_pos1 = 4;
8603 dgst_pos2 = 2;
8604 dgst_pos3 = 1;
8605 break;
8606
8607 case 4800: hash_type = HASH_TYPE_MD5;
8608 salt_type = SALT_TYPE_EMBEDDED;
8609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8610 opts_type = OPTS_TYPE_PT_GENERATE_LE
8611 | OPTS_TYPE_PT_ADDBITS14;
8612 kern_type = KERN_TYPE_MD5_CHAP;
8613 dgst_size = DGST_SIZE_4_4;
8614 parse_func = chap_parse_hash;
8615 sort_by_digest = sort_by_digest_4_4;
8616 opti_type = OPTI_TYPE_ZERO_BYTE
8617 | OPTI_TYPE_PRECOMPUTE_INIT
8618 | OPTI_TYPE_PRECOMPUTE_MERKLE
8619 | OPTI_TYPE_MEET_IN_MIDDLE
8620 | OPTI_TYPE_EARLY_SKIP
8621 | OPTI_TYPE_NOT_ITERATED
8622 | OPTI_TYPE_RAW_HASH;
8623 dgst_pos0 = 0;
8624 dgst_pos1 = 3;
8625 dgst_pos2 = 2;
8626 dgst_pos3 = 1;
8627 break;
8628
8629 case 4900: hash_type = HASH_TYPE_SHA1;
8630 salt_type = SALT_TYPE_INTERN;
8631 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8632 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8633 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8634 dgst_size = DGST_SIZE_4_5;
8635 parse_func = sha1s_parse_hash;
8636 sort_by_digest = sort_by_digest_4_5;
8637 opti_type = OPTI_TYPE_ZERO_BYTE
8638 | OPTI_TYPE_PRECOMPUTE_INIT
8639 | OPTI_TYPE_PRECOMPUTE_MERKLE
8640 | OPTI_TYPE_EARLY_SKIP;
8641 dgst_pos0 = 3;
8642 dgst_pos1 = 4;
8643 dgst_pos2 = 2;
8644 dgst_pos3 = 1;
8645 break;
8646
8647 case 5000: hash_type = HASH_TYPE_KECCAK;
8648 salt_type = SALT_TYPE_EMBEDDED;
8649 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8650 opts_type = OPTS_TYPE_PT_GENERATE_LE
8651 | OPTS_TYPE_PT_ADD01;
8652 kern_type = KERN_TYPE_KECCAK;
8653 dgst_size = DGST_SIZE_8_25;
8654 parse_func = keccak_parse_hash;
8655 sort_by_digest = sort_by_digest_8_25;
8656 opti_type = OPTI_TYPE_ZERO_BYTE
8657 | OPTI_TYPE_USES_BITS_64
8658 | OPTI_TYPE_RAW_HASH;
8659 dgst_pos0 = 2;
8660 dgst_pos1 = 3;
8661 dgst_pos2 = 4;
8662 dgst_pos3 = 5;
8663 break;
8664
8665 case 5100: hash_type = HASH_TYPE_MD5H;
8666 salt_type = SALT_TYPE_NONE;
8667 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8668 opts_type = OPTS_TYPE_PT_GENERATE_LE
8669 | OPTS_TYPE_PT_ADD80
8670 | OPTS_TYPE_PT_ADDBITS14;
8671 kern_type = KERN_TYPE_MD5H;
8672 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8673 parse_func = md5half_parse_hash;
8674 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8675 opti_type = OPTI_TYPE_ZERO_BYTE
8676 | OPTI_TYPE_RAW_HASH;
8677 dgst_pos0 = 0;
8678 dgst_pos1 = 1;
8679 dgst_pos2 = 2;
8680 dgst_pos3 = 3;
8681 break;
8682
8683 case 5200: hash_type = HASH_TYPE_SHA256;
8684 salt_type = SALT_TYPE_EMBEDDED;
8685 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8686 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8687 kern_type = KERN_TYPE_PSAFE3;
8688 dgst_size = DGST_SIZE_4_8;
8689 parse_func = psafe3_parse_hash;
8690 sort_by_digest = sort_by_digest_4_8;
8691 opti_type = OPTI_TYPE_ZERO_BYTE;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 1;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 3;
8696 break;
8697
8698 case 5300: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_EMBEDDED;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE
8702 | OPTS_TYPE_ST_ADD80;
8703 kern_type = KERN_TYPE_IKEPSK_MD5;
8704 dgst_size = DGST_SIZE_4_4;
8705 parse_func = ikepsk_md5_parse_hash;
8706 sort_by_digest = sort_by_digest_4_4;
8707 opti_type = OPTI_TYPE_ZERO_BYTE;
8708 dgst_pos0 = 0;
8709 dgst_pos1 = 3;
8710 dgst_pos2 = 2;
8711 dgst_pos3 = 1;
8712 break;
8713
8714 case 5400: hash_type = HASH_TYPE_SHA1;
8715 salt_type = SALT_TYPE_EMBEDDED;
8716 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8717 opts_type = OPTS_TYPE_PT_GENERATE_BE
8718 | OPTS_TYPE_ST_ADD80;
8719 kern_type = KERN_TYPE_IKEPSK_SHA1;
8720 dgst_size = DGST_SIZE_4_5;
8721 parse_func = ikepsk_sha1_parse_hash;
8722 sort_by_digest = sort_by_digest_4_5;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 3;
8725 dgst_pos1 = 4;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 1;
8728 break;
8729
8730 case 5500: hash_type = HASH_TYPE_NETNTLM;
8731 salt_type = SALT_TYPE_EMBEDDED;
8732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_LE
8734 | OPTS_TYPE_PT_ADD80
8735 | OPTS_TYPE_PT_ADDBITS14
8736 | OPTS_TYPE_PT_UNICODE
8737 | OPTS_TYPE_ST_HEX;
8738 kern_type = KERN_TYPE_NETNTLMv1;
8739 dgst_size = DGST_SIZE_4_4;
8740 parse_func = netntlmv1_parse_hash;
8741 sort_by_digest = sort_by_digest_4_4;
8742 opti_type = OPTI_TYPE_ZERO_BYTE
8743 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8744 dgst_pos0 = 0;
8745 dgst_pos1 = 1;
8746 dgst_pos2 = 2;
8747 dgst_pos3 = 3;
8748 break;
8749
8750 case 5600: hash_type = HASH_TYPE_MD5;
8751 salt_type = SALT_TYPE_EMBEDDED;
8752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8753 opts_type = OPTS_TYPE_PT_GENERATE_LE
8754 | OPTS_TYPE_PT_ADD80
8755 | OPTS_TYPE_PT_ADDBITS14
8756 | OPTS_TYPE_PT_UNICODE;
8757 kern_type = KERN_TYPE_NETNTLMv2;
8758 dgst_size = DGST_SIZE_4_4;
8759 parse_func = netntlmv2_parse_hash;
8760 sort_by_digest = sort_by_digest_4_4;
8761 opti_type = OPTI_TYPE_ZERO_BYTE;
8762 dgst_pos0 = 0;
8763 dgst_pos1 = 3;
8764 dgst_pos2 = 2;
8765 dgst_pos3 = 1;
8766 break;
8767
8768 case 5700: hash_type = HASH_TYPE_SHA256;
8769 salt_type = SALT_TYPE_NONE;
8770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8771 opts_type = OPTS_TYPE_PT_GENERATE_BE
8772 | OPTS_TYPE_PT_ADD80
8773 | OPTS_TYPE_PT_ADDBITS15;
8774 kern_type = KERN_TYPE_SHA256;
8775 dgst_size = DGST_SIZE_4_8;
8776 parse_func = cisco4_parse_hash;
8777 sort_by_digest = sort_by_digest_4_8;
8778 opti_type = OPTI_TYPE_ZERO_BYTE
8779 | OPTI_TYPE_PRECOMPUTE_INIT
8780 | OPTI_TYPE_PRECOMPUTE_MERKLE
8781 | OPTI_TYPE_EARLY_SKIP
8782 | OPTI_TYPE_NOT_ITERATED
8783 | OPTI_TYPE_NOT_SALTED
8784 | OPTI_TYPE_RAW_HASH;
8785 dgst_pos0 = 3;
8786 dgst_pos1 = 7;
8787 dgst_pos2 = 2;
8788 dgst_pos3 = 6;
8789 break;
8790
8791 case 5800: hash_type = HASH_TYPE_SHA1;
8792 salt_type = SALT_TYPE_INTERN;
8793 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8794 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8795 | OPTS_TYPE_ST_ADD80;
8796 kern_type = KERN_TYPE_ANDROIDPIN;
8797 dgst_size = DGST_SIZE_4_5;
8798 parse_func = androidpin_parse_hash;
8799 sort_by_digest = sort_by_digest_4_5;
8800 opti_type = OPTI_TYPE_ZERO_BYTE;
8801 dgst_pos0 = 0;
8802 dgst_pos1 = 1;
8803 dgst_pos2 = 2;
8804 dgst_pos3 = 3;
8805 break;
8806
8807 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8808 salt_type = SALT_TYPE_NONE;
8809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8810 opts_type = OPTS_TYPE_PT_GENERATE_LE
8811 | OPTS_TYPE_PT_ADD80;
8812 kern_type = KERN_TYPE_RIPEMD160;
8813 dgst_size = DGST_SIZE_4_5;
8814 parse_func = ripemd160_parse_hash;
8815 sort_by_digest = sort_by_digest_4_5;
8816 opti_type = OPTI_TYPE_ZERO_BYTE;
8817 dgst_pos0 = 0;
8818 dgst_pos1 = 1;
8819 dgst_pos2 = 2;
8820 dgst_pos3 = 3;
8821 break;
8822
8823 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8824 salt_type = SALT_TYPE_NONE;
8825 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8826 opts_type = OPTS_TYPE_PT_GENERATE_BE
8827 | OPTS_TYPE_PT_ADD80;
8828 kern_type = KERN_TYPE_WHIRLPOOL;
8829 dgst_size = DGST_SIZE_4_16;
8830 parse_func = whirlpool_parse_hash;
8831 sort_by_digest = sort_by_digest_4_16;
8832 opti_type = OPTI_TYPE_ZERO_BYTE;
8833 dgst_pos0 = 0;
8834 dgst_pos1 = 1;
8835 dgst_pos2 = 2;
8836 dgst_pos3 = 3;
8837 break;
8838
8839 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8840 salt_type = SALT_TYPE_EMBEDDED;
8841 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8842 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8843 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8844 dgst_size = DGST_SIZE_4_5;
8845 parse_func = truecrypt_parse_hash_2k;
8846 sort_by_digest = sort_by_digest_4_5;
8847 opti_type = OPTI_TYPE_ZERO_BYTE;
8848 dgst_pos0 = 0;
8849 dgst_pos1 = 1;
8850 dgst_pos2 = 2;
8851 dgst_pos3 = 3;
8852 break;
8853
8854 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8855 salt_type = SALT_TYPE_EMBEDDED;
8856 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8857 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8858 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8859 dgst_size = DGST_SIZE_4_5;
8860 parse_func = truecrypt_parse_hash_2k;
8861 sort_by_digest = sort_by_digest_4_5;
8862 opti_type = OPTI_TYPE_ZERO_BYTE;
8863 dgst_pos0 = 0;
8864 dgst_pos1 = 1;
8865 dgst_pos2 = 2;
8866 dgst_pos3 = 3;
8867 break;
8868
8869 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8870 salt_type = SALT_TYPE_EMBEDDED;
8871 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8872 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8873 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8874 dgst_size = DGST_SIZE_4_5;
8875 parse_func = truecrypt_parse_hash_2k;
8876 sort_by_digest = sort_by_digest_4_5;
8877 opti_type = OPTI_TYPE_ZERO_BYTE;
8878 dgst_pos0 = 0;
8879 dgst_pos1 = 1;
8880 dgst_pos2 = 2;
8881 dgst_pos3 = 3;
8882 break;
8883
8884 case 6221: hash_type = HASH_TYPE_SHA512;
8885 salt_type = SALT_TYPE_EMBEDDED;
8886 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8887 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8888 kern_type = KERN_TYPE_TCSHA512_XTS512;
8889 dgst_size = DGST_SIZE_8_8;
8890 parse_func = truecrypt_parse_hash_1k;
8891 sort_by_digest = sort_by_digest_8_8;
8892 opti_type = OPTI_TYPE_ZERO_BYTE
8893 | OPTI_TYPE_USES_BITS_64;
8894 dgst_pos0 = 0;
8895 dgst_pos1 = 1;
8896 dgst_pos2 = 2;
8897 dgst_pos3 = 3;
8898 break;
8899
8900 case 6222: hash_type = HASH_TYPE_SHA512;
8901 salt_type = SALT_TYPE_EMBEDDED;
8902 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8903 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8904 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8905 dgst_size = DGST_SIZE_8_8;
8906 parse_func = truecrypt_parse_hash_1k;
8907 sort_by_digest = sort_by_digest_8_8;
8908 opti_type = OPTI_TYPE_ZERO_BYTE
8909 | OPTI_TYPE_USES_BITS_64;
8910 dgst_pos0 = 0;
8911 dgst_pos1 = 1;
8912 dgst_pos2 = 2;
8913 dgst_pos3 = 3;
8914 break;
8915
8916 case 6223: hash_type = HASH_TYPE_SHA512;
8917 salt_type = SALT_TYPE_EMBEDDED;
8918 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8919 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8920 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8921 dgst_size = DGST_SIZE_8_8;
8922 parse_func = truecrypt_parse_hash_1k;
8923 sort_by_digest = sort_by_digest_8_8;
8924 opti_type = OPTI_TYPE_ZERO_BYTE
8925 | OPTI_TYPE_USES_BITS_64;
8926 dgst_pos0 = 0;
8927 dgst_pos1 = 1;
8928 dgst_pos2 = 2;
8929 dgst_pos3 = 3;
8930 break;
8931
8932 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8933 salt_type = SALT_TYPE_EMBEDDED;
8934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8935 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8936 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8937 dgst_size = DGST_SIZE_4_8;
8938 parse_func = truecrypt_parse_hash_1k;
8939 sort_by_digest = sort_by_digest_4_8;
8940 opti_type = OPTI_TYPE_ZERO_BYTE;
8941 dgst_pos0 = 0;
8942 dgst_pos1 = 1;
8943 dgst_pos2 = 2;
8944 dgst_pos3 = 3;
8945 break;
8946
8947 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8948 salt_type = SALT_TYPE_EMBEDDED;
8949 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8951 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8952 dgst_size = DGST_SIZE_4_8;
8953 parse_func = truecrypt_parse_hash_1k;
8954 sort_by_digest = sort_by_digest_4_8;
8955 opti_type = OPTI_TYPE_ZERO_BYTE;
8956 dgst_pos0 = 0;
8957 dgst_pos1 = 1;
8958 dgst_pos2 = 2;
8959 dgst_pos3 = 3;
8960 break;
8961
8962 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8963 salt_type = SALT_TYPE_EMBEDDED;
8964 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8965 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8966 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8967 dgst_size = DGST_SIZE_4_8;
8968 parse_func = truecrypt_parse_hash_1k;
8969 sort_by_digest = sort_by_digest_4_8;
8970 opti_type = OPTI_TYPE_ZERO_BYTE;
8971 dgst_pos0 = 0;
8972 dgst_pos1 = 1;
8973 dgst_pos2 = 2;
8974 dgst_pos3 = 3;
8975 break;
8976
8977 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8978 salt_type = SALT_TYPE_EMBEDDED;
8979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8980 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8981 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8982 dgst_size = DGST_SIZE_4_5;
8983 parse_func = truecrypt_parse_hash_1k;
8984 sort_by_digest = sort_by_digest_4_5;
8985 opti_type = OPTI_TYPE_ZERO_BYTE;
8986 dgst_pos0 = 0;
8987 dgst_pos1 = 1;
8988 dgst_pos2 = 2;
8989 dgst_pos3 = 3;
8990 break;
8991
8992 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8993 salt_type = SALT_TYPE_EMBEDDED;
8994 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8995 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8996 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8997 dgst_size = DGST_SIZE_4_5;
8998 parse_func = truecrypt_parse_hash_1k;
8999 sort_by_digest = sort_by_digest_4_5;
9000 opti_type = OPTI_TYPE_ZERO_BYTE;
9001 dgst_pos0 = 0;
9002 dgst_pos1 = 1;
9003 dgst_pos2 = 2;
9004 dgst_pos3 = 3;
9005 break;
9006
9007 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9008 salt_type = SALT_TYPE_EMBEDDED;
9009 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9010 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9011 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9012 dgst_size = DGST_SIZE_4_5;
9013 parse_func = truecrypt_parse_hash_1k;
9014 sort_by_digest = sort_by_digest_4_5;
9015 opti_type = OPTI_TYPE_ZERO_BYTE;
9016 dgst_pos0 = 0;
9017 dgst_pos1 = 1;
9018 dgst_pos2 = 2;
9019 dgst_pos3 = 3;
9020 break;
9021
9022 case 6300: hash_type = HASH_TYPE_MD5;
9023 salt_type = SALT_TYPE_EMBEDDED;
9024 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9025 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9026 kern_type = KERN_TYPE_MD5AIX;
9027 dgst_size = DGST_SIZE_4_4;
9028 parse_func = md5aix_parse_hash;
9029 sort_by_digest = sort_by_digest_4_4;
9030 opti_type = OPTI_TYPE_ZERO_BYTE;
9031 dgst_pos0 = 0;
9032 dgst_pos1 = 1;
9033 dgst_pos2 = 2;
9034 dgst_pos3 = 3;
9035 break;
9036
9037 case 6400: hash_type = HASH_TYPE_SHA256;
9038 salt_type = SALT_TYPE_EMBEDDED;
9039 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9040 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9041 kern_type = KERN_TYPE_SHA256AIX;
9042 dgst_size = DGST_SIZE_4_8;
9043 parse_func = sha256aix_parse_hash;
9044 sort_by_digest = sort_by_digest_4_8;
9045 opti_type = OPTI_TYPE_ZERO_BYTE;
9046 dgst_pos0 = 0;
9047 dgst_pos1 = 1;
9048 dgst_pos2 = 2;
9049 dgst_pos3 = 3;
9050 break;
9051
9052 case 6500: hash_type = HASH_TYPE_SHA512;
9053 salt_type = SALT_TYPE_EMBEDDED;
9054 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9055 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9056 kern_type = KERN_TYPE_SHA512AIX;
9057 dgst_size = DGST_SIZE_8_8;
9058 parse_func = sha512aix_parse_hash;
9059 sort_by_digest = sort_by_digest_8_8;
9060 opti_type = OPTI_TYPE_ZERO_BYTE
9061 | OPTI_TYPE_USES_BITS_64;
9062 dgst_pos0 = 0;
9063 dgst_pos1 = 1;
9064 dgst_pos2 = 2;
9065 dgst_pos3 = 3;
9066 break;
9067
9068 case 6600: hash_type = HASH_TYPE_AES;
9069 salt_type = SALT_TYPE_EMBEDDED;
9070 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9071 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9072 kern_type = KERN_TYPE_AGILEKEY;
9073 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9074 parse_func = agilekey_parse_hash;
9075 sort_by_digest = sort_by_digest_4_5;
9076 opti_type = OPTI_TYPE_ZERO_BYTE;
9077 dgst_pos0 = 0;
9078 dgst_pos1 = 1;
9079 dgst_pos2 = 2;
9080 dgst_pos3 = 3;
9081 break;
9082
9083 case 6700: hash_type = HASH_TYPE_SHA1;
9084 salt_type = SALT_TYPE_EMBEDDED;
9085 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9086 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9087 kern_type = KERN_TYPE_SHA1AIX;
9088 dgst_size = DGST_SIZE_4_5;
9089 parse_func = sha1aix_parse_hash;
9090 sort_by_digest = sort_by_digest_4_5;
9091 opti_type = OPTI_TYPE_ZERO_BYTE;
9092 dgst_pos0 = 0;
9093 dgst_pos1 = 1;
9094 dgst_pos2 = 2;
9095 dgst_pos3 = 3;
9096 break;
9097
9098 case 6800: hash_type = HASH_TYPE_AES;
9099 salt_type = SALT_TYPE_EMBEDDED;
9100 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9101 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9102 kern_type = KERN_TYPE_LASTPASS;
9103 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9104 parse_func = lastpass_parse_hash;
9105 sort_by_digest = sort_by_digest_4_8;
9106 opti_type = OPTI_TYPE_ZERO_BYTE;
9107 dgst_pos0 = 0;
9108 dgst_pos1 = 1;
9109 dgst_pos2 = 2;
9110 dgst_pos3 = 3;
9111 break;
9112
9113 case 6900: hash_type = HASH_TYPE_GOST;
9114 salt_type = SALT_TYPE_NONE;
9115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9116 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9117 kern_type = KERN_TYPE_GOST;
9118 dgst_size = DGST_SIZE_4_8;
9119 parse_func = gost_parse_hash;
9120 sort_by_digest = sort_by_digest_4_8;
9121 opti_type = OPTI_TYPE_ZERO_BYTE;
9122 dgst_pos0 = 0;
9123 dgst_pos1 = 1;
9124 dgst_pos2 = 2;
9125 dgst_pos3 = 3;
9126 break;
9127
9128 case 7100: hash_type = HASH_TYPE_SHA512;
9129 salt_type = SALT_TYPE_EMBEDDED;
9130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9131 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9132 kern_type = KERN_TYPE_PBKDF2_SHA512;
9133 dgst_size = DGST_SIZE_8_16;
9134 parse_func = sha512osx_parse_hash;
9135 sort_by_digest = sort_by_digest_8_16;
9136 opti_type = OPTI_TYPE_ZERO_BYTE
9137 | OPTI_TYPE_USES_BITS_64
9138 | OPTI_TYPE_SLOW_HASH_SIMD;
9139 dgst_pos0 = 0;
9140 dgst_pos1 = 1;
9141 dgst_pos2 = 2;
9142 dgst_pos3 = 3;
9143 break;
9144
9145 case 7200: hash_type = HASH_TYPE_SHA512;
9146 salt_type = SALT_TYPE_EMBEDDED;
9147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9148 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9149 kern_type = KERN_TYPE_PBKDF2_SHA512;
9150 dgst_size = DGST_SIZE_8_16;
9151 parse_func = sha512grub_parse_hash;
9152 sort_by_digest = sort_by_digest_8_16;
9153 opti_type = OPTI_TYPE_ZERO_BYTE
9154 | OPTI_TYPE_USES_BITS_64
9155 | OPTI_TYPE_SLOW_HASH_SIMD;
9156 dgst_pos0 = 0;
9157 dgst_pos1 = 1;
9158 dgst_pos2 = 2;
9159 dgst_pos3 = 3;
9160 break;
9161
9162 case 7300: hash_type = HASH_TYPE_SHA1;
9163 salt_type = SALT_TYPE_EMBEDDED;
9164 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9165 opts_type = OPTS_TYPE_PT_GENERATE_BE
9166 | OPTS_TYPE_ST_ADD80
9167 | OPTS_TYPE_ST_ADDBITS15;
9168 kern_type = KERN_TYPE_RAKP;
9169 dgst_size = DGST_SIZE_4_5;
9170 parse_func = rakp_parse_hash;
9171 sort_by_digest = sort_by_digest_4_5;
9172 opti_type = OPTI_TYPE_ZERO_BYTE
9173 | OPTI_TYPE_NOT_ITERATED;
9174 dgst_pos0 = 3;
9175 dgst_pos1 = 4;
9176 dgst_pos2 = 2;
9177 dgst_pos3 = 1;
9178 break;
9179
9180 case 7400: hash_type = HASH_TYPE_SHA256;
9181 salt_type = SALT_TYPE_EMBEDDED;
9182 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9183 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9184 kern_type = KERN_TYPE_SHA256CRYPT;
9185 dgst_size = DGST_SIZE_4_8;
9186 parse_func = sha256crypt_parse_hash;
9187 sort_by_digest = sort_by_digest_4_8;
9188 opti_type = OPTI_TYPE_ZERO_BYTE;
9189 dgst_pos0 = 0;
9190 dgst_pos1 = 1;
9191 dgst_pos2 = 2;
9192 dgst_pos3 = 3;
9193 break;
9194
9195 case 7500: hash_type = HASH_TYPE_KRB5PA;
9196 salt_type = SALT_TYPE_EMBEDDED;
9197 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9198 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9199 kern_type = KERN_TYPE_KRB5PA;
9200 dgst_size = DGST_SIZE_4_4;
9201 parse_func = krb5pa_parse_hash;
9202 sort_by_digest = sort_by_digest_4_4;
9203 opti_type = OPTI_TYPE_ZERO_BYTE
9204 | OPTI_TYPE_NOT_ITERATED;
9205 dgst_pos0 = 0;
9206 dgst_pos1 = 1;
9207 dgst_pos2 = 2;
9208 dgst_pos3 = 3;
9209 break;
9210
9211 case 7600: hash_type = HASH_TYPE_SHA1;
9212 salt_type = SALT_TYPE_INTERN;
9213 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9214 opts_type = OPTS_TYPE_PT_GENERATE_BE
9215 | OPTS_TYPE_PT_ADD80
9216 | OPTS_TYPE_PT_ADDBITS15;
9217 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9218 dgst_size = DGST_SIZE_4_5;
9219 parse_func = redmine_parse_hash;
9220 sort_by_digest = sort_by_digest_4_5;
9221 opti_type = OPTI_TYPE_ZERO_BYTE
9222 | OPTI_TYPE_PRECOMPUTE_INIT
9223 | OPTI_TYPE_EARLY_SKIP
9224 | OPTI_TYPE_NOT_ITERATED
9225 | OPTI_TYPE_PREPENDED_SALT;
9226 dgst_pos0 = 3;
9227 dgst_pos1 = 4;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 1;
9230 break;
9231
9232 case 7700: hash_type = HASH_TYPE_SAPB;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE
9236 | OPTS_TYPE_PT_UPPER
9237 | OPTS_TYPE_ST_UPPER;
9238 kern_type = KERN_TYPE_SAPB;
9239 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9240 parse_func = sapb_parse_hash;
9241 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9242 opti_type = OPTI_TYPE_ZERO_BYTE
9243 | OPTI_TYPE_PRECOMPUTE_INIT
9244 | OPTI_TYPE_NOT_ITERATED;
9245 dgst_pos0 = 0;
9246 dgst_pos1 = 1;
9247 dgst_pos2 = 2;
9248 dgst_pos3 = 3;
9249 break;
9250
9251 case 7800: hash_type = HASH_TYPE_SAPG;
9252 salt_type = SALT_TYPE_EMBEDDED;
9253 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9254 opts_type = OPTS_TYPE_PT_GENERATE_BE
9255 | OPTS_TYPE_ST_ADD80
9256 | OPTS_TYPE_ST_UPPER;
9257 kern_type = KERN_TYPE_SAPG;
9258 dgst_size = DGST_SIZE_4_5;
9259 parse_func = sapg_parse_hash;
9260 sort_by_digest = sort_by_digest_4_5;
9261 opti_type = OPTI_TYPE_ZERO_BYTE
9262 | OPTI_TYPE_PRECOMPUTE_INIT
9263 | OPTI_TYPE_NOT_ITERATED;
9264 dgst_pos0 = 3;
9265 dgst_pos1 = 4;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 1;
9268 break;
9269
9270 case 7900: hash_type = HASH_TYPE_SHA512;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9274 kern_type = KERN_TYPE_DRUPAL7;
9275 dgst_size = DGST_SIZE_8_8;
9276 parse_func = drupal7_parse_hash;
9277 sort_by_digest = sort_by_digest_8_8;
9278 opti_type = OPTI_TYPE_ZERO_BYTE
9279 | OPTI_TYPE_USES_BITS_64;
9280 dgst_pos0 = 0;
9281 dgst_pos1 = 1;
9282 dgst_pos2 = 2;
9283 dgst_pos3 = 3;
9284 break;
9285
9286 case 8000: hash_type = HASH_TYPE_SHA256;
9287 salt_type = SALT_TYPE_EMBEDDED;
9288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9289 opts_type = OPTS_TYPE_PT_GENERATE_BE
9290 | OPTS_TYPE_PT_UNICODE
9291 | OPTS_TYPE_ST_ADD80
9292 | OPTS_TYPE_ST_HEX;
9293 kern_type = KERN_TYPE_SYBASEASE;
9294 dgst_size = DGST_SIZE_4_8;
9295 parse_func = sybasease_parse_hash;
9296 sort_by_digest = sort_by_digest_4_8;
9297 opti_type = OPTI_TYPE_ZERO_BYTE
9298 | OPTI_TYPE_PRECOMPUTE_INIT
9299 | OPTI_TYPE_EARLY_SKIP
9300 | OPTI_TYPE_NOT_ITERATED
9301 | OPTI_TYPE_RAW_HASH;
9302 dgst_pos0 = 3;
9303 dgst_pos1 = 7;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 6;
9306 break;
9307
9308 case 8100: hash_type = HASH_TYPE_SHA1;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9312 kern_type = KERN_TYPE_NETSCALER;
9313 dgst_size = DGST_SIZE_4_5;
9314 parse_func = netscaler_parse_hash;
9315 sort_by_digest = sort_by_digest_4_5;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_PRECOMPUTE_INIT
9318 | OPTI_TYPE_PRECOMPUTE_MERKLE
9319 | OPTI_TYPE_EARLY_SKIP
9320 | OPTI_TYPE_NOT_ITERATED
9321 | OPTI_TYPE_PREPENDED_SALT
9322 | OPTI_TYPE_RAW_HASH;
9323 dgst_pos0 = 3;
9324 dgst_pos1 = 4;
9325 dgst_pos2 = 2;
9326 dgst_pos3 = 1;
9327 break;
9328
9329 case 8200: hash_type = HASH_TYPE_SHA256;
9330 salt_type = SALT_TYPE_EMBEDDED;
9331 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9332 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9333 kern_type = KERN_TYPE_CLOUDKEY;
9334 dgst_size = DGST_SIZE_4_8;
9335 parse_func = cloudkey_parse_hash;
9336 sort_by_digest = sort_by_digest_4_8;
9337 opti_type = OPTI_TYPE_ZERO_BYTE;
9338 dgst_pos0 = 0;
9339 dgst_pos1 = 1;
9340 dgst_pos2 = 2;
9341 dgst_pos3 = 3;
9342 break;
9343
9344 case 8300: hash_type = HASH_TYPE_SHA1;
9345 salt_type = SALT_TYPE_EMBEDDED;
9346 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9347 opts_type = OPTS_TYPE_PT_GENERATE_BE
9348 | OPTS_TYPE_ST_HEX
9349 | OPTS_TYPE_ST_ADD80;
9350 kern_type = KERN_TYPE_NSEC3;
9351 dgst_size = DGST_SIZE_4_5;
9352 parse_func = nsec3_parse_hash;
9353 sort_by_digest = sort_by_digest_4_5;
9354 opti_type = OPTI_TYPE_ZERO_BYTE;
9355 dgst_pos0 = 3;
9356 dgst_pos1 = 4;
9357 dgst_pos2 = 2;
9358 dgst_pos3 = 1;
9359 break;
9360
9361 case 8400: hash_type = HASH_TYPE_SHA1;
9362 salt_type = SALT_TYPE_INTERN;
9363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9364 opts_type = OPTS_TYPE_PT_GENERATE_BE
9365 | OPTS_TYPE_PT_ADD80
9366 | OPTS_TYPE_PT_ADDBITS15;
9367 kern_type = KERN_TYPE_WBB3;
9368 dgst_size = DGST_SIZE_4_5;
9369 parse_func = wbb3_parse_hash;
9370 sort_by_digest = sort_by_digest_4_5;
9371 opti_type = OPTI_TYPE_ZERO_BYTE
9372 | OPTI_TYPE_PRECOMPUTE_INIT
9373 | OPTI_TYPE_NOT_ITERATED;
9374 dgst_pos0 = 3;
9375 dgst_pos1 = 4;
9376 dgst_pos2 = 2;
9377 dgst_pos3 = 1;
9378 break;
9379
9380 case 8500: hash_type = HASH_TYPE_DESRACF;
9381 salt_type = SALT_TYPE_EMBEDDED;
9382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9383 opts_type = OPTS_TYPE_PT_GENERATE_LE
9384 | OPTS_TYPE_ST_UPPER;
9385 kern_type = KERN_TYPE_RACF;
9386 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9387 parse_func = racf_parse_hash;
9388 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9389 opti_type = OPTI_TYPE_ZERO_BYTE
9390 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9391 dgst_pos0 = 0;
9392 dgst_pos1 = 1;
9393 dgst_pos2 = 2;
9394 dgst_pos3 = 3;
9395 break;
9396
9397 case 8600: hash_type = HASH_TYPE_LOTUS5;
9398 salt_type = SALT_TYPE_NONE;
9399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9400 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9401 kern_type = KERN_TYPE_LOTUS5;
9402 dgst_size = DGST_SIZE_4_4;
9403 parse_func = lotus5_parse_hash;
9404 sort_by_digest = sort_by_digest_4_4;
9405 opti_type = OPTI_TYPE_EARLY_SKIP
9406 | OPTI_TYPE_NOT_ITERATED
9407 | OPTI_TYPE_NOT_SALTED
9408 | OPTI_TYPE_RAW_HASH;
9409 dgst_pos0 = 0;
9410 dgst_pos1 = 1;
9411 dgst_pos2 = 2;
9412 dgst_pos3 = 3;
9413 break;
9414
9415 case 8700: hash_type = HASH_TYPE_LOTUS6;
9416 salt_type = SALT_TYPE_EMBEDDED;
9417 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9418 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9419 kern_type = KERN_TYPE_LOTUS6;
9420 dgst_size = DGST_SIZE_4_4;
9421 parse_func = lotus6_parse_hash;
9422 sort_by_digest = sort_by_digest_4_4;
9423 opti_type = OPTI_TYPE_EARLY_SKIP
9424 | OPTI_TYPE_NOT_ITERATED
9425 | OPTI_TYPE_RAW_HASH;
9426 dgst_pos0 = 0;
9427 dgst_pos1 = 1;
9428 dgst_pos2 = 2;
9429 dgst_pos3 = 3;
9430 break;
9431
9432 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9433 salt_type = SALT_TYPE_EMBEDDED;
9434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9436 kern_type = KERN_TYPE_ANDROIDFDE;
9437 dgst_size = DGST_SIZE_4_4;
9438 parse_func = androidfde_parse_hash;
9439 sort_by_digest = sort_by_digest_4_4;
9440 opti_type = OPTI_TYPE_ZERO_BYTE;
9441 dgst_pos0 = 0;
9442 dgst_pos1 = 1;
9443 dgst_pos2 = 2;
9444 dgst_pos3 = 3;
9445 break;
9446
9447 case 8900: hash_type = HASH_TYPE_SCRYPT;
9448 salt_type = SALT_TYPE_EMBEDDED;
9449 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9451 kern_type = KERN_TYPE_SCRYPT;
9452 dgst_size = DGST_SIZE_4_8;
9453 parse_func = scrypt_parse_hash;
9454 sort_by_digest = sort_by_digest_4_8;
9455 opti_type = OPTI_TYPE_ZERO_BYTE;
9456 dgst_pos0 = 0;
9457 dgst_pos1 = 1;
9458 dgst_pos2 = 2;
9459 dgst_pos3 = 3;
9460 break;
9461
9462 case 9000: hash_type = HASH_TYPE_SHA1;
9463 salt_type = SALT_TYPE_EMBEDDED;
9464 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9465 opts_type = OPTS_TYPE_PT_GENERATE_LE
9466 | OPTS_TYPE_ST_GENERATE_LE;
9467 kern_type = KERN_TYPE_PSAFE2;
9468 dgst_size = DGST_SIZE_4_5;
9469 parse_func = psafe2_parse_hash;
9470 sort_by_digest = sort_by_digest_4_5;
9471 opti_type = OPTI_TYPE_ZERO_BYTE;
9472 dgst_pos0 = 0;
9473 dgst_pos1 = 1;
9474 dgst_pos2 = 2;
9475 dgst_pos3 = 3;
9476 break;
9477
9478 case 9100: hash_type = HASH_TYPE_LOTUS8;
9479 salt_type = SALT_TYPE_EMBEDDED;
9480 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9481 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9482 kern_type = KERN_TYPE_LOTUS8;
9483 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9484 parse_func = lotus8_parse_hash;
9485 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9486 opti_type = OPTI_TYPE_ZERO_BYTE;
9487 dgst_pos0 = 0;
9488 dgst_pos1 = 1;
9489 dgst_pos2 = 2;
9490 dgst_pos3 = 3;
9491 break;
9492
9493 case 9200: hash_type = HASH_TYPE_SHA256;
9494 salt_type = SALT_TYPE_EMBEDDED;
9495 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9496 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9497 kern_type = KERN_TYPE_PBKDF2_SHA256;
9498 dgst_size = DGST_SIZE_4_32;
9499 parse_func = cisco8_parse_hash;
9500 sort_by_digest = sort_by_digest_4_32;
9501 opti_type = OPTI_TYPE_ZERO_BYTE
9502 | OPTI_TYPE_SLOW_HASH_SIMD;
9503 dgst_pos0 = 0;
9504 dgst_pos1 = 1;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 3;
9507 break;
9508
9509 case 9300: hash_type = HASH_TYPE_SCRYPT;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9513 kern_type = KERN_TYPE_SCRYPT;
9514 dgst_size = DGST_SIZE_4_8;
9515 parse_func = cisco9_parse_hash;
9516 sort_by_digest = sort_by_digest_4_8;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9528 kern_type = KERN_TYPE_OFFICE2007;
9529 dgst_size = DGST_SIZE_4_4;
9530 parse_func = office2007_parse_hash;
9531 sort_by_digest = sort_by_digest_4_4;
9532 opti_type = OPTI_TYPE_ZERO_BYTE;
9533 dgst_pos0 = 0;
9534 dgst_pos1 = 1;
9535 dgst_pos2 = 2;
9536 dgst_pos3 = 3;
9537 break;
9538
9539 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9540 salt_type = SALT_TYPE_EMBEDDED;
9541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9543 kern_type = KERN_TYPE_OFFICE2010;
9544 dgst_size = DGST_SIZE_4_4;
9545 parse_func = office2010_parse_hash;
9546 sort_by_digest = sort_by_digest_4_4;
9547 opti_type = OPTI_TYPE_ZERO_BYTE;
9548 dgst_pos0 = 0;
9549 dgst_pos1 = 1;
9550 dgst_pos2 = 2;
9551 dgst_pos3 = 3;
9552 break;
9553
9554 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9555 salt_type = SALT_TYPE_EMBEDDED;
9556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9557 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9558 kern_type = KERN_TYPE_OFFICE2013;
9559 dgst_size = DGST_SIZE_4_4;
9560 parse_func = office2013_parse_hash;
9561 sort_by_digest = sort_by_digest_4_4;
9562 opti_type = OPTI_TYPE_ZERO_BYTE;
9563 dgst_pos0 = 0;
9564 dgst_pos1 = 1;
9565 dgst_pos2 = 2;
9566 dgst_pos3 = 3;
9567 break;
9568
9569 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9570 salt_type = SALT_TYPE_EMBEDDED;
9571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9572 opts_type = OPTS_TYPE_PT_GENERATE_LE
9573 | OPTS_TYPE_PT_ADD80
9574 | OPTS_TYPE_PT_UNICODE;
9575 kern_type = KERN_TYPE_OLDOFFICE01;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = oldoffice01_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_PRECOMPUTE_INIT
9581 | OPTI_TYPE_NOT_ITERATED;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_LE
9592 | OPTS_TYPE_PT_ADD80;
9593 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9594 dgst_size = DGST_SIZE_4_4;
9595 parse_func = oldoffice01cm1_parse_hash;
9596 sort_by_digest = sort_by_digest_4_4;
9597 opti_type = OPTI_TYPE_ZERO_BYTE
9598 | OPTI_TYPE_PRECOMPUTE_INIT
9599 | OPTI_TYPE_NOT_ITERATED;
9600 dgst_pos0 = 0;
9601 dgst_pos1 = 1;
9602 dgst_pos2 = 2;
9603 dgst_pos3 = 3;
9604 break;
9605
9606 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9607 salt_type = SALT_TYPE_EMBEDDED;
9608 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9609 opts_type = OPTS_TYPE_PT_GENERATE_LE
9610 | OPTS_TYPE_PT_ADD80
9611 | OPTS_TYPE_PT_UNICODE
9612 | OPTS_TYPE_PT_NEVERCRACK;
9613 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9614 dgst_size = DGST_SIZE_4_4;
9615 parse_func = oldoffice01cm2_parse_hash;
9616 sort_by_digest = sort_by_digest_4_4;
9617 opti_type = OPTI_TYPE_ZERO_BYTE
9618 | OPTI_TYPE_PRECOMPUTE_INIT
9619 | OPTI_TYPE_NOT_ITERATED;
9620 dgst_pos0 = 0;
9621 dgst_pos1 = 1;
9622 dgst_pos2 = 2;
9623 dgst_pos3 = 3;
9624 break;
9625
9626 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9627 salt_type = SALT_TYPE_EMBEDDED;
9628 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9629 opts_type = OPTS_TYPE_PT_GENERATE_BE
9630 | OPTS_TYPE_PT_ADD80
9631 | OPTS_TYPE_PT_UNICODE;
9632 kern_type = KERN_TYPE_OLDOFFICE34;
9633 dgst_size = DGST_SIZE_4_4;
9634 parse_func = oldoffice34_parse_hash;
9635 sort_by_digest = sort_by_digest_4_4;
9636 opti_type = OPTI_TYPE_ZERO_BYTE
9637 | OPTI_TYPE_PRECOMPUTE_INIT
9638 | OPTI_TYPE_NOT_ITERATED;
9639 dgst_pos0 = 0;
9640 dgst_pos1 = 1;
9641 dgst_pos2 = 2;
9642 dgst_pos3 = 3;
9643 break;
9644
9645 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9646 salt_type = SALT_TYPE_EMBEDDED;
9647 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9648 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9649 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9650 dgst_size = DGST_SIZE_4_4;
9651 parse_func = oldoffice34cm1_parse_hash;
9652 sort_by_digest = sort_by_digest_4_4;
9653 opti_type = OPTI_TYPE_ZERO_BYTE
9654 | OPTI_TYPE_PRECOMPUTE_INIT
9655 | OPTI_TYPE_NOT_ITERATED;
9656 dgst_pos0 = 0;
9657 dgst_pos1 = 1;
9658 dgst_pos2 = 2;
9659 dgst_pos3 = 3;
9660 break;
9661
9662 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9663 salt_type = SALT_TYPE_EMBEDDED;
9664 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9665 opts_type = OPTS_TYPE_PT_GENERATE_BE
9666 | OPTS_TYPE_PT_ADD80
9667 | OPTS_TYPE_PT_UNICODE
9668 | OPTS_TYPE_PT_NEVERCRACK;
9669 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9670 dgst_size = DGST_SIZE_4_4;
9671 parse_func = oldoffice34cm2_parse_hash;
9672 sort_by_digest = sort_by_digest_4_4;
9673 opti_type = OPTI_TYPE_ZERO_BYTE
9674 | OPTI_TYPE_PRECOMPUTE_INIT
9675 | OPTI_TYPE_NOT_ITERATED;
9676 dgst_pos0 = 0;
9677 dgst_pos1 = 1;
9678 dgst_pos2 = 2;
9679 dgst_pos3 = 3;
9680 break;
9681
9682 case 9900: hash_type = HASH_TYPE_MD5;
9683 salt_type = SALT_TYPE_NONE;
9684 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9685 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9686 kern_type = KERN_TYPE_RADMIN2;
9687 dgst_size = DGST_SIZE_4_4;
9688 parse_func = radmin2_parse_hash;
9689 sort_by_digest = sort_by_digest_4_4;
9690 opti_type = OPTI_TYPE_ZERO_BYTE
9691 | OPTI_TYPE_PRECOMPUTE_INIT
9692 | OPTI_TYPE_EARLY_SKIP
9693 | OPTI_TYPE_NOT_ITERATED
9694 | OPTI_TYPE_NOT_SALTED;
9695 dgst_pos0 = 0;
9696 dgst_pos1 = 3;
9697 dgst_pos2 = 2;
9698 dgst_pos3 = 1;
9699 break;
9700
9701 case 10000: hash_type = HASH_TYPE_SHA256;
9702 salt_type = SALT_TYPE_EMBEDDED;
9703 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9704 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9705 kern_type = KERN_TYPE_PBKDF2_SHA256;
9706 dgst_size = DGST_SIZE_4_32;
9707 parse_func = djangopbkdf2_parse_hash;
9708 sort_by_digest = sort_by_digest_4_32;
9709 opti_type = OPTI_TYPE_ZERO_BYTE
9710 | OPTI_TYPE_SLOW_HASH_SIMD;
9711 dgst_pos0 = 0;
9712 dgst_pos1 = 1;
9713 dgst_pos2 = 2;
9714 dgst_pos3 = 3;
9715 break;
9716
9717 case 10100: hash_type = HASH_TYPE_SIPHASH;
9718 salt_type = SALT_TYPE_EMBEDDED;
9719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9720 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9721 kern_type = KERN_TYPE_SIPHASH;
9722 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9723 parse_func = siphash_parse_hash;
9724 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9725 opti_type = OPTI_TYPE_ZERO_BYTE
9726 | OPTI_TYPE_NOT_ITERATED
9727 | OPTI_TYPE_RAW_HASH;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 10200: hash_type = HASH_TYPE_MD5;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE
9738 | OPTS_TYPE_ST_ADD80
9739 | OPTS_TYPE_ST_ADDBITS14;
9740 kern_type = KERN_TYPE_HMACMD5_PW;
9741 dgst_size = DGST_SIZE_4_4;
9742 parse_func = crammd5_parse_hash;
9743 sort_by_digest = sort_by_digest_4_4;
9744 opti_type = OPTI_TYPE_ZERO_BYTE
9745 | OPTI_TYPE_NOT_ITERATED;
9746 dgst_pos0 = 0;
9747 dgst_pos1 = 3;
9748 dgst_pos2 = 2;
9749 dgst_pos3 = 1;
9750 break;
9751
9752 case 10300: hash_type = HASH_TYPE_SHA1;
9753 salt_type = SALT_TYPE_EMBEDDED;
9754 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9755 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9756 kern_type = KERN_TYPE_SAPH_SHA1;
9757 dgst_size = DGST_SIZE_4_5;
9758 parse_func = saph_sha1_parse_hash;
9759 sort_by_digest = sort_by_digest_4_5;
9760 opti_type = OPTI_TYPE_ZERO_BYTE;
9761 dgst_pos0 = 0;
9762 dgst_pos1 = 1;
9763 dgst_pos2 = 2;
9764 dgst_pos3 = 3;
9765 break;
9766
9767 case 10400: hash_type = HASH_TYPE_PDFU16;
9768 salt_type = SALT_TYPE_EMBEDDED;
9769 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9770 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9771 kern_type = KERN_TYPE_PDF11;
9772 dgst_size = DGST_SIZE_4_4;
9773 parse_func = pdf11_parse_hash;
9774 sort_by_digest = sort_by_digest_4_4;
9775 opti_type = OPTI_TYPE_ZERO_BYTE
9776 | OPTI_TYPE_NOT_ITERATED;
9777 dgst_pos0 = 0;
9778 dgst_pos1 = 1;
9779 dgst_pos2 = 2;
9780 dgst_pos3 = 3;
9781 break;
9782
9783 case 10410: hash_type = HASH_TYPE_PDFU16;
9784 salt_type = SALT_TYPE_EMBEDDED;
9785 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9786 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9787 kern_type = KERN_TYPE_PDF11CM1;
9788 dgst_size = DGST_SIZE_4_4;
9789 parse_func = pdf11cm1_parse_hash;
9790 sort_by_digest = sort_by_digest_4_4;
9791 opti_type = OPTI_TYPE_ZERO_BYTE
9792 | OPTI_TYPE_NOT_ITERATED;
9793 dgst_pos0 = 0;
9794 dgst_pos1 = 1;
9795 dgst_pos2 = 2;
9796 dgst_pos3 = 3;
9797 break;
9798
9799 case 10420: hash_type = HASH_TYPE_PDFU16;
9800 salt_type = SALT_TYPE_EMBEDDED;
9801 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9802 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9803 kern_type = KERN_TYPE_PDF11CM2;
9804 dgst_size = DGST_SIZE_4_4;
9805 parse_func = pdf11cm2_parse_hash;
9806 sort_by_digest = sort_by_digest_4_4;
9807 opti_type = OPTI_TYPE_ZERO_BYTE
9808 | OPTI_TYPE_NOT_ITERATED;
9809 dgst_pos0 = 0;
9810 dgst_pos1 = 1;
9811 dgst_pos2 = 2;
9812 dgst_pos3 = 3;
9813 break;
9814
9815 case 10500: hash_type = HASH_TYPE_PDFU16;
9816 salt_type = SALT_TYPE_EMBEDDED;
9817 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9818 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9819 kern_type = KERN_TYPE_PDF14;
9820 dgst_size = DGST_SIZE_4_4;
9821 parse_func = pdf14_parse_hash;
9822 sort_by_digest = sort_by_digest_4_4;
9823 opti_type = OPTI_TYPE_ZERO_BYTE
9824 | OPTI_TYPE_NOT_ITERATED;
9825 dgst_pos0 = 0;
9826 dgst_pos1 = 1;
9827 dgst_pos2 = 2;
9828 dgst_pos3 = 3;
9829 break;
9830
9831 case 10600: hash_type = HASH_TYPE_SHA256;
9832 salt_type = SALT_TYPE_EMBEDDED;
9833 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9834 opts_type = OPTS_TYPE_PT_GENERATE_BE
9835 | OPTS_TYPE_ST_ADD80
9836 | OPTS_TYPE_ST_ADDBITS15
9837 | OPTS_TYPE_HASH_COPY;
9838 kern_type = KERN_TYPE_SHA256_PWSLT;
9839 dgst_size = DGST_SIZE_4_8;
9840 parse_func = pdf17l3_parse_hash;
9841 sort_by_digest = sort_by_digest_4_8;
9842 opti_type = OPTI_TYPE_ZERO_BYTE
9843 | OPTI_TYPE_PRECOMPUTE_INIT
9844 | OPTI_TYPE_PRECOMPUTE_MERKLE
9845 | OPTI_TYPE_EARLY_SKIP
9846 | OPTI_TYPE_NOT_ITERATED
9847 | OPTI_TYPE_APPENDED_SALT
9848 | OPTI_TYPE_RAW_HASH;
9849 dgst_pos0 = 3;
9850 dgst_pos1 = 7;
9851 dgst_pos2 = 2;
9852 dgst_pos3 = 6;
9853 break;
9854
9855 case 10700: hash_type = HASH_TYPE_PDFU32;
9856 salt_type = SALT_TYPE_EMBEDDED;
9857 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9858 opts_type = OPTS_TYPE_PT_GENERATE_LE
9859 | OPTS_TYPE_HASH_COPY;
9860 kern_type = KERN_TYPE_PDF17L8;
9861 dgst_size = DGST_SIZE_4_8;
9862 parse_func = pdf17l8_parse_hash;
9863 sort_by_digest = sort_by_digest_4_8;
9864 opti_type = OPTI_TYPE_ZERO_BYTE
9865 | OPTI_TYPE_NOT_ITERATED;
9866 dgst_pos0 = 0;
9867 dgst_pos1 = 1;
9868 dgst_pos2 = 2;
9869 dgst_pos3 = 3;
9870 break;
9871
9872 case 10800: hash_type = HASH_TYPE_SHA384;
9873 salt_type = SALT_TYPE_NONE;
9874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9875 opts_type = OPTS_TYPE_PT_GENERATE_BE
9876 | OPTS_TYPE_PT_ADD80
9877 | OPTS_TYPE_PT_ADDBITS15;
9878 kern_type = KERN_TYPE_SHA384;
9879 dgst_size = DGST_SIZE_8_8;
9880 parse_func = sha384_parse_hash;
9881 sort_by_digest = sort_by_digest_8_8;
9882 opti_type = OPTI_TYPE_ZERO_BYTE
9883 | OPTI_TYPE_PRECOMPUTE_INIT
9884 | OPTI_TYPE_PRECOMPUTE_MERKLE
9885 | OPTI_TYPE_EARLY_SKIP
9886 | OPTI_TYPE_NOT_ITERATED
9887 | OPTI_TYPE_NOT_SALTED
9888 | OPTI_TYPE_USES_BITS_64
9889 | OPTI_TYPE_RAW_HASH;
9890 dgst_pos0 = 6;
9891 dgst_pos1 = 7;
9892 dgst_pos2 = 4;
9893 dgst_pos3 = 5;
9894 break;
9895
9896 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9897 salt_type = SALT_TYPE_EMBEDDED;
9898 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9899 opts_type = OPTS_TYPE_PT_GENERATE_LE
9900 | OPTS_TYPE_ST_BASE64
9901 | OPTS_TYPE_HASH_COPY;
9902 kern_type = KERN_TYPE_PBKDF2_SHA256;
9903 dgst_size = DGST_SIZE_4_32;
9904 parse_func = pbkdf2_sha256_parse_hash;
9905 sort_by_digest = sort_by_digest_4_32;
9906 opti_type = OPTI_TYPE_ZERO_BYTE
9907 | OPTI_TYPE_SLOW_HASH_SIMD;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 11000: hash_type = HASH_TYPE_MD5;
9915 salt_type = SALT_TYPE_INTERN;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_PT_ADD80;
9919 kern_type = KERN_TYPE_PRESTASHOP;
9920 dgst_size = DGST_SIZE_4_4;
9921 parse_func = prestashop_parse_hash;
9922 sort_by_digest = sort_by_digest_4_4;
9923 opti_type = OPTI_TYPE_ZERO_BYTE
9924 | OPTI_TYPE_PRECOMPUTE_INIT
9925 | OPTI_TYPE_NOT_ITERATED
9926 | OPTI_TYPE_PREPENDED_SALT;
9927 dgst_pos0 = 0;
9928 dgst_pos1 = 3;
9929 dgst_pos2 = 2;
9930 dgst_pos3 = 1;
9931 break;
9932
9933 case 11100: hash_type = HASH_TYPE_MD5;
9934 salt_type = SALT_TYPE_EMBEDDED;
9935 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9936 opts_type = OPTS_TYPE_PT_GENERATE_LE
9937 | OPTS_TYPE_ST_ADD80;
9938 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9939 dgst_size = DGST_SIZE_4_4;
9940 parse_func = postgresql_auth_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4;
9942 opti_type = OPTI_TYPE_ZERO_BYTE
9943 | OPTI_TYPE_PRECOMPUTE_INIT
9944 | OPTI_TYPE_PRECOMPUTE_MERKLE
9945 | OPTI_TYPE_EARLY_SKIP;
9946 dgst_pos0 = 0;
9947 dgst_pos1 = 3;
9948 dgst_pos2 = 2;
9949 dgst_pos3 = 1;
9950 break;
9951
9952 case 11200: hash_type = HASH_TYPE_SHA1;
9953 salt_type = SALT_TYPE_EMBEDDED;
9954 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9955 opts_type = OPTS_TYPE_PT_GENERATE_BE
9956 | OPTS_TYPE_PT_ADD80
9957 | OPTS_TYPE_ST_HEX;
9958 kern_type = KERN_TYPE_MYSQL_AUTH;
9959 dgst_size = DGST_SIZE_4_5;
9960 parse_func = mysql_auth_parse_hash;
9961 sort_by_digest = sort_by_digest_4_5;
9962 opti_type = OPTI_TYPE_ZERO_BYTE
9963 | OPTI_TYPE_EARLY_SKIP;
9964 dgst_pos0 = 3;
9965 dgst_pos1 = 4;
9966 dgst_pos2 = 2;
9967 dgst_pos3 = 1;
9968 break;
9969
9970 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9971 salt_type = SALT_TYPE_EMBEDDED;
9972 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9973 opts_type = OPTS_TYPE_PT_GENERATE_LE
9974 | OPTS_TYPE_ST_HEX
9975 | OPTS_TYPE_ST_ADD80;
9976 kern_type = KERN_TYPE_BITCOIN_WALLET;
9977 dgst_size = DGST_SIZE_4_4;
9978 parse_func = bitcoin_wallet_parse_hash;
9979 sort_by_digest = sort_by_digest_4_4;
9980 opti_type = OPTI_TYPE_ZERO_BYTE;
9981 dgst_pos0 = 0;
9982 dgst_pos1 = 1;
9983 dgst_pos2 = 2;
9984 dgst_pos3 = 3;
9985 break;
9986
9987 case 11400: hash_type = HASH_TYPE_MD5;
9988 salt_type = SALT_TYPE_EMBEDDED;
9989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9990 opts_type = OPTS_TYPE_PT_GENERATE_LE
9991 | OPTS_TYPE_PT_ADD80
9992 | OPTS_TYPE_HASH_COPY;
9993 kern_type = KERN_TYPE_SIP_AUTH;
9994 dgst_size = DGST_SIZE_4_4;
9995 parse_func = sip_auth_parse_hash;
9996 sort_by_digest = sort_by_digest_4_4;
9997 opti_type = OPTI_TYPE_ZERO_BYTE;
9998 dgst_pos0 = 0;
9999 dgst_pos1 = 3;
10000 dgst_pos2 = 2;
10001 dgst_pos3 = 1;
10002 break;
10003
10004 case 11500: hash_type = HASH_TYPE_CRC32;
10005 salt_type = SALT_TYPE_INTERN;
10006 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10007 opts_type = OPTS_TYPE_PT_GENERATE_LE
10008 | OPTS_TYPE_ST_GENERATE_LE
10009 | OPTS_TYPE_ST_HEX;
10010 kern_type = KERN_TYPE_CRC32;
10011 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10012 parse_func = crc32_parse_hash;
10013 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10014 opti_type = OPTI_TYPE_ZERO_BYTE;
10015 dgst_pos0 = 0;
10016 dgst_pos1 = 1;
10017 dgst_pos2 = 2;
10018 dgst_pos3 = 3;
10019 break;
10020
10021 case 11600: hash_type = HASH_TYPE_AES;
10022 salt_type = SALT_TYPE_EMBEDDED;
10023 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10024 opts_type = OPTS_TYPE_PT_GENERATE_LE
10025 | OPTS_TYPE_PT_NEVERCRACK;
10026 kern_type = KERN_TYPE_SEVEN_ZIP;
10027 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10028 parse_func = seven_zip_parse_hash;
10029 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10030 opti_type = OPTI_TYPE_ZERO_BYTE;
10031 dgst_pos0 = 0;
10032 dgst_pos1 = 1;
10033 dgst_pos2 = 2;
10034 dgst_pos3 = 3;
10035 break;
10036
10037 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10038 salt_type = SALT_TYPE_NONE;
10039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10040 opts_type = OPTS_TYPE_PT_GENERATE_LE
10041 | OPTS_TYPE_PT_ADD01;
10042 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10043 dgst_size = DGST_SIZE_4_8;
10044 parse_func = gost2012sbog_256_parse_hash;
10045 sort_by_digest = sort_by_digest_4_8;
10046 opti_type = OPTI_TYPE_ZERO_BYTE;
10047 dgst_pos0 = 0;
10048 dgst_pos1 = 1;
10049 dgst_pos2 = 2;
10050 dgst_pos3 = 3;
10051 break;
10052
10053 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10054 salt_type = SALT_TYPE_NONE;
10055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10056 opts_type = OPTS_TYPE_PT_GENERATE_LE
10057 | OPTS_TYPE_PT_ADD01;
10058 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10059 dgst_size = DGST_SIZE_4_16;
10060 parse_func = gost2012sbog_512_parse_hash;
10061 sort_by_digest = sort_by_digest_4_16;
10062 opti_type = OPTI_TYPE_ZERO_BYTE;
10063 dgst_pos0 = 0;
10064 dgst_pos1 = 1;
10065 dgst_pos2 = 2;
10066 dgst_pos3 = 3;
10067 break;
10068
10069 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10070 salt_type = SALT_TYPE_EMBEDDED;
10071 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10072 opts_type = OPTS_TYPE_PT_GENERATE_LE
10073 | OPTS_TYPE_ST_BASE64
10074 | OPTS_TYPE_HASH_COPY;
10075 kern_type = KERN_TYPE_PBKDF2_MD5;
10076 dgst_size = DGST_SIZE_4_32;
10077 parse_func = pbkdf2_md5_parse_hash;
10078 sort_by_digest = sort_by_digest_4_32;
10079 opti_type = OPTI_TYPE_ZERO_BYTE
10080 | OPTI_TYPE_SLOW_HASH_SIMD;
10081 dgst_pos0 = 0;
10082 dgst_pos1 = 1;
10083 dgst_pos2 = 2;
10084 dgst_pos3 = 3;
10085 break;
10086
10087 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10088 salt_type = SALT_TYPE_EMBEDDED;
10089 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10090 opts_type = OPTS_TYPE_PT_GENERATE_LE
10091 | OPTS_TYPE_ST_BASE64
10092 | OPTS_TYPE_HASH_COPY;
10093 kern_type = KERN_TYPE_PBKDF2_SHA1;
10094 dgst_size = DGST_SIZE_4_32;
10095 parse_func = pbkdf2_sha1_parse_hash;
10096 sort_by_digest = sort_by_digest_4_32;
10097 opti_type = OPTI_TYPE_ZERO_BYTE
10098 | OPTI_TYPE_SLOW_HASH_SIMD;
10099 dgst_pos0 = 0;
10100 dgst_pos1 = 1;
10101 dgst_pos2 = 2;
10102 dgst_pos3 = 3;
10103 break;
10104
10105 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10106 salt_type = SALT_TYPE_EMBEDDED;
10107 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10108 opts_type = OPTS_TYPE_PT_GENERATE_LE
10109 | OPTS_TYPE_ST_BASE64
10110 | OPTS_TYPE_HASH_COPY;
10111 kern_type = KERN_TYPE_PBKDF2_SHA512;
10112 dgst_size = DGST_SIZE_8_16;
10113 parse_func = pbkdf2_sha512_parse_hash;
10114 sort_by_digest = sort_by_digest_8_16;
10115 opti_type = OPTI_TYPE_ZERO_BYTE
10116 | OPTI_TYPE_USES_BITS_64
10117 | OPTI_TYPE_SLOW_HASH_SIMD;
10118 dgst_pos0 = 0;
10119 dgst_pos1 = 1;
10120 dgst_pos2 = 2;
10121 dgst_pos3 = 3;
10122 break;
10123
10124 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10125 salt_type = SALT_TYPE_EMBEDDED;
10126 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10127 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10128 kern_type = KERN_TYPE_ECRYPTFS;
10129 dgst_size = DGST_SIZE_8_8;
10130 parse_func = ecryptfs_parse_hash;
10131 sort_by_digest = sort_by_digest_8_8;
10132 opti_type = OPTI_TYPE_ZERO_BYTE
10133 | OPTI_TYPE_USES_BITS_64;
10134 dgst_pos0 = 0;
10135 dgst_pos1 = 1;
10136 dgst_pos2 = 2;
10137 dgst_pos3 = 3;
10138 break;
10139
10140 case 12300: hash_type = HASH_TYPE_ORACLET;
10141 salt_type = SALT_TYPE_EMBEDDED;
10142 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10143 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10144 kern_type = KERN_TYPE_ORACLET;
10145 dgst_size = DGST_SIZE_8_16;
10146 parse_func = oraclet_parse_hash;
10147 sort_by_digest = sort_by_digest_8_16;
10148 opti_type = OPTI_TYPE_ZERO_BYTE
10149 | OPTI_TYPE_USES_BITS_64;
10150 dgst_pos0 = 0;
10151 dgst_pos1 = 1;
10152 dgst_pos2 = 2;
10153 dgst_pos3 = 3;
10154 break;
10155
10156 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10157 salt_type = SALT_TYPE_EMBEDDED;
10158 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10159 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10160 kern_type = KERN_TYPE_BSDICRYPT;
10161 dgst_size = DGST_SIZE_4_4;
10162 parse_func = bsdicrypt_parse_hash;
10163 sort_by_digest = sort_by_digest_4_4;
10164 opti_type = OPTI_TYPE_ZERO_BYTE
10165 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10166 dgst_pos0 = 0;
10167 dgst_pos1 = 1;
10168 dgst_pos2 = 2;
10169 dgst_pos3 = 3;
10170 break;
10171
10172 case 12500: hash_type = HASH_TYPE_RAR3HP;
10173 salt_type = SALT_TYPE_EMBEDDED;
10174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10176 kern_type = KERN_TYPE_RAR3;
10177 dgst_size = DGST_SIZE_4_4;
10178 parse_func = rar3hp_parse_hash;
10179 sort_by_digest = sort_by_digest_4_4;
10180 opti_type = OPTI_TYPE_ZERO_BYTE;
10181 dgst_pos0 = 0;
10182 dgst_pos1 = 1;
10183 dgst_pos2 = 2;
10184 dgst_pos3 = 3;
10185 break;
10186
10187 case 12600: hash_type = HASH_TYPE_SHA256;
10188 salt_type = SALT_TYPE_INTERN;
10189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10190 opts_type = OPTS_TYPE_PT_GENERATE_BE
10191 | OPTS_TYPE_PT_ADD80;
10192 kern_type = KERN_TYPE_CF10;
10193 dgst_size = DGST_SIZE_4_8;
10194 parse_func = cf10_parse_hash;
10195 sort_by_digest = sort_by_digest_4_8;
10196 opti_type = OPTI_TYPE_ZERO_BYTE
10197 | OPTI_TYPE_PRECOMPUTE_INIT
10198 | OPTI_TYPE_EARLY_SKIP
10199 | OPTI_TYPE_NOT_ITERATED;
10200 dgst_pos0 = 3;
10201 dgst_pos1 = 7;
10202 dgst_pos2 = 2;
10203 dgst_pos3 = 6;
10204 break;
10205
10206 case 12700: hash_type = HASH_TYPE_AES;
10207 salt_type = SALT_TYPE_EMBEDDED;
10208 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10209 opts_type = OPTS_TYPE_PT_GENERATE_LE
10210 | OPTS_TYPE_HASH_COPY;
10211 kern_type = KERN_TYPE_MYWALLET;
10212 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10213 parse_func = mywallet_parse_hash;
10214 sort_by_digest = sort_by_digest_4_5;
10215 opti_type = OPTI_TYPE_ZERO_BYTE;
10216 dgst_pos0 = 0;
10217 dgst_pos1 = 1;
10218 dgst_pos2 = 2;
10219 dgst_pos3 = 3;
10220 break;
10221
10222 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10223 salt_type = SALT_TYPE_EMBEDDED;
10224 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10225 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10226 kern_type = KERN_TYPE_MS_DRSR;
10227 dgst_size = DGST_SIZE_4_8;
10228 parse_func = ms_drsr_parse_hash;
10229 sort_by_digest = sort_by_digest_4_8;
10230 opti_type = OPTI_TYPE_ZERO_BYTE;
10231 dgst_pos0 = 0;
10232 dgst_pos1 = 1;
10233 dgst_pos2 = 2;
10234 dgst_pos3 = 3;
10235 break;
10236
10237 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10238 salt_type = SALT_TYPE_EMBEDDED;
10239 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10240 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10241 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10242 dgst_size = DGST_SIZE_4_8;
10243 parse_func = androidfde_samsung_parse_hash;
10244 sort_by_digest = sort_by_digest_4_8;
10245 opti_type = OPTI_TYPE_ZERO_BYTE;
10246 dgst_pos0 = 0;
10247 dgst_pos1 = 1;
10248 dgst_pos2 = 2;
10249 dgst_pos3 = 3;
10250 break;
10251
10252 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10253 salt_type = SALT_TYPE_EMBEDDED;
10254 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10255 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10256 kern_type = KERN_TYPE_RAR5;
10257 dgst_size = DGST_SIZE_4_4;
10258 parse_func = rar5_parse_hash;
10259 sort_by_digest = sort_by_digest_4_4;
10260 opti_type = OPTI_TYPE_ZERO_BYTE;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10271 kern_type = KERN_TYPE_KRB5TGS;
10272 dgst_size = DGST_SIZE_4_4;
10273 parse_func = krb5tgs_parse_hash;
10274 sort_by_digest = sort_by_digest_4_4;
10275 opti_type = OPTI_TYPE_ZERO_BYTE
10276 | OPTI_TYPE_NOT_ITERATED;
10277 dgst_pos0 = 0;
10278 dgst_pos1 = 1;
10279 dgst_pos2 = 2;
10280 dgst_pos3 = 3;
10281 break;
10282
10283 case 13200: hash_type = HASH_TYPE_AES;
10284 salt_type = SALT_TYPE_EMBEDDED;
10285 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10286 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10287 kern_type = KERN_TYPE_AXCRYPT;
10288 dgst_size = DGST_SIZE_4_4;
10289 parse_func = axcrypt_parse_hash;
10290 sort_by_digest = sort_by_digest_4_4;
10291 opti_type = OPTI_TYPE_ZERO_BYTE;
10292 dgst_pos0 = 0;
10293 dgst_pos1 = 1;
10294 dgst_pos2 = 2;
10295 dgst_pos3 = 3;
10296 break;
10297
10298 case 13300: hash_type = HASH_TYPE_SHA1;
10299 salt_type = SALT_TYPE_NONE;
10300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10301 opts_type = OPTS_TYPE_PT_GENERATE_BE
10302 | OPTS_TYPE_PT_ADD80
10303 | OPTS_TYPE_PT_ADDBITS15;
10304 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10305 dgst_size = DGST_SIZE_4_5;
10306 parse_func = sha1axcrypt_parse_hash;
10307 sort_by_digest = sort_by_digest_4_5;
10308 opti_type = OPTI_TYPE_ZERO_BYTE
10309 | OPTI_TYPE_PRECOMPUTE_INIT
10310 | OPTI_TYPE_EARLY_SKIP
10311 | OPTI_TYPE_NOT_ITERATED
10312 | OPTI_TYPE_NOT_SALTED;
10313 dgst_pos0 = 0;
10314 dgst_pos1 = 4;
10315 dgst_pos2 = 3;
10316 dgst_pos3 = 2;
10317 break;
10318
10319 case 13400: hash_type = HASH_TYPE_AES;
10320 salt_type = SALT_TYPE_EMBEDDED;
10321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10322 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10323 kern_type = KERN_TYPE_KEEPASS;
10324 dgst_size = DGST_SIZE_4_4;
10325 parse_func = keepass_parse_hash;
10326 sort_by_digest = sort_by_digest_4_4;
10327 opti_type = OPTI_TYPE_ZERO_BYTE;
10328 dgst_pos0 = 0;
10329 dgst_pos1 = 1;
10330 dgst_pos2 = 2;
10331 dgst_pos3 = 3;
10332 break;
10333
10334 case 13500: hash_type = HASH_TYPE_SHA1;
10335 salt_type = SALT_TYPE_EMBEDDED;
10336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10337 opts_type = OPTS_TYPE_PT_GENERATE_BE
10338 | OPTS_TYPE_PT_UNICODE
10339 | OPTS_TYPE_PT_ADD80;
10340 kern_type = KERN_TYPE_PSTOKEN;
10341 dgst_size = DGST_SIZE_4_5;
10342 parse_func = pstoken_parse_hash;
10343 sort_by_digest = sort_by_digest_4_5;
10344 opti_type = OPTI_TYPE_ZERO_BYTE
10345 | OPTI_TYPE_PRECOMPUTE_INIT
10346 | OPTI_TYPE_EARLY_SKIP
10347 | OPTI_TYPE_NOT_ITERATED
10348 | OPTI_TYPE_PREPENDED_SALT
10349 | OPTI_TYPE_RAW_HASH;
10350 dgst_pos0 = 3;
10351 dgst_pos1 = 4;
10352 dgst_pos2 = 2;
10353 dgst_pos3 = 1;
10354 break;
10355
10356 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10357 salt_type = SALT_TYPE_EMBEDDED;
10358 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10359 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10360 kern_type = KERN_TYPE_ZIP2;
10361 dgst_size = DGST_SIZE_4_4;
10362 parse_func = zip2_parse_hash;
10363 sort_by_digest = sort_by_digest_4_4;
10364 opti_type = OPTI_TYPE_ZERO_BYTE;
10365 dgst_pos0 = 0;
10366 dgst_pos1 = 1;
10367 dgst_pos2 = 2;
10368 dgst_pos3 = 3;
10369 break;
10370
10371 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10372 salt_type = SALT_TYPE_EMBEDDED;
10373 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10375 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10376 dgst_size = DGST_SIZE_4_5;
10377 parse_func = veracrypt_parse_hash_655331;
10378 sort_by_digest = sort_by_digest_4_5;
10379 opti_type = OPTI_TYPE_ZERO_BYTE;
10380 dgst_pos0 = 0;
10381 dgst_pos1 = 1;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 3;
10384 break;
10385
10386 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10390 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10391 dgst_size = DGST_SIZE_4_5;
10392 parse_func = veracrypt_parse_hash_655331;
10393 sort_by_digest = sort_by_digest_4_5;
10394 opti_type = OPTI_TYPE_ZERO_BYTE;
10395 dgst_pos0 = 0;
10396 dgst_pos1 = 1;
10397 dgst_pos2 = 2;
10398 dgst_pos3 = 3;
10399 break;
10400
10401 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10402 salt_type = SALT_TYPE_EMBEDDED;
10403 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10404 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10405 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10406 dgst_size = DGST_SIZE_4_5;
10407 parse_func = veracrypt_parse_hash_655331;
10408 sort_by_digest = sort_by_digest_4_5;
10409 opti_type = OPTI_TYPE_ZERO_BYTE;
10410 dgst_pos0 = 0;
10411 dgst_pos1 = 1;
10412 dgst_pos2 = 2;
10413 dgst_pos3 = 3;
10414 break;
10415
10416 case 13721: hash_type = HASH_TYPE_SHA512;
10417 salt_type = SALT_TYPE_EMBEDDED;
10418 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10419 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10420 kern_type = KERN_TYPE_TCSHA512_XTS512;
10421 dgst_size = DGST_SIZE_8_8;
10422 parse_func = veracrypt_parse_hash_500000;
10423 sort_by_digest = sort_by_digest_8_8;
10424 opti_type = OPTI_TYPE_ZERO_BYTE
10425 | OPTI_TYPE_USES_BITS_64;
10426 dgst_pos0 = 0;
10427 dgst_pos1 = 1;
10428 dgst_pos2 = 2;
10429 dgst_pos3 = 3;
10430 break;
10431
10432 case 13722: hash_type = HASH_TYPE_SHA512;
10433 salt_type = SALT_TYPE_EMBEDDED;
10434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10435 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10436 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10437 dgst_size = DGST_SIZE_8_8;
10438 parse_func = veracrypt_parse_hash_500000;
10439 sort_by_digest = sort_by_digest_8_8;
10440 opti_type = OPTI_TYPE_ZERO_BYTE
10441 | OPTI_TYPE_USES_BITS_64;
10442 dgst_pos0 = 0;
10443 dgst_pos1 = 1;
10444 dgst_pos2 = 2;
10445 dgst_pos3 = 3;
10446 break;
10447
10448 case 13723: hash_type = HASH_TYPE_SHA512;
10449 salt_type = SALT_TYPE_EMBEDDED;
10450 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10451 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10452 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10453 dgst_size = DGST_SIZE_8_8;
10454 parse_func = veracrypt_parse_hash_500000;
10455 sort_by_digest = sort_by_digest_8_8;
10456 opti_type = OPTI_TYPE_ZERO_BYTE
10457 | OPTI_TYPE_USES_BITS_64;
10458 dgst_pos0 = 0;
10459 dgst_pos1 = 1;
10460 dgst_pos2 = 2;
10461 dgst_pos3 = 3;
10462 break;
10463
10464 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10465 salt_type = SALT_TYPE_EMBEDDED;
10466 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10467 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10468 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10469 dgst_size = DGST_SIZE_4_8;
10470 parse_func = veracrypt_parse_hash_500000;
10471 sort_by_digest = sort_by_digest_4_8;
10472 opti_type = OPTI_TYPE_ZERO_BYTE;
10473 dgst_pos0 = 0;
10474 dgst_pos1 = 1;
10475 dgst_pos2 = 2;
10476 dgst_pos3 = 3;
10477 break;
10478
10479 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10480 salt_type = SALT_TYPE_EMBEDDED;
10481 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10482 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10483 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10484 dgst_size = DGST_SIZE_4_8;
10485 parse_func = veracrypt_parse_hash_500000;
10486 sort_by_digest = sort_by_digest_4_8;
10487 opti_type = OPTI_TYPE_ZERO_BYTE;
10488 dgst_pos0 = 0;
10489 dgst_pos1 = 1;
10490 dgst_pos2 = 2;
10491 dgst_pos3 = 3;
10492 break;
10493
10494 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10495 salt_type = SALT_TYPE_EMBEDDED;
10496 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10497 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10498 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10499 dgst_size = DGST_SIZE_4_8;
10500 parse_func = veracrypt_parse_hash_500000;
10501 sort_by_digest = sort_by_digest_4_8;
10502 opti_type = OPTI_TYPE_ZERO_BYTE;
10503 dgst_pos0 = 0;
10504 dgst_pos1 = 1;
10505 dgst_pos2 = 2;
10506 dgst_pos3 = 3;
10507 break;
10508
10509 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10510 salt_type = SALT_TYPE_EMBEDDED;
10511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10512 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10513 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10514 dgst_size = DGST_SIZE_4_5;
10515 parse_func = veracrypt_parse_hash_327661;
10516 sort_by_digest = sort_by_digest_4_5;
10517 opti_type = OPTI_TYPE_ZERO_BYTE;
10518 dgst_pos0 = 0;
10519 dgst_pos1 = 1;
10520 dgst_pos2 = 2;
10521 dgst_pos3 = 3;
10522 break;
10523
10524 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10525 salt_type = SALT_TYPE_EMBEDDED;
10526 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10527 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10528 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10529 dgst_size = DGST_SIZE_4_5;
10530 parse_func = veracrypt_parse_hash_327661;
10531 sort_by_digest = sort_by_digest_4_5;
10532 opti_type = OPTI_TYPE_ZERO_BYTE;
10533 dgst_pos0 = 0;
10534 dgst_pos1 = 1;
10535 dgst_pos2 = 2;
10536 dgst_pos3 = 3;
10537 break;
10538
10539 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10540 salt_type = SALT_TYPE_EMBEDDED;
10541 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10542 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10543 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10544 dgst_size = DGST_SIZE_4_5;
10545 parse_func = veracrypt_parse_hash_327661;
10546 sort_by_digest = sort_by_digest_4_5;
10547 opti_type = OPTI_TYPE_ZERO_BYTE;
10548 dgst_pos0 = 0;
10549 dgst_pos1 = 1;
10550 dgst_pos2 = 2;
10551 dgst_pos3 = 3;
10552 break;
10553
10554 case 13751: hash_type = HASH_TYPE_SHA256;
10555 salt_type = SALT_TYPE_EMBEDDED;
10556 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10557 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10558 kern_type = KERN_TYPE_VCSHA256_XTS512;
10559 dgst_size = DGST_SIZE_4_8;
10560 parse_func = veracrypt_parse_hash_500000;
10561 sort_by_digest = sort_by_digest_4_8;
10562 opti_type = OPTI_TYPE_ZERO_BYTE;
10563 dgst_pos0 = 0;
10564 dgst_pos1 = 1;
10565 dgst_pos2 = 2;
10566 dgst_pos3 = 3;
10567 break;
10568
10569 case 13752: hash_type = HASH_TYPE_SHA256;
10570 salt_type = SALT_TYPE_EMBEDDED;
10571 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10572 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10573 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10574 dgst_size = DGST_SIZE_4_8;
10575 parse_func = veracrypt_parse_hash_500000;
10576 sort_by_digest = sort_by_digest_4_8;
10577 opti_type = OPTI_TYPE_ZERO_BYTE;
10578 dgst_pos0 = 0;
10579 dgst_pos1 = 1;
10580 dgst_pos2 = 2;
10581 dgst_pos3 = 3;
10582 break;
10583
10584 case 13753: hash_type = HASH_TYPE_SHA256;
10585 salt_type = SALT_TYPE_EMBEDDED;
10586 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10587 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10588 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10589 dgst_size = DGST_SIZE_4_8;
10590 parse_func = veracrypt_parse_hash_500000;
10591 sort_by_digest = sort_by_digest_4_8;
10592 opti_type = OPTI_TYPE_ZERO_BYTE;
10593 dgst_pos0 = 0;
10594 dgst_pos1 = 1;
10595 dgst_pos2 = 2;
10596 dgst_pos3 = 3;
10597 break;
10598
10599 case 13761: hash_type = HASH_TYPE_SHA256;
10600 salt_type = SALT_TYPE_EMBEDDED;
10601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10602 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10603 kern_type = KERN_TYPE_VCSHA256_XTS512;
10604 dgst_size = DGST_SIZE_4_8;
10605 parse_func = veracrypt_parse_hash_200000;
10606 sort_by_digest = sort_by_digest_4_8;
10607 opti_type = OPTI_TYPE_ZERO_BYTE;
10608 dgst_pos0 = 0;
10609 dgst_pos1 = 1;
10610 dgst_pos2 = 2;
10611 dgst_pos3 = 3;
10612 break;
10613
10614 case 13762: hash_type = HASH_TYPE_SHA256;
10615 salt_type = SALT_TYPE_EMBEDDED;
10616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10617 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10618 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10619 dgst_size = DGST_SIZE_4_8;
10620 parse_func = veracrypt_parse_hash_200000;
10621 sort_by_digest = sort_by_digest_4_8;
10622 opti_type = OPTI_TYPE_ZERO_BYTE;
10623 dgst_pos0 = 0;
10624 dgst_pos1 = 1;
10625 dgst_pos2 = 2;
10626 dgst_pos3 = 3;
10627 break;
10628
10629 case 13763: hash_type = HASH_TYPE_SHA256;
10630 salt_type = SALT_TYPE_EMBEDDED;
10631 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10632 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10633 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10634 dgst_size = DGST_SIZE_4_8;
10635 parse_func = veracrypt_parse_hash_200000;
10636 sort_by_digest = sort_by_digest_4_8;
10637 opti_type = OPTI_TYPE_ZERO_BYTE;
10638 dgst_pos0 = 0;
10639 dgst_pos1 = 1;
10640 dgst_pos2 = 2;
10641 dgst_pos3 = 3;
10642 break;
10643
10644
10645 default: usage_mini_print (PROGNAME); return (-1);
10646 }
10647
10648 /**
10649 * parser
10650 */
10651
10652 data.parse_func = parse_func;
10653
10654 /**
10655 * misc stuff
10656 */
10657
10658 if (hex_salt)
10659 {
10660 if (salt_type == SALT_TYPE_INTERN)
10661 {
10662 opts_type |= OPTS_TYPE_ST_HEX;
10663 }
10664 else
10665 {
10666 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10667
10668 return (-1);
10669 }
10670 }
10671
10672 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10673 | (salt_type == SALT_TYPE_EXTERN)
10674 | (salt_type == SALT_TYPE_EMBEDDED)
10675 | (salt_type == SALT_TYPE_VIRTUAL));
10676
10677 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10678
10679 data.hash_type = hash_type;
10680 data.attack_mode = attack_mode;
10681 data.attack_kern = attack_kern;
10682 data.attack_exec = attack_exec;
10683 data.kern_type = kern_type;
10684 data.opts_type = opts_type;
10685 data.dgst_size = dgst_size;
10686 data.salt_type = salt_type;
10687 data.isSalted = isSalted;
10688 data.sort_by_digest = sort_by_digest;
10689 data.dgst_pos0 = dgst_pos0;
10690 data.dgst_pos1 = dgst_pos1;
10691 data.dgst_pos2 = dgst_pos2;
10692 data.dgst_pos3 = dgst_pos3;
10693
10694 esalt_size = 0;
10695
10696 switch (hash_mode)
10697 {
10698 case 2500: esalt_size = sizeof (wpa_t); break;
10699 case 5300: esalt_size = sizeof (ikepsk_t); break;
10700 case 5400: esalt_size = sizeof (ikepsk_t); break;
10701 case 5500: esalt_size = sizeof (netntlm_t); break;
10702 case 5600: esalt_size = sizeof (netntlm_t); break;
10703 case 6211: esalt_size = sizeof (tc_t); break;
10704 case 6212: esalt_size = sizeof (tc_t); break;
10705 case 6213: esalt_size = sizeof (tc_t); break;
10706 case 6221: esalt_size = sizeof (tc_t); break;
10707 case 6222: esalt_size = sizeof (tc_t); break;
10708 case 6223: esalt_size = sizeof (tc_t); break;
10709 case 6231: esalt_size = sizeof (tc_t); break;
10710 case 6232: esalt_size = sizeof (tc_t); break;
10711 case 6233: esalt_size = sizeof (tc_t); break;
10712 case 6241: esalt_size = sizeof (tc_t); break;
10713 case 6242: esalt_size = sizeof (tc_t); break;
10714 case 6243: esalt_size = sizeof (tc_t); break;
10715 case 6600: esalt_size = sizeof (agilekey_t); break;
10716 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10717 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10718 case 7300: esalt_size = sizeof (rakp_t); break;
10719 case 7500: esalt_size = sizeof (krb5pa_t); break;
10720 case 8200: esalt_size = sizeof (cloudkey_t); break;
10721 case 8800: esalt_size = sizeof (androidfde_t); break;
10722 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10723 case 9400: esalt_size = sizeof (office2007_t); break;
10724 case 9500: esalt_size = sizeof (office2010_t); break;
10725 case 9600: esalt_size = sizeof (office2013_t); break;
10726 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10727 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10728 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10729 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10730 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10731 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10732 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10733 case 10200: esalt_size = sizeof (cram_md5_t); break;
10734 case 10400: esalt_size = sizeof (pdf_t); break;
10735 case 10410: esalt_size = sizeof (pdf_t); break;
10736 case 10420: esalt_size = sizeof (pdf_t); break;
10737 case 10500: esalt_size = sizeof (pdf_t); break;
10738 case 10600: esalt_size = sizeof (pdf_t); break;
10739 case 10700: esalt_size = sizeof (pdf_t); break;
10740 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10741 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10742 case 11400: esalt_size = sizeof (sip_t); break;
10743 case 11600: esalt_size = sizeof (seven_zip_t); break;
10744 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10745 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10746 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10747 case 13000: esalt_size = sizeof (rar5_t); break;
10748 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10749 case 13400: esalt_size = sizeof (keepass_t); break;
10750 case 13500: esalt_size = sizeof (pstoken_t); break;
10751 case 13600: esalt_size = sizeof (zip2_t); break;
10752 case 13711: esalt_size = sizeof (tc_t); break;
10753 case 13712: esalt_size = sizeof (tc_t); break;
10754 case 13713: esalt_size = sizeof (tc_t); break;
10755 case 13721: esalt_size = sizeof (tc_t); break;
10756 case 13722: esalt_size = sizeof (tc_t); break;
10757 case 13723: esalt_size = sizeof (tc_t); break;
10758 case 13731: esalt_size = sizeof (tc_t); break;
10759 case 13732: esalt_size = sizeof (tc_t); break;
10760 case 13733: esalt_size = sizeof (tc_t); break;
10761 case 13741: esalt_size = sizeof (tc_t); break;
10762 case 13742: esalt_size = sizeof (tc_t); break;
10763 case 13743: esalt_size = sizeof (tc_t); break;
10764 case 13751: esalt_size = sizeof (tc_t); break;
10765 case 13752: esalt_size = sizeof (tc_t); break;
10766 case 13753: esalt_size = sizeof (tc_t); break;
10767 case 13761: esalt_size = sizeof (tc_t); break;
10768 case 13762: esalt_size = sizeof (tc_t); break;
10769 case 13763: esalt_size = sizeof (tc_t); break;
10770 }
10771
10772 data.esalt_size = esalt_size;
10773
10774 /**
10775 * choose dictionary parser
10776 */
10777
10778 if (hash_type == HASH_TYPE_LM)
10779 {
10780 get_next_word_func = get_next_word_lm;
10781 }
10782 else if (opts_type & OPTS_TYPE_PT_UPPER)
10783 {
10784 get_next_word_func = get_next_word_uc;
10785 }
10786 else
10787 {
10788 get_next_word_func = get_next_word_std;
10789 }
10790
10791 /**
10792 * dictstat
10793 */
10794
10795 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10796
10797 #ifdef _POSIX
10798 size_t dictstat_nmemb = 0;
10799 #endif
10800
10801 #ifdef _WIN
10802 uint dictstat_nmemb = 0;
10803 #endif
10804
10805 char dictstat[256] = { 0 };
10806
10807 FILE *dictstat_fp = NULL;
10808
10809 if (keyspace == 0)
10810 {
10811 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10812
10813 dictstat_fp = fopen (dictstat, "rb");
10814
10815 if (dictstat_fp)
10816 {
10817 #ifdef _POSIX
10818 struct stat tmpstat;
10819
10820 fstat (fileno (dictstat_fp), &tmpstat);
10821 #endif
10822
10823 #ifdef _WIN
10824 struct stat64 tmpstat;
10825
10826 _fstat64 (fileno (dictstat_fp), &tmpstat);
10827 #endif
10828
10829 if (tmpstat.st_mtime < COMPTIME)
10830 {
10831 /* with v0.15 the format changed so we have to ensure user is using a good version
10832 since there is no version-header in the dictstat file */
10833
10834 fclose (dictstat_fp);
10835
10836 unlink (dictstat);
10837 }
10838 else
10839 {
10840 while (!feof (dictstat_fp))
10841 {
10842 dictstat_t d;
10843
10844 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10845
10846 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10847
10848 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10849 {
10850 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10851
10852 return -1;
10853 }
10854 }
10855
10856 fclose (dictstat_fp);
10857 }
10858 }
10859 }
10860
10861 /**
10862 * potfile
10863 */
10864
10865 char potfile[256] = { 0 };
10866
10867 if (potfile_path == NULL)
10868 {
10869 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10870 }
10871 else
10872 {
10873 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10874 }
10875
10876 data.pot_fp = NULL;
10877
10878 FILE *out_fp = NULL;
10879 FILE *pot_fp = NULL;
10880
10881 if (show == 1 || left == 1)
10882 {
10883 pot_fp = fopen (potfile, "rb");
10884
10885 if (pot_fp == NULL)
10886 {
10887 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10888
10889 return (-1);
10890 }
10891
10892 if (outfile != NULL)
10893 {
10894 if ((out_fp = fopen (outfile, "ab")) == NULL)
10895 {
10896 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10897
10898 fclose (pot_fp);
10899
10900 return (-1);
10901 }
10902 }
10903 else
10904 {
10905 out_fp = stdout;
10906 }
10907 }
10908 else
10909 {
10910 if (potfile_disable == 0)
10911 {
10912 pot_fp = fopen (potfile, "ab");
10913
10914 if (pot_fp == NULL)
10915 {
10916 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10917
10918 return (-1);
10919 }
10920
10921 data.pot_fp = pot_fp;
10922 }
10923 }
10924
10925 pot_t *pot = NULL;
10926
10927 uint pot_cnt = 0;
10928 uint pot_avail = 0;
10929
10930 if (show == 1 || left == 1)
10931 {
10932 SUPPRESS_OUTPUT = 1;
10933
10934 pot_avail = count_lines (pot_fp);
10935
10936 rewind (pot_fp);
10937
10938 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10939
10940 uint pot_hashes_avail = 0;
10941
10942 uint line_num = 0;
10943
10944 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10945
10946 while (!feof (pot_fp))
10947 {
10948 line_num++;
10949
10950 int line_len = fgetl (pot_fp, line_buf);
10951
10952 if (line_len == 0) continue;
10953
10954 char *plain_buf = line_buf + line_len;
10955
10956 pot_t *pot_ptr = &pot[pot_cnt];
10957
10958 hash_t *hashes_buf = &pot_ptr->hash;
10959
10960 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10961 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10962
10963 if (pot_cnt == pot_hashes_avail)
10964 {
10965 uint pos = 0;
10966
10967 for (pos = 0; pos < INCR_POT; pos++)
10968 {
10969 if ((pot_cnt + pos) >= pot_avail) break;
10970
10971 pot_t *tmp_pot = &pot[pot_cnt + pos];
10972
10973 hash_t *tmp_hash = &tmp_pot->hash;
10974
10975 tmp_hash->digest = mymalloc (dgst_size);
10976
10977 if (isSalted)
10978 {
10979 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10980 }
10981
10982 if (esalt_size)
10983 {
10984 tmp_hash->esalt = mymalloc (esalt_size);
10985 }
10986
10987 pot_hashes_avail++;
10988 }
10989 }
10990
10991 int plain_len = 0;
10992
10993 int parser_status;
10994
10995 int iter = MAX_CUT_TRIES;
10996
10997 do
10998 {
10999 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11000 {
11001 if (line_buf[i] == ':')
11002 {
11003 line_len--;
11004
11005 break;
11006 }
11007 }
11008
11009 if (data.hash_mode != 2500)
11010 {
11011 parser_status = parse_func (line_buf, line_len, hashes_buf);
11012 }
11013 else
11014 {
11015 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11016
11017 if (line_len > max_salt_size)
11018 {
11019 parser_status = PARSER_GLOBAL_LENGTH;
11020 }
11021 else
11022 {
11023 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11024
11025 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11026
11027 hashes_buf->salt->salt_len = line_len;
11028
11029 parser_status = PARSER_OK;
11030 }
11031 }
11032
11033 // if NOT parsed without error, we add the ":" to the plain
11034
11035 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11036 {
11037 plain_len++;
11038 plain_buf--;
11039 }
11040
11041 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11042
11043 if (parser_status < PARSER_GLOBAL_ZERO)
11044 {
11045 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11046
11047 continue;
11048 }
11049
11050 if (plain_len >= 255) continue;
11051
11052 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11053
11054 pot_ptr->plain_len = plain_len;
11055
11056 pot_cnt++;
11057 }
11058
11059 myfree (line_buf);
11060
11061 fclose (pot_fp);
11062
11063 SUPPRESS_OUTPUT = 0;
11064
11065 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11066 }
11067
11068 /**
11069 * word len
11070 */
11071
11072 uint pw_min = PW_MIN;
11073 uint pw_max = PW_MAX;
11074
11075 switch (hash_mode)
11076 {
11077 case 125: if (pw_max > 32) pw_max = 32;
11078 break;
11079 case 400: if (pw_max > 40) pw_max = 40;
11080 break;
11081 case 500: if (pw_max > 16) pw_max = 16;
11082 break;
11083 case 1500: if (pw_max > 8) pw_max = 8;
11084 break;
11085 case 1600: if (pw_max > 16) pw_max = 16;
11086 break;
11087 case 1800: if (pw_max > 16) pw_max = 16;
11088 break;
11089 case 2100: if (pw_max > 16) pw_max = 16;
11090 break;
11091 case 2500: if (pw_min < 8) pw_min = 8;
11092 break;
11093 case 3000: if (pw_max > 7) pw_max = 7;
11094 break;
11095 case 5200: if (pw_max > 24) pw_max = 24;
11096 break;
11097 case 5800: if (pw_max > 16) pw_max = 16;
11098 break;
11099 case 6300: if (pw_max > 16) pw_max = 16;
11100 break;
11101 case 7400: if (pw_max > 16) pw_max = 16;
11102 break;
11103 case 7900: if (pw_max > 48) pw_max = 48;
11104 break;
11105 case 8500: if (pw_max > 8) pw_max = 8;
11106 break;
11107 case 8600: if (pw_max > 16) pw_max = 16;
11108 break;
11109 case 9710: pw_min = 5;
11110 pw_max = 5;
11111 break;
11112 case 9810: pw_min = 5;
11113 pw_max = 5;
11114 break;
11115 case 10410: pw_min = 5;
11116 pw_max = 5;
11117 break;
11118 case 10300: if (pw_max < 3) pw_min = 3;
11119 if (pw_max > 40) pw_max = 40;
11120 break;
11121 case 10500: if (pw_max < 3) pw_min = 3;
11122 if (pw_max > 40) pw_max = 40;
11123 break;
11124 case 10700: if (pw_max > 16) pw_max = 16;
11125 break;
11126 case 11300: if (pw_max > 40) pw_max = 40;
11127 break;
11128 case 11600: if (pw_max > 32) pw_max = 32;
11129 break;
11130 case 12500: if (pw_max > 20) pw_max = 20;
11131 break;
11132 case 12800: if (pw_max > 24) pw_max = 24;
11133 break;
11134 }
11135
11136 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11137 {
11138 switch (attack_kern)
11139 {
11140 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11141 break;
11142 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11143 break;
11144 }
11145 }
11146
11147 /**
11148 * charsets : keep them together for more easy maintainnce
11149 */
11150
11151 cs_t mp_sys[6] = { { { 0 }, 0 } };
11152 cs_t mp_usr[4] = { { { 0 }, 0 } };
11153
11154 mp_setup_sys (mp_sys);
11155
11156 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11157 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11158 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11159 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11160
11161 /**
11162 * load hashes, part I: find input mode, count hashes
11163 */
11164
11165 uint hashlist_mode = 0;
11166 uint hashlist_format = HLFMT_HASHCAT;
11167
11168 uint hashes_avail = 0;
11169
11170 if (benchmark == 0)
11171 {
11172 struct stat f;
11173
11174 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11175
11176 if ((hash_mode == 2500) ||
11177 (hash_mode == 5200) ||
11178 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11179 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11180 (hash_mode == 9000))
11181 {
11182 hashlist_mode = HL_MODE_ARG;
11183
11184 char *hashfile = myargv[optind];
11185
11186 data.hashfile = hashfile;
11187
11188 logfile_top_var_string ("target", hashfile);
11189 }
11190
11191 if (hashlist_mode == HL_MODE_ARG)
11192 {
11193 if (hash_mode == 2500)
11194 {
11195 struct stat st;
11196
11197 if (stat (data.hashfile, &st) == -1)
11198 {
11199 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11200
11201 return (-1);
11202 }
11203
11204 hashes_avail = st.st_size / sizeof (hccap_t);
11205 }
11206 else
11207 {
11208 hashes_avail = 1;
11209 }
11210 }
11211 else if (hashlist_mode == HL_MODE_FILE)
11212 {
11213 char *hashfile = myargv[optind];
11214
11215 data.hashfile = hashfile;
11216
11217 logfile_top_var_string ("target", hashfile);
11218
11219 FILE *fp = NULL;
11220
11221 if ((fp = fopen (hashfile, "rb")) == NULL)
11222 {
11223 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11224
11225 return (-1);
11226 }
11227
11228 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11229
11230 hashes_avail = count_lines (fp);
11231
11232 rewind (fp);
11233
11234 if (hashes_avail == 0)
11235 {
11236 log_error ("ERROR: hashfile is empty or corrupt");
11237
11238 fclose (fp);
11239
11240 return (-1);
11241 }
11242
11243 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11244
11245 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11246 {
11247 log_error ("ERROR: remove not supported in native hashfile-format mode");
11248
11249 fclose (fp);
11250
11251 return (-1);
11252 }
11253
11254 fclose (fp);
11255 }
11256 }
11257 else
11258 {
11259 hashlist_mode = HL_MODE_ARG;
11260
11261 hashes_avail = 1;
11262 }
11263
11264 if (hash_mode == 3000) hashes_avail *= 2;
11265
11266 data.hashlist_mode = hashlist_mode;
11267 data.hashlist_format = hashlist_format;
11268
11269 logfile_top_uint (hashlist_mode);
11270 logfile_top_uint (hashlist_format);
11271
11272 /**
11273 * load hashes, part II: allocate required memory, set pointers
11274 */
11275
11276 hash_t *hashes_buf = NULL;
11277 void *digests_buf = NULL;
11278 salt_t *salts_buf = NULL;
11279 void *esalts_buf = NULL;
11280
11281 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11282
11283 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11284
11285 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11286 {
11287 u32 hash_pos;
11288
11289 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11290 {
11291 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11292
11293 hashes_buf[hash_pos].hash_info = hash_info;
11294
11295 if (username && (remove || show || left))
11296 {
11297 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11298 }
11299
11300 if (benchmark)
11301 {
11302 hash_info->orighash = (char *) mymalloc (256);
11303 }
11304 }
11305 }
11306
11307 if (isSalted)
11308 {
11309 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11310
11311 if (esalt_size)
11312 {
11313 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11314 }
11315 }
11316 else
11317 {
11318 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11319 }
11320
11321 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11322 {
11323 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11324
11325 if (isSalted)
11326 {
11327 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11328
11329 if (esalt_size)
11330 {
11331 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11332 }
11333 }
11334 else
11335 {
11336 hashes_buf[hash_pos].salt = &salts_buf[0];
11337 }
11338 }
11339
11340 /**
11341 * load hashes, part III: parse hashes or generate them if benchmark
11342 */
11343
11344 uint hashes_cnt = 0;
11345
11346 if (benchmark == 0)
11347 {
11348 if (keyspace == 1)
11349 {
11350 // useless to read hash file for keyspace, cheat a little bit w/ optind
11351 }
11352 else if (hashes_avail == 0)
11353 {
11354 }
11355 else if (hashlist_mode == HL_MODE_ARG)
11356 {
11357 char *input_buf = myargv[optind];
11358
11359 uint input_len = strlen (input_buf);
11360
11361 logfile_top_var_string ("target", input_buf);
11362
11363 char *hash_buf = NULL;
11364 int hash_len = 0;
11365
11366 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11367
11368 bool hash_fmt_error = 0;
11369
11370 if (hash_len < 1) hash_fmt_error = 1;
11371 if (hash_buf == NULL) hash_fmt_error = 1;
11372
11373 if (hash_fmt_error)
11374 {
11375 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11376 }
11377 else
11378 {
11379 if (opts_type & OPTS_TYPE_HASH_COPY)
11380 {
11381 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11382
11383 hash_info_tmp->orighash = mystrdup (hash_buf);
11384 }
11385
11386 if (isSalted)
11387 {
11388 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11389 }
11390
11391 int parser_status = PARSER_OK;
11392
11393 if (hash_mode == 2500)
11394 {
11395 if (hash_len == 0)
11396 {
11397 log_error ("ERROR: hccap file not specified");
11398
11399 return (-1);
11400 }
11401
11402 hashlist_mode = HL_MODE_FILE;
11403
11404 data.hashlist_mode = hashlist_mode;
11405
11406 FILE *fp = fopen (hash_buf, "rb");
11407
11408 if (fp == NULL)
11409 {
11410 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11411
11412 return (-1);
11413 }
11414
11415 if (hashes_avail < 1)
11416 {
11417 log_error ("ERROR: hccap file is empty or corrupt");
11418
11419 fclose (fp);
11420
11421 return (-1);
11422 }
11423
11424 uint hccap_size = sizeof (hccap_t);
11425
11426 char *in = (char *) mymalloc (hccap_size);
11427
11428 while (!feof (fp))
11429 {
11430 int n = fread (in, hccap_size, 1, fp);
11431
11432 if (n != 1)
11433 {
11434 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11435
11436 break;
11437 }
11438
11439 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11440
11441 if (parser_status != PARSER_OK)
11442 {
11443 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11444
11445 continue;
11446 }
11447
11448 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11449
11450 if ((show == 1) || (left == 1))
11451 {
11452 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11453
11454 char *salt_ptr = (char *) tmp_salt->salt_buf;
11455
11456 int cur_pos = tmp_salt->salt_len;
11457 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11458
11459 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11460
11461 // do the appending task
11462
11463 snprintf (salt_ptr + cur_pos,
11464 rem_len,
11465 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11466 wpa->orig_mac1[0],
11467 wpa->orig_mac1[1],
11468 wpa->orig_mac1[2],
11469 wpa->orig_mac1[3],
11470 wpa->orig_mac1[4],
11471 wpa->orig_mac1[5],
11472 wpa->orig_mac2[0],
11473 wpa->orig_mac2[1],
11474 wpa->orig_mac2[2],
11475 wpa->orig_mac2[3],
11476 wpa->orig_mac2[4],
11477 wpa->orig_mac2[5]);
11478
11479 // memset () the remaining part of the salt
11480
11481 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11482 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11483
11484 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11485
11486 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11487 }
11488
11489 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);
11490 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);
11491
11492 hashes_cnt++;
11493 }
11494
11495 fclose (fp);
11496
11497 myfree (in);
11498 }
11499 else if (hash_mode == 3000)
11500 {
11501 if (hash_len == 32)
11502 {
11503 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11504
11505 hash_t *lm_hash_left = NULL;
11506
11507 if (parser_status == PARSER_OK)
11508 {
11509 lm_hash_left = &hashes_buf[hashes_cnt];
11510
11511 hashes_cnt++;
11512 }
11513 else
11514 {
11515 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11516 }
11517
11518 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11519
11520 hash_t *lm_hash_right = NULL;
11521
11522 if (parser_status == PARSER_OK)
11523 {
11524 lm_hash_right = &hashes_buf[hashes_cnt];
11525
11526 hashes_cnt++;
11527 }
11528 else
11529 {
11530 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11531 }
11532
11533 // show / left
11534
11535 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11536 {
11537 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);
11538 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);
11539 }
11540 }
11541 else
11542 {
11543 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11544
11545 if (parser_status == PARSER_OK)
11546 {
11547 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11548 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11549 }
11550
11551 if (parser_status == PARSER_OK)
11552 {
11553 hashes_cnt++;
11554 }
11555 else
11556 {
11557 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11558 }
11559 }
11560 }
11561 else
11562 {
11563 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11564
11565 if (parser_status == PARSER_OK)
11566 {
11567 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11568 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11569 }
11570
11571 if (parser_status == PARSER_OK)
11572 {
11573 hashes_cnt++;
11574 }
11575 else
11576 {
11577 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11578 }
11579 }
11580 }
11581 }
11582 else if (hashlist_mode == HL_MODE_FILE)
11583 {
11584 char *hashfile = data.hashfile;
11585
11586 FILE *fp;
11587
11588 if ((fp = fopen (hashfile, "rb")) == NULL)
11589 {
11590 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11591
11592 return (-1);
11593 }
11594
11595 uint line_num = 0;
11596
11597 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11598
11599 while (!feof (fp))
11600 {
11601 line_num++;
11602
11603 int line_len = fgetl (fp, line_buf);
11604
11605 if (line_len == 0) continue;
11606
11607 char *hash_buf = NULL;
11608 int hash_len = 0;
11609
11610 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11611
11612 bool hash_fmt_error = 0;
11613
11614 if (hash_len < 1) hash_fmt_error = 1;
11615 if (hash_buf == NULL) hash_fmt_error = 1;
11616
11617 if (hash_fmt_error)
11618 {
11619 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11620
11621 continue;
11622 }
11623
11624 if (username)
11625 {
11626 char *user_buf = NULL;
11627 int user_len = 0;
11628
11629 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11630
11631 if (remove || show)
11632 {
11633 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11634
11635 *user = (user_t *) mymalloc (sizeof (user_t));
11636
11637 user_t *user_ptr = *user;
11638
11639 if (user_buf != NULL)
11640 {
11641 user_ptr->user_name = mystrdup (user_buf);
11642 }
11643 else
11644 {
11645 user_ptr->user_name = mystrdup ("");
11646 }
11647
11648 user_ptr->user_len = user_len;
11649 }
11650 }
11651
11652 if (opts_type & OPTS_TYPE_HASH_COPY)
11653 {
11654 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11655
11656 hash_info_tmp->orighash = mystrdup (hash_buf);
11657 }
11658
11659 if (isSalted)
11660 {
11661 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11662 }
11663
11664 if (hash_mode == 3000)
11665 {
11666 if (hash_len == 32)
11667 {
11668 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11669
11670 if (parser_status < PARSER_GLOBAL_ZERO)
11671 {
11672 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11673
11674 continue;
11675 }
11676
11677 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11678
11679 hashes_cnt++;
11680
11681 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11682
11683 if (parser_status < PARSER_GLOBAL_ZERO)
11684 {
11685 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11686
11687 continue;
11688 }
11689
11690 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11691
11692 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);
11693
11694 hashes_cnt++;
11695
11696 // show / left
11697
11698 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);
11699 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);
11700 }
11701 else
11702 {
11703 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11704
11705 if (parser_status < PARSER_GLOBAL_ZERO)
11706 {
11707 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11708
11709 continue;
11710 }
11711
11712 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);
11713
11714 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11715 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11716
11717 hashes_cnt++;
11718 }
11719 }
11720 else
11721 {
11722 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11723
11724 if (parser_status < PARSER_GLOBAL_ZERO)
11725 {
11726 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11727
11728 continue;
11729 }
11730
11731 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);
11732
11733 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11734 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11735
11736 hashes_cnt++;
11737 }
11738 }
11739
11740 myfree (line_buf);
11741
11742 fclose (fp);
11743
11744 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11745
11746 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11747 }
11748 }
11749 else
11750 {
11751 if (isSalted)
11752 {
11753 hashes_buf[0].salt->salt_len = 8;
11754
11755 // special salt handling
11756
11757 switch (hash_mode)
11758 {
11759 case 1500: hashes_buf[0].salt->salt_len = 2;
11760 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11761 break;
11762 case 1731: hashes_buf[0].salt->salt_len = 4;
11763 break;
11764 case 2410: hashes_buf[0].salt->salt_len = 4;
11765 break;
11766 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11767 break;
11768 case 3100: hashes_buf[0].salt->salt_len = 1;
11769 break;
11770 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11771 break;
11772 case 5800: hashes_buf[0].salt->salt_len = 16;
11773 break;
11774 case 6800: hashes_buf[0].salt->salt_len = 32;
11775 break;
11776 case 8400: hashes_buf[0].salt->salt_len = 40;
11777 break;
11778 case 8800: hashes_buf[0].salt->salt_len = 16;
11779 break;
11780 case 8900: hashes_buf[0].salt->salt_len = 16;
11781 hashes_buf[0].salt->scrypt_N = 1024;
11782 hashes_buf[0].salt->scrypt_r = 1;
11783 hashes_buf[0].salt->scrypt_p = 1;
11784 break;
11785 case 9100: hashes_buf[0].salt->salt_len = 16;
11786 break;
11787 case 9300: hashes_buf[0].salt->salt_len = 14;
11788 hashes_buf[0].salt->scrypt_N = 16384;
11789 hashes_buf[0].salt->scrypt_r = 1;
11790 hashes_buf[0].salt->scrypt_p = 1;
11791 break;
11792 case 9400: hashes_buf[0].salt->salt_len = 16;
11793 break;
11794 case 9500: hashes_buf[0].salt->salt_len = 16;
11795 break;
11796 case 9600: hashes_buf[0].salt->salt_len = 16;
11797 break;
11798 case 9700: hashes_buf[0].salt->salt_len = 16;
11799 break;
11800 case 9710: hashes_buf[0].salt->salt_len = 16;
11801 break;
11802 case 9720: hashes_buf[0].salt->salt_len = 16;
11803 break;
11804 case 9800: hashes_buf[0].salt->salt_len = 16;
11805 break;
11806 case 9810: hashes_buf[0].salt->salt_len = 16;
11807 break;
11808 case 9820: hashes_buf[0].salt->salt_len = 16;
11809 break;
11810 case 10300: hashes_buf[0].salt->salt_len = 12;
11811 break;
11812 case 11500: hashes_buf[0].salt->salt_len = 4;
11813 break;
11814 case 11600: hashes_buf[0].salt->salt_len = 4;
11815 break;
11816 case 12400: hashes_buf[0].salt->salt_len = 4;
11817 break;
11818 case 12500: hashes_buf[0].salt->salt_len = 8;
11819 break;
11820 case 12600: hashes_buf[0].salt->salt_len = 64;
11821 break;
11822 }
11823
11824 // special esalt handling
11825
11826 switch (hash_mode)
11827 {
11828 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11829 break;
11830 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11831 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11832 break;
11833 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11834 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11835 break;
11836 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11837 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11838 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11839 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11840 break;
11841 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11842 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11843 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11844 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11845 break;
11846 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11847 break;
11848 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11849 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11850 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11851 break;
11852 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11853 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11854 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11855 break;
11856 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11857 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11858 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11859 break;
11860 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11861 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11862 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11863 break;
11864 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11865 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11866 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11867 break;
11868 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11869 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11870 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11871 break;
11872 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11873 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11874 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11875 break;
11876 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11877 break;
11878 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11879 break;
11880 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11881 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11882 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11883 break;
11884 }
11885 }
11886
11887 // set hashfile
11888
11889 switch (hash_mode)
11890 {
11891 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11892 break;
11893 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11894 break;
11895 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11896 break;
11897 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11898 break;
11899 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11900 break;
11901 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11902 break;
11903 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11904 break;
11905 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11906 break;
11907 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11908 break;
11909 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11910 break;
11911 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11912 break;
11913 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11914 break;
11915 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11916 break;
11917 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11918 break;
11919 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11920 break;
11921 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11922 break;
11923 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11924 break;
11925 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11926 break;
11927 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11928 break;
11929 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11930 break;
11931 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11932 break;
11933 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11934 break;
11935 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11936 break;
11937 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11938 break;
11939 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11940 break;
11941 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11942 break;
11943 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11944 break;
11945 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11946 break;
11947 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11948 break;
11949 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11950 break;
11951 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11952 break;
11953 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11954 break;
11955 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11956 break;
11957 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11958 break;
11959 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11960 break;
11961 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11962 break;
11963 }
11964
11965 // set default iterations
11966
11967 switch (hash_mode)
11968 {
11969 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11970 break;
11971 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11972 break;
11973 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11974 break;
11975 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11976 break;
11977 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11978 break;
11979 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11980 break;
11981 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11982 break;
11983 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11984 break;
11985 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11986 break;
11987 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11988 break;
11989 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11990 break;
11991 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11992 break;
11993 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11994 break;
11995 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11996 break;
11997 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11998 break;
11999 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12000 break;
12001 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12002 break;
12003 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12004 break;
12005 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12006 break;
12007 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12008 break;
12009 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12010 break;
12011 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12012 break;
12013 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12014 break;
12015 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12016 break;
12017 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12018 break;
12019 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12020 break;
12021 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12022 break;
12023 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12024 break;
12025 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12026 break;
12027 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12028 break;
12029 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12030 break;
12031 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12032 break;
12033 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12034 break;
12035 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12036 break;
12037 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12038 break;
12039 case 8900: hashes_buf[0].salt->salt_iter = 1;
12040 break;
12041 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12042 break;
12043 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12044 break;
12045 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12046 break;
12047 case 9300: hashes_buf[0].salt->salt_iter = 1;
12048 break;
12049 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12050 break;
12051 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12052 break;
12053 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12054 break;
12055 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12056 break;
12057 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12058 break;
12059 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12060 break;
12061 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12062 break;
12063 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12064 break;
12065 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12066 break;
12067 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12068 break;
12069 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12070 break;
12071 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12072 break;
12073 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12074 break;
12075 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12076 break;
12077 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12078 break;
12079 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12080 break;
12081 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12082 break;
12083 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12084 break;
12085 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12086 break;
12087 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12088 break;
12089 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12090 break;
12091 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12092 break;
12093 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12094 break;
12095 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12096 break;
12097 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12098 break;
12099 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12100 break;
12101 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12102 break;
12103 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12104 break;
12105 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12106 break;
12107 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12108 break;
12109 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12110 break;
12111 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12112 break;
12113 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12114 break;
12115 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12116 break;
12117 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12118 break;
12119 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12120 break;
12121 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12122 break;
12123 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12124 break;
12125 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12126 break;
12127 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12128 break;
12129 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12130 break;
12131 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12132 break;
12133 }
12134
12135 hashes_cnt = 1;
12136 }
12137
12138 if (show == 1 || left == 1)
12139 {
12140 for (uint i = 0; i < pot_cnt; i++)
12141 {
12142 pot_t *pot_ptr = &pot[i];
12143
12144 hash_t *hashes_buf = &pot_ptr->hash;
12145
12146 local_free (hashes_buf->digest);
12147
12148 if (isSalted)
12149 {
12150 local_free (hashes_buf->salt);
12151 }
12152 }
12153
12154 local_free (pot);
12155
12156 if (data.quiet == 0) log_info_nn ("");
12157
12158 return (0);
12159 }
12160
12161 if (keyspace == 0)
12162 {
12163 if (hashes_cnt == 0)
12164 {
12165 log_error ("ERROR: No hashes loaded");
12166
12167 return (-1);
12168 }
12169 }
12170
12171 /**
12172 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12173 */
12174
12175 if (data.outfile != NULL)
12176 {
12177 if (data.hashfile != NULL)
12178 {
12179 #ifdef _POSIX
12180 struct stat tmpstat_outfile;
12181 struct stat tmpstat_hashfile;
12182 #endif
12183
12184 #ifdef _WIN
12185 struct stat64 tmpstat_outfile;
12186 struct stat64 tmpstat_hashfile;
12187 #endif
12188
12189 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12190
12191 if (tmp_outfile_fp)
12192 {
12193 #ifdef _POSIX
12194 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12195 #endif
12196
12197 #ifdef _WIN
12198 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12199 #endif
12200
12201 fclose (tmp_outfile_fp);
12202 }
12203
12204 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12205
12206 if (tmp_hashfile_fp)
12207 {
12208 #ifdef _POSIX
12209 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12210 #endif
12211
12212 #ifdef _WIN
12213 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12214 #endif
12215
12216 fclose (tmp_hashfile_fp);
12217 }
12218
12219 if (tmp_outfile_fp && tmp_outfile_fp)
12220 {
12221 tmpstat_outfile.st_mode = 0;
12222 tmpstat_outfile.st_nlink = 0;
12223 tmpstat_outfile.st_uid = 0;
12224 tmpstat_outfile.st_gid = 0;
12225 tmpstat_outfile.st_rdev = 0;
12226 tmpstat_outfile.st_atime = 0;
12227
12228 tmpstat_hashfile.st_mode = 0;
12229 tmpstat_hashfile.st_nlink = 0;
12230 tmpstat_hashfile.st_uid = 0;
12231 tmpstat_hashfile.st_gid = 0;
12232 tmpstat_hashfile.st_rdev = 0;
12233 tmpstat_hashfile.st_atime = 0;
12234
12235 #ifdef _POSIX
12236 tmpstat_outfile.st_blksize = 0;
12237 tmpstat_outfile.st_blocks = 0;
12238
12239 tmpstat_hashfile.st_blksize = 0;
12240 tmpstat_hashfile.st_blocks = 0;
12241 #endif
12242
12243 #ifdef _POSIX
12244 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12245 {
12246 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12247
12248 return (-1);
12249 }
12250 #endif
12251
12252 #ifdef _WIN
12253 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12254 {
12255 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12256
12257 return (-1);
12258 }
12259 #endif
12260 }
12261 }
12262 }
12263
12264 /**
12265 * Remove duplicates
12266 */
12267
12268 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12269
12270 if (isSalted)
12271 {
12272 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12273 }
12274 else
12275 {
12276 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12277 }
12278
12279 uint hashes_cnt_orig = hashes_cnt;
12280
12281 hashes_cnt = 1;
12282
12283 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12284 {
12285 if (isSalted)
12286 {
12287 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12288 {
12289 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12290 }
12291 }
12292 else
12293 {
12294 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12295 }
12296
12297 if (hashes_pos > hashes_cnt)
12298 {
12299 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12300 }
12301
12302 hashes_cnt++;
12303 }
12304
12305 /**
12306 * Potfile removes
12307 */
12308
12309 uint potfile_remove_cracks = 0;
12310
12311 if (potfile_disable == 0)
12312 {
12313 hash_t hash_buf;
12314
12315 hash_buf.digest = mymalloc (dgst_size);
12316 hash_buf.salt = NULL;
12317 hash_buf.esalt = NULL;
12318 hash_buf.hash_info = NULL;
12319 hash_buf.cracked = 0;
12320
12321 if (isSalted)
12322 {
12323 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12324 }
12325
12326 if (esalt_size)
12327 {
12328 hash_buf.esalt = mymalloc (esalt_size);
12329 }
12330
12331 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12332
12333 // no solution for these special hash types (for instane because they use hashfile in output etc)
12334 if ((hash_mode != 5200) &&
12335 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12336 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12337 (hash_mode != 9000))
12338 {
12339 FILE *fp = fopen (potfile, "rb");
12340
12341 if (fp != NULL)
12342 {
12343 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12344
12345 // to be safe work with a copy (because of line_len loop, i etc)
12346 // moved up here because it's easier to handle continue case
12347 // it's just 64kb
12348
12349 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12350
12351 while (!feof (fp))
12352 {
12353 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12354
12355 if (ptr == NULL) break;
12356
12357 int line_len = strlen (line_buf);
12358
12359 if (line_len == 0) continue;
12360
12361 int iter = MAX_CUT_TRIES;
12362
12363 for (int i = line_len - 1; i && iter; i--, line_len--)
12364 {
12365 if (line_buf[i] != ':') continue;
12366
12367 if (isSalted)
12368 {
12369 memset (hash_buf.salt, 0, sizeof (salt_t));
12370 }
12371
12372 hash_t *found = NULL;
12373
12374 if (hash_mode == 6800)
12375 {
12376 if (i < 64) // 64 = 16 * uint in salt_buf[]
12377 {
12378 // manipulate salt_buf
12379 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12380
12381 hash_buf.salt->salt_len = i;
12382
12383 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12384 }
12385 }
12386 else if (hash_mode == 2500)
12387 {
12388 if (i < 64) // 64 = 16 * uint in salt_buf[]
12389 {
12390 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12391 // manipulate salt_buf
12392
12393 memcpy (line_buf_cpy, line_buf, i);
12394
12395 char *mac2_pos = strrchr (line_buf_cpy, ':');
12396
12397 if (mac2_pos == NULL) continue;
12398
12399 mac2_pos[0] = 0;
12400 mac2_pos++;
12401
12402 if (strlen (mac2_pos) != 12) continue;
12403
12404 char *mac1_pos = strrchr (line_buf_cpy, ':');
12405
12406 if (mac1_pos == NULL) continue;
12407
12408 mac1_pos[0] = 0;
12409 mac1_pos++;
12410
12411 if (strlen (mac1_pos) != 12) continue;
12412
12413 uint essid_length = mac1_pos - line_buf_cpy - 1;
12414
12415 // here we need the ESSID
12416 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12417
12418 hash_buf.salt->salt_len = essid_length;
12419
12420 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12421
12422 if (found)
12423 {
12424 wpa_t *wpa = (wpa_t *) found->esalt;
12425
12426 // compare hex string(s) vs binary MAC address(es)
12427
12428 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12429 {
12430 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12431 {
12432 found = NULL;
12433
12434 break;
12435 }
12436 }
12437
12438 // early skip ;)
12439 if (!found) continue;
12440
12441 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12442 {
12443 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12444 {
12445 found = NULL;
12446
12447 break;
12448 }
12449 }
12450 }
12451 }
12452 }
12453 else
12454 {
12455 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12456
12457 if (parser_status == PARSER_OK)
12458 {
12459 if (isSalted)
12460 {
12461 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12462 }
12463 else
12464 {
12465 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12466 }
12467 }
12468 }
12469
12470 if (found == NULL) continue;
12471
12472 if (!found->cracked) potfile_remove_cracks++;
12473
12474 found->cracked = 1;
12475
12476 if (found) break;
12477
12478 iter--;
12479 }
12480 }
12481
12482 myfree (line_buf_cpy);
12483
12484 myfree (line_buf);
12485
12486 fclose (fp);
12487 }
12488 }
12489
12490 if (esalt_size)
12491 {
12492 local_free (hash_buf.esalt);
12493 }
12494
12495 if (isSalted)
12496 {
12497 local_free (hash_buf.salt);
12498 }
12499
12500 local_free (hash_buf.digest);
12501 }
12502
12503 /**
12504 * Now generate all the buffers required for later
12505 */
12506
12507 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12508
12509 salt_t *salts_buf_new = NULL;
12510 void *esalts_buf_new = NULL;
12511
12512 if (isSalted)
12513 {
12514 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12515
12516 if (esalt_size)
12517 {
12518 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12519 }
12520 }
12521 else
12522 {
12523 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12524 }
12525
12526 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12527
12528 uint digests_cnt = hashes_cnt;
12529 uint digests_done = 0;
12530
12531 size_t size_digests = digests_cnt * dgst_size;
12532 size_t size_shown = digests_cnt * sizeof (uint);
12533
12534 uint *digests_shown = (uint *) mymalloc (size_shown);
12535 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12536
12537 uint salts_cnt = 0;
12538 uint salts_done = 0;
12539
12540 hashinfo_t **hash_info = NULL;
12541
12542 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12543 {
12544 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12545
12546 if (username && (remove || show))
12547 {
12548 uint user_pos;
12549
12550 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12551 {
12552 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12553
12554 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12555 }
12556 }
12557 }
12558
12559 uint *salts_shown = (uint *) mymalloc (size_shown);
12560
12561 salt_t *salt_buf;
12562
12563 {
12564 // copied from inner loop
12565
12566 salt_buf = &salts_buf_new[salts_cnt];
12567
12568 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12569
12570 if (esalt_size)
12571 {
12572 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12573 }
12574
12575 salt_buf->digests_cnt = 0;
12576 salt_buf->digests_done = 0;
12577 salt_buf->digests_offset = 0;
12578
12579 salts_cnt++;
12580 }
12581
12582 if (hashes_buf[0].cracked == 1)
12583 {
12584 digests_shown[0] = 1;
12585
12586 digests_done++;
12587
12588 salt_buf->digests_done++;
12589 }
12590
12591 salt_buf->digests_cnt++;
12592
12593 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12594
12595 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12596 {
12597 hash_info[0] = hashes_buf[0].hash_info;
12598 }
12599
12600 // copy from inner loop
12601
12602 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12603 {
12604 if (isSalted)
12605 {
12606 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12607 {
12608 salt_buf = &salts_buf_new[salts_cnt];
12609
12610 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12611
12612 if (esalt_size)
12613 {
12614 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12615 }
12616
12617 salt_buf->digests_cnt = 0;
12618 salt_buf->digests_done = 0;
12619 salt_buf->digests_offset = hashes_pos;
12620
12621 salts_cnt++;
12622 }
12623 }
12624
12625 if (hashes_buf[hashes_pos].cracked == 1)
12626 {
12627 digests_shown[hashes_pos] = 1;
12628
12629 digests_done++;
12630
12631 salt_buf->digests_done++;
12632 }
12633
12634 salt_buf->digests_cnt++;
12635
12636 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12637
12638 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12639 {
12640 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12641 }
12642 }
12643
12644 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12645 {
12646 salt_t *salt_buf = &salts_buf_new[salt_pos];
12647
12648 if (salt_buf->digests_done == salt_buf->digests_cnt)
12649 {
12650 salts_shown[salt_pos] = 1;
12651
12652 salts_done++;
12653 }
12654
12655 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12656 }
12657
12658 local_free (digests_buf);
12659 local_free (salts_buf);
12660 local_free (esalts_buf);
12661
12662 digests_buf = digests_buf_new;
12663 salts_buf = salts_buf_new;
12664 esalts_buf = esalts_buf_new;
12665
12666 local_free (hashes_buf);
12667
12668 /**
12669 * special modification not set from parser
12670 */
12671
12672 switch (hash_mode)
12673 {
12674 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12675 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12676 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12677 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12678 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12679 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12680 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12681 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12682 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12683 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12684 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12685 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12686 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12687 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12688 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12689 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12690 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12691 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12692 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12693 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12694 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12695 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12696 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12697 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12698 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12699 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12700 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12701 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12702 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12703 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12704 }
12705
12706 if (truecrypt_keyfiles)
12707 {
12708 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12709
12710 char *keyfiles = strdup (truecrypt_keyfiles);
12711
12712 char *keyfile = strtok (keyfiles, ",");
12713
12714 do
12715 {
12716 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12717
12718 } while ((keyfile = strtok (NULL, ",")) != NULL);
12719
12720 free (keyfiles);
12721 }
12722
12723 if (veracrypt_keyfiles)
12724 {
12725 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12726
12727 char *keyfiles = strdup (veracrypt_keyfiles);
12728
12729 char *keyfile = strtok (keyfiles, ",");
12730
12731 do
12732 {
12733 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12734
12735 } while ((keyfile = strtok (NULL, ",")) != NULL);
12736
12737 free (keyfiles);
12738 }
12739
12740 data.digests_cnt = digests_cnt;
12741 data.digests_done = digests_done;
12742 data.digests_buf = digests_buf;
12743 data.digests_shown = digests_shown;
12744 data.digests_shown_tmp = digests_shown_tmp;
12745
12746 data.salts_cnt = salts_cnt;
12747 data.salts_done = salts_done;
12748 data.salts_buf = salts_buf;
12749 data.salts_shown = salts_shown;
12750
12751 data.esalts_buf = esalts_buf;
12752 data.hash_info = hash_info;
12753
12754 /**
12755 * Automatic Optimizers
12756 */
12757
12758 if (salts_cnt == 1)
12759 opti_type |= OPTI_TYPE_SINGLE_SALT;
12760
12761 if (digests_cnt == 1)
12762 opti_type |= OPTI_TYPE_SINGLE_HASH;
12763
12764 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12765 opti_type |= OPTI_TYPE_NOT_ITERATED;
12766
12767 if (attack_mode == ATTACK_MODE_BF)
12768 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12769
12770 data.opti_type = opti_type;
12771
12772 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12773 {
12774 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12775 {
12776 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12777 {
12778 if (opts_type & OPTS_TYPE_ST_ADD80)
12779 {
12780 opts_type &= ~OPTS_TYPE_ST_ADD80;
12781 opts_type |= OPTS_TYPE_PT_ADD80;
12782 }
12783
12784 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12785 {
12786 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12787 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12788 }
12789
12790 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12791 {
12792 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12793 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12794 }
12795 }
12796 }
12797 }
12798
12799 /**
12800 * Some algorithm, like descrypt, can benefit from JIT compilation
12801 */
12802
12803 int force_jit_compilation = -1;
12804
12805 if (hash_mode == 8900)
12806 {
12807 force_jit_compilation = 8900;
12808 }
12809 else if (hash_mode == 9300)
12810 {
12811 force_jit_compilation = 8900;
12812 }
12813 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12814 {
12815 force_jit_compilation = 1500;
12816 }
12817
12818 /**
12819 * generate bitmap tables
12820 */
12821
12822 const uint bitmap_shift1 = 5;
12823 const uint bitmap_shift2 = 13;
12824
12825 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12826
12827 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12828 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12829 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12830 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12831 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12832 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12833 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12834 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12835
12836 uint bitmap_bits;
12837 uint bitmap_nums;
12838 uint bitmap_mask;
12839 uint bitmap_size;
12840
12841 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12842 {
12843 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12844
12845 bitmap_nums = 1 << bitmap_bits;
12846
12847 bitmap_mask = bitmap_nums - 1;
12848
12849 bitmap_size = bitmap_nums * sizeof (uint);
12850
12851 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12852
12853 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;
12854 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;
12855
12856 break;
12857 }
12858
12859 bitmap_nums = 1 << bitmap_bits;
12860
12861 bitmap_mask = bitmap_nums - 1;
12862
12863 bitmap_size = bitmap_nums * sizeof (uint);
12864
12865 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);
12866 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);
12867
12868 /**
12869 * prepare quick rule
12870 */
12871
12872 data.rule_buf_l = rule_buf_l;
12873 data.rule_buf_r = rule_buf_r;
12874
12875 int rule_len_l = (int) strlen (rule_buf_l);
12876 int rule_len_r = (int) strlen (rule_buf_r);
12877
12878 data.rule_len_l = rule_len_l;
12879 data.rule_len_r = rule_len_r;
12880
12881 /**
12882 * load rules
12883 */
12884
12885 uint *all_kernel_rules_cnt = NULL;
12886
12887 kernel_rule_t **all_kernel_rules_buf = NULL;
12888
12889 if (rp_files_cnt)
12890 {
12891 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12892
12893 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12894 }
12895
12896 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12897
12898 int rule_len = 0;
12899
12900 for (uint i = 0; i < rp_files_cnt; i++)
12901 {
12902 uint kernel_rules_avail = 0;
12903
12904 uint kernel_rules_cnt = 0;
12905
12906 kernel_rule_t *kernel_rules_buf = NULL;
12907
12908 char *rp_file = rp_files[i];
12909
12910 char in[BLOCK_SIZE] = { 0 };
12911 char out[BLOCK_SIZE] = { 0 };
12912
12913 FILE *fp = NULL;
12914
12915 uint rule_line = 0;
12916
12917 if ((fp = fopen (rp_file, "rb")) == NULL)
12918 {
12919 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12920
12921 return (-1);
12922 }
12923
12924 while (!feof (fp))
12925 {
12926 memset (rule_buf, 0, HCBUFSIZ);
12927
12928 rule_len = fgetl (fp, rule_buf);
12929
12930 rule_line++;
12931
12932 if (rule_len == 0) continue;
12933
12934 if (rule_buf[0] == '#') continue;
12935
12936 if (kernel_rules_avail == kernel_rules_cnt)
12937 {
12938 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12939
12940 kernel_rules_avail += INCR_RULES;
12941 }
12942
12943 memset (in, 0, BLOCK_SIZE);
12944 memset (out, 0, BLOCK_SIZE);
12945
12946 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12947
12948 if (result == -1)
12949 {
12950 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12951
12952 continue;
12953 }
12954
12955 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12956 {
12957 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12958
12959 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12960
12961 continue;
12962 }
12963
12964 /* its so slow
12965 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12966 {
12967 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12968
12969 continue;
12970 }
12971 */
12972
12973 kernel_rules_cnt++;
12974 }
12975
12976 fclose (fp);
12977
12978 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12979
12980 all_kernel_rules_buf[i] = kernel_rules_buf;
12981 }
12982
12983 /**
12984 * merge rules or automatic rule generator
12985 */
12986
12987 uint kernel_rules_cnt = 0;
12988
12989 kernel_rule_t *kernel_rules_buf = NULL;
12990
12991 if (attack_mode == ATTACK_MODE_STRAIGHT)
12992 {
12993 if (rp_files_cnt)
12994 {
12995 kernel_rules_cnt = 1;
12996
12997 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12998
12999 repeats[0] = kernel_rules_cnt;
13000
13001 for (uint i = 0; i < rp_files_cnt; i++)
13002 {
13003 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13004
13005 repeats[i + 1] = kernel_rules_cnt;
13006 }
13007
13008 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13009
13010 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13011
13012 for (uint i = 0; i < kernel_rules_cnt; i++)
13013 {
13014 uint out_pos = 0;
13015
13016 kernel_rule_t *out = &kernel_rules_buf[i];
13017
13018 for (uint j = 0; j < rp_files_cnt; j++)
13019 {
13020 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13021 uint in_pos;
13022
13023 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13024
13025 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13026 {
13027 if (out_pos == RULES_MAX - 1)
13028 {
13029 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13030
13031 break;
13032 }
13033
13034 out->cmds[out_pos] = in->cmds[in_pos];
13035 }
13036 }
13037 }
13038
13039 local_free (repeats);
13040 }
13041 else if (rp_gen)
13042 {
13043 uint kernel_rules_avail = 0;
13044
13045 while (kernel_rules_cnt < rp_gen)
13046 {
13047 if (kernel_rules_avail == kernel_rules_cnt)
13048 {
13049 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13050
13051 kernel_rules_avail += INCR_RULES;
13052 }
13053
13054 memset (rule_buf, 0, HCBUFSIZ);
13055
13056 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13057
13058 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13059
13060 kernel_rules_cnt++;
13061 }
13062 }
13063 }
13064
13065 myfree (rule_buf);
13066
13067 /**
13068 * generate NOP rules
13069 */
13070
13071 if (kernel_rules_cnt == 0)
13072 {
13073 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13074
13075 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13076
13077 kernel_rules_cnt++;
13078 }
13079
13080 data.kernel_rules_cnt = kernel_rules_cnt;
13081 data.kernel_rules_buf = kernel_rules_buf;
13082
13083 /**
13084 * OpenCL platforms: detect
13085 */
13086
13087 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13088 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13089
13090 cl_uint platforms_cnt = 0;
13091 cl_uint platform_devices_cnt = 0;
13092
13093 if (keyspace == 0)
13094 {
13095 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13096
13097 if (platforms_cnt == 0)
13098 {
13099 log_info ("");
13100 log_info ("ATTENTION! No OpenCL compatible platform found");
13101 log_info ("");
13102 log_info ("You're probably missing the OpenCL runtime installation");
13103 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13104 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13105 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13106 log_info ("");
13107
13108 return (-1);
13109 }
13110
13111 if (opencl_platforms_filter != (uint) -1)
13112 {
13113 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13114
13115 if (opencl_platforms_filter > platform_cnt_mask)
13116 {
13117 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13118
13119 return (-1);
13120 }
13121 }
13122 }
13123
13124 /**
13125 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13126 */
13127
13128 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13129 {
13130 cl_platform_id platform = platforms[platform_id];
13131
13132 char platform_vendor[INFOSZ] = { 0 };
13133
13134 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13135
13136 #ifdef HAVE_HWMON
13137 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13138 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13139 {
13140 // make sure that we do not directly control the fan for NVidia
13141
13142 gpu_temp_retain = 0;
13143
13144 data.gpu_temp_retain = gpu_temp_retain;
13145 }
13146 #endif // HAVE_NVML || HAVE_NVAPI
13147 #endif
13148 }
13149
13150 /**
13151 * OpenCL device types:
13152 * 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.
13153 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13154 */
13155
13156 if (opencl_device_types == NULL)
13157 {
13158 cl_device_type device_types_all = 0;
13159
13160 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13161 {
13162 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13163
13164 cl_platform_id platform = platforms[platform_id];
13165
13166 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13167
13168 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13169 {
13170 cl_device_id device = platform_devices[platform_devices_id];
13171
13172 cl_device_type device_type;
13173
13174 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13175
13176 device_types_all |= device_type;
13177 }
13178 }
13179
13180 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13181 {
13182 device_types_filter |= CL_DEVICE_TYPE_CPU;
13183 }
13184 }
13185
13186 /**
13187 * OpenCL devices: simply push all devices from all platforms into the same device array
13188 */
13189
13190 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13191
13192 data.devices_param = devices_param;
13193
13194 uint devices_cnt = 0;
13195
13196 uint devices_active = 0;
13197
13198 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13199 {
13200 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13201
13202 cl_platform_id platform = platforms[platform_id];
13203
13204 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13205
13206 char platform_vendor[INFOSZ] = { 0 };
13207
13208 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13209
13210 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13211 // this causes trouble with vendor id based macros
13212 // we'll assign generic to those without special optimization available
13213
13214 cl_uint vendor_id = 0;
13215
13216 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13217 {
13218 vendor_id = VENDOR_ID_AMD;
13219 }
13220 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13221 {
13222 vendor_id = VENDOR_ID_APPLE;
13223 }
13224 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13225 {
13226 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13227 }
13228 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13229 {
13230 vendor_id = VENDOR_ID_INTEL_SDK;
13231 }
13232 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13233 {
13234 vendor_id = VENDOR_ID_MESA;
13235 }
13236 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13237 {
13238 vendor_id = VENDOR_ID_NV;
13239 }
13240 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13241 {
13242 vendor_id = VENDOR_ID_POCL;
13243 }
13244 else
13245 {
13246 vendor_id = VENDOR_ID_GENERIC;
13247 }
13248
13249 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13250 {
13251 size_t param_value_size = 0;
13252
13253 const uint device_id = devices_cnt;
13254
13255 hc_device_param_t *device_param = &data.devices_param[device_id];
13256
13257 device_param->vendor_id = vendor_id;
13258
13259 device_param->device = platform_devices[platform_devices_id];
13260
13261 device_param->device_id = device_id;
13262
13263 device_param->platform_devices_id = platform_devices_id;
13264
13265 // device_type
13266
13267 cl_device_type device_type;
13268
13269 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13270
13271 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13272
13273 device_param->device_type = device_type;
13274
13275 // device_name
13276
13277 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13278
13279 char *device_name = (char *) mymalloc (param_value_size);
13280
13281 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13282
13283 device_param->device_name = device_name;
13284
13285 // tuning db
13286
13287 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13288
13289 // device_version
13290
13291 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13292
13293 char *device_version = (char *) mymalloc (param_value_size);
13294
13295 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13296
13297 device_param->device_version = device_version;
13298
13299 // device_opencl_version
13300
13301 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13302
13303 char *device_opencl_version = (char *) mymalloc (param_value_size);
13304
13305 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13306
13307 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13308
13309 myfree (device_opencl_version);
13310
13311 // vector_width
13312
13313 cl_uint vector_width;
13314
13315 if (opencl_vector_width_chgd == 0)
13316 {
13317 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13318 {
13319 if (opti_type & OPTI_TYPE_USES_BITS_64)
13320 {
13321 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13322 }
13323 else
13324 {
13325 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13326 }
13327 }
13328 else
13329 {
13330 vector_width = (cl_uint) tuningdb_entry->vector_width;
13331 }
13332 }
13333 else
13334 {
13335 vector_width = opencl_vector_width;
13336 }
13337
13338 if (vector_width > 16) vector_width = 16;
13339
13340 device_param->vector_width = vector_width;
13341
13342 // max_compute_units
13343
13344 cl_uint device_processors;
13345
13346 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13347
13348 device_param->device_processors = device_processors;
13349
13350 // device_maxmem_alloc
13351 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13352
13353 cl_ulong device_maxmem_alloc;
13354
13355 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13356
13357 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13358
13359 // device_global_mem
13360
13361 cl_ulong device_global_mem;
13362
13363 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13364
13365 device_param->device_global_mem = device_global_mem;
13366
13367 // max_work_group_size
13368
13369 size_t device_maxworkgroup_size;
13370
13371 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13372
13373 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13374
13375 // max_clock_frequency
13376
13377 cl_uint device_maxclock_frequency;
13378
13379 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13380
13381 device_param->device_maxclock_frequency = device_maxclock_frequency;
13382
13383 // device_endian_little
13384
13385 cl_bool device_endian_little;
13386
13387 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13388
13389 if (device_endian_little == CL_FALSE)
13390 {
13391 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13392
13393 device_param->skipped = 1;
13394 }
13395
13396 // device_available
13397
13398 cl_bool device_available;
13399
13400 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13401
13402 if (device_available == CL_FALSE)
13403 {
13404 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13405
13406 device_param->skipped = 1;
13407 }
13408
13409 // device_compiler_available
13410
13411 cl_bool device_compiler_available;
13412
13413 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13414
13415 if (device_compiler_available == CL_FALSE)
13416 {
13417 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13418
13419 device_param->skipped = 1;
13420 }
13421
13422 // device_execution_capabilities
13423
13424 cl_device_exec_capabilities device_execution_capabilities;
13425
13426 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13427
13428 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13429 {
13430 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13431
13432 device_param->skipped = 1;
13433 }
13434
13435 // device_extensions
13436
13437 size_t device_extensions_size;
13438
13439 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13440
13441 char *device_extensions = mymalloc (device_extensions_size + 1);
13442
13443 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13444
13445 if (strstr (device_extensions, "base_atomics") == 0)
13446 {
13447 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13448
13449 device_param->skipped = 1;
13450 }
13451
13452 if (strstr (device_extensions, "byte_addressable_store") == 0)
13453 {
13454 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13455
13456 device_param->skipped = 1;
13457 }
13458
13459 myfree (device_extensions);
13460
13461 // device_local_mem_size
13462
13463 cl_ulong device_local_mem_size;
13464
13465 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13466
13467 if (device_local_mem_size < 32768)
13468 {
13469 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13470
13471 device_param->skipped = 1;
13472 }
13473
13474
13475 // skipped
13476
13477 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13478 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13479
13480 // driver_version
13481
13482 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13483
13484 char *driver_version = (char *) mymalloc (param_value_size);
13485
13486 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13487
13488 device_param->driver_version = driver_version;
13489
13490 // device_name_chksum
13491
13492 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13493
13494 #if __x86_64__
13495 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);
13496 #else
13497 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);
13498 #endif
13499
13500 uint device_name_digest[4] = { 0 };
13501
13502 md5_64 ((uint *) device_name_chksum, device_name_digest);
13503
13504 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13505
13506 device_param->device_name_chksum = device_name_chksum;
13507
13508 // device_processor_cores
13509
13510 if (device_type & CL_DEVICE_TYPE_CPU)
13511 {
13512 cl_uint device_processor_cores = 1;
13513
13514 device_param->device_processor_cores = device_processor_cores;
13515 }
13516
13517 if (device_type & CL_DEVICE_TYPE_GPU)
13518 {
13519 if (vendor_id == VENDOR_ID_AMD)
13520 {
13521 cl_uint device_processor_cores = 0;
13522
13523 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13524
13525 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13526
13527 device_param->device_processor_cores = device_processor_cores;
13528 }
13529 else if (vendor_id == VENDOR_ID_NV)
13530 {
13531 cl_uint kernel_exec_timeout = 0;
13532
13533 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13534
13535 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13536
13537 device_param->kernel_exec_timeout = kernel_exec_timeout;
13538
13539 cl_uint device_processor_cores = 0;
13540
13541 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13542
13543 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13544
13545 device_param->device_processor_cores = device_processor_cores;
13546
13547 cl_uint sm_minor = 0;
13548 cl_uint sm_major = 0;
13549
13550 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13551 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13552
13553 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13554 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13555
13556 device_param->sm_minor = sm_minor;
13557 device_param->sm_major = sm_major;
13558 }
13559 else
13560 {
13561 cl_uint device_processor_cores = 1;
13562
13563 device_param->device_processor_cores = device_processor_cores;
13564 }
13565 }
13566
13567 // display results
13568
13569 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13570 {
13571 if (status_automat == 0)
13572 {
13573 if (device_param->skipped == 0)
13574 {
13575 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13576 device_id + 1,
13577 device_name,
13578 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13579 (unsigned int) (device_global_mem / 1024 / 1024),
13580 (unsigned int) (device_maxclock_frequency),
13581 (unsigned int) device_processors);
13582 }
13583 else
13584 {
13585 log_info ("Device #%u: %s, skipped",
13586 device_id + 1,
13587 device_name);
13588 }
13589 }
13590 }
13591
13592 // common driver check
13593
13594 if (device_param->skipped == 0)
13595 {
13596 if (device_type & CL_DEVICE_TYPE_GPU)
13597 {
13598 if (vendor_id == VENDOR_ID_AMD)
13599 {
13600 int catalyst_check = (force == 1) ? 0 : 1;
13601
13602 int catalyst_warn = 0;
13603
13604 int catalyst_broken = 0;
13605
13606 if (catalyst_check == 1)
13607 {
13608 catalyst_warn = 1;
13609
13610 // v14.9 and higher
13611 if (atoi (device_param->driver_version) >= 1573)
13612 {
13613 catalyst_warn = 0;
13614 }
13615
13616 catalyst_check = 0;
13617 }
13618
13619 if (catalyst_broken == 1)
13620 {
13621 log_info ("");
13622 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13623 log_info ("It will pass over cracked hashes and does not report them as cracked");
13624 log_info ("You are STRONGLY encouraged not to use it");
13625 log_info ("You can use --force to override this but do not post error reports if you do so");
13626 log_info ("");
13627
13628 return (-1);
13629 }
13630
13631 if (catalyst_warn == 1)
13632 {
13633 log_info ("");
13634 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13635 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13636 log_info ("See hashcat's homepage for official supported catalyst drivers");
13637 #ifdef _WIN
13638 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13639 #endif
13640 log_info ("You can use --force to override this but do not post error reports if you do so");
13641 log_info ("");
13642
13643 return (-1);
13644 }
13645 }
13646 else if (vendor_id == VENDOR_ID_NV)
13647 {
13648 if (device_param->kernel_exec_timeout != 0)
13649 {
13650 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);
13651 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13652 }
13653 }
13654 }
13655
13656 /* turns out pocl still creates segfaults (because of llvm)
13657 if (device_type & CL_DEVICE_TYPE_CPU)
13658 {
13659 if (vendor_id == VENDOR_ID_AMD)
13660 {
13661 if (force == 0)
13662 {
13663 log_info ("");
13664 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13665 log_info ("You are STRONGLY encouraged not to use it");
13666 log_info ("You can use --force to override this but do not post error reports if you do so");
13667 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13668 log_info ("");
13669
13670 return (-1);
13671 }
13672 }
13673 }
13674 */
13675
13676 /**
13677 * kernel accel and loops tuning db adjustment
13678 */
13679
13680 device_param->kernel_accel_min = 1;
13681 device_param->kernel_accel_max = 1024;
13682
13683 device_param->kernel_loops_min = 1;
13684 device_param->kernel_loops_max = 1024;
13685
13686 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13687
13688 if (tuningdb_entry)
13689 {
13690 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13691 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13692
13693 if (_kernel_accel)
13694 {
13695 device_param->kernel_accel_min = _kernel_accel;
13696 device_param->kernel_accel_max = _kernel_accel;
13697 }
13698
13699 if (_kernel_loops)
13700 {
13701 if (workload_profile == 1)
13702 {
13703 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13704 }
13705 else if (workload_profile == 2)
13706 {
13707 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13708 }
13709
13710 device_param->kernel_loops_min = _kernel_loops;
13711 device_param->kernel_loops_max = _kernel_loops;
13712 }
13713 }
13714
13715 // commandline parameters overwrite tuningdb entries
13716
13717 if (kernel_accel)
13718 {
13719 device_param->kernel_accel_min = kernel_accel;
13720 device_param->kernel_accel_max = kernel_accel;
13721 }
13722
13723 if (kernel_loops)
13724 {
13725 device_param->kernel_loops_min = kernel_loops;
13726 device_param->kernel_loops_max = kernel_loops;
13727 }
13728
13729 /**
13730 * activate device
13731 */
13732
13733 devices_active++;
13734 }
13735
13736 // next please
13737
13738 devices_cnt++;
13739 }
13740 }
13741
13742 if (keyspace == 0 && devices_active == 0)
13743 {
13744 log_error ("ERROR: No devices found/left");
13745
13746 return (-1);
13747 }
13748
13749 // 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)
13750
13751 if (devices_filter != (uint) -1)
13752 {
13753 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13754
13755 if (devices_filter > devices_cnt_mask)
13756 {
13757 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13758
13759 return (-1);
13760 }
13761 }
13762
13763 data.devices_cnt = devices_cnt;
13764
13765 data.devices_active = devices_active;
13766
13767 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13768 {
13769 if (status_automat == 0)
13770 {
13771 log_info ("");
13772 }
13773 }
13774
13775 /**
13776 * HM devices: init
13777 */
13778
13779 #ifdef HAVE_HWMON
13780 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13781 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13782 #endif
13783
13784 #ifdef HAVE_ADL
13785 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13786 #endif
13787
13788 if (gpu_temp_disable == 0)
13789 {
13790 #if defined(WIN) && defined(HAVE_NVAPI)
13791 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13792
13793 if (nvapi_init (nvapi) == 0)
13794 data.hm_nv = nvapi;
13795
13796 if (data.hm_nv)
13797 {
13798 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13799 {
13800 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13801
13802 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13803
13804 int tmp_out = 0;
13805
13806 for (int i = 0; i < tmp_in; i++)
13807 {
13808 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13809 }
13810
13811 for (int i = 0; i < tmp_out; i++)
13812 {
13813 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13814
13815 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13816
13817 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;
13818 }
13819 }
13820 }
13821 #endif // WIN && HAVE_NVAPI
13822
13823 #if defined(LINUX) && defined(HAVE_NVML)
13824 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13825
13826 if (nvml_init (nvml) == 0)
13827 data.hm_nv = nvml;
13828
13829 if (data.hm_nv)
13830 {
13831 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13832 {
13833 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13834
13835 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13836
13837 int tmp_out = 0;
13838
13839 for (int i = 0; i < tmp_in; i++)
13840 {
13841 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13842 }
13843
13844 for (int i = 0; i < tmp_out; i++)
13845 {
13846 unsigned int speed;
13847
13848 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;
13849 }
13850 }
13851 }
13852 #endif // LINUX && HAVE_NVML
13853
13854 data.hm_amd = NULL;
13855
13856 #ifdef HAVE_ADL
13857 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13858
13859 if (adl_init (adl) == 0)
13860 data.hm_amd = adl;
13861
13862 if (data.hm_amd)
13863 {
13864 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13865 {
13866 // total number of adapters
13867
13868 int hm_adapters_num;
13869
13870 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13871
13872 // adapter info
13873
13874 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13875
13876 if (lpAdapterInfo == NULL) return (-1);
13877
13878 // get a list (of ids of) valid/usable adapters
13879
13880 int num_adl_adapters = 0;
13881
13882 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13883
13884 if (num_adl_adapters > 0)
13885 {
13886 hc_thread_mutex_lock (mux_adl);
13887
13888 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13889
13890 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13891
13892 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13893 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13894
13895 hc_thread_mutex_unlock (mux_adl);
13896 }
13897
13898 myfree (valid_adl_device_list);
13899 myfree (lpAdapterInfo);
13900 }
13901 }
13902 #endif // HAVE_ADL
13903
13904 if (data.hm_amd == NULL && data.hm_nv == NULL)
13905 {
13906 gpu_temp_disable = 1;
13907 }
13908 }
13909
13910 /**
13911 * OpenCL devices: allocate buffer for device specific information
13912 */
13913
13914 #ifdef HAVE_HWMON
13915 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13916
13917 #ifdef HAVE_ADL
13918 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13919
13920 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13921 #endif // ADL
13922 #endif
13923
13924 /**
13925 * enable custom signal handler(s)
13926 */
13927
13928 if (benchmark == 0)
13929 {
13930 hc_signal (sigHandler_default);
13931 }
13932 else
13933 {
13934 hc_signal (sigHandler_benchmark);
13935 }
13936
13937 /**
13938 * User-defined GPU temp handling
13939 */
13940
13941 #ifdef HAVE_HWMON
13942 if (gpu_temp_disable == 1)
13943 {
13944 gpu_temp_abort = 0;
13945 gpu_temp_retain = 0;
13946 }
13947
13948 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13949 {
13950 if (gpu_temp_abort < gpu_temp_retain)
13951 {
13952 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13953
13954 return (-1);
13955 }
13956 }
13957
13958 data.gpu_temp_disable = gpu_temp_disable;
13959 data.gpu_temp_abort = gpu_temp_abort;
13960 data.gpu_temp_retain = gpu_temp_retain;
13961 #endif
13962
13963 /**
13964 * inform the user
13965 */
13966
13967 if (data.quiet == 0)
13968 {
13969 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13970
13971 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);
13972
13973 if (attack_mode == ATTACK_MODE_STRAIGHT)
13974 {
13975 log_info ("Rules: %u", kernel_rules_cnt);
13976 }
13977
13978 if (opti_type)
13979 {
13980 log_info ("Applicable Optimizers:");
13981
13982 for (uint i = 0; i < 32; i++)
13983 {
13984 const uint opti_bit = 1u << i;
13985
13986 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13987 }
13988 }
13989
13990 /**
13991 * Watchdog and Temperature balance
13992 */
13993
13994 #ifdef HAVE_HWMON
13995 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13996 {
13997 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13998 }
13999
14000 if (gpu_temp_abort == 0)
14001 {
14002 log_info ("Watchdog: Temperature abort trigger disabled");
14003 }
14004 else
14005 {
14006 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14007 }
14008
14009 if (gpu_temp_retain == 0)
14010 {
14011 log_info ("Watchdog: Temperature retain trigger disabled");
14012 }
14013 else
14014 {
14015 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14016 }
14017
14018 if (data.quiet == 0) log_info ("");
14019 #endif
14020 }
14021
14022 /**
14023 * HM devices: copy
14024 */
14025
14026 if (gpu_temp_disable == 0)
14027 {
14028 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14029 {
14030 hc_device_param_t *device_param = &data.devices_param[device_id];
14031
14032 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14033
14034 if (device_param->skipped) continue;
14035
14036 const uint platform_devices_id = device_param->platform_devices_id;
14037
14038 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14039 if (device_param->vendor_id == VENDOR_ID_NV)
14040 {
14041 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14042 }
14043 #endif
14044
14045 #ifdef HAVE_ADL
14046 if (device_param->vendor_id == VENDOR_ID_AMD)
14047 {
14048 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14049 }
14050 #endif
14051 }
14052 }
14053
14054 /*
14055 * Temporary fix:
14056 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14057 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14058 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14059 * Driver / ADL bug?
14060 */
14061
14062 #ifdef HAVE_ADL
14063 if (powertune_enable == 1)
14064 {
14065 hc_thread_mutex_lock (mux_adl);
14066
14067 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14068 {
14069 hc_device_param_t *device_param = &data.devices_param[device_id];
14070
14071 if (device_param->skipped) continue;
14072
14073 if (data.hm_device[device_id].od_version == 6)
14074 {
14075 // set powertune value only
14076
14077 int powertune_supported = 0;
14078
14079 int ADL_rc = 0;
14080
14081 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14082 {
14083 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14084
14085 return (-1);
14086 }
14087
14088 if (powertune_supported != 0)
14089 {
14090 // powertune set
14091 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14092
14093 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14094 {
14095 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14096
14097 return (-1);
14098 }
14099
14100 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14101 {
14102 log_error ("ERROR: Failed to set new ADL PowerControl values");
14103
14104 return (-1);
14105 }
14106 }
14107 }
14108 }
14109
14110 hc_thread_mutex_unlock (mux_adl);
14111 }
14112 #endif // HAVE_ADK
14113 #endif // HAVE_HWMON
14114
14115 #ifdef DEBUG
14116 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14117 #endif
14118
14119 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14120
14121 uint kernel_power_all = 0;
14122
14123 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14124 {
14125 /**
14126 * host buffer
14127 */
14128
14129 hc_device_param_t *device_param = &data.devices_param[device_id];
14130
14131 if (device_param->skipped) continue;
14132
14133 /**
14134 * device properties
14135 */
14136
14137 const char *device_name_chksum = device_param->device_name_chksum;
14138 const u32 device_processors = device_param->device_processors;
14139 const u32 device_processor_cores = device_param->device_processor_cores;
14140
14141 /**
14142 * create context for each device
14143 */
14144
14145 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14146
14147 /**
14148 * create command-queue
14149 */
14150
14151 // not supported with NV
14152 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14153
14154 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14155
14156 /**
14157 * kernel threads: some algorithms need a fixed kernel-threads count
14158 * because of shared memory usage or bitslice
14159 * there needs to be some upper limit, otherwise there's too much overhead
14160 */
14161
14162 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14163
14164 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14165 {
14166 kernel_threads = KERNEL_THREADS_MAX_CPU;
14167 }
14168
14169 if (hash_mode == 1500) kernel_threads = 64; // DES
14170 if (hash_mode == 3000) kernel_threads = 64; // DES
14171 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14172 if (hash_mode == 7500) kernel_threads = 64; // RC4
14173 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14174 if (hash_mode == 9700) kernel_threads = 64; // RC4
14175 if (hash_mode == 9710) kernel_threads = 64; // RC4
14176 if (hash_mode == 9800) kernel_threads = 64; // RC4
14177 if (hash_mode == 9810) kernel_threads = 64; // RC4
14178 if (hash_mode == 10400) kernel_threads = 64; // RC4
14179 if (hash_mode == 10410) kernel_threads = 64; // RC4
14180 if (hash_mode == 10500) kernel_threads = 64; // RC4
14181 if (hash_mode == 13100) kernel_threads = 64; // RC4
14182
14183 /**
14184 * create input buffers on device : calculate size of fixed memory buffers
14185 */
14186
14187 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14188 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14189
14190 device_param->size_root_css = size_root_css;
14191 device_param->size_markov_css = size_markov_css;
14192
14193 size_t size_results = sizeof (uint);
14194
14195 device_param->size_results = size_results;
14196
14197 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14198 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14199
14200 size_t size_plains = digests_cnt * sizeof (plain_t);
14201 size_t size_salts = salts_cnt * sizeof (salt_t);
14202 size_t size_esalts = salts_cnt * esalt_size;
14203
14204 device_param->size_plains = size_plains;
14205 device_param->size_digests = size_digests;
14206 device_param->size_shown = size_shown;
14207 device_param->size_salts = size_salts;
14208
14209 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14210 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14211 size_t size_tm = 32 * sizeof (bs_word_t);
14212
14213 // scryptV stuff
14214
14215 size_t size_scryptV = 1;
14216
14217 if ((hash_mode == 8900) || (hash_mode == 9300))
14218 {
14219 uint tmto_start = 0;
14220 uint tmto_stop = 10;
14221
14222 if (scrypt_tmto)
14223 {
14224 tmto_start = scrypt_tmto;
14225 }
14226 else
14227 {
14228 // in case the user did not specify the tmto manually
14229 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14230 // but set the lower end only in case the user has a device with too less memory
14231
14232 if (hash_mode == 8900)
14233 {
14234 if (device_param->vendor_id == VENDOR_ID_AMD)
14235 {
14236 tmto_start = 1;
14237 }
14238 else if (device_param->vendor_id == VENDOR_ID_NV)
14239 {
14240 tmto_start = 2;
14241 }
14242 }
14243 else if (hash_mode == 9300)
14244 {
14245 if (device_param->vendor_id == VENDOR_ID_AMD)
14246 {
14247 tmto_start = 2;
14248 }
14249 else if (device_param->vendor_id == VENDOR_ID_NV)
14250 {
14251 tmto_start = 2;
14252 }
14253 }
14254 }
14255
14256 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14257 {
14258 // TODO: in theory the following calculation needs to be done per salt, not global
14259 // we assume all hashes have the same scrypt settings
14260
14261 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14262
14263 size_scryptV /= 1 << tmto;
14264
14265 size_scryptV *= device_processors * device_processor_cores;
14266
14267 if (size_scryptV > device_param->device_maxmem_alloc)
14268 {
14269 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14270
14271 continue;
14272 }
14273
14274 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14275 {
14276 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14277 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14278 }
14279
14280 break;
14281 }
14282
14283 if (data.salts_buf[0].scrypt_phy == 0)
14284 {
14285 log_error ("ERROR: can't allocate enough device memory");
14286
14287 return -1;
14288 }
14289
14290 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14291 }
14292
14293 /**
14294 * some algorithms need a fixed kernel-loops count
14295 */
14296
14297 if (hash_mode == 1500)
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 == 3000)
14306 {
14307 const u32 kernel_loops_fixed = 1024;
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 == 8900)
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 == 9300)
14322 {
14323 const u32 kernel_loops_fixed = 1;
14324
14325 device_param->kernel_loops_min = kernel_loops_fixed;
14326 device_param->kernel_loops_max = kernel_loops_fixed;
14327 }
14328
14329 if (hash_mode == 12500)
14330 {
14331 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14332
14333 device_param->kernel_loops_min = kernel_loops_fixed;
14334 device_param->kernel_loops_max = kernel_loops_fixed;
14335 }
14336
14337 /**
14338 * some algorithms have a maximum kernel-loops count
14339 */
14340
14341 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14342 {
14343 u32 innerloop_cnt = 0;
14344
14345 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14346 {
14347 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14348 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14349 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14350 }
14351 else
14352 {
14353 innerloop_cnt = data.salts_buf[0].salt_iter;
14354 }
14355
14356 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14357 (innerloop_cnt <= device_param->kernel_loops_max))
14358 {
14359 device_param->kernel_loops_max = innerloop_cnt;
14360 }
14361 }
14362
14363 u32 kernel_accel_min = device_param->kernel_accel_min;
14364 u32 kernel_accel_max = device_param->kernel_accel_max;
14365
14366 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14367
14368 size_t size_pws = 4;
14369 size_t size_tmps = 4;
14370 size_t size_hooks = 4;
14371
14372 while (kernel_accel_max >= kernel_accel_min)
14373 {
14374 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14375
14376 // size_pws
14377
14378 size_pws = kernel_power_max * sizeof (pw_t);
14379
14380 // size_tmps
14381
14382 switch (hash_mode)
14383 {
14384 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14385 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14386 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14387 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14388 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14389 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14390 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14391 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14392 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14393 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14394 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14395 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14396 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14397 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14398 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14399 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14400 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14401 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14402 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14403 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14404 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14405 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14406 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14407 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14408 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14409 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14410 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14411 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14412 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14413 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14414 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14415 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14416 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14417 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14418 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14419 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14420 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14421 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14422 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14423 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14424 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14425 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14426 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14427 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14428 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14429 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14430 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14431 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14432 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14433 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14434 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14435 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14436 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14437 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14438 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14439 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14440 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14441 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14442 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14443 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14444 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14445 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14446 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14447 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14448 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14452 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14453 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14454 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14455 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14456 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14457 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14458 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14459 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14460 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14461 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14462 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14463 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14464 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14465 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14466 };
14467
14468 // size_hooks
14469
14470 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14471 {
14472 // none yet
14473 }
14474
14475 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14476 // if not, decrease amplifier and try again
14477
14478 int skip = 0;
14479
14480 const u64 size_total
14481 = bitmap_size
14482 + bitmap_size
14483 + bitmap_size
14484 + bitmap_size
14485 + bitmap_size
14486 + bitmap_size
14487 + bitmap_size
14488 + bitmap_size
14489 + size_bfs
14490 + size_combs
14491 + size_digests
14492 + size_esalts
14493 + size_hooks
14494 + size_markov_css
14495 + size_plains
14496 + size_pws
14497 + size_pws // not a bug
14498 + size_results
14499 + size_root_css
14500 + size_rules
14501 + size_rules_c
14502 + size_salts
14503 + size_scryptV
14504 + size_shown
14505 + size_tm
14506 + size_tmps;
14507
14508 // Don't ask me, ask AMD!
14509
14510 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14511 if (size_total > device_param->device_global_mem) skip = 1;
14512
14513 if (skip == 1)
14514 {
14515 kernel_accel_max--;
14516
14517 continue;
14518 }
14519
14520 break;
14521 }
14522
14523 /*
14524 if (kernel_accel_max == 0)
14525 {
14526 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14527
14528 return -1;
14529 }
14530 */
14531
14532 device_param->kernel_accel_min = kernel_accel_min;
14533 device_param->kernel_accel_max = kernel_accel_max;
14534
14535 /*
14536 if (kernel_accel_max < kernel_accel)
14537 {
14538 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14539
14540 device_param->kernel_accel = kernel_accel_max;
14541 }
14542 */
14543
14544 device_param->size_bfs = size_bfs;
14545 device_param->size_combs = size_combs;
14546 device_param->size_rules = size_rules;
14547 device_param->size_rules_c = size_rules_c;
14548 device_param->size_pws = size_pws;
14549 device_param->size_tmps = size_tmps;
14550 device_param->size_hooks = size_hooks;
14551
14552 // do not confuse kernel_accel_max with kernel_accel here
14553
14554 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14555
14556 device_param->kernel_threads = kernel_threads;
14557 device_param->kernel_power_user = kernel_power;
14558
14559 kernel_power_all += kernel_power;
14560
14561 /**
14562 * default building options
14563 */
14564
14565 char build_opts[1024] = { 0 };
14566
14567 // we don't have sm_* on vendors not NV but it doesn't matter
14568
14569 #if _WIN
14570 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14571 #else
14572 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14573 #endif
14574
14575 char build_opts_new[1024] = { 0 };
14576
14577 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14578
14579 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14580
14581
14582 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14583 {
14584 // we do vectorizing much better than the auto-vectorizer
14585
14586 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14587
14588 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14589 }
14590
14591 #ifdef DEBUG
14592 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14593 #endif
14594
14595 /**
14596 * main kernel
14597 */
14598
14599 {
14600 /**
14601 * kernel source filename
14602 */
14603
14604 char source_file[256] = { 0 };
14605
14606 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14607
14608 struct stat sst;
14609
14610 if (stat (source_file, &sst) == -1)
14611 {
14612 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14613
14614 return -1;
14615 }
14616
14617 /**
14618 * kernel cached filename
14619 */
14620
14621 char cached_file[256] = { 0 };
14622
14623 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14624
14625 int cached = 1;
14626
14627 struct stat cst;
14628
14629 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14630 {
14631 cached = 0;
14632 }
14633
14634 /**
14635 * kernel compile or load
14636 */
14637
14638 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14639
14640 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14641
14642 if (force_jit_compilation == -1)
14643 {
14644 if (cached == 0)
14645 {
14646 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14647
14648 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14649
14650 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14651
14652 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14653
14654 #ifdef DEBUG
14655 size_t build_log_size = 0;
14656
14657 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14658
14659 if (build_log_size > 1)
14660 {
14661 char *build_log = (char *) malloc (build_log_size + 1);
14662
14663 memset (build_log, 0, build_log_size + 1);
14664
14665 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14666
14667 puts (build_log);
14668
14669 free (build_log);
14670 }
14671 #endif
14672
14673 if (rc != 0)
14674 {
14675 device_param->skipped = true;
14676
14677 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14678
14679 continue;
14680 }
14681
14682 size_t binary_size;
14683
14684 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14685
14686 u8 *binary = (u8 *) mymalloc (binary_size);
14687
14688 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14689
14690 writeProgramBin (cached_file, binary, binary_size);
14691
14692 local_free (binary);
14693 }
14694 else
14695 {
14696 #ifdef DEBUG
14697 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14698 #endif
14699
14700 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14701
14702 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14703
14704 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14705 }
14706 }
14707 else
14708 {
14709 #ifdef DEBUG
14710 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14711 #endif
14712
14713 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14714
14715 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14716
14717 char build_opts_update[1024] = { 0 };
14718
14719 if (force_jit_compilation == 1500)
14720 {
14721 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14722 }
14723 else if (force_jit_compilation == 8900)
14724 {
14725 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);
14726 }
14727 else
14728 {
14729 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14730 }
14731
14732 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14733
14734 #ifdef DEBUG
14735 size_t build_log_size = 0;
14736
14737 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14738
14739 if (build_log_size > 1)
14740 {
14741 char *build_log = (char *) malloc (build_log_size + 1);
14742
14743 memset (build_log, 0, build_log_size + 1);
14744
14745 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14746
14747 puts (build_log);
14748
14749 free (build_log);
14750 }
14751 #endif
14752
14753 if (rc != 0)
14754 {
14755 device_param->skipped = true;
14756
14757 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14758 }
14759 }
14760
14761 local_free (kernel_lengths);
14762 local_free (kernel_sources[0]);
14763 local_free (kernel_sources);
14764 }
14765
14766 /**
14767 * word generator kernel
14768 */
14769
14770 if (attack_mode != ATTACK_MODE_STRAIGHT)
14771 {
14772 /**
14773 * kernel mp source filename
14774 */
14775
14776 char source_file[256] = { 0 };
14777
14778 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14779
14780 struct stat sst;
14781
14782 if (stat (source_file, &sst) == -1)
14783 {
14784 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14785
14786 return -1;
14787 }
14788
14789 /**
14790 * kernel mp cached filename
14791 */
14792
14793 char cached_file[256] = { 0 };
14794
14795 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14796
14797 int cached = 1;
14798
14799 struct stat cst;
14800
14801 if (stat (cached_file, &cst) == -1)
14802 {
14803 cached = 0;
14804 }
14805
14806 /**
14807 * kernel compile or load
14808 */
14809
14810 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14811
14812 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14813
14814 if (cached == 0)
14815 {
14816 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14817 if (quiet == 0) log_info ("");
14818
14819 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14820
14821 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14822
14823 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14824
14825 if (rc != 0)
14826 {
14827 device_param->skipped = true;
14828
14829 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14830
14831 continue;
14832 }
14833
14834 size_t binary_size;
14835
14836 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14837
14838 u8 *binary = (u8 *) mymalloc (binary_size);
14839
14840 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14841
14842 writeProgramBin (cached_file, binary, binary_size);
14843
14844 local_free (binary);
14845 }
14846 else
14847 {
14848 #ifdef DEBUG
14849 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14850 #endif
14851
14852 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14853
14854 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14855
14856 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14857 }
14858
14859 local_free (kernel_lengths);
14860 local_free (kernel_sources[0]);
14861 local_free (kernel_sources);
14862 }
14863
14864 /**
14865 * amplifier kernel
14866 */
14867
14868 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14869 {
14870
14871 }
14872 else
14873 {
14874 /**
14875 * kernel amp source filename
14876 */
14877
14878 char source_file[256] = { 0 };
14879
14880 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14881
14882 struct stat sst;
14883
14884 if (stat (source_file, &sst) == -1)
14885 {
14886 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14887
14888 return -1;
14889 }
14890
14891 /**
14892 * kernel amp cached filename
14893 */
14894
14895 char cached_file[256] = { 0 };
14896
14897 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14898
14899 int cached = 1;
14900
14901 struct stat cst;
14902
14903 if (stat (cached_file, &cst) == -1)
14904 {
14905 cached = 0;
14906 }
14907
14908 /**
14909 * kernel compile or load
14910 */
14911
14912 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14913
14914 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14915
14916 if (cached == 0)
14917 {
14918 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14919 if (quiet == 0) log_info ("");
14920
14921 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14922
14923 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14924
14925 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14926
14927 if (rc != 0)
14928 {
14929 device_param->skipped = true;
14930
14931 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14932
14933 continue;
14934 }
14935
14936 size_t binary_size;
14937
14938 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14939
14940 u8 *binary = (u8 *) mymalloc (binary_size);
14941
14942 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14943
14944 writeProgramBin (cached_file, binary, binary_size);
14945
14946 local_free (binary);
14947 }
14948 else
14949 {
14950 #ifdef DEBUG
14951 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14952 #endif
14953
14954 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14955
14956 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14957
14958 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14959 }
14960
14961 local_free (kernel_lengths);
14962 local_free (kernel_sources[0]);
14963 local_free (kernel_sources);
14964 }
14965
14966 // some algorithm collide too fast, make that impossible
14967
14968 if (benchmark == 1)
14969 {
14970 ((uint *) digests_buf)[0] = -1;
14971 ((uint *) digests_buf)[1] = -1;
14972 ((uint *) digests_buf)[2] = -1;
14973 ((uint *) digests_buf)[3] = -1;
14974 }
14975
14976 /**
14977 * global buffers
14978 */
14979
14980 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14981 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14982 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14983 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14984 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14985 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14986 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14987 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14988 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14989 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14990 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14991 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14992 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14993 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14994 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14995 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14996 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14997 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14998
14999 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);
15000 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);
15001 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);
15002 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);
15003 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);
15004 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);
15005 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);
15006 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);
15007 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15008 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15009 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15010
15011 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15012 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15013 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15014 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15015 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15016 run_kernel_bzero (device_param, device_param->d_result, size_results);
15017
15018 /**
15019 * special buffers
15020 */
15021
15022 if (attack_kern == ATTACK_KERN_STRAIGHT)
15023 {
15024 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15025 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15026
15027 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15028
15029 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15030 }
15031 else if (attack_kern == ATTACK_KERN_COMBI)
15032 {
15033 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15034 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15035 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15036 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15037
15038 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15039 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15040 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15041 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15042 }
15043 else if (attack_kern == ATTACK_KERN_BF)
15044 {
15045 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15046 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15047 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15048 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15049 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15050
15051 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15052 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15053 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15054 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15055 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15056 }
15057
15058 if (size_esalts)
15059 {
15060 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15061
15062 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15063 }
15064
15065 /**
15066 * main host data
15067 */
15068
15069 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15070
15071 device_param->pws_buf = pws_buf;
15072
15073 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15074
15075 device_param->combs_buf = combs_buf;
15076
15077 void *hooks_buf = mymalloc (size_hooks);
15078
15079 device_param->hooks_buf = hooks_buf;
15080
15081 /**
15082 * kernel args
15083 */
15084
15085 device_param->kernel_params_buf32[21] = bitmap_mask;
15086 device_param->kernel_params_buf32[22] = bitmap_shift1;
15087 device_param->kernel_params_buf32[23] = bitmap_shift2;
15088 device_param->kernel_params_buf32[24] = 0; // salt_pos
15089 device_param->kernel_params_buf32[25] = 0; // loop_pos
15090 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15091 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15092 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15093 device_param->kernel_params_buf32[29] = 0; // digests_offset
15094 device_param->kernel_params_buf32[30] = 0; // combs_mode
15095 device_param->kernel_params_buf32[31] = 0; // gid_max
15096
15097 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15098 ? &device_param->d_pws_buf
15099 : &device_param->d_pws_amp_buf;
15100 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15101 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15102 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15103 device_param->kernel_params[ 4] = &device_param->d_tmps;
15104 device_param->kernel_params[ 5] = &device_param->d_hooks;
15105 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15106 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15107 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15108 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15109 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15110 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15111 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15112 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15113 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15114 device_param->kernel_params[15] = &device_param->d_digests_buf;
15115 device_param->kernel_params[16] = &device_param->d_digests_shown;
15116 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15117 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15118 device_param->kernel_params[19] = &device_param->d_result;
15119 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15120 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15121 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15122 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15123 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15124 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15125 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15126 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15127 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15128 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15129 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15130 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15131
15132 device_param->kernel_params_mp_buf64[3] = 0;
15133 device_param->kernel_params_mp_buf32[4] = 0;
15134 device_param->kernel_params_mp_buf32[5] = 0;
15135 device_param->kernel_params_mp_buf32[6] = 0;
15136 device_param->kernel_params_mp_buf32[7] = 0;
15137 device_param->kernel_params_mp_buf32[8] = 0;
15138
15139 device_param->kernel_params_mp[0] = NULL;
15140 device_param->kernel_params_mp[1] = NULL;
15141 device_param->kernel_params_mp[2] = NULL;
15142 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15143 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15144 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15145 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15146 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15147 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15148
15149 device_param->kernel_params_mp_l_buf64[3] = 0;
15150 device_param->kernel_params_mp_l_buf32[4] = 0;
15151 device_param->kernel_params_mp_l_buf32[5] = 0;
15152 device_param->kernel_params_mp_l_buf32[6] = 0;
15153 device_param->kernel_params_mp_l_buf32[7] = 0;
15154 device_param->kernel_params_mp_l_buf32[8] = 0;
15155 device_param->kernel_params_mp_l_buf32[9] = 0;
15156
15157 device_param->kernel_params_mp_l[0] = NULL;
15158 device_param->kernel_params_mp_l[1] = NULL;
15159 device_param->kernel_params_mp_l[2] = NULL;
15160 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15161 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15162 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15163 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15164 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15165 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15166 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15167
15168 device_param->kernel_params_mp_r_buf64[3] = 0;
15169 device_param->kernel_params_mp_r_buf32[4] = 0;
15170 device_param->kernel_params_mp_r_buf32[5] = 0;
15171 device_param->kernel_params_mp_r_buf32[6] = 0;
15172 device_param->kernel_params_mp_r_buf32[7] = 0;
15173 device_param->kernel_params_mp_r_buf32[8] = 0;
15174
15175 device_param->kernel_params_mp_r[0] = NULL;
15176 device_param->kernel_params_mp_r[1] = NULL;
15177 device_param->kernel_params_mp_r[2] = NULL;
15178 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15179 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15180 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15181 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15182 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15183 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15184
15185 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15186 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15187
15188 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15189 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15190 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15191 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15192 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15193 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15194 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15195
15196 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15197 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15198
15199 /**
15200 * kernel name
15201 */
15202
15203 size_t kernel_wgs_tmp;
15204
15205 char kernel_name[64] = { 0 };
15206
15207 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15208 {
15209 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15210 {
15211 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15212
15213 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15214
15215 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15216
15217 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15218
15219 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15220
15221 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15222 }
15223 else
15224 {
15225 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15226
15227 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15228
15229 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15230
15231 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15232
15233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15234
15235 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15236 }
15237
15238 if (data.attack_mode == ATTACK_MODE_BF)
15239 {
15240 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15241 {
15242 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15243
15244 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15245
15246 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);
15247 }
15248 }
15249 }
15250 else
15251 {
15252 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15253
15254 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15255
15256 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15257
15258 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15259
15260 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15261
15262 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15263
15264 if (opts_type & OPTS_TYPE_HOOK12)
15265 {
15266 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15267
15268 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15269
15270 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);
15271 }
15272
15273 if (opts_type & OPTS_TYPE_HOOK23)
15274 {
15275 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15276
15277 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15278
15279 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);
15280 }
15281 }
15282
15283 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);
15284 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);
15285 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);
15286
15287 for (uint i = 0; i <= 20; i++)
15288 {
15289 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15290 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15291 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15292
15293 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15294 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15295 }
15296
15297 for (uint i = 21; i <= 31; i++)
15298 {
15299 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15300 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15301 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15302
15303 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15304 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15305 }
15306
15307 if (attack_mode == ATTACK_MODE_BF)
15308 {
15309 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15310 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15311
15312 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);
15313 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);
15314
15315 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15316 {
15317 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15318 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15319 }
15320 }
15321 else if (attack_mode == ATTACK_MODE_HYBRID1)
15322 {
15323 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15324
15325 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);
15326 }
15327 else if (attack_mode == ATTACK_MODE_HYBRID2)
15328 {
15329 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15330
15331 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);
15332 }
15333
15334 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15335 {
15336 // nothing to do
15337 }
15338 else
15339 {
15340 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15341
15342 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);
15343 }
15344
15345 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15346 {
15347 // nothing to do
15348 }
15349 else
15350 {
15351 for (uint i = 0; i < 5; i++)
15352 {
15353 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15354 }
15355
15356 for (uint i = 5; i < 7; i++)
15357 {
15358 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15359 }
15360 }
15361
15362 // maybe this has been updated by clGetKernelWorkGroupInfo()
15363 // value can only be decreased, so we don't need to reallocate buffers
15364
15365 device_param->kernel_threads = kernel_threads;
15366
15367 /**
15368 * Store initial fanspeed if gpu_temp_retain is enabled
15369 */
15370
15371 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15372 int gpu_temp_retain_set = 0;
15373
15374 if (gpu_temp_disable == 0)
15375 {
15376 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15377 {
15378 hc_thread_mutex_lock (mux_adl);
15379
15380 if (data.hm_device[device_id].fan_supported == 1)
15381 {
15382 if (gpu_temp_retain_chgd == 0)
15383 {
15384 uint cur_temp = 0;
15385 uint default_temp = 0;
15386
15387 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);
15388
15389 if (ADL_rc == ADL_OK)
15390 {
15391 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15392
15393 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15394
15395 // special case with multi gpu setups: always use minimum retain
15396
15397 if (gpu_temp_retain_set == 0)
15398 {
15399 gpu_temp_retain = gpu_temp_retain_target;
15400 gpu_temp_retain_set = 1;
15401 }
15402 else
15403 {
15404 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15405 }
15406
15407 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15408 }
15409 }
15410
15411 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15412
15413 temp_retain_fanspeed_value[device_id] = fan_speed;
15414
15415 if (fan_speed == -1)
15416 {
15417 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15418
15419 temp_retain_fanspeed_value[device_id] = 0;
15420 }
15421 }
15422
15423 hc_thread_mutex_unlock (mux_adl);
15424 }
15425 }
15426
15427 /**
15428 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15429 */
15430
15431 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15432 {
15433 hc_thread_mutex_lock (mux_adl);
15434
15435 if (data.hm_device[device_id].od_version == 6)
15436 {
15437 int ADL_rc;
15438
15439 // check powertune capabilities first, if not available then skip device
15440
15441 int powertune_supported = 0;
15442
15443 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15444 {
15445 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15446
15447 return (-1);
15448 }
15449
15450 if (powertune_supported != 0)
15451 {
15452 // powercontrol settings
15453
15454 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15455
15456 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15457 {
15458 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15459 }
15460
15461 if (ADL_rc != ADL_OK)
15462 {
15463 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15464
15465 return (-1);
15466 }
15467
15468 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15469 {
15470 log_error ("ERROR: Failed to set new ADL PowerControl values");
15471
15472 return (-1);
15473 }
15474
15475 // clocks
15476
15477 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15478
15479 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15480
15481 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)
15482 {
15483 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15484
15485 return (-1);
15486 }
15487
15488 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15489
15490 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15491
15492 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15493 {
15494 log_error ("ERROR: Failed to get ADL device capabilities");
15495
15496 return (-1);
15497 }
15498
15499 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15500 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15501
15502 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15503 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15504
15505 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15506 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15507
15508 // warning if profile has too low max values
15509
15510 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15511 {
15512 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15513 }
15514
15515 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15516 {
15517 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15518 }
15519
15520 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15521
15522 performance_state->iNumberOfPerformanceLevels = 2;
15523
15524 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15525 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15526 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15527 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15528
15529 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)
15530 {
15531 log_info ("ERROR: Failed to set ADL performance state");
15532
15533 return (-1);
15534 }
15535
15536 local_free (performance_state);
15537 }
15538 }
15539
15540 hc_thread_mutex_unlock (mux_adl);
15541 }
15542 #endif // HAVE_HWMON && HAVE_ADL
15543 }
15544
15545 data.kernel_power_all = kernel_power_all;
15546
15547 if (data.quiet == 0) log_info_nn ("");
15548
15549 /**
15550 * In benchmark-mode, inform user which algorithm is checked
15551 */
15552
15553 if (benchmark == 1)
15554 {
15555 if (status_automat == 0)
15556 {
15557 quiet = 0;
15558
15559 data.quiet = quiet;
15560
15561 char *hash_type = strhashtype (data.hash_mode); // not a bug
15562
15563 log_info ("Hashtype: %s", hash_type);
15564 log_info ("");
15565 }
15566 }
15567
15568 /**
15569 * keep track of the progress
15570 */
15571
15572 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15573 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15574 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15575
15576 /**
15577 * open filehandles
15578 */
15579
15580 #if _WIN
15581 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15582 {
15583 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15584
15585 return (-1);
15586 }
15587
15588 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15589 {
15590 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15591
15592 return (-1);
15593 }
15594
15595 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15596 {
15597 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15598
15599 return (-1);
15600 }
15601 #endif
15602
15603 /**
15604 * dictionary pad
15605 */
15606
15607 segment_size *= (1024 * 1024);
15608
15609 data.segment_size = segment_size;
15610
15611 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15612
15613 wl_data->buf = (char *) mymalloc (segment_size);
15614 wl_data->avail = segment_size;
15615 wl_data->incr = segment_size;
15616 wl_data->cnt = 0;
15617 wl_data->pos = 0;
15618
15619 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15620
15621 data.wordlist_mode = wordlist_mode;
15622
15623 cs_t *css_buf = NULL;
15624 uint css_cnt = 0;
15625 uint dictcnt = 0;
15626 uint maskcnt = 1;
15627 char **masks = NULL;
15628 char **dictfiles = NULL;
15629
15630 uint mask_from_file = 0;
15631
15632 if (attack_mode == ATTACK_MODE_STRAIGHT)
15633 {
15634 if (wordlist_mode == WL_MODE_FILE)
15635 {
15636 int wls_left = myargc - (optind + 1);
15637
15638 for (int i = 0; i < wls_left; i++)
15639 {
15640 char *l0_filename = myargv[optind + 1 + i];
15641
15642 struct stat l0_stat;
15643
15644 if (stat (l0_filename, &l0_stat) == -1)
15645 {
15646 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15647
15648 return (-1);
15649 }
15650
15651 uint is_dir = S_ISDIR (l0_stat.st_mode);
15652
15653 if (is_dir == 0)
15654 {
15655 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15656
15657 dictcnt++;
15658
15659 dictfiles[dictcnt - 1] = l0_filename;
15660 }
15661 else
15662 {
15663 // do not allow --keyspace w/ a directory
15664
15665 if (keyspace == 1)
15666 {
15667 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15668
15669 return (-1);
15670 }
15671
15672 char **dictionary_files = NULL;
15673
15674 dictionary_files = scan_directory (l0_filename);
15675
15676 if (dictionary_files != NULL)
15677 {
15678 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15679
15680 for (int d = 0; dictionary_files[d] != NULL; d++)
15681 {
15682 char *l1_filename = dictionary_files[d];
15683
15684 struct stat l1_stat;
15685
15686 if (stat (l1_filename, &l1_stat) == -1)
15687 {
15688 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15689
15690 return (-1);
15691 }
15692
15693 if (S_ISREG (l1_stat.st_mode))
15694 {
15695 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15696
15697 dictcnt++;
15698
15699 dictfiles[dictcnt - 1] = strdup (l1_filename);
15700 }
15701 }
15702 }
15703
15704 local_free (dictionary_files);
15705 }
15706 }
15707
15708 if (dictcnt < 1)
15709 {
15710 log_error ("ERROR: No usable dictionary file found.");
15711
15712 return (-1);
15713 }
15714 }
15715 else if (wordlist_mode == WL_MODE_STDIN)
15716 {
15717 dictcnt = 1;
15718 }
15719 }
15720 else if (attack_mode == ATTACK_MODE_COMBI)
15721 {
15722 // display
15723
15724 char *dictfile1 = myargv[optind + 1 + 0];
15725 char *dictfile2 = myargv[optind + 1 + 1];
15726
15727 // find the bigger dictionary and use as base
15728
15729 FILE *fp1 = NULL;
15730 FILE *fp2 = NULL;
15731
15732 struct stat tmp_stat;
15733
15734 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15735 {
15736 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15737
15738 return (-1);
15739 }
15740
15741 if (stat (dictfile1, &tmp_stat) == -1)
15742 {
15743 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15744
15745 fclose (fp1);
15746
15747 return (-1);
15748 }
15749
15750 if (S_ISDIR (tmp_stat.st_mode))
15751 {
15752 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15753
15754 fclose (fp1);
15755
15756 return (-1);
15757 }
15758
15759 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15760 {
15761 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15762
15763 fclose (fp1);
15764
15765 return (-1);
15766 }
15767
15768 if (stat (dictfile2, &tmp_stat) == -1)
15769 {
15770 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15771
15772 fclose (fp1);
15773 fclose (fp2);
15774
15775 return (-1);
15776 }
15777
15778 if (S_ISDIR (tmp_stat.st_mode))
15779 {
15780 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15781
15782 fclose (fp1);
15783 fclose (fp2);
15784
15785 return (-1);
15786 }
15787
15788 data.combs_cnt = 1;
15789
15790 data.quiet = 1;
15791
15792 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15793
15794 data.quiet = quiet;
15795
15796 if (words1_cnt == 0)
15797 {
15798 log_error ("ERROR: %s: empty file", dictfile1);
15799
15800 fclose (fp1);
15801 fclose (fp2);
15802
15803 return (-1);
15804 }
15805
15806 data.combs_cnt = 1;
15807
15808 data.quiet = 1;
15809
15810 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15811
15812 data.quiet = quiet;
15813
15814 if (words2_cnt == 0)
15815 {
15816 log_error ("ERROR: %s: empty file", dictfile2);
15817
15818 fclose (fp1);
15819 fclose (fp2);
15820
15821 return (-1);
15822 }
15823
15824 fclose (fp1);
15825 fclose (fp2);
15826
15827 data.dictfile = dictfile1;
15828 data.dictfile2 = dictfile2;
15829
15830 if (words1_cnt >= words2_cnt)
15831 {
15832 data.combs_cnt = words2_cnt;
15833 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15834
15835 dictfiles = &data.dictfile;
15836
15837 dictcnt = 1;
15838 }
15839 else
15840 {
15841 data.combs_cnt = words1_cnt;
15842 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15843
15844 dictfiles = &data.dictfile2;
15845
15846 dictcnt = 1;
15847
15848 // we also have to switch wordlist related rules!
15849
15850 char *tmpc = data.rule_buf_l;
15851
15852 data.rule_buf_l = data.rule_buf_r;
15853 data.rule_buf_r = tmpc;
15854
15855 int tmpi = data.rule_len_l;
15856
15857 data.rule_len_l = data.rule_len_r;
15858 data.rule_len_r = tmpi;
15859 }
15860 }
15861 else if (attack_mode == ATTACK_MODE_BF)
15862 {
15863 char *mask = NULL;
15864
15865 maskcnt = 0;
15866
15867 if (benchmark == 0)
15868 {
15869 mask = myargv[optind + 1];
15870
15871 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15872
15873 if ((optind + 2) <= myargc)
15874 {
15875 struct stat file_stat;
15876
15877 if (stat (mask, &file_stat) == -1)
15878 {
15879 maskcnt = 1;
15880
15881 masks[maskcnt - 1] = mystrdup (mask);
15882 }
15883 else
15884 {
15885 int wls_left = myargc - (optind + 1);
15886
15887 uint masks_avail = INCR_MASKS;
15888
15889 for (int i = 0; i < wls_left; i++)
15890 {
15891 if (i != 0)
15892 {
15893 mask = myargv[optind + 1 + i];
15894
15895 if (stat (mask, &file_stat) == -1)
15896 {
15897 log_error ("ERROR: %s: %s", mask, strerror (errno));
15898
15899 return (-1);
15900 }
15901 }
15902
15903 uint is_file = S_ISREG (file_stat.st_mode);
15904
15905 if (is_file == 1)
15906 {
15907 FILE *mask_fp;
15908
15909 if ((mask_fp = fopen (mask, "r")) == NULL)
15910 {
15911 log_error ("ERROR: %s: %s", mask, strerror (errno));
15912
15913 return (-1);
15914 }
15915
15916 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15917
15918 while (!feof (mask_fp))
15919 {
15920 memset (line_buf, 0, HCBUFSIZ);
15921
15922 int line_len = fgetl (mask_fp, line_buf);
15923
15924 if (line_len == 0) continue;
15925
15926 if (line_buf[0] == '#') continue;
15927
15928 if (masks_avail == maskcnt)
15929 {
15930 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15931
15932 masks_avail += INCR_MASKS;
15933 }
15934
15935 masks[maskcnt] = mystrdup (line_buf);
15936
15937 maskcnt++;
15938 }
15939
15940 myfree (line_buf);
15941
15942 fclose (mask_fp);
15943 }
15944 else
15945 {
15946 log_error ("ERROR: %s: unsupported file-type", mask);
15947
15948 return (-1);
15949 }
15950 }
15951
15952 mask_from_file = 1;
15953 }
15954 }
15955 else
15956 {
15957 custom_charset_1 = (char *) "?l?d?u";
15958 custom_charset_2 = (char *) "?l?d";
15959 custom_charset_3 = (char *) "?l?d*!$@_";
15960
15961 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15962 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15963 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15964
15965 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15966
15967 wordlist_mode = WL_MODE_MASK;
15968
15969 data.wordlist_mode = wordlist_mode;
15970
15971 increment = 1;
15972
15973 maskcnt = 1;
15974 }
15975 }
15976 else
15977 {
15978 /**
15979 * generate full masks and charsets
15980 */
15981
15982 masks = (char **) mymalloc (sizeof (char *));
15983
15984 switch (hash_mode)
15985 {
15986 case 1731: pw_min = 5;
15987 pw_max = 5;
15988 mask = mystrdup ("?b?b?b?b?b");
15989 break;
15990 case 12500: pw_min = 5;
15991 pw_max = 5;
15992 mask = mystrdup ("?b?b?b?b?b");
15993 break;
15994 default: pw_min = 7;
15995 pw_max = 7;
15996 mask = mystrdup ("?b?b?b?b?b?b?b");
15997 break;
15998 }
15999
16000 maskcnt = 1;
16001
16002 masks[maskcnt - 1] = mystrdup (mask);
16003
16004 wordlist_mode = WL_MODE_MASK;
16005
16006 data.wordlist_mode = wordlist_mode;
16007
16008 increment = 1;
16009 }
16010
16011 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16012
16013 if (increment)
16014 {
16015 if (increment_min > pw_min) pw_min = increment_min;
16016
16017 if (increment_max < pw_max) pw_max = increment_max;
16018 }
16019 }
16020 else if (attack_mode == ATTACK_MODE_HYBRID1)
16021 {
16022 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16023
16024 // display
16025
16026 char *mask = myargv[myargc - 1];
16027
16028 maskcnt = 0;
16029
16030 masks = (char **) mymalloc (1 * sizeof (char *));
16031
16032 // mod
16033
16034 struct stat file_stat;
16035
16036 if (stat (mask, &file_stat) == -1)
16037 {
16038 maskcnt = 1;
16039
16040 masks[maskcnt - 1] = mystrdup (mask);
16041 }
16042 else
16043 {
16044 uint is_file = S_ISREG (file_stat.st_mode);
16045
16046 if (is_file == 1)
16047 {
16048 FILE *mask_fp;
16049
16050 if ((mask_fp = fopen (mask, "r")) == NULL)
16051 {
16052 log_error ("ERROR: %s: %s", mask, strerror (errno));
16053
16054 return (-1);
16055 }
16056
16057 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16058
16059 uint masks_avail = 1;
16060
16061 while (!feof (mask_fp))
16062 {
16063 memset (line_buf, 0, HCBUFSIZ);
16064
16065 int line_len = fgetl (mask_fp, line_buf);
16066
16067 if (line_len == 0) continue;
16068
16069 if (line_buf[0] == '#') continue;
16070
16071 if (masks_avail == maskcnt)
16072 {
16073 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16074
16075 masks_avail += INCR_MASKS;
16076 }
16077
16078 masks[maskcnt] = mystrdup (line_buf);
16079
16080 maskcnt++;
16081 }
16082
16083 myfree (line_buf);
16084
16085 fclose (mask_fp);
16086
16087 mask_from_file = 1;
16088 }
16089 else
16090 {
16091 maskcnt = 1;
16092
16093 masks[maskcnt - 1] = mystrdup (mask);
16094 }
16095 }
16096
16097 // base
16098
16099 int wls_left = myargc - (optind + 2);
16100
16101 for (int i = 0; i < wls_left; i++)
16102 {
16103 char *filename = myargv[optind + 1 + i];
16104
16105 struct stat file_stat;
16106
16107 if (stat (filename, &file_stat) == -1)
16108 {
16109 log_error ("ERROR: %s: %s", filename, strerror (errno));
16110
16111 return (-1);
16112 }
16113
16114 uint is_dir = S_ISDIR (file_stat.st_mode);
16115
16116 if (is_dir == 0)
16117 {
16118 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16119
16120 dictcnt++;
16121
16122 dictfiles[dictcnt - 1] = filename;
16123 }
16124 else
16125 {
16126 // do not allow --keyspace w/ a directory
16127
16128 if (keyspace == 1)
16129 {
16130 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16131
16132 return (-1);
16133 }
16134
16135 char **dictionary_files = NULL;
16136
16137 dictionary_files = scan_directory (filename);
16138
16139 if (dictionary_files != NULL)
16140 {
16141 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16142
16143 for (int d = 0; dictionary_files[d] != NULL; d++)
16144 {
16145 char *l1_filename = dictionary_files[d];
16146
16147 struct stat l1_stat;
16148
16149 if (stat (l1_filename, &l1_stat) == -1)
16150 {
16151 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16152
16153 return (-1);
16154 }
16155
16156 if (S_ISREG (l1_stat.st_mode))
16157 {
16158 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16159
16160 dictcnt++;
16161
16162 dictfiles[dictcnt - 1] = strdup (l1_filename);
16163 }
16164 }
16165 }
16166
16167 local_free (dictionary_files);
16168 }
16169 }
16170
16171 if (dictcnt < 1)
16172 {
16173 log_error ("ERROR: No usable dictionary file found.");
16174
16175 return (-1);
16176 }
16177
16178 if (increment)
16179 {
16180 maskcnt = 0;
16181
16182 uint mask_min = increment_min; // we can't reject smaller masks here
16183 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16184
16185 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16186 {
16187 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16188
16189 if (cur_mask == NULL) break;
16190
16191 masks[maskcnt] = cur_mask;
16192
16193 maskcnt++;
16194
16195 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16196 }
16197 }
16198 }
16199 else if (attack_mode == ATTACK_MODE_HYBRID2)
16200 {
16201 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16202
16203 // display
16204
16205 char *mask = myargv[optind + 1 + 0];
16206
16207 maskcnt = 0;
16208
16209 masks = (char **) mymalloc (1 * sizeof (char *));
16210
16211 // mod
16212
16213 struct stat file_stat;
16214
16215 if (stat (mask, &file_stat) == -1)
16216 {
16217 maskcnt = 1;
16218
16219 masks[maskcnt - 1] = mystrdup (mask);
16220 }
16221 else
16222 {
16223 uint is_file = S_ISREG (file_stat.st_mode);
16224
16225 if (is_file == 1)
16226 {
16227 FILE *mask_fp;
16228
16229 if ((mask_fp = fopen (mask, "r")) == NULL)
16230 {
16231 log_error ("ERROR: %s: %s", mask, strerror (errno));
16232
16233 return (-1);
16234 }
16235
16236 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16237
16238 uint masks_avail = 1;
16239
16240 while (!feof (mask_fp))
16241 {
16242 memset (line_buf, 0, HCBUFSIZ);
16243
16244 int line_len = fgetl (mask_fp, line_buf);
16245
16246 if (line_len == 0) continue;
16247
16248 if (line_buf[0] == '#') continue;
16249
16250 if (masks_avail == maskcnt)
16251 {
16252 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16253
16254 masks_avail += INCR_MASKS;
16255 }
16256
16257 masks[maskcnt] = mystrdup (line_buf);
16258
16259 maskcnt++;
16260 }
16261
16262 myfree (line_buf);
16263
16264 fclose (mask_fp);
16265
16266 mask_from_file = 1;
16267 }
16268 else
16269 {
16270 maskcnt = 1;
16271
16272 masks[maskcnt - 1] = mystrdup (mask);
16273 }
16274 }
16275
16276 // base
16277
16278 int wls_left = myargc - (optind + 2);
16279
16280 for (int i = 0; i < wls_left; i++)
16281 {
16282 char *filename = myargv[optind + 2 + i];
16283
16284 struct stat file_stat;
16285
16286 if (stat (filename, &file_stat) == -1)
16287 {
16288 log_error ("ERROR: %s: %s", filename, strerror (errno));
16289
16290 return (-1);
16291 }
16292
16293 uint is_dir = S_ISDIR (file_stat.st_mode);
16294
16295 if (is_dir == 0)
16296 {
16297 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16298
16299 dictcnt++;
16300
16301 dictfiles[dictcnt - 1] = filename;
16302 }
16303 else
16304 {
16305 // do not allow --keyspace w/ a directory
16306
16307 if (keyspace == 1)
16308 {
16309 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16310
16311 return (-1);
16312 }
16313
16314 char **dictionary_files = NULL;
16315
16316 dictionary_files = scan_directory (filename);
16317
16318 if (dictionary_files != NULL)
16319 {
16320 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16321
16322 for (int d = 0; dictionary_files[d] != NULL; d++)
16323 {
16324 char *l1_filename = dictionary_files[d];
16325
16326 struct stat l1_stat;
16327
16328 if (stat (l1_filename, &l1_stat) == -1)
16329 {
16330 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16331
16332 return (-1);
16333 }
16334
16335 if (S_ISREG (l1_stat.st_mode))
16336 {
16337 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16338
16339 dictcnt++;
16340
16341 dictfiles[dictcnt - 1] = strdup (l1_filename);
16342 }
16343 }
16344 }
16345
16346 local_free (dictionary_files);
16347 }
16348 }
16349
16350 if (dictcnt < 1)
16351 {
16352 log_error ("ERROR: No usable dictionary file found.");
16353
16354 return (-1);
16355 }
16356
16357 if (increment)
16358 {
16359 maskcnt = 0;
16360
16361 uint mask_min = increment_min; // we can't reject smaller masks here
16362 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16363
16364 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16365 {
16366 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16367
16368 if (cur_mask == NULL) break;
16369
16370 masks[maskcnt] = cur_mask;
16371
16372 maskcnt++;
16373
16374 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16375 }
16376 }
16377 }
16378
16379 data.pw_min = pw_min;
16380 data.pw_max = pw_max;
16381
16382 /**
16383 * weak hash check
16384 */
16385
16386 if (weak_hash_threshold >= salts_cnt)
16387 {
16388 hc_device_param_t *device_param = NULL;
16389
16390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16391 {
16392 device_param = &data.devices_param[device_id];
16393
16394 if (device_param->skipped) continue;
16395
16396 break;
16397 }
16398
16399 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16400
16401 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16402 {
16403 weak_hash_check (device_param, salt_pos);
16404 }
16405
16406 // Display hack, guarantee that there is at least one \r before real start
16407
16408 //if (data.quiet == 0) log_info ("");
16409 }
16410
16411 /**
16412 * status and monitor threads
16413 */
16414
16415 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16416
16417 hc_thread_t i_thread = 0;
16418
16419 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16420 {
16421 hc_thread_create (i_thread, thread_keypress, &benchmark);
16422 }
16423
16424 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16425
16426 uint ni_threads_cnt = 0;
16427
16428 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16429
16430 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16431
16432 ni_threads_cnt++;
16433
16434 /**
16435 * Outfile remove
16436 */
16437
16438 if (keyspace == 0)
16439 {
16440 if (outfile_check_timer != 0)
16441 {
16442 if (data.outfile_check_directory != NULL)
16443 {
16444 if ((hash_mode != 5200) &&
16445 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16446 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16447 (hash_mode != 9000))
16448 {
16449 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16450
16451 ni_threads_cnt++;
16452 }
16453 else
16454 {
16455 outfile_check_timer = 0;
16456 }
16457 }
16458 else
16459 {
16460 outfile_check_timer = 0;
16461 }
16462 }
16463 }
16464
16465 /**
16466 * Inform the user if we got some hashes remove because of the pot file remove feature
16467 */
16468
16469 if (data.quiet == 0)
16470 {
16471 if (potfile_remove_cracks > 0)
16472 {
16473 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16474 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16475 }
16476 }
16477
16478 data.outfile_check_timer = outfile_check_timer;
16479
16480 /**
16481 * main loop
16482 */
16483
16484 char **induction_dictionaries = NULL;
16485
16486 int induction_dictionaries_cnt = 0;
16487
16488 hcstat_table_t *root_table_buf = NULL;
16489 hcstat_table_t *markov_table_buf = NULL;
16490
16491 uint initial_restore_done = 0;
16492
16493 data.maskcnt = maskcnt;
16494
16495 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16496 {
16497 if (data.devices_status == STATUS_CRACKED) break;
16498
16499 data.devices_status = STATUS_INIT;
16500
16501 if (maskpos > rd->maskpos)
16502 {
16503 rd->dictpos = 0;
16504 }
16505
16506 rd->maskpos = maskpos;
16507 data.maskpos = maskpos;
16508
16509 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16510 {
16511 char *mask = masks[maskpos];
16512
16513 if (mask_from_file == 1)
16514 {
16515 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16516
16517 char *str_ptr;
16518 uint str_pos;
16519
16520 uint mask_offset = 0;
16521
16522 uint separator_cnt;
16523
16524 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16525 {
16526 str_ptr = strstr (mask + mask_offset, ",");
16527
16528 if (str_ptr == NULL) break;
16529
16530 str_pos = str_ptr - mask;
16531
16532 // escaped separator, i.e. "\,"
16533
16534 if (str_pos > 0)
16535 {
16536 if (mask[str_pos - 1] == '\\')
16537 {
16538 separator_cnt --;
16539
16540 mask_offset = str_pos + 1;
16541
16542 continue;
16543 }
16544 }
16545
16546 // reset the offset
16547
16548 mask_offset = 0;
16549
16550 mask[str_pos] = '\0';
16551
16552 switch (separator_cnt)
16553 {
16554 case 0:
16555 mp_reset_usr (mp_usr, 0);
16556
16557 custom_charset_1 = mask;
16558 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16559 break;
16560
16561 case 1:
16562 mp_reset_usr (mp_usr, 1);
16563
16564 custom_charset_2 = mask;
16565 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16566 break;
16567
16568 case 2:
16569 mp_reset_usr (mp_usr, 2);
16570
16571 custom_charset_3 = mask;
16572 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16573 break;
16574
16575 case 3:
16576 mp_reset_usr (mp_usr, 3);
16577
16578 custom_charset_4 = mask;
16579 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16580 break;
16581 }
16582
16583 mask = mask + str_pos + 1;
16584 }
16585 }
16586
16587 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16588 {
16589 if (maskpos > 0)
16590 {
16591 local_free (css_buf);
16592 local_free (data.root_css_buf);
16593 local_free (data.markov_css_buf);
16594
16595 local_free (masks[maskpos - 1]);
16596 }
16597
16598 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16599
16600 data.mask = mask;
16601 data.css_cnt = css_cnt;
16602 data.css_buf = css_buf;
16603
16604 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16605
16606 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16607
16608 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16609 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16610
16611 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16612
16613 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16614
16615 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16616 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16617
16618 data.root_css_buf = root_css_buf;
16619 data.markov_css_buf = markov_css_buf;
16620
16621 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16622
16623 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16624
16625 local_free (root_table_buf);
16626 local_free (markov_table_buf);
16627
16628 // args
16629
16630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16631 {
16632 hc_device_param_t *device_param = &data.devices_param[device_id];
16633
16634 if (device_param->skipped) continue;
16635
16636 device_param->kernel_params_mp[0] = &device_param->d_combs;
16637 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16638 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16639
16640 device_param->kernel_params_mp_buf64[3] = 0;
16641 device_param->kernel_params_mp_buf32[4] = css_cnt;
16642 device_param->kernel_params_mp_buf32[5] = 0;
16643 device_param->kernel_params_mp_buf32[6] = 0;
16644 device_param->kernel_params_mp_buf32[7] = 0;
16645
16646 if (attack_mode == ATTACK_MODE_HYBRID1)
16647 {
16648 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16649 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16650 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16651 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16652 }
16653 else if (attack_mode == ATTACK_MODE_HYBRID2)
16654 {
16655 device_param->kernel_params_mp_buf32[5] = 0;
16656 device_param->kernel_params_mp_buf32[6] = 0;
16657 device_param->kernel_params_mp_buf32[7] = 0;
16658 }
16659
16660 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]);
16661 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]);
16662 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]);
16663
16664 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);
16665 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);
16666 }
16667 }
16668 else if (attack_mode == ATTACK_MODE_BF)
16669 {
16670 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16671
16672 if (increment)
16673 {
16674 for (uint i = 0; i < dictcnt; i++)
16675 {
16676 local_free (dictfiles[i]);
16677 }
16678
16679 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16680 {
16681 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16682
16683 if (l1_filename == NULL) break;
16684
16685 dictcnt++;
16686
16687 dictfiles[dictcnt - 1] = l1_filename;
16688 }
16689 }
16690 else
16691 {
16692 dictcnt++;
16693
16694 dictfiles[dictcnt - 1] = mask;
16695 }
16696
16697 if (dictcnt == 0)
16698 {
16699 log_error ("ERROR: Mask is too small");
16700
16701 return (-1);
16702 }
16703 }
16704 }
16705
16706 free (induction_dictionaries);
16707
16708 // induction_dictionaries_cnt = 0; // implied
16709
16710 if (attack_mode != ATTACK_MODE_BF)
16711 {
16712 if (keyspace == 0)
16713 {
16714 induction_dictionaries = scan_directory (induction_directory);
16715
16716 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16717 }
16718 }
16719
16720 if (induction_dictionaries_cnt)
16721 {
16722 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16723 }
16724
16725 /**
16726 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16727 */
16728 if (keyspace == 1)
16729 {
16730 if ((maskcnt > 1) || (dictcnt > 1))
16731 {
16732 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16733
16734 return (-1);
16735 }
16736 }
16737
16738 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16739 {
16740 char *subid = logfile_generate_subid ();
16741
16742 data.subid = subid;
16743
16744 logfile_sub_msg ("START");
16745
16746 data.devices_status = STATUS_INIT;
16747
16748 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16749 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16750 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16751
16752 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16753
16754 data.cpt_pos = 0;
16755
16756 data.cpt_start = time (NULL);
16757
16758 data.cpt_total = 0;
16759
16760 if (data.restore == 0)
16761 {
16762 rd->words_cur = skip;
16763
16764 skip = 0;
16765
16766 data.skip = 0;
16767 }
16768
16769 data.ms_paused = 0;
16770
16771 data.words_cur = rd->words_cur;
16772
16773 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16774 {
16775 hc_device_param_t *device_param = &data.devices_param[device_id];
16776
16777 if (device_param->skipped) continue;
16778
16779 device_param->speed_pos = 0;
16780
16781 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16782 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16783
16784 device_param->exec_pos = 0;
16785
16786 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16787
16788 device_param->kernel_power = device_param->kernel_power_user;
16789
16790 device_param->outerloop_pos = 0;
16791 device_param->outerloop_left = 0;
16792 device_param->innerloop_pos = 0;
16793 device_param->innerloop_left = 0;
16794
16795 // some more resets:
16796
16797 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16798
16799 device_param->pws_cnt = 0;
16800
16801 device_param->words_off = 0;
16802 device_param->words_done = 0;
16803 }
16804
16805 data.kernel_power_div = 0;
16806
16807 // figure out some workload
16808
16809 if (attack_mode == ATTACK_MODE_STRAIGHT)
16810 {
16811 if (data.wordlist_mode == WL_MODE_FILE)
16812 {
16813 char *dictfile = NULL;
16814
16815 if (induction_dictionaries_cnt)
16816 {
16817 dictfile = induction_dictionaries[0];
16818 }
16819 else
16820 {
16821 dictfile = dictfiles[dictpos];
16822 }
16823
16824 data.dictfile = dictfile;
16825
16826 logfile_sub_string (dictfile);
16827
16828 for (uint i = 0; i < rp_files_cnt; i++)
16829 {
16830 logfile_sub_var_string ("rulefile", rp_files[i]);
16831 }
16832
16833 FILE *fd2 = fopen (dictfile, "rb");
16834
16835 if (fd2 == NULL)
16836 {
16837 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16838
16839 return (-1);
16840 }
16841
16842 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16843
16844 fclose (fd2);
16845
16846 if (data.words_cnt == 0)
16847 {
16848 if (data.devices_status == STATUS_CRACKED) break;
16849 if (data.devices_status == STATUS_ABORTED) break;
16850
16851 dictpos++;
16852
16853 continue;
16854 }
16855 }
16856 }
16857 else if (attack_mode == ATTACK_MODE_COMBI)
16858 {
16859 char *dictfile = data.dictfile;
16860 char *dictfile2 = data.dictfile2;
16861
16862 logfile_sub_string (dictfile);
16863 logfile_sub_string (dictfile2);
16864
16865 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16866 {
16867 FILE *fd2 = fopen (dictfile, "rb");
16868
16869 if (fd2 == NULL)
16870 {
16871 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16872
16873 return (-1);
16874 }
16875
16876 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16877
16878 fclose (fd2);
16879 }
16880 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16881 {
16882 FILE *fd2 = fopen (dictfile2, "rb");
16883
16884 if (fd2 == NULL)
16885 {
16886 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16887
16888 return (-1);
16889 }
16890
16891 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16892
16893 fclose (fd2);
16894 }
16895
16896 if (data.words_cnt == 0)
16897 {
16898 if (data.devices_status == STATUS_CRACKED) break;
16899 if (data.devices_status == STATUS_ABORTED) break;
16900
16901 dictpos++;
16902
16903 continue;
16904 }
16905 }
16906 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16907 {
16908 char *dictfile = NULL;
16909
16910 if (induction_dictionaries_cnt)
16911 {
16912 dictfile = induction_dictionaries[0];
16913 }
16914 else
16915 {
16916 dictfile = dictfiles[dictpos];
16917 }
16918
16919 data.dictfile = dictfile;
16920
16921 char *mask = data.mask;
16922
16923 logfile_sub_string (dictfile);
16924 logfile_sub_string (mask);
16925
16926 FILE *fd2 = fopen (dictfile, "rb");
16927
16928 if (fd2 == NULL)
16929 {
16930 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16931
16932 return (-1);
16933 }
16934
16935 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16936
16937 fclose (fd2);
16938
16939 if (data.words_cnt == 0)
16940 {
16941 if (data.devices_status == STATUS_CRACKED) break;
16942 if (data.devices_status == STATUS_ABORTED) break;
16943
16944 dictpos++;
16945
16946 continue;
16947 }
16948 }
16949 else if (attack_mode == ATTACK_MODE_BF)
16950 {
16951 local_free (css_buf);
16952 local_free (data.root_css_buf);
16953 local_free (data.markov_css_buf);
16954
16955 char *mask = dictfiles[dictpos];
16956
16957 logfile_sub_string (mask);
16958
16959 // base
16960
16961 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16962
16963 if (opts_type & OPTS_TYPE_PT_UNICODE)
16964 {
16965 uint css_cnt_unicode = css_cnt * 2;
16966
16967 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16968
16969 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16970 {
16971 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16972
16973 css_buf_unicode[j + 1].cs_buf[0] = 0;
16974 css_buf_unicode[j + 1].cs_len = 1;
16975 }
16976
16977 free (css_buf);
16978
16979 css_buf = css_buf_unicode;
16980 css_cnt = css_cnt_unicode;
16981 }
16982
16983 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16984
16985 uint mask_min = pw_min;
16986 uint mask_max = pw_max;
16987
16988 if (opts_type & OPTS_TYPE_PT_UNICODE)
16989 {
16990 mask_min *= 2;
16991 mask_max *= 2;
16992 }
16993
16994 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16995 {
16996 if (css_cnt < mask_min)
16997 {
16998 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16999 }
17000
17001 if (css_cnt > mask_max)
17002 {
17003 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17004 }
17005
17006 // skip to next mask
17007
17008 dictpos++;
17009
17010 rd->dictpos = dictpos;
17011
17012 logfile_sub_msg ("STOP");
17013
17014 continue;
17015 }
17016
17017 uint save_css_cnt = css_cnt;
17018
17019 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17020 {
17021 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17022 {
17023 uint salt_len = (uint) data.salts_buf[0].salt_len;
17024 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17025
17026 uint css_cnt_salt = css_cnt + salt_len;
17027
17028 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17029
17030 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17031
17032 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17033 {
17034 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17035 css_buf_salt[j].cs_len = 1;
17036 }
17037
17038 free (css_buf);
17039
17040 css_buf = css_buf_salt;
17041 css_cnt = css_cnt_salt;
17042 }
17043 }
17044
17045 data.mask = mask;
17046 data.css_cnt = css_cnt;
17047 data.css_buf = css_buf;
17048
17049 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17050
17051 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17052
17053 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17054
17055 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17056 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17057
17058 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17059
17060 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17061
17062 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17063 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17064
17065 data.root_css_buf = root_css_buf;
17066 data.markov_css_buf = markov_css_buf;
17067
17068 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17069
17070 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17071
17072 local_free (root_table_buf);
17073 local_free (markov_table_buf);
17074
17075 // copy + args
17076
17077 uint css_cnt_l = css_cnt;
17078 uint css_cnt_r;
17079
17080 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17081 {
17082 if (save_css_cnt < 6)
17083 {
17084 css_cnt_r = 1;
17085 }
17086 else if (save_css_cnt == 6)
17087 {
17088 css_cnt_r = 2;
17089 }
17090 else
17091 {
17092 if (opts_type & OPTS_TYPE_PT_UNICODE)
17093 {
17094 if (save_css_cnt == 8 || save_css_cnt == 10)
17095 {
17096 css_cnt_r = 2;
17097 }
17098 else
17099 {
17100 css_cnt_r = 4;
17101 }
17102 }
17103 else
17104 {
17105 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17106 {
17107 css_cnt_r = 3;
17108 }
17109 else
17110 {
17111 css_cnt_r = 4;
17112 }
17113 }
17114 }
17115 }
17116 else
17117 {
17118 css_cnt_r = 1;
17119
17120 /* unfinished code?
17121 int sum = css_buf[css_cnt_r - 1].cs_len;
17122
17123 for (uint i = 1; i < 4 && i < css_cnt; i++)
17124 {
17125 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17126
17127 css_cnt_r++;
17128
17129 sum *= css_buf[css_cnt_r - 1].cs_len;
17130 }
17131 */
17132 }
17133
17134 css_cnt_l -= css_cnt_r;
17135
17136 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17137
17138 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17139 {
17140 hc_device_param_t *device_param = &data.devices_param[device_id];
17141
17142 if (device_param->skipped) continue;
17143
17144 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17145 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17146 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17147
17148 device_param->kernel_params_mp_l_buf64[3] = 0;
17149 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17150 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17151 device_param->kernel_params_mp_l_buf32[6] = 0;
17152 device_param->kernel_params_mp_l_buf32[7] = 0;
17153 device_param->kernel_params_mp_l_buf32[8] = 0;
17154
17155 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17156 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17157 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17158 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17159
17160 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17161 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17162 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17163
17164 device_param->kernel_params_mp_r_buf64[3] = 0;
17165 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17166 device_param->kernel_params_mp_r_buf32[5] = 0;
17167 device_param->kernel_params_mp_r_buf32[6] = 0;
17168 device_param->kernel_params_mp_r_buf32[7] = 0;
17169
17170 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]);
17171 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]);
17172 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]);
17173
17174 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]);
17175 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]);
17176 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]);
17177
17178 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);
17179 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);
17180 }
17181 }
17182
17183 u64 words_base = data.words_cnt;
17184
17185 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17186 {
17187 if (data.kernel_rules_cnt)
17188 {
17189 words_base /= data.kernel_rules_cnt;
17190 }
17191 }
17192 else if (data.attack_kern == ATTACK_KERN_COMBI)
17193 {
17194 if (data.combs_cnt)
17195 {
17196 words_base /= data.combs_cnt;
17197 }
17198 }
17199 else if (data.attack_kern == ATTACK_KERN_BF)
17200 {
17201 if (data.bfs_cnt)
17202 {
17203 words_base /= data.bfs_cnt;
17204 }
17205 }
17206
17207 data.words_base = words_base;
17208
17209 if (keyspace == 1)
17210 {
17211 log_info ("%llu", (unsigned long long int) words_base);
17212
17213 return (0);
17214 }
17215
17216 if (data.words_cur > data.words_base)
17217 {
17218 log_error ("ERROR: restore value greater keyspace");
17219
17220 return (-1);
17221 }
17222
17223 if (data.words_cur)
17224 {
17225 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17226 {
17227 for (uint i = 0; i < data.salts_cnt; i++)
17228 {
17229 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17230 }
17231 }
17232 else if (data.attack_kern == ATTACK_KERN_COMBI)
17233 {
17234 for (uint i = 0; i < data.salts_cnt; i++)
17235 {
17236 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17237 }
17238 }
17239 else if (data.attack_kern == ATTACK_KERN_BF)
17240 {
17241 for (uint i = 0; i < data.salts_cnt; i++)
17242 {
17243 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17244 }
17245 }
17246 }
17247
17248 /*
17249 * Inform user about possible slow speeds
17250 */
17251
17252 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17253 {
17254 if (data.words_base < kernel_power_all)
17255 {
17256 if (quiet == 0)
17257 {
17258 log_info ("ATTENTION!");
17259 log_info (" The wordlist or mask you are using is too small.");
17260 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17261 log_info (" The cracking speed will drop.");
17262 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17263 log_info ("");
17264 }
17265 }
17266 }
17267
17268 /*
17269 * Update loopback file
17270 */
17271
17272 if (loopback == 1)
17273 {
17274 time_t now;
17275
17276 time (&now);
17277
17278 uint random_num = get_random_num (0, 9999);
17279
17280 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17281
17282 data.loopback_file = loopback_file;
17283 }
17284
17285 /*
17286 * Update dictionary statistic
17287 */
17288
17289 if (keyspace == 0)
17290 {
17291 dictstat_fp = fopen (dictstat, "wb");
17292
17293 if (dictstat_fp)
17294 {
17295 lock_file (dictstat_fp);
17296
17297 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17298
17299 fclose (dictstat_fp);
17300 }
17301 }
17302
17303 data.devices_status = STATUS_RUNNING;
17304
17305 if (initial_restore_done == 0)
17306 {
17307 if (data.restore_disable == 0) cycle_restore ();
17308
17309 initial_restore_done = 1;
17310 }
17311
17312 hc_timer_set (&data.timer_running);
17313
17314 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17315 {
17316 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17317 {
17318 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17319 if (quiet == 0) fflush (stdout);
17320 }
17321 }
17322 else if (wordlist_mode == WL_MODE_STDIN)
17323 {
17324 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17325 if (data.quiet == 0) log_info ("");
17326 }
17327
17328 time_t runtime_start;
17329
17330 time (&runtime_start);
17331
17332 data.runtime_start = runtime_start;
17333
17334 /**
17335 * create cracker threads
17336 */
17337
17338 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17339
17340 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17341 {
17342 hc_device_param_t *device_param = &devices_param[device_id];
17343
17344 if (wordlist_mode == WL_MODE_STDIN)
17345 {
17346 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17347 }
17348 else
17349 {
17350 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17351 }
17352 }
17353
17354 // wait for crack threads to exit
17355
17356 hc_thread_wait (data.devices_cnt, c_threads);
17357
17358 local_free (c_threads);
17359
17360 data.restore = 0;
17361
17362 // finalize task
17363
17364 logfile_sub_var_uint ("status-after-work", data.devices_status);
17365
17366 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17367
17368 if (data.devices_status == STATUS_CRACKED) break;
17369 if (data.devices_status == STATUS_ABORTED) break;
17370
17371 if (data.devices_status == STATUS_BYPASS)
17372 {
17373 data.devices_status = STATUS_RUNNING;
17374 }
17375
17376 if (induction_dictionaries_cnt)
17377 {
17378 unlink (induction_dictionaries[0]);
17379 }
17380
17381 free (induction_dictionaries);
17382
17383 if (attack_mode != ATTACK_MODE_BF)
17384 {
17385 induction_dictionaries = scan_directory (induction_directory);
17386
17387 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17388 }
17389
17390 if (benchmark == 0)
17391 {
17392 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17393 {
17394 if (quiet == 0) clear_prompt ();
17395
17396 if (quiet == 0) log_info ("");
17397
17398 if (status == 1)
17399 {
17400 status_display ();
17401 }
17402 else
17403 {
17404 if (quiet == 0) status_display ();
17405 }
17406
17407 if (quiet == 0) log_info ("");
17408 }
17409 }
17410
17411 if (attack_mode == ATTACK_MODE_BF)
17412 {
17413 dictpos++;
17414
17415 rd->dictpos = dictpos;
17416 }
17417 else
17418 {
17419 if (induction_dictionaries_cnt)
17420 {
17421 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17422 }
17423 else
17424 {
17425 dictpos++;
17426
17427 rd->dictpos = dictpos;
17428 }
17429 }
17430
17431 time_t runtime_stop;
17432
17433 time (&runtime_stop);
17434
17435 data.runtime_stop = runtime_stop;
17436
17437 logfile_sub_uint (runtime_start);
17438 logfile_sub_uint (runtime_stop);
17439
17440 logfile_sub_msg ("STOP");
17441
17442 global_free (subid);
17443 }
17444
17445 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17446
17447 if (data.devices_status == STATUS_CRACKED) break;
17448 if (data.devices_status == STATUS_ABORTED) break;
17449 if (data.devices_status == STATUS_QUIT) break;
17450
17451 if (data.devices_status == STATUS_BYPASS)
17452 {
17453 data.devices_status = STATUS_RUNNING;
17454 }
17455 }
17456
17457 // 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
17458
17459 if (attack_mode == ATTACK_MODE_STRAIGHT)
17460 {
17461 if (data.wordlist_mode == WL_MODE_FILE)
17462 {
17463 if (data.dictfile == NULL)
17464 {
17465 if (dictfiles != NULL)
17466 {
17467 data.dictfile = dictfiles[0];
17468
17469 hc_timer_set (&data.timer_running);
17470 }
17471 }
17472 }
17473 }
17474 // NOTE: combi is okay because it is already set beforehand
17475 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17476 {
17477 if (data.dictfile == NULL)
17478 {
17479 if (dictfiles != NULL)
17480 {
17481 hc_timer_set (&data.timer_running);
17482
17483 data.dictfile = dictfiles[0];
17484 }
17485 }
17486 }
17487 else if (attack_mode == ATTACK_MODE_BF)
17488 {
17489 if (data.mask == NULL)
17490 {
17491 hc_timer_set (&data.timer_running);
17492
17493 data.mask = masks[0];
17494 }
17495 }
17496
17497 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17498 {
17499 data.devices_status = STATUS_EXHAUSTED;
17500 }
17501
17502 // if cracked / aborted remove last induction dictionary
17503
17504 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17505 {
17506 struct stat induct_stat;
17507
17508 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17509 {
17510 unlink (induction_dictionaries[file_pos]);
17511 }
17512 }
17513
17514 // wait for non-interactive threads
17515
17516 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17517 {
17518 hc_thread_wait (1, &ni_threads[thread_idx]);
17519 }
17520
17521 local_free (ni_threads);
17522
17523 // wait for interactive threads
17524
17525 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17526 {
17527 hc_thread_wait (1, &i_thread);
17528 }
17529
17530 // we dont need restore file anymore
17531 if (data.restore_disable == 0)
17532 {
17533 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17534 {
17535 unlink (eff_restore_file);
17536 unlink (new_restore_file);
17537 }
17538 else
17539 {
17540 cycle_restore ();
17541 }
17542 }
17543
17544 // finally save left hashes
17545
17546 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17547 {
17548 save_hash ();
17549 }
17550
17551 /**
17552 * Clean up
17553 */
17554
17555 if (benchmark == 1)
17556 {
17557 status_benchmark ();
17558
17559 if (status_automat == 0)
17560 {
17561 log_info ("");
17562 }
17563 }
17564 else
17565 {
17566 if (quiet == 0) clear_prompt ();
17567
17568 if (quiet == 0) log_info ("");
17569
17570 if (status == 1)
17571 {
17572 status_display ();
17573 }
17574 else
17575 {
17576 if (quiet == 0) status_display ();
17577 }
17578
17579 if (quiet == 0) log_info ("");
17580 }
17581
17582 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17583 {
17584 hc_device_param_t *device_param = &data.devices_param[device_id];
17585
17586 if (device_param->skipped) continue;
17587
17588 local_free (device_param->combs_buf);
17589
17590 local_free (device_param->hooks_buf);
17591
17592 local_free (device_param->device_name);
17593
17594 local_free (device_param->device_name_chksum);
17595
17596 local_free (device_param->device_version);
17597
17598 local_free (device_param->driver_version);
17599
17600 if (device_param->pws_buf) myfree (device_param->pws_buf);
17601 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17602 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17603 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17604 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17605 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17606 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17607 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17608 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17609 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17610 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17611 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17612 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17613 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17614 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17615 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17616 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17617 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17618 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17619 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17620 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17621 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17622 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17623 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17624 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17625 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17626 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17627 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17628 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17629
17630 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17631 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17632 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17633 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17634 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17635 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17636 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17637 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17638 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17639 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17640
17641 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17642 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17643 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17644
17645 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17646 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17647 }
17648
17649 // reset default fan speed
17650
17651 #ifdef HAVE_HWMON
17652 if (gpu_temp_disable == 0)
17653 {
17654 #ifdef HAVE_ADL
17655 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17656 {
17657 hc_thread_mutex_lock (mux_adl);
17658
17659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17660 {
17661 hc_device_param_t *device_param = &data.devices_param[device_id];
17662
17663 if (device_param->skipped) continue;
17664
17665 if (data.hm_device[device_id].fan_supported == 1)
17666 {
17667 int fanspeed = temp_retain_fanspeed_value[device_id];
17668
17669 if (fanspeed == -1) continue;
17670
17671 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17672
17673 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17674 }
17675 }
17676
17677 hc_thread_mutex_unlock (mux_adl);
17678 }
17679 #endif // HAVE_ADL
17680 }
17681
17682 #ifdef HAVE_ADL
17683 // reset power tuning
17684
17685 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17686 {
17687 hc_thread_mutex_lock (mux_adl);
17688
17689 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17690 {
17691 hc_device_param_t *device_param = &data.devices_param[device_id];
17692
17693 if (device_param->skipped) continue;
17694
17695 if (data.hm_device[device_id].od_version == 6)
17696 {
17697 // check powertune capabilities first, if not available then skip device
17698
17699 int powertune_supported = 0;
17700
17701 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17702 {
17703 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17704
17705 return (-1);
17706 }
17707
17708 if (powertune_supported != 0)
17709 {
17710 // powercontrol settings
17711
17712 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)
17713 {
17714 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17715
17716 return (-1);
17717 }
17718
17719 // clocks
17720
17721 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17722
17723 performance_state->iNumberOfPerformanceLevels = 2;
17724
17725 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17726 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17727 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17728 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17729
17730 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)
17731 {
17732 log_info ("ERROR: Failed to restore ADL performance state");
17733
17734 return (-1);
17735 }
17736
17737 local_free (performance_state);
17738 }
17739 }
17740 }
17741
17742 hc_thread_mutex_unlock (mux_adl);
17743 }
17744 #endif // HAVE_ADL
17745
17746 if (gpu_temp_disable == 0)
17747 {
17748 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17749 if (data.hm_nv)
17750 {
17751 #if defined(LINUX) && defined(HAVE_NVML)
17752
17753 hm_NVML_nvmlShutdown (data.hm_nv);
17754
17755 nvml_close (data.hm_nv);
17756
17757 #elif defined(WIN) && (HAVE_NVAPI)
17758
17759 hm_NvAPI_Unload (data.hm_nv);
17760
17761 nvapi_close (data.hm_nv);
17762
17763 #endif
17764
17765 data.hm_nv = NULL;
17766 }
17767 #endif
17768
17769 #ifdef HAVE_ADL
17770 if (data.hm_amd)
17771 {
17772 hm_ADL_Main_Control_Destroy (data.hm_amd);
17773
17774 adl_close (data.hm_amd);
17775 data.hm_amd = NULL;
17776 }
17777 #endif
17778 }
17779 #endif // HAVE_HWMON
17780
17781 // free memory
17782
17783 local_free (masks);
17784
17785 local_free (dictstat_base);
17786
17787 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17788 {
17789 pot_t *pot_ptr = &pot[pot_pos];
17790
17791 hash_t *hash = &pot_ptr->hash;
17792
17793 local_free (hash->digest);
17794
17795 if (isSalted)
17796 {
17797 local_free (hash->salt);
17798 }
17799 }
17800
17801 local_free (pot);
17802
17803 local_free (all_kernel_rules_cnt);
17804 local_free (all_kernel_rules_buf);
17805
17806 local_free (wl_data->buf);
17807 local_free (wl_data);
17808
17809 local_free (bitmap_s1_a);
17810 local_free (bitmap_s1_b);
17811 local_free (bitmap_s1_c);
17812 local_free (bitmap_s1_d);
17813 local_free (bitmap_s2_a);
17814 local_free (bitmap_s2_b);
17815 local_free (bitmap_s2_c);
17816 local_free (bitmap_s2_d);
17817
17818 #ifdef HAVE_HWMON
17819 local_free (temp_retain_fanspeed_value);
17820 #ifdef HAVE_ADL
17821 local_free (od_clock_mem_status);
17822 local_free (od_power_control_status);
17823 #endif // ADL
17824 #endif
17825
17826 global_free (devices_param);
17827
17828 global_free (kernel_rules_buf);
17829
17830 global_free (root_css_buf);
17831 global_free (markov_css_buf);
17832
17833 global_free (digests_buf);
17834 global_free (digests_shown);
17835 global_free (digests_shown_tmp);
17836
17837 global_free (salts_buf);
17838 global_free (salts_shown);
17839
17840 global_free (esalts_buf);
17841
17842 global_free (words_progress_done);
17843 global_free (words_progress_rejected);
17844 global_free (words_progress_restored);
17845
17846 if (pot_fp) fclose (pot_fp);
17847
17848 if (data.devices_status == STATUS_QUIT) break;
17849 }
17850
17851 // destroy others mutex
17852
17853 hc_thread_mutex_delete (mux_dispatcher);
17854 hc_thread_mutex_delete (mux_counter);
17855 hc_thread_mutex_delete (mux_display);
17856 hc_thread_mutex_delete (mux_adl);
17857
17858 // free memory
17859
17860 local_free (eff_restore_file);
17861 local_free (new_restore_file);
17862
17863 local_free (rd);
17864
17865 // tuning db
17866
17867 tuning_db_destroy (tuning_db);
17868
17869 // loopback
17870
17871 local_free (loopback_file);
17872
17873 if (loopback == 1) unlink (loopback_file);
17874
17875 // induction directory
17876
17877 if (induction_dir == NULL)
17878 {
17879 if (attack_mode != ATTACK_MODE_BF)
17880 {
17881 if (rmdir (induction_directory) == -1)
17882 {
17883 if (errno == ENOENT)
17884 {
17885 // good, we can ignore
17886 }
17887 else if (errno == ENOTEMPTY)
17888 {
17889 // good, we can ignore
17890 }
17891 else
17892 {
17893 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17894
17895 return (-1);
17896 }
17897 }
17898
17899 local_free (induction_directory);
17900 }
17901 }
17902
17903 // outfile-check directory
17904
17905 if (outfile_check_dir == NULL)
17906 {
17907 if (rmdir (outfile_check_directory) == -1)
17908 {
17909 if (errno == ENOENT)
17910 {
17911 // good, we can ignore
17912 }
17913 else if (errno == ENOTEMPTY)
17914 {
17915 // good, we can ignore
17916 }
17917 else
17918 {
17919 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17920
17921 return (-1);
17922 }
17923 }
17924
17925 local_free (outfile_check_directory);
17926 }
17927
17928 time_t proc_stop;
17929
17930 time (&proc_stop);
17931
17932 logfile_top_uint (proc_start);
17933 logfile_top_uint (proc_stop);
17934
17935 logfile_top_msg ("STOP");
17936
17937 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17938 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17939
17940 if (data.ocl) ocl_close (data.ocl);
17941
17942 if (data.devices_status == STATUS_ABORTED) return 2;
17943 if (data.devices_status == STATUS_QUIT) return 2;
17944 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17945 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17946 if (data.devices_status == STATUS_CRACKED) return 0;
17947
17948 return -1;
17949 }
Hashcat additions to support pwdhash