projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix bug in -a 1 mode: If left wordlist has less entries than right wordlist then...
[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 CHR 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-CHR set1 | CS | User-defined CHR set ?1 | -1 ?l?d?u",
432 " -2, --custom-CHR set2 | CS | User-defined CHR set ?2 | -2 ?l?d?s",
433 " -3, --custom-CHR set3 | CS | User-defined CHR set ?3 |",
434 " -4, --custom-CHR set4 | CS | User-defined CHR set ?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 happend 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 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2219 {
2220 data.digests_shown[hash_pos] = 1;
2221
2222 data.digests_done++;
2223
2224 cpt_cracked++;
2225
2226 salt_buf->digests_done++;
2227
2228 if (salt_buf->digests_done == salt_buf->digests_cnt)
2229 {
2230 data.salts_shown[salt_pos] = 1;
2231
2232 data.salts_done++;
2233 }
2234 }
2235
2236 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2237
2238 check_hash (device_param, &cracked[i]);
2239 }
2240
2241 myfree (cracked);
2242
2243 if (cpt_cracked > 0)
2244 {
2245 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2246 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2247
2248 data.cpt_pos++;
2249
2250 data.cpt_total += cpt_cracked;
2251
2252 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2253 }
2254
2255 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2256 {
2257 // we need to reset cracked state on the device
2258 // otherwise host thinks again and again the hash was cracked
2259 // and returns invalid password each time
2260
2261 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2262
2263 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);
2264 }
2265
2266 num_cracked = 0;
2267
2268 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2269 }
2270 }
2271
2272 static void save_hash ()
2273 {
2274 char *hashfile = data.hashfile;
2275
2276 char new_hashfile[256] = { 0 };
2277 char old_hashfile[256] = { 0 };
2278
2279 snprintf (new_hashfile, 255, "%s.new", hashfile);
2280 snprintf (old_hashfile, 255, "%s.old", hashfile);
2281
2282 unlink (new_hashfile);
2283
2284 char separator = data.separator;
2285
2286 FILE *fp = fopen (new_hashfile, "wb");
2287
2288 if (fp == NULL)
2289 {
2290 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2291
2292 exit (-1);
2293 }
2294
2295 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2296 {
2297 if (data.salts_shown[salt_pos] == 1) continue;
2298
2299 salt_t *salt_buf = &data.salts_buf[salt_pos];
2300
2301 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2302 {
2303 uint idx = salt_buf->digests_offset + digest_pos;
2304
2305 if (data.digests_shown[idx] == 1) continue;
2306
2307 if (data.hash_mode != 2500)
2308 {
2309 char out_buf[HCBUFSIZ] = { 0 };
2310
2311 if (data.username == 1)
2312 {
2313 user_t *user = data.hash_info[idx]->user;
2314
2315 uint i;
2316
2317 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2318
2319 fputc (separator, fp);
2320 }
2321
2322 ascii_digest (out_buf, salt_pos, digest_pos);
2323
2324 fputs (out_buf, fp);
2325
2326 log_out (fp, "");
2327 }
2328 else
2329 {
2330 hccap_t hccap;
2331
2332 to_hccap_t (&hccap, salt_pos, digest_pos);
2333
2334 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2335 }
2336 }
2337 }
2338
2339 fflush (fp);
2340
2341 fclose (fp);
2342
2343 unlink (old_hashfile);
2344
2345 if (rename (hashfile, old_hashfile) != 0)
2346 {
2347 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2348
2349 exit (-1);
2350 }
2351
2352 unlink (hashfile);
2353
2354 if (rename (new_hashfile, hashfile) != 0)
2355 {
2356 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2357
2358 exit (-1);
2359 }
2360
2361 unlink (old_hashfile);
2362 }
2363
2364 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2365 {
2366 // function called only in case kernel_power_all > words_left
2367
2368 float kernel_power_div = (float) (total_left) / kernel_power_all;
2369
2370 kernel_power_div += kernel_power_div / 100;
2371
2372 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2373
2374 while (kernel_power_new < total_left)
2375 {
2376 kernel_power_div += kernel_power_div / 100;
2377
2378 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2379 }
2380
2381 if (data.quiet == 0)
2382 {
2383 clear_prompt ();
2384
2385 //log_info ("");
2386
2387 log_info ("INFO: approaching final keyspace, workload adjusted");
2388 log_info ("");
2389
2390 fprintf (stdout, "%s", PROMPT);
2391
2392 fflush (stdout);
2393 }
2394
2395 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2396
2397 return kernel_power_div;
2398 }
2399
2400 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2401 {
2402 uint num_elements = num;
2403
2404 device_param->kernel_params_buf32[30] = data.combs_mode;
2405 device_param->kernel_params_buf32[31] = num;
2406
2407 uint kernel_threads = device_param->kernel_threads;
2408
2409 while (num_elements % kernel_threads) num_elements++;
2410
2411 cl_kernel kernel = NULL;
2412
2413 switch (kern_run)
2414 {
2415 case KERN_RUN_1: kernel = device_param->kernel1; break;
2416 case KERN_RUN_12: kernel = device_param->kernel12; break;
2417 case KERN_RUN_2: kernel = device_param->kernel2; break;
2418 case KERN_RUN_23: kernel = device_param->kernel23; break;
2419 case KERN_RUN_3: kernel = device_param->kernel3; break;
2420 }
2421
2422 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2423 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2424 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2425 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2426 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2427 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2428 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2429 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2430 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2431 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2432 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2433
2434 cl_event event;
2435
2436 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2437 {
2438 const size_t global_work_size[3] = { num_elements, 32, 1 };
2439 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2440
2441 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2442 }
2443 else
2444 {
2445 if (kern_run == KERN_RUN_2)
2446 {
2447 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2448 {
2449 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2450 }
2451 }
2452
2453 while (num_elements % kernel_threads) num_elements++;
2454
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2459 }
2460
2461 hc_clFlush (data.ocl, device_param->command_queue);
2462
2463 hc_clWaitForEvents (data.ocl, 1, &event);
2464
2465 if (event_update)
2466 {
2467 cl_ulong time_start;
2468 cl_ulong time_end;
2469
2470 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2471 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2472
2473 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2474
2475 uint exec_pos = device_param->exec_pos;
2476
2477 device_param->exec_ms[exec_pos] = exec_time;
2478
2479 exec_pos++;
2480
2481 if (exec_pos == EXEC_CACHE)
2482 {
2483 exec_pos = 0;
2484 }
2485
2486 device_param->exec_pos = exec_pos;
2487 }
2488
2489 hc_clReleaseEvent (data.ocl, event);
2490
2491 hc_clFinish (data.ocl, device_param->command_queue);
2492 }
2493
2494 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2495 {
2496 uint num_elements = num;
2497
2498 switch (kern_run)
2499 {
2500 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2501 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2502 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2503 }
2504
2505 // causes problems with special threads like in bcrypt
2506 // const uint kernel_threads = device_param->kernel_threads;
2507
2508 uint kernel_threads = device_param->kernel_threads;
2509
2510 while (num_elements % kernel_threads) num_elements++;
2511
2512 cl_kernel kernel = NULL;
2513
2514 switch (kern_run)
2515 {
2516 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2517 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2518 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2519 }
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2524 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2525 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2526 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2527 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2528 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2529 break;
2530 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2536 break;
2537 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2543 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2544 break;
2545 }
2546
2547 const size_t global_work_size[3] = { num_elements, 1, 1 };
2548 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2549
2550 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2551
2552 hc_clFlush (data.ocl, device_param->command_queue);
2553
2554 hc_clFinish (data.ocl, device_param->command_queue);
2555 }
2556
2557 static void run_kernel_tm (hc_device_param_t *device_param)
2558 {
2559 const uint num_elements = 1024; // fixed
2560
2561 uint kernel_threads = 32;
2562
2563 cl_kernel kernel = device_param->kernel_tm;
2564
2565 const size_t global_work_size[3] = { num_elements, 1, 1 };
2566 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2567
2568 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2569
2570 hc_clFlush (data.ocl, device_param->command_queue);
2571
2572 hc_clFinish (data.ocl, device_param->command_queue);
2573 }
2574
2575 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2576 {
2577 uint num_elements = num;
2578
2579 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2580 device_param->kernel_params_amp_buf32[6] = num_elements;
2581
2582 // causes problems with special threads like in bcrypt
2583 // const uint kernel_threads = device_param->kernel_threads;
2584
2585 uint kernel_threads = device_param->kernel_threads;
2586
2587 while (num_elements % kernel_threads) num_elements++;
2588
2589 cl_kernel kernel = device_param->kernel_amp;
2590
2591 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2592 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2593
2594 const size_t global_work_size[3] = { num_elements, 1, 1 };
2595 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2596
2597 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2598
2599 hc_clFlush (data.ocl, device_param->command_queue);
2600
2601 hc_clFinish (data.ocl, device_param->command_queue);
2602 }
2603
2604 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2605 {
2606 int rc = -1;
2607
2608 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2609 {
2610 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2611
2612 const cl_uchar zero = 0;
2613
2614 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2615 }
2616
2617 if (rc != 0)
2618 {
2619 // NOTE: clEnqueueFillBuffer () always fails with -59
2620 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2621 // How's that possible, OpenCL 1.2 support is advertised??
2622 // We need to workaround...
2623
2624 #define FILLSZ 0x100000
2625
2626 char *tmp = (char *) mymalloc (FILLSZ);
2627
2628 for (size_t i = 0; i < size; i += FILLSZ)
2629 {
2630 const size_t left = size - i;
2631
2632 const size_t fillsz = MIN (FILLSZ, left);
2633
2634 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2635 }
2636
2637 myfree (tmp);
2638 }
2639 }
2640
2641 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)
2642 {
2643 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2644 {
2645 if (attack_mode == ATTACK_MODE_BF)
2646 {
2647 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2648 {
2649 const uint size_tm = 32 * sizeof (bs_word_t);
2650
2651 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2652
2653 run_kernel_tm (device_param);
2654
2655 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);
2656 }
2657 }
2658
2659 if (highest_pw_len < 16)
2660 {
2661 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2662 }
2663 else if (highest_pw_len < 32)
2664 {
2665 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2666 }
2667 else
2668 {
2669 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2670 }
2671 }
2672 else
2673 {
2674 run_kernel_amp (device_param, pws_cnt);
2675
2676 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2677
2678 if (opts_type & OPTS_TYPE_HOOK12)
2679 {
2680 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2681 }
2682
2683 uint iter = salt_buf->salt_iter;
2684
2685 uint loop_step = device_param->kernel_loops;
2686
2687 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2688 {
2689 uint loop_left = iter - loop_pos;
2690
2691 loop_left = MIN (loop_left, loop_step);
2692
2693 device_param->kernel_params_buf32[25] = loop_pos;
2694 device_param->kernel_params_buf32[26] = loop_left;
2695
2696 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2697
2698 if (data.devices_status == STATUS_CRACKED) break;
2699 if (data.devices_status == STATUS_ABORTED) break;
2700 if (data.devices_status == STATUS_QUIT) break;
2701
2702 /**
2703 * speed
2704 */
2705
2706 const float iter_part = (float) (loop_pos + loop_left) / iter;
2707
2708 const u64 perf_sum_all = pws_cnt * iter_part;
2709
2710 double speed_ms;
2711
2712 hc_timer_get (device_param->timer_speed, speed_ms);
2713
2714 const u32 speed_pos = device_param->speed_pos;
2715
2716 device_param->speed_cnt[speed_pos] = perf_sum_all;
2717
2718 device_param->speed_ms[speed_pos] = speed_ms;
2719
2720 if (data.benchmark == 1)
2721 {
2722 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2723 }
2724 }
2725
2726 if (opts_type & OPTS_TYPE_HOOK23)
2727 {
2728 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2729
2730 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);
2731
2732 // do something with data
2733
2734 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);
2735 }
2736
2737 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2738 }
2739 }
2740
2741 static int run_rule_engine (const int rule_len, const char *rule_buf)
2742 {
2743 if (rule_len == 0)
2744 {
2745 return 0;
2746 }
2747 else if (rule_len == 1)
2748 {
2749 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2750 }
2751
2752 return 1;
2753 }
2754
2755 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2756 {
2757 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2758 {
2759 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);
2760 }
2761 else if (data.attack_kern == ATTACK_KERN_COMBI)
2762 {
2763 if (data.attack_mode == ATTACK_MODE_COMBI)
2764 {
2765 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2766 {
2767 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2768 {
2769 for (u32 i = 0; i < pws_cnt; i++)
2770 {
2771 const u32 pw_len = device_param->pws_buf[i].pw_len;
2772
2773 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2774
2775 ptr[pw_len] = 0x01;
2776 }
2777 }
2778 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2779 {
2780 for (u32 i = 0; i < pws_cnt; i++)
2781 {
2782 const u32 pw_len = device_param->pws_buf[i].pw_len;
2783
2784 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2785
2786 ptr[pw_len] = 0x80;
2787 }
2788 }
2789 }
2790 }
2791 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2792 {
2793 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2794 {
2795 for (u32 i = 0; i < pws_cnt; i++)
2796 {
2797 const u32 pw_len = device_param->pws_buf[i].pw_len;
2798
2799 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2800
2801 ptr[pw_len] = 0x01;
2802 }
2803 }
2804 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2805 {
2806 for (u32 i = 0; i < pws_cnt; i++)
2807 {
2808 const u32 pw_len = device_param->pws_buf[i].pw_len;
2809
2810 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2811
2812 ptr[pw_len] = 0x80;
2813 }
2814 }
2815 }
2816
2817 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);
2818 }
2819 else if (data.attack_kern == ATTACK_KERN_BF)
2820 {
2821 const u64 off = device_param->words_off;
2822
2823 device_param->kernel_params_mp_l_buf64[3] = off;
2824
2825 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2826 }
2827 }
2828
2829 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2830 {
2831 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2832
2833 device_param->kernel_params_buf32[25] = 0;
2834 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2835 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2836
2837 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2838 {
2839 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2840 }
2841 else
2842 {
2843 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2844 }
2845
2846 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2847
2848 return exec_ms_prev;
2849 }
2850
2851 static void autotune (hc_device_param_t *device_param)
2852 {
2853 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2854
2855 const u32 kernel_accel_min = device_param->kernel_accel_min;
2856 const u32 kernel_accel_max = device_param->kernel_accel_max;
2857
2858 const u32 kernel_loops_min = device_param->kernel_loops_min;
2859 const u32 kernel_loops_max = device_param->kernel_loops_max;
2860
2861 u32 kernel_accel = kernel_accel_min;
2862 u32 kernel_loops = kernel_loops_min;
2863
2864 // in this case the user specified a fixed -u and -n on the commandline
2865 // no way to tune anything
2866 // but we need to run a few caching rounds
2867
2868 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2869 {
2870 try_run (device_param, kernel_accel, kernel_loops);
2871 try_run (device_param, kernel_accel, kernel_loops);
2872 try_run (device_param, kernel_accel, kernel_loops);
2873 try_run (device_param, kernel_accel, kernel_loops);
2874
2875 device_param->kernel_accel = kernel_accel;
2876 device_param->kernel_loops = kernel_loops;
2877
2878 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2879
2880 device_param->kernel_power = kernel_power;
2881
2882 return;
2883 }
2884
2885 // from here it's clear we are allowed to autotune
2886 // so let's init some fake words
2887
2888 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2889
2890 for (u32 i = 0; i < kernel_power_max; i++)
2891 {
2892 device_param->pws_buf[i].i[0] = i;
2893 device_param->pws_buf[i].i[1] = 0x01234567;
2894 device_param->pws_buf[i].pw_len = 7;
2895 }
2896
2897 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);
2898
2899 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2900 {
2901 run_kernel_amp (device_param, kernel_power_max);
2902 }
2903
2904 #define VERIFIER_CNT 1
2905
2906 // first find out highest kernel-loops that stays below target_ms
2907
2908 if (kernel_loops_min < kernel_loops_max)
2909 {
2910 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2911 {
2912 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2913
2914 for (int i = 0; i < VERIFIER_CNT; i++)
2915 {
2916 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2917
2918 exec_ms = MIN (exec_ms, exec_ms_v);
2919 }
2920
2921 if (exec_ms < target_ms) break;
2922 }
2923 }
2924
2925 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2926
2927 #define STEPS_CNT 10
2928
2929 if (kernel_accel_min < kernel_accel_max)
2930 {
2931 for (int i = 0; i < STEPS_CNT; i++)
2932 {
2933 const u32 kernel_accel_try = 1 << i;
2934
2935 if (kernel_accel_try < kernel_accel_min) continue;
2936 if (kernel_accel_try > kernel_accel_max) break;
2937
2938 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2939
2940 for (int i = 0; i < VERIFIER_CNT; i++)
2941 {
2942 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2943
2944 exec_ms = MIN (exec_ms, exec_ms_v);
2945 }
2946
2947 if (exec_ms > target_ms) break;
2948
2949 kernel_accel = kernel_accel_try;
2950 }
2951 }
2952
2953 // at this point we want to know the actual runtime for the following reason:
2954 // we need a reference for the balancing loop following up, and this
2955 // the balancing loop can have an effect that the creates a new opportunity, for example:
2956 // if the target is 95 ms and the current runtime is 48ms the above loop
2957 // stopped the execution because the previous exec_ms was > 95ms
2958 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2959 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2960
2961 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2962
2963 for (int i = 0; i < VERIFIER_CNT; i++)
2964 {
2965 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2966
2967 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2968 }
2969
2970 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2971 {
2972 for (u32 f = 2; f < 1024; f++)
2973 {
2974 const u32 kernel_accel_try = kernel_accel * f;
2975 const u32 kernel_loops_try = kernel_loops / f;
2976
2977 if (kernel_accel_try > kernel_accel_max) break;
2978 if (kernel_loops_try < kernel_loops_min) break;
2979
2980 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2981
2982 for (int i = 0; i < VERIFIER_CNT; i++)
2983 {
2984 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2985
2986 exec_ms = MIN (exec_ms, exec_ms_v);
2987 }
2988
2989 if (exec_ms < exec_ms_pre_final)
2990 {
2991 exec_ms_pre_final = exec_ms;
2992
2993 kernel_accel = kernel_accel_try;
2994 kernel_loops = kernel_loops_try;
2995 }
2996 }
2997 }
2998
2999 const double exec_left = target_ms / exec_ms_pre_final;
3000
3001 const double accel_left = kernel_accel_max / kernel_accel;
3002
3003 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3004
3005 if (exec_accel_min >= 1.0)
3006 {
3007 // this is safe to not overflow kernel_accel_max because of accel_left
3008
3009 kernel_accel = (double) kernel_accel * exec_accel_min;
3010 }
3011
3012 // reset them fake words
3013
3014 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3015
3016 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);
3017 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);
3018
3019 // reset timer
3020
3021 device_param->exec_pos = 0;
3022
3023 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3024
3025 // store
3026
3027 device_param->kernel_accel = kernel_accel;
3028 device_param->kernel_loops = kernel_loops;
3029
3030 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3031
3032 device_param->kernel_power = kernel_power;
3033
3034 #ifdef DEBUG
3035
3036 if (data.quiet == 0)
3037 {
3038 clear_prompt ();
3039
3040 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3041 "Device #%u: autotuned kernel-loops to %u\n",
3042 device_param->device_id + 1, kernel_accel,
3043 device_param->device_id + 1, kernel_loops);
3044
3045 fprintf (stdout, "%s", PROMPT);
3046
3047 fflush (stdout);
3048 }
3049
3050 #endif
3051 }
3052
3053 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3054 {
3055 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3056
3057 // init speed timer
3058
3059 uint speed_pos = device_param->speed_pos;
3060
3061 #ifdef _POSIX
3062 if (device_param->timer_speed.tv_sec == 0)
3063 {
3064 hc_timer_set (&device_param->timer_speed);
3065 }
3066 #endif
3067
3068 #ifdef _WIN
3069 if (device_param->timer_speed.QuadPart == 0)
3070 {
3071 hc_timer_set (&device_param->timer_speed);
3072 }
3073 #endif
3074
3075 // find higest password length, this is for optimization stuff
3076
3077 uint highest_pw_len = 0;
3078
3079 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3080 {
3081 }
3082 else if (data.attack_kern == ATTACK_KERN_COMBI)
3083 {
3084 }
3085 else if (data.attack_kern == ATTACK_KERN_BF)
3086 {
3087 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3088 + device_param->kernel_params_mp_l_buf32[5];
3089 }
3090
3091 // iteration type
3092
3093 uint innerloop_step = 0;
3094 uint innerloop_cnt = 0;
3095
3096 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3097 else innerloop_step = 1;
3098
3099 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3100 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3101 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3102
3103 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3104
3105 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3106 {
3107 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3108
3109 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3110
3111 if (data.devices_status == STATUS_CRACKED) break;
3112 if (data.devices_status == STATUS_ABORTED) break;
3113 if (data.devices_status == STATUS_QUIT) break;
3114 if (data.devices_status == STATUS_BYPASS) break;
3115
3116 salt_t *salt_buf = &data.salts_buf[salt_pos];
3117
3118 device_param->kernel_params_buf32[24] = salt_pos;
3119 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3120 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3121
3122 FILE *combs_fp = device_param->combs_fp;
3123
3124 if (data.attack_mode == ATTACK_MODE_COMBI)
3125 {
3126 rewind (combs_fp);
3127 }
3128
3129 // innerloops
3130
3131 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3132 {
3133 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3134
3135 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3136
3137 if (data.devices_status == STATUS_CRACKED) break;
3138 if (data.devices_status == STATUS_ABORTED) break;
3139 if (data.devices_status == STATUS_QUIT) break;
3140 if (data.devices_status == STATUS_BYPASS) break;
3141
3142 uint innerloop_left = innerloop_cnt - innerloop_pos;
3143
3144 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3145
3146 device_param->innerloop_pos = innerloop_pos;
3147 device_param->innerloop_left = innerloop_left;
3148
3149 device_param->kernel_params_buf32[27] = innerloop_left;
3150
3151 // i think we can get rid of this
3152 if (innerloop_left == 0)
3153 {
3154 puts ("bug, how should this happen????\n");
3155
3156 continue;
3157 }
3158
3159 if (data.salts_shown[salt_pos] == 1)
3160 {
3161 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3162
3163 continue;
3164 }
3165
3166 // initialize amplifiers
3167
3168 if (data.attack_mode == ATTACK_MODE_COMBI)
3169 {
3170 uint i = 0;
3171
3172 while (i < innerloop_left)
3173 {
3174 if (feof (combs_fp)) break;
3175
3176 int line_len = fgetl (combs_fp, line_buf);
3177
3178 if (line_len >= PW_MAX1) continue;
3179
3180 line_len = convert_from_hex (line_buf, line_len);
3181
3182 char *line_buf_new = line_buf;
3183
3184 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3185 {
3186 char rule_buf_out[BLOCK_SIZE] = { 0 };
3187
3188 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3189
3190 if (rule_len_out < 0)
3191 {
3192 data.words_progress_rejected[salt_pos] += pws_cnt;
3193
3194 continue;
3195 }
3196
3197 line_len = rule_len_out;
3198
3199 line_buf_new = rule_buf_out;
3200 }
3201
3202 line_len = MIN (line_len, PW_DICTMAX);
3203
3204 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3205
3206 memcpy (ptr, line_buf_new, line_len);
3207
3208 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3209
3210 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3211 {
3212 uppercase (ptr, line_len);
3213 }
3214
3215 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3216 {
3217 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3218 {
3219 ptr[line_len] = 0x80;
3220 }
3221
3222 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3223 {
3224 ptr[line_len] = 0x01;
3225 }
3226 }
3227
3228 device_param->combs_buf[i].pw_len = line_len;
3229
3230 i++;
3231 }
3232
3233 for (uint j = i; j < innerloop_left; j++)
3234 {
3235 device_param->combs_buf[j].i[0] = 0;
3236 device_param->combs_buf[j].i[1] = 0;
3237 device_param->combs_buf[j].i[2] = 0;
3238 device_param->combs_buf[j].i[3] = 0;
3239 device_param->combs_buf[j].i[4] = 0;
3240 device_param->combs_buf[j].i[5] = 0;
3241 device_param->combs_buf[j].i[6] = 0;
3242 device_param->combs_buf[j].i[7] = 0;
3243
3244 device_param->combs_buf[j].pw_len = 0;
3245 }
3246
3247 innerloop_left = i;
3248 }
3249 else if (data.attack_mode == ATTACK_MODE_BF)
3250 {
3251 u64 off = innerloop_pos;
3252
3253 device_param->kernel_params_mp_r_buf64[3] = off;
3254
3255 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3256 }
3257 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3258 {
3259 u64 off = innerloop_pos;
3260
3261 device_param->kernel_params_mp_buf64[3] = off;
3262
3263 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3264 }
3265 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3266 {
3267 u64 off = innerloop_pos;
3268
3269 device_param->kernel_params_mp_buf64[3] = off;
3270
3271 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3272 }
3273
3274 // copy amplifiers
3275
3276 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3277 {
3278 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);
3279 }
3280 else if (data.attack_mode == ATTACK_MODE_COMBI)
3281 {
3282 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);
3283 }
3284 else if (data.attack_mode == ATTACK_MODE_BF)
3285 {
3286 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);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3289 {
3290 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);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3293 {
3294 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);
3295 }
3296
3297 if (data.benchmark == 1)
3298 {
3299 hc_timer_set (&device_param->timer_speed);
3300 }
3301
3302 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3303
3304 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3305
3306 if (data.devices_status == STATUS_CRACKED) break;
3307 if (data.devices_status == STATUS_ABORTED) break;
3308 if (data.devices_status == STATUS_QUIT) break;
3309
3310 /**
3311 * result
3312 */
3313
3314 hc_thread_mutex_lock (mux_display);
3315
3316 check_cracked (device_param, salt_pos);
3317
3318 hc_thread_mutex_unlock (mux_display);
3319
3320 /**
3321 * progress
3322 */
3323
3324 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3325
3326 hc_thread_mutex_lock (mux_counter);
3327
3328 data.words_progress_done[salt_pos] += perf_sum_all;
3329
3330 hc_thread_mutex_unlock (mux_counter);
3331
3332 /**
3333 * speed
3334 */
3335
3336 double speed_ms;
3337
3338 hc_timer_get (device_param->timer_speed, speed_ms);
3339
3340 hc_timer_set (&device_param->timer_speed);
3341
3342 hc_thread_mutex_lock (mux_display);
3343
3344 // current speed
3345
3346 device_param->speed_cnt[speed_pos] = perf_sum_all;
3347
3348 device_param->speed_ms[speed_pos] = speed_ms;
3349
3350 hc_thread_mutex_unlock (mux_display);
3351
3352 speed_pos++;
3353
3354 if (speed_pos == SPEED_CACHE)
3355 {
3356 speed_pos = 0;
3357 }
3358
3359 /**
3360 * benchmark
3361 */
3362
3363 if (data.benchmark == 1) break;
3364 }
3365 }
3366
3367 device_param->speed_pos = speed_pos;
3368
3369 myfree (line_buf);
3370 }
3371
3372 static void load_segment (wl_data_t *wl_data, FILE *fd)
3373 {
3374 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3375
3376 wl_data->pos = 0;
3377
3378 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3379
3380 wl_data->buf[wl_data->cnt] = 0;
3381
3382 if (wl_data->cnt == 0) return;
3383
3384 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3385
3386 while (!feof (fd))
3387 {
3388 if (wl_data->cnt == wl_data->avail)
3389 {
3390 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3391
3392 wl_data->avail += wl_data->incr;
3393 }
3394
3395 const int c = fgetc (fd);
3396
3397 if (c == EOF) break;
3398
3399 wl_data->buf[wl_data->cnt] = (char) c;
3400
3401 wl_data->cnt++;
3402
3403 if (c == '\n') break;
3404 }
3405
3406 // ensure stream ends with a newline
3407
3408 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3409 {
3410 wl_data->cnt++;
3411
3412 wl_data->buf[wl_data->cnt - 1] = '\n';
3413 }
3414
3415 return;
3416 }
3417
3418 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3419 {
3420 char *ptr = buf;
3421
3422 for (u32 i = 0; i < sz; i++, ptr++)
3423 {
3424 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3425
3426 if (i == 7)
3427 {
3428 *off = i;
3429 *len = i;
3430
3431 return;
3432 }
3433
3434 if (*ptr != '\n') continue;
3435
3436 *off = i + 1;
3437
3438 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3439
3440 *len = i;
3441
3442 return;
3443 }
3444
3445 *off = sz;
3446 *len = sz;
3447 }
3448
3449 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3450 {
3451 char *ptr = buf;
3452
3453 for (u32 i = 0; i < sz; i++, ptr++)
3454 {
3455 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3456
3457 if (*ptr != '\n') continue;
3458
3459 *off = i + 1;
3460
3461 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3462
3463 *len = i;
3464
3465 return;
3466 }
3467
3468 *off = sz;
3469 *len = sz;
3470 }
3471
3472 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3473 {
3474 char *ptr = buf;
3475
3476 for (u32 i = 0; i < sz; i++, ptr++)
3477 {
3478 if (*ptr != '\n') continue;
3479
3480 *off = i + 1;
3481
3482 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3483
3484 *len = i;
3485
3486 return;
3487 }
3488
3489 *off = sz;
3490 *len = sz;
3491 }
3492
3493 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3494 {
3495 while (wl_data->pos < wl_data->cnt)
3496 {
3497 uint off;
3498 uint len;
3499
3500 char *ptr = wl_data->buf + wl_data->pos;
3501
3502 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3503
3504 wl_data->pos += off;
3505
3506 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3507 {
3508 char rule_buf_out[BLOCK_SIZE] = { 0 };
3509
3510 int rule_len_out = -1;
3511
3512 if (len < BLOCK_SIZE)
3513 {
3514 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3515 }
3516
3517 if (rule_len_out < 0)
3518 {
3519 continue;
3520 }
3521
3522 if (rule_len_out > PW_MAX)
3523 {
3524 continue;
3525 }
3526 }
3527 else
3528 {
3529 if (len > PW_MAX)
3530 {
3531 continue;
3532 }
3533 }
3534
3535 *out_buf = ptr;
3536 *out_len = len;
3537
3538 return;
3539 }
3540
3541 if (feof (fd))
3542 {
3543 fprintf (stderr, "BUG feof()!!\n");
3544
3545 return;
3546 }
3547
3548 load_segment (wl_data, fd);
3549
3550 get_next_word (wl_data, fd, out_buf, out_len);
3551 }
3552
3553 #ifdef _POSIX
3554 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3555 #endif
3556
3557 #ifdef _WIN
3558 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3559 #endif
3560 {
3561 hc_signal (NULL);
3562
3563 dictstat_t d;
3564
3565 d.cnt = 0;
3566
3567 #ifdef _POSIX
3568 fstat (fileno (fd), &d.stat);
3569 #endif
3570
3571 #ifdef _WIN
3572 _fstat64 (fileno (fd), &d.stat);
3573 #endif
3574
3575 d.stat.st_mode = 0;
3576 d.stat.st_nlink = 0;
3577 d.stat.st_uid = 0;
3578 d.stat.st_gid = 0;
3579 d.stat.st_rdev = 0;
3580 d.stat.st_atime = 0;
3581
3582 #ifdef _POSIX
3583 d.stat.st_blksize = 0;
3584 d.stat.st_blocks = 0;
3585 #endif
3586
3587 if (d.stat.st_size == 0) return 0;
3588
3589 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3590
3591 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3592 {
3593 if (d_cache)
3594 {
3595 u64 cnt = d_cache->cnt;
3596
3597 u64 keyspace = cnt;
3598
3599 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3600 {
3601 keyspace *= data.kernel_rules_cnt;
3602 }
3603 else if (data.attack_kern == ATTACK_KERN_COMBI)
3604 {
3605 keyspace *= data.combs_cnt;
3606 }
3607
3608 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);
3609 if (data.quiet == 0) log_info ("");
3610
3611 hc_signal (sigHandler_default);
3612
3613 return (keyspace);
3614 }
3615 }
3616
3617 time_t now = 0;
3618 time_t prev = 0;
3619
3620 u64 comp = 0;
3621 u64 cnt = 0;
3622 u64 cnt2 = 0;
3623
3624 while (!feof (fd))
3625 {
3626 load_segment (wl_data, fd);
3627
3628 comp += wl_data->cnt;
3629
3630 u32 i = 0;
3631
3632 while (i < wl_data->cnt)
3633 {
3634 u32 len;
3635 u32 off;
3636
3637 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3638
3639 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3640 {
3641 char rule_buf_out[BLOCK_SIZE] = { 0 };
3642
3643 int rule_len_out = -1;
3644
3645 if (len < BLOCK_SIZE)
3646 {
3647 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3648 }
3649
3650 if (rule_len_out < 0)
3651 {
3652 len = PW_MAX1;
3653 }
3654 else
3655 {
3656 len = rule_len_out;
3657 }
3658 }
3659
3660 if (len < PW_MAX1)
3661 {
3662 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3663 {
3664 cnt += data.kernel_rules_cnt;
3665 }
3666 else if (data.attack_kern == ATTACK_KERN_COMBI)
3667 {
3668 cnt += data.combs_cnt;
3669 }
3670
3671 d.cnt++;
3672 }
3673
3674 i += off;
3675
3676 cnt2++;
3677 }
3678
3679 time (&now);
3680
3681 if ((now - prev) == 0) continue;
3682
3683 float percent = (float) comp / (float) d.stat.st_size;
3684
3685 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);
3686
3687 time (&prev);
3688 }
3689
3690 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);
3691 if (data.quiet == 0) log_info ("");
3692
3693 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3694
3695 hc_signal (sigHandler_default);
3696
3697 return (cnt);
3698 }
3699
3700 static void *thread_monitor (void *p)
3701 {
3702 uint runtime_check = 0;
3703 uint remove_check = 0;
3704 uint status_check = 0;
3705 uint restore_check = 0;
3706
3707 uint restore_left = data.restore_timer;
3708 uint remove_left = data.remove_timer;
3709 uint status_left = data.status_timer;
3710
3711 #ifdef HAVE_HWMON
3712 uint hwmon_check = 0;
3713
3714 // these variables are mainly used for fan control (AMD only)
3715
3716 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3717
3718 // temperature controller "loopback" values
3719
3720 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3721 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3722
3723 #ifdef HAVE_ADL
3724 int temp_threshold = 1; // degrees celcius
3725
3726 int fan_speed_min = 15; // in percentage
3727 int fan_speed_max = 100;
3728 #endif // HAVE_ADL
3729
3730 time_t last_temp_check_time;
3731 #endif // HAVE_HWMON
3732
3733 uint sleep_time = 1;
3734
3735 if (data.runtime)
3736 {
3737 runtime_check = 1;
3738 }
3739
3740 if (data.restore_timer)
3741 {
3742 restore_check = 1;
3743 }
3744
3745 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3746 {
3747 remove_check = 1;
3748 }
3749
3750 if (data.status == 1)
3751 {
3752 status_check = 1;
3753 }
3754
3755 #ifdef HAVE_HWMON
3756 if (data.gpu_temp_disable == 0)
3757 {
3758 time (&last_temp_check_time);
3759
3760 hwmon_check = 1;
3761 }
3762 #endif
3763
3764 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3765 {
3766 #ifdef HAVE_HWMON
3767 if (hwmon_check == 0)
3768 #endif
3769 return (p);
3770 }
3771
3772 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3773 {
3774 hc_sleep (sleep_time);
3775
3776 if (data.devices_status != STATUS_RUNNING) continue;
3777
3778 #ifdef HAVE_HWMON
3779 if (hwmon_check == 1)
3780 {
3781 hc_thread_mutex_lock (mux_adl);
3782
3783 time_t temp_check_time;
3784
3785 time (&temp_check_time);
3786
3787 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3788
3789 if (Ta == 0) Ta = 1;
3790
3791 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3792 {
3793 hc_device_param_t *device_param = &data.devices_param[device_id];
3794
3795 if (device_param->skipped) continue;
3796
3797 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3798
3799 const int temperature = hm_get_temperature_with_device_id (device_id);
3800
3801 if (temperature > (int) data.gpu_temp_abort)
3802 {
3803 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3804
3805 if (data.devices_status != STATUS_QUIT) myabort ();
3806
3807 break;
3808 }
3809
3810 #ifdef HAVE_ADL
3811 const int gpu_temp_retain = data.gpu_temp_retain;
3812
3813 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3814 {
3815 if (data.hm_device[device_id].fan_supported == 1)
3816 {
3817 int temp_cur = temperature;
3818
3819 int temp_diff_new = gpu_temp_retain - temp_cur;
3820
3821 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3822
3823 // calculate Ta value (time difference in seconds between the last check and this check)
3824
3825 last_temp_check_time = temp_check_time;
3826
3827 float Kp = 1.8;
3828 float Ki = 0.005;
3829 float Kd = 6;
3830
3831 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3832
3833 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);
3834
3835 if (abs (fan_diff_required) >= temp_threshold)
3836 {
3837 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3838
3839 int fan_speed_level = fan_speed_cur;
3840
3841 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3842
3843 int fan_speed_new = fan_speed_level - fan_diff_required;
3844
3845 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3846 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3847
3848 if (fan_speed_new != fan_speed_cur)
3849 {
3850 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3851 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3852
3853 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3854 {
3855 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3856
3857 fan_speed_chgd[device_id] = 1;
3858 }
3859
3860 temp_diff_old[device_id] = temp_diff_new;
3861 }
3862 }
3863 }
3864 }
3865 #endif // HAVE_ADL
3866 }
3867
3868 hc_thread_mutex_unlock (mux_adl);
3869 }
3870 #endif // HAVE_HWMON
3871
3872 if (restore_check == 1)
3873 {
3874 restore_left--;
3875
3876 if (restore_left == 0)
3877 {
3878 if (data.restore_disable == 0) cycle_restore ();
3879
3880 restore_left = data.restore_timer;
3881 }
3882 }
3883
3884 if ((runtime_check == 1) && (data.runtime_start > 0))
3885 {
3886 time_t runtime_cur;
3887
3888 time (&runtime_cur);
3889
3890 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3891
3892 if (runtime_left <= 0)
3893 {
3894 if (data.benchmark == 0)
3895 {
3896 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3897 }
3898
3899 if (data.devices_status != STATUS_QUIT) myabort ();
3900 }
3901 }
3902
3903 if (remove_check == 1)
3904 {
3905 remove_left--;
3906
3907 if (remove_left == 0)
3908 {
3909 if (data.digests_saved != data.digests_done)
3910 {
3911 data.digests_saved = data.digests_done;
3912
3913 save_hash ();
3914 }
3915
3916 remove_left = data.remove_timer;
3917 }
3918 }
3919
3920 if (status_check == 1)
3921 {
3922 status_left--;
3923
3924 if (status_left == 0)
3925 {
3926 hc_thread_mutex_lock (mux_display);
3927
3928 if (data.quiet == 0) clear_prompt ();
3929
3930 if (data.quiet == 0) log_info ("");
3931
3932 status_display ();
3933
3934 if (data.quiet == 0) log_info ("");
3935
3936 hc_thread_mutex_unlock (mux_display);
3937
3938 status_left = data.status_timer;
3939 }
3940 }
3941 }
3942
3943 #ifdef HAVE_HWMON
3944 myfree (fan_speed_chgd);
3945
3946 myfree (temp_diff_old);
3947 myfree (temp_diff_sum);
3948 #endif
3949
3950 p = NULL;
3951
3952 return (p);
3953 }
3954
3955 static void *thread_outfile_remove (void *p)
3956 {
3957 // some hash-dependent constants
3958 char *outfile_dir = data.outfile_check_directory;
3959 uint dgst_size = data.dgst_size;
3960 uint isSalted = data.isSalted;
3961 uint esalt_size = data.esalt_size;
3962 uint hash_mode = data.hash_mode;
3963
3964 uint outfile_check_timer = data.outfile_check_timer;
3965
3966 char separator = data.separator;
3967
3968 // some hash-dependent functions
3969 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3970 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3971
3972 // buffers
3973 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3974
3975 hash_buf.digest = mymalloc (dgst_size);
3976
3977 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3978
3979 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3980
3981 uint digest_buf[64] = { 0 };
3982
3983 outfile_data_t *out_info = NULL;
3984
3985 char **out_files = NULL;
3986
3987 time_t folder_mtime = 0;
3988
3989 int out_cnt = 0;
3990
3991 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3992
3993 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3994 {
3995 hc_sleep (1);
3996
3997 if (data.devices_status != STATUS_RUNNING) continue;
3998
3999 check_left--;
4000
4001 if (check_left == 0)
4002 {
4003 struct stat outfile_check_stat;
4004
4005 if (stat (outfile_dir, &outfile_check_stat) == 0)
4006 {
4007 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4008
4009 if (is_dir == 1)
4010 {
4011 if (outfile_check_stat.st_mtime > folder_mtime)
4012 {
4013 char **out_files_new = scan_directory (outfile_dir);
4014
4015 int out_cnt_new = count_dictionaries (out_files_new);
4016
4017 outfile_data_t *out_info_new = NULL;
4018
4019 if (out_cnt_new > 0)
4020 {
4021 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4022
4023 for (int i = 0; i < out_cnt_new; i++)
4024 {
4025 out_info_new[i].file_name = out_files_new[i];
4026
4027 // check if there are files that we have seen/checked before (and not changed)
4028
4029 for (int j = 0; j < out_cnt; j++)
4030 {
4031 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4032 {
4033 struct stat outfile_stat;
4034
4035 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4036 {
4037 if (outfile_stat.st_ctime == out_info[j].ctime)
4038 {
4039 out_info_new[i].ctime = out_info[j].ctime;
4040 out_info_new[i].seek = out_info[j].seek;
4041 }
4042 }
4043 }
4044 }
4045 }
4046 }
4047
4048 local_free (out_info);
4049 local_free (out_files);
4050
4051 out_files = out_files_new;
4052 out_cnt = out_cnt_new;
4053 out_info = out_info_new;
4054
4055 folder_mtime = outfile_check_stat.st_mtime;
4056 }
4057
4058 for (int j = 0; j < out_cnt; j++)
4059 {
4060 FILE *fp = fopen (out_info[j].file_name, "rb");
4061
4062 if (fp != NULL)
4063 {
4064 //hc_thread_mutex_lock (mux_display);
4065
4066 #ifdef _POSIX
4067 struct stat outfile_stat;
4068
4069 fstat (fileno (fp), &outfile_stat);
4070 #endif
4071
4072 #ifdef _WIN
4073 struct stat64 outfile_stat;
4074
4075 _fstat64 (fileno (fp), &outfile_stat);
4076 #endif
4077
4078 if (outfile_stat.st_ctime > out_info[j].ctime)
4079 {
4080 out_info[j].ctime = outfile_stat.st_ctime;
4081 out_info[j].seek = 0;
4082 }
4083
4084 fseek (fp, out_info[j].seek, SEEK_SET);
4085
4086 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4087
4088 while (!feof (fp))
4089 {
4090 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4091
4092 if (ptr == NULL) break;
4093
4094 int line_len = strlen (line_buf);
4095
4096 if (line_len <= 0) continue;
4097
4098 int iter = MAX_CUT_TRIES;
4099
4100 for (uint i = line_len - 1; i && iter; i--, line_len--)
4101 {
4102 if (line_buf[i] != separator) continue;
4103
4104 int parser_status = PARSER_OK;
4105
4106 if ((hash_mode != 2500) && (hash_mode != 6800))
4107 {
4108 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4109 }
4110
4111 uint found = 0;
4112
4113 if (parser_status == PARSER_OK)
4114 {
4115 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4116 {
4117 if (data.salts_shown[salt_pos] == 1) continue;
4118
4119 salt_t *salt_buf = &data.salts_buf[salt_pos];
4120
4121 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4122 {
4123 uint idx = salt_buf->digests_offset + digest_pos;
4124
4125 if (data.digests_shown[idx] == 1) continue;
4126
4127 uint cracked = 0;
4128
4129 if (hash_mode == 6800)
4130 {
4131 if (i == salt_buf->salt_len)
4132 {
4133 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4134 }
4135 }
4136 else if (hash_mode == 2500)
4137 {
4138 // BSSID : MAC1 : MAC2 (:plain)
4139 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4140 {
4141 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4142
4143 if (!cracked) continue;
4144
4145 // now compare MAC1 and MAC2 too, since we have this additional info
4146 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4147 char *mac2_pos = mac1_pos + 12 + 1;
4148
4149 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4150 wpa_t *wpa = &wpas[salt_pos];
4151
4152 // compare hex string(s) vs binary MAC address(es)
4153
4154 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4155 {
4156 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4157 {
4158 cracked = 0;
4159
4160 break;
4161 }
4162 }
4163
4164 // early skip ;)
4165 if (!cracked) continue;
4166
4167 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4168 {
4169 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4170 {
4171 cracked = 0;
4172
4173 break;
4174 }
4175 }
4176 }
4177 }
4178 else
4179 {
4180 char *digests_buf_ptr = (char *) data.digests_buf;
4181
4182 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4183
4184 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4185 }
4186
4187 if (cracked == 1)
4188 {
4189 found = 1;
4190
4191 data.digests_shown[idx] = 1;
4192
4193 data.digests_done++;
4194
4195 salt_buf->digests_done++;
4196
4197 if (salt_buf->digests_done == salt_buf->digests_cnt)
4198 {
4199 data.salts_shown[salt_pos] = 1;
4200
4201 data.salts_done++;
4202
4203 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4204 }
4205 }
4206 }
4207
4208 if (data.devices_status == STATUS_CRACKED) break;
4209 }
4210 }
4211
4212 if (found) break;
4213
4214 if (data.devices_status == STATUS_CRACKED) break;
4215
4216 iter--;
4217 }
4218
4219 if (data.devices_status == STATUS_CRACKED) break;
4220 }
4221
4222 myfree (line_buf);
4223
4224 out_info[j].seek = ftell (fp);
4225
4226 //hc_thread_mutex_unlock (mux_display);
4227
4228 fclose (fp);
4229 }
4230 }
4231 }
4232 }
4233
4234 check_left = outfile_check_timer;
4235 }
4236 }
4237
4238 if (esalt_size) local_free (hash_buf.esalt);
4239
4240 if (isSalted) local_free (hash_buf.salt);
4241
4242 local_free (hash_buf.digest);
4243
4244 local_free (out_info);
4245
4246 local_free (out_files);
4247
4248 p = NULL;
4249
4250 return (p);
4251 }
4252
4253 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4254 {
4255 if (device_param->pws_cnt < device_param->kernel_power)
4256 {
4257 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4258
4259 u8 *ptr = (u8 *) pw->i;
4260
4261 memcpy (ptr, pw_buf, pw_len);
4262
4263 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4264
4265 pw->pw_len = pw_len;
4266
4267 device_param->pws_cnt++;
4268 }
4269 else
4270 {
4271 fprintf (stderr, "BUG pw_add()!!\n");
4272
4273 return;
4274 }
4275 }
4276
4277 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4278 {
4279 hc_thread_mutex_lock (mux_dispatcher);
4280
4281 const u64 words_cur = data.words_cur;
4282 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4283
4284 device_param->words_off = words_cur;
4285
4286 const u64 words_left = words_base - words_cur;
4287
4288 if (allow_div)
4289 {
4290 if (data.kernel_power_all > words_left)
4291 {
4292 if (data.kernel_power_div == 0)
4293 {
4294 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4295 }
4296 }
4297
4298 if (data.kernel_power_div)
4299 {
4300 if (device_param->kernel_power == device_param->kernel_power_user)
4301 {
4302 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4303
4304 if (kernel_power_new < device_param->kernel_power)
4305 {
4306 device_param->kernel_power = kernel_power_new;
4307 }
4308 }
4309 }
4310 }
4311
4312 const uint kernel_power = device_param->kernel_power;
4313
4314 uint work = MIN (words_left, kernel_power);
4315
4316 work = MIN (work, max);
4317
4318 data.words_cur += work;
4319
4320 hc_thread_mutex_unlock (mux_dispatcher);
4321
4322 return work;
4323 }
4324
4325 static void *thread_calc_stdin (void *p)
4326 {
4327 hc_device_param_t *device_param = (hc_device_param_t *) p;
4328
4329 if (device_param->skipped) return NULL;
4330
4331 autotune (device_param);
4332
4333 char *buf = (char *) mymalloc (HCBUFSIZ);
4334
4335 const uint attack_kern = data.attack_kern;
4336
4337 const uint kernel_power = device_param->kernel_power;
4338
4339 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4340 {
4341 hc_thread_mutex_lock (mux_dispatcher);
4342
4343 if (feof (stdin) != 0)
4344 {
4345 hc_thread_mutex_unlock (mux_dispatcher);
4346
4347 break;
4348 }
4349
4350 uint words_cur = 0;
4351
4352 while (words_cur < kernel_power)
4353 {
4354 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4355
4356 if (line_buf == NULL) break;
4357
4358 uint line_len = in_superchop (line_buf);
4359
4360 line_len = convert_from_hex (line_buf, line_len);
4361
4362 // post-process rule engine
4363
4364 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4365 {
4366 char rule_buf_out[BLOCK_SIZE] = { 0 };
4367
4368 int rule_len_out = -1;
4369
4370 if (line_len < BLOCK_SIZE)
4371 {
4372 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4373 }
4374
4375 if (rule_len_out < 0) continue;
4376
4377 line_buf = rule_buf_out;
4378 line_len = rule_len_out;
4379 }
4380
4381 if (line_len > PW_MAX)
4382 {
4383 continue;
4384 }
4385
4386 if (attack_kern == ATTACK_KERN_STRAIGHT)
4387 {
4388 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4389 {
4390 hc_thread_mutex_lock (mux_counter);
4391
4392 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4393 {
4394 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4395 }
4396
4397 hc_thread_mutex_unlock (mux_counter);
4398
4399 continue;
4400 }
4401 }
4402 else if (attack_kern == ATTACK_KERN_COMBI)
4403 {
4404 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4405 // since we still need to combine the plains
4406
4407 if (line_len > data.pw_max)
4408 {
4409 hc_thread_mutex_lock (mux_counter);
4410
4411 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4412 {
4413 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4414 }
4415
4416 hc_thread_mutex_unlock (mux_counter);
4417
4418 continue;
4419 }
4420 }
4421
4422 pw_add (device_param, (u8 *) line_buf, line_len);
4423
4424 words_cur++;
4425
4426 if (data.devices_status == STATUS_CRACKED) break;
4427 if (data.devices_status == STATUS_ABORTED) break;
4428 if (data.devices_status == STATUS_QUIT) break;
4429 if (data.devices_status == STATUS_BYPASS) break;
4430 }
4431
4432 hc_thread_mutex_unlock (mux_dispatcher);
4433
4434 if (data.devices_status == STATUS_CRACKED) break;
4435 if (data.devices_status == STATUS_ABORTED) break;
4436 if (data.devices_status == STATUS_QUIT) break;
4437 if (data.devices_status == STATUS_BYPASS) break;
4438
4439 // flush
4440
4441 const uint pws_cnt = device_param->pws_cnt;
4442
4443 if (pws_cnt)
4444 {
4445 run_copy (device_param, pws_cnt);
4446
4447 run_cracker (device_param, pws_cnt);
4448
4449 device_param->pws_cnt = 0;
4450
4451 /*
4452 still required?
4453 if (attack_kern == ATTACK_KERN_STRAIGHT)
4454 {
4455 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4456 }
4457 else if (attack_kern == ATTACK_KERN_COMBI)
4458 {
4459 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4460 }
4461 */
4462 }
4463 }
4464
4465 device_param->kernel_accel = 0;
4466 device_param->kernel_loops = 0;
4467
4468 myfree (buf);
4469
4470 return NULL;
4471 }
4472
4473 static void *thread_calc (void *p)
4474 {
4475 hc_device_param_t *device_param = (hc_device_param_t *) p;
4476
4477 if (device_param->skipped) return NULL;
4478
4479 autotune (device_param);
4480
4481 const uint attack_mode = data.attack_mode;
4482 const uint attack_kern = data.attack_kern;
4483
4484 if (attack_mode == ATTACK_MODE_BF)
4485 {
4486 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4487 {
4488 const uint work = get_work (device_param, -1, true);
4489
4490 if (work == 0) break;
4491
4492 const u64 words_off = device_param->words_off;
4493 const u64 words_fin = words_off + work;
4494
4495 const uint pws_cnt = work;
4496
4497 device_param->pws_cnt = pws_cnt;
4498
4499 if (pws_cnt)
4500 {
4501 run_copy (device_param, pws_cnt);
4502
4503 run_cracker (device_param, pws_cnt);
4504
4505 device_param->pws_cnt = 0;
4506
4507 /*
4508 still required?
4509 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4510 */
4511 }
4512
4513 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4514
4515 if (data.devices_status == STATUS_CRACKED) break;
4516 if (data.devices_status == STATUS_ABORTED) break;
4517 if (data.devices_status == STATUS_QUIT) break;
4518 if (data.devices_status == STATUS_BYPASS) break;
4519
4520 if (data.benchmark == 1) break;
4521
4522 device_param->words_done = words_fin;
4523 }
4524 }
4525 else
4526 {
4527 const uint segment_size = data.segment_size;
4528
4529 char *dictfile = data.dictfile;
4530
4531 if (attack_mode == ATTACK_MODE_COMBI)
4532 {
4533 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4534 {
4535 dictfile = data.dictfile2;
4536 }
4537 }
4538
4539 FILE *fd = fopen (dictfile, "rb");
4540
4541 if (fd == NULL)
4542 {
4543 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4544
4545 return NULL;
4546 }
4547
4548 if (attack_mode == ATTACK_MODE_COMBI)
4549 {
4550 const uint combs_mode = data.combs_mode;
4551
4552 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4553 {
4554 const char *dictfilec = data.dictfile2;
4555
4556 FILE *combs_fp = fopen (dictfilec, "rb");
4557
4558 if (combs_fp == NULL)
4559 {
4560 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4561
4562 fclose (fd);
4563
4564 return NULL;
4565 }
4566
4567 device_param->combs_fp = combs_fp;
4568 }
4569 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4570 {
4571 const char *dictfilec = data.dictfile;
4572
4573 FILE *combs_fp = fopen (dictfilec, "rb");
4574
4575 if (combs_fp == NULL)
4576 {
4577 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4578
4579 fclose (fd);
4580
4581 return NULL;
4582 }
4583
4584 device_param->combs_fp = combs_fp;
4585 }
4586 }
4587
4588 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4589
4590 wl_data->buf = (char *) mymalloc (segment_size);
4591 wl_data->avail = segment_size;
4592 wl_data->incr = segment_size;
4593 wl_data->cnt = 0;
4594 wl_data->pos = 0;
4595
4596 u64 words_cur = 0;
4597
4598 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4599 {
4600 u64 words_off = 0;
4601 u64 words_fin = 0;
4602
4603 bool allow_div = true;
4604
4605 u64 max = -1;
4606
4607 while (max)
4608 {
4609 const uint work = get_work (device_param, max, allow_div);
4610
4611 allow_div = false;
4612
4613 if (work == 0) break;
4614
4615 words_off = device_param->words_off;
4616 words_fin = words_off + work;
4617
4618 char *line_buf;
4619 uint line_len;
4620
4621 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4622
4623 max = 0;
4624
4625 for ( ; words_cur < words_fin; words_cur++)
4626 {
4627 get_next_word (wl_data, fd, &line_buf, &line_len);
4628
4629 line_len = convert_from_hex (line_buf, line_len);
4630
4631 // post-process rule engine
4632
4633 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4634 {
4635 char rule_buf_out[BLOCK_SIZE] = { 0 };
4636
4637 int rule_len_out = -1;
4638
4639 if (line_len < BLOCK_SIZE)
4640 {
4641 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4642 }
4643
4644 if (rule_len_out < 0) continue;
4645
4646 line_buf = rule_buf_out;
4647 line_len = rule_len_out;
4648 }
4649
4650 if (attack_kern == ATTACK_KERN_STRAIGHT)
4651 {
4652 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4653 {
4654 max++;
4655
4656 hc_thread_mutex_lock (mux_counter);
4657
4658 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4659 {
4660 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4661 }
4662
4663 hc_thread_mutex_unlock (mux_counter);
4664
4665 continue;
4666 }
4667 }
4668 else if (attack_kern == ATTACK_KERN_COMBI)
4669 {
4670 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4671 // since we still need to combine the plains
4672
4673 if (line_len > data.pw_max)
4674 {
4675 max++;
4676
4677 hc_thread_mutex_lock (mux_counter);
4678
4679 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4680 {
4681 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4682 }
4683
4684 hc_thread_mutex_unlock (mux_counter);
4685
4686 continue;
4687 }
4688 }
4689
4690 pw_add (device_param, (u8 *) line_buf, line_len);
4691
4692 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4693
4694 if (data.devices_status == STATUS_CRACKED) break;
4695 if (data.devices_status == STATUS_ABORTED) break;
4696 if (data.devices_status == STATUS_QUIT) break;
4697 if (data.devices_status == STATUS_BYPASS) break;
4698 }
4699
4700 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4701
4702 if (data.devices_status == STATUS_CRACKED) break;
4703 if (data.devices_status == STATUS_ABORTED) break;
4704 if (data.devices_status == STATUS_QUIT) break;
4705 if (data.devices_status == STATUS_BYPASS) break;
4706 }
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714
4715 //
4716 // flush
4717 //
4718
4719 const uint pws_cnt = device_param->pws_cnt;
4720
4721 if (pws_cnt)
4722 {
4723 run_copy (device_param, pws_cnt);
4724
4725 run_cracker (device_param, pws_cnt);
4726
4727 device_param->pws_cnt = 0;
4728
4729 /*
4730 still required?
4731 if (attack_kern == ATTACK_KERN_STRAIGHT)
4732 {
4733 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4734 }
4735 else if (attack_kern == ATTACK_KERN_COMBI)
4736 {
4737 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4738 }
4739 */
4740 }
4741
4742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4743
4744 if (data.devices_status == STATUS_CRACKED) break;
4745 if (data.devices_status == STATUS_ABORTED) break;
4746 if (data.devices_status == STATUS_QUIT) break;
4747 if (data.devices_status == STATUS_BYPASS) break;
4748
4749 if (words_fin == 0) break;
4750
4751 device_param->words_done = words_fin;
4752 }
4753
4754 if (attack_mode == ATTACK_MODE_COMBI)
4755 {
4756 fclose (device_param->combs_fp);
4757 }
4758
4759 free (wl_data->buf);
4760 free (wl_data);
4761
4762 fclose (fd);
4763 }
4764
4765 device_param->kernel_accel = 0;
4766 device_param->kernel_loops = 0;
4767
4768 return NULL;
4769 }
4770
4771 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4772 {
4773 if (!device_param)
4774 {
4775 log_error ("ERROR: %s : Invalid argument", __func__);
4776
4777 exit (-1);
4778 }
4779
4780 salt_t *salt_buf = &data.salts_buf[salt_pos];
4781
4782 device_param->kernel_params_buf32[24] = salt_pos;
4783 device_param->kernel_params_buf32[27] = 1;
4784 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4785 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4786 device_param->kernel_params_buf32[30] = 0;
4787 device_param->kernel_params_buf32[31] = 1;
4788
4789 char *dictfile_old = data.dictfile;
4790
4791 const char *weak_hash_check = "weak-hash-check";
4792
4793 data.dictfile = (char *) weak_hash_check;
4794
4795 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4796
4797 data.kernel_rules_buf[0].cmds[0] = 0;
4798
4799 /**
4800 * run the kernel
4801 */
4802
4803 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4804 {
4805 run_kernel (KERN_RUN_1, device_param, 1, false);
4806 }
4807 else
4808 {
4809 run_kernel (KERN_RUN_1, device_param, 1, false);
4810
4811 uint loop_step = 16;
4812
4813 const uint iter = salt_buf->salt_iter;
4814
4815 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4816 {
4817 uint loop_left = iter - loop_pos;
4818
4819 loop_left = MIN (loop_left, loop_step);
4820
4821 device_param->kernel_params_buf32[25] = loop_pos;
4822 device_param->kernel_params_buf32[26] = loop_left;
4823
4824 run_kernel (KERN_RUN_2, device_param, 1, false);
4825 }
4826
4827 run_kernel (KERN_RUN_3, device_param, 1, false);
4828 }
4829
4830 /**
4831 * result
4832 */
4833
4834 check_cracked (device_param, salt_pos);
4835
4836 /**
4837 * cleanup
4838 */
4839
4840 device_param->kernel_params_buf32[24] = 0;
4841 device_param->kernel_params_buf32[25] = 0;
4842 device_param->kernel_params_buf32[26] = 0;
4843 device_param->kernel_params_buf32[27] = 0;
4844 device_param->kernel_params_buf32[28] = 0;
4845 device_param->kernel_params_buf32[29] = 0;
4846 device_param->kernel_params_buf32[30] = 0;
4847 device_param->kernel_params_buf32[31] = 0;
4848
4849 data.dictfile = dictfile_old;
4850
4851 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4852 }
4853
4854 // hlfmt hashcat
4855
4856 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4857 {
4858 if (data.username == 0)
4859 {
4860 *hashbuf_pos = line_buf;
4861 *hashbuf_len = line_len;
4862 }
4863 else
4864 {
4865 char *pos = line_buf;
4866 int len = line_len;
4867
4868 for (int i = 0; i < line_len; i++, pos++, len--)
4869 {
4870 if (line_buf[i] == data.separator)
4871 {
4872 pos++;
4873
4874 len--;
4875
4876 break;
4877 }
4878 }
4879
4880 *hashbuf_pos = pos;
4881 *hashbuf_len = len;
4882 }
4883 }
4884
4885 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4886 {
4887 char *pos = NULL;
4888 int len = 0;
4889
4890 int sep_cnt = 0;
4891
4892 for (int i = 0; i < line_len; i++)
4893 {
4894 if (line_buf[i] == data.separator)
4895 {
4896 sep_cnt++;
4897
4898 continue;
4899 }
4900
4901 if (sep_cnt == 0)
4902 {
4903 if (pos == NULL) pos = line_buf + i;
4904
4905 len++;
4906 }
4907 }
4908
4909 *userbuf_pos = pos;
4910 *userbuf_len = len;
4911 }
4912
4913 // hlfmt pwdump
4914
4915 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4916 {
4917 int sep_cnt = 0;
4918
4919 int sep2_len = 0;
4920 int sep3_len = 0;
4921
4922 for (int i = 0; i < line_len; i++)
4923 {
4924 if (line_buf[i] == ':')
4925 {
4926 sep_cnt++;
4927
4928 continue;
4929 }
4930
4931 if (sep_cnt == 2) sep2_len++;
4932 if (sep_cnt == 3) sep3_len++;
4933 }
4934
4935 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4936
4937 return 0;
4938 }
4939
4940 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4941 {
4942 char *pos = NULL;
4943 int len = 0;
4944
4945 int sep_cnt = 0;
4946
4947 for (int i = 0; i < line_len; i++)
4948 {
4949 if (line_buf[i] == ':')
4950 {
4951 sep_cnt++;
4952
4953 continue;
4954 }
4955
4956 if (data.hash_mode == 1000)
4957 {
4958 if (sep_cnt == 3)
4959 {
4960 if (pos == NULL) pos = line_buf + i;
4961
4962 len++;
4963 }
4964 }
4965 else if (data.hash_mode == 3000)
4966 {
4967 if (sep_cnt == 2)
4968 {
4969 if (pos == NULL) pos = line_buf + i;
4970
4971 len++;
4972 }
4973 }
4974 }
4975
4976 *hashbuf_pos = pos;
4977 *hashbuf_len = len;
4978 }
4979
4980 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4981 {
4982 char *pos = NULL;
4983 int len = 0;
4984
4985 int sep_cnt = 0;
4986
4987 for (int i = 0; i < line_len; i++)
4988 {
4989 if (line_buf[i] == ':')
4990 {
4991 sep_cnt++;
4992
4993 continue;
4994 }
4995
4996 if (sep_cnt == 0)
4997 {
4998 if (pos == NULL) pos = line_buf + i;
4999
5000 len++;
5001 }
5002 }
5003
5004 *userbuf_pos = pos;
5005 *userbuf_len = len;
5006 }
5007
5008 // hlfmt passwd
5009
5010 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5011 {
5012 int sep_cnt = 0;
5013
5014 char sep5_first = 0;
5015 char sep6_first = 0;
5016
5017 for (int i = 0; i < line_len; i++)
5018 {
5019 if (line_buf[i] == ':')
5020 {
5021 sep_cnt++;
5022
5023 continue;
5024 }
5025
5026 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5027 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5028 }
5029
5030 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5031
5032 return 0;
5033 }
5034
5035 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5036 {
5037 char *pos = NULL;
5038 int len = 0;
5039
5040 int sep_cnt = 0;
5041
5042 for (int i = 0; i < line_len; i++)
5043 {
5044 if (line_buf[i] == ':')
5045 {
5046 sep_cnt++;
5047
5048 continue;
5049 }
5050
5051 if (sep_cnt == 1)
5052 {
5053 if (pos == NULL) pos = line_buf + i;
5054
5055 len++;
5056 }
5057 }
5058
5059 *hashbuf_pos = pos;
5060 *hashbuf_len = len;
5061 }
5062
5063 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5064 {
5065 char *pos = NULL;
5066 int len = 0;
5067
5068 int sep_cnt = 0;
5069
5070 for (int i = 0; i < line_len; i++)
5071 {
5072 if (line_buf[i] == ':')
5073 {
5074 sep_cnt++;
5075
5076 continue;
5077 }
5078
5079 if (sep_cnt == 0)
5080 {
5081 if (pos == NULL) pos = line_buf + i;
5082
5083 len++;
5084 }
5085 }
5086
5087 *userbuf_pos = pos;
5088 *userbuf_len = len;
5089 }
5090
5091 // hlfmt shadow
5092
5093 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5094 {
5095 int sep_cnt = 0;
5096
5097 for (int i = 0; i < line_len; i++)
5098 {
5099 if (line_buf[i] == ':') sep_cnt++;
5100 }
5101
5102 if (sep_cnt == 8) return 1;
5103
5104 return 0;
5105 }
5106
5107 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5108 {
5109 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5110 }
5111
5112 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5113 {
5114 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5115 }
5116
5117 // hlfmt main
5118
5119 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5120 {
5121 switch (hashfile_format)
5122 {
5123 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5124 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5125 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5126 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5127 }
5128 }
5129
5130 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5131 {
5132 switch (hashfile_format)
5133 {
5134 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5135 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5136 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5137 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5138 }
5139 }
5140
5141 char *strhlfmt (const uint hashfile_format)
5142 {
5143 switch (hashfile_format)
5144 {
5145 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5146 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5147 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5148 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5149 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5150 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5151 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5152 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5153 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5154 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5155 }
5156
5157 return ((char *) "Unknown");
5158 }
5159
5160 static uint hlfmt_detect (FILE *fp, uint max_check)
5161 {
5162 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5163
5164 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5165 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5166
5167 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5168
5169 uint num_check = 0;
5170
5171 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5172
5173 while (!feof (fp))
5174 {
5175 int line_len = fgetl (fp, line_buf);
5176
5177 if (line_len == 0) continue;
5178
5179 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5180 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5181 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5182
5183 if (num_check == max_check) break;
5184
5185 num_check++;
5186 }
5187
5188 myfree (line_buf);
5189
5190 uint hashlist_format = HLFMT_HASHCAT;
5191
5192 for (int i = 1; i < HLFMTS_CNT; i++)
5193 {
5194 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5195
5196 hashlist_format = i;
5197 }
5198
5199 free (formats_cnt);
5200
5201 return hashlist_format;
5202 }
5203
5204 /**
5205 * some further helper function
5206 */
5207
5208 // wrapper around mymalloc for ADL
5209
5210 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5211 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5212 {
5213 return mymalloc (iSize);
5214 }
5215 #endif
5216
5217 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)
5218 {
5219 u64 collisions = 0;
5220
5221 const uint dgst_pos0 = data.dgst_pos0;
5222 const uint dgst_pos1 = data.dgst_pos1;
5223 const uint dgst_pos2 = data.dgst_pos2;
5224 const uint dgst_pos3 = data.dgst_pos3;
5225
5226 memset (bitmap_a, 0, bitmap_size);
5227 memset (bitmap_b, 0, bitmap_size);
5228 memset (bitmap_c, 0, bitmap_size);
5229 memset (bitmap_d, 0, bitmap_size);
5230
5231 for (uint i = 0; i < digests_cnt; i++)
5232 {
5233 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5234
5235 uint *digest_ptr = (uint *) digests_buf_ptr;
5236
5237 digests_buf_ptr += dgst_size;
5238
5239 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5240 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5241 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5242 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5243
5244 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5245 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5246 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5247 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5248
5249 if (bitmap_a[idx0] & val0) collisions++;
5250 if (bitmap_b[idx1] & val1) collisions++;
5251 if (bitmap_c[idx2] & val2) collisions++;
5252 if (bitmap_d[idx3] & val3) collisions++;
5253
5254 bitmap_a[idx0] |= val0;
5255 bitmap_b[idx1] |= val1;
5256 bitmap_c[idx2] |= val2;
5257 bitmap_d[idx3] |= val3;
5258
5259 if (collisions >= collisions_max) return 0x7fffffff;
5260 }
5261
5262 return collisions;
5263 }
5264
5265 /**
5266 * main
5267 */
5268
5269 int main (int argc, char **argv)
5270 {
5271 /**
5272 * To help users a bit
5273 */
5274
5275 char *compute = getenv ("COMPUTE");
5276
5277 if (compute)
5278 {
5279 static char display[100];
5280
5281 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5282
5283 putenv (display);
5284 }
5285 else
5286 {
5287 if (getenv ("DISPLAY") == NULL)
5288 putenv ((char *) "DISPLAY=:0");
5289 }
5290
5291 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5292 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5293
5294 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5295 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5296
5297 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5298 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5299
5300 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5301 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5302
5303 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5304 putenv ((char *) "POCL_KERNEL_CACHE=0");
5305
5306 umask (077);
5307
5308 /**
5309 * Real init
5310 */
5311
5312 memset (&data, 0, sizeof (hc_global_data_t));
5313
5314 time_t proc_start;
5315
5316 time (&proc_start);
5317
5318 data.proc_start = proc_start;
5319
5320 int myargc = argc;
5321 char **myargv = argv;
5322
5323 hc_thread_mutex_init (mux_dispatcher);
5324 hc_thread_mutex_init (mux_counter);
5325 hc_thread_mutex_init (mux_display);
5326 hc_thread_mutex_init (mux_adl);
5327
5328 /**
5329 * commandline parameters
5330 */
5331
5332 uint usage = USAGE;
5333 uint version = VERSION;
5334 uint quiet = QUIET;
5335 uint benchmark = BENCHMARK;
5336 uint show = SHOW;
5337 uint left = LEFT;
5338 uint username = USERNAME;
5339 uint remove = REMOVE;
5340 uint remove_timer = REMOVE_TIMER;
5341 u64 skip = SKIP;
5342 u64 limit = LIMIT;
5343 uint keyspace = KEYSPACE;
5344 uint potfile_disable = POTFILE_DISABLE;
5345 char *potfile_path = NULL;
5346 uint debug_mode = DEBUG_MODE;
5347 char *debug_file = NULL;
5348 char *induction_dir = NULL;
5349 char *outfile_check_dir = NULL;
5350 uint force = FORCE;
5351 uint runtime = RUNTIME;
5352 uint hash_mode = HASH_MODE;
5353 uint attack_mode = ATTACK_MODE;
5354 uint markov_disable = MARKOV_DISABLE;
5355 uint markov_classic = MARKOV_CLASSIC;
5356 uint markov_threshold = MARKOV_THRESHOLD;
5357 char *markov_hcstat = NULL;
5358 char *outfile = NULL;
5359 uint outfile_format = OUTFILE_FORMAT;
5360 uint outfile_autohex = OUTFILE_AUTOHEX;
5361 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5362 uint restore = RESTORE;
5363 uint restore_timer = RESTORE_TIMER;
5364 uint restore_disable = RESTORE_DISABLE;
5365 uint status = STATUS;
5366 uint status_timer = STATUS_TIMER;
5367 uint status_automat = STATUS_AUTOMAT;
5368 uint loopback = LOOPBACK;
5369 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5370 char *session = NULL;
5371 uint hex_charset = HEX_CHARSET;
5372 uint hex_salt = HEX_SALT;
5373 uint hex_wordlist = HEX_WORDLIST;
5374 uint rp_gen = RP_GEN;
5375 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5376 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5377 uint rp_gen_seed = RP_GEN_SEED;
5378 char *rule_buf_l = (char *) RULE_BUF_L;
5379 char *rule_buf_r = (char *) RULE_BUF_R;
5380 uint increment = INCREMENT;
5381 uint increment_min = INCREMENT_MIN;
5382 uint increment_max = INCREMENT_MAX;
5383 char *cpu_affinity = NULL;
5384 OCL_PTR *ocl = NULL;
5385 char *opencl_devices = NULL;
5386 char *opencl_platforms = NULL;
5387 char *opencl_device_types = NULL;
5388 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5389 char *truecrypt_keyfiles = NULL;
5390 char *veracrypt_keyfiles = NULL;
5391 uint veracrypt_pim = 0;
5392 uint workload_profile = WORKLOAD_PROFILE;
5393 uint kernel_accel = KERNEL_ACCEL;
5394 uint kernel_loops = KERNEL_LOOPS;
5395 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5396 #ifdef HAVE_HWMON
5397 uint gpu_temp_abort = GPU_TEMP_ABORT;
5398 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5399 #ifdef HAVE_ADL
5400 uint powertune_enable = POWERTUNE_ENABLE;
5401 #endif
5402 #endif
5403 uint logfile_disable = LOGFILE_DISABLE;
5404 uint segment_size = SEGMENT_SIZE;
5405 uint scrypt_tmto = SCRYPT_TMTO;
5406 char separator = SEPARATOR;
5407 uint bitmap_min = BITMAP_MIN;
5408 uint bitmap_max = BITMAP_MAX;
5409 char *custom_charset_1 = NULL;
5410 char *custom_charset_2 = NULL;
5411 char *custom_charset_3 = NULL;
5412 char *custom_charset_4 = NULL;
5413
5414 #define IDX_HELP 'h'
5415 #define IDX_VERSION 'V'
5416 #define IDX_VERSION_LOWER 'v'
5417 #define IDX_QUIET 0xff02
5418 #define IDX_SHOW 0xff03
5419 #define IDX_LEFT 0xff04
5420 #define IDX_REMOVE 0xff05
5421 #define IDX_REMOVE_TIMER 0xff37
5422 #define IDX_SKIP 's'
5423 #define IDX_LIMIT 'l'
5424 #define IDX_KEYSPACE 0xff35
5425 #define IDX_POTFILE_DISABLE 0xff06
5426 #define IDX_POTFILE_PATH 0xffe0
5427 #define IDX_DEBUG_MODE 0xff43
5428 #define IDX_DEBUG_FILE 0xff44
5429 #define IDX_INDUCTION_DIR 0xff46
5430 #define IDX_OUTFILE_CHECK_DIR 0xff47
5431 #define IDX_USERNAME 0xff07
5432 #define IDX_FORCE 0xff08
5433 #define IDX_RUNTIME 0xff09
5434 #define IDX_BENCHMARK 'b'
5435 #define IDX_HASH_MODE 'm'
5436 #define IDX_ATTACK_MODE 'a'
5437 #define IDX_RP_FILE 'r'
5438 #define IDX_RP_GEN 'g'
5439 #define IDX_RP_GEN_FUNC_MIN 0xff10
5440 #define IDX_RP_GEN_FUNC_MAX 0xff11
5441 #define IDX_RP_GEN_SEED 0xff34
5442 #define IDX_RULE_BUF_L 'j'
5443 #define IDX_RULE_BUF_R 'k'
5444 #define IDX_INCREMENT 'i'
5445 #define IDX_INCREMENT_MIN 0xff12
5446 #define IDX_INCREMENT_MAX 0xff13
5447 #define IDX_OUTFILE 'o'
5448 #define IDX_OUTFILE_FORMAT 0xff14
5449 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5450 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5451 #define IDX_RESTORE 0xff15
5452 #define IDX_RESTORE_DISABLE 0xff27
5453 #define IDX_STATUS 0xff17
5454 #define IDX_STATUS_TIMER 0xff18
5455 #define IDX_STATUS_AUTOMAT 0xff50
5456 #define IDX_LOOPBACK 0xff38
5457 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5458 #define IDX_SESSION 0xff19
5459 #define IDX_HEX_CHARSET 0xff20
5460 #define IDX_HEX_SALT 0xff21
5461 #define IDX_HEX_WORDLIST 0xff40
5462 #define IDX_MARKOV_DISABLE 0xff22
5463 #define IDX_MARKOV_CLASSIC 0xff23
5464 #define IDX_MARKOV_THRESHOLD 't'
5465 #define IDX_MARKOV_HCSTAT 0xff24
5466 #define IDX_CPU_AFFINITY 0xff25
5467 #define IDX_OPENCL_DEVICES 'd'
5468 #define IDX_OPENCL_PLATFORMS 0xff72
5469 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5470 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5471 #define IDX_WORKLOAD_PROFILE 'w'
5472 #define IDX_KERNEL_ACCEL 'n'
5473 #define IDX_KERNEL_LOOPS 'u'
5474 #define IDX_GPU_TEMP_DISABLE 0xff29
5475 #define IDX_GPU_TEMP_ABORT 0xff30
5476 #define IDX_GPU_TEMP_RETAIN 0xff31
5477 #define IDX_POWERTUNE_ENABLE 0xff41
5478 #define IDX_LOGFILE_DISABLE 0xff51
5479 #define IDX_TRUECRYPT_KEYFILES 0xff52
5480 #define IDX_VERACRYPT_KEYFILES 0xff53
5481 #define IDX_VERACRYPT_PIM 0xff54
5482 #define IDX_SCRYPT_TMTO 0xff61
5483 #define IDX_SEGMENT_SIZE 'c'
5484 #define IDX_SEPARATOR 'p'
5485 #define IDX_BITMAP_MIN 0xff70
5486 #define IDX_BITMAP_MAX 0xff71
5487 #define IDX_CUSTOM_CHARSET_1 '1'
5488 #define IDX_CUSTOM_CHARSET_2 '2'
5489 #define IDX_CUSTOM_CHARSET_3 '3'
5490 #define IDX_CUSTOM_CHARSET_4 '4'
5491
5492 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5493
5494 struct option long_options[] =
5495 {
5496 {"help", no_argument, 0, IDX_HELP},
5497 {"version", no_argument, 0, IDX_VERSION},
5498 {"quiet", no_argument, 0, IDX_QUIET},
5499 {"show", no_argument, 0, IDX_SHOW},
5500 {"left", no_argument, 0, IDX_LEFT},
5501 {"username", no_argument, 0, IDX_USERNAME},
5502 {"remove", no_argument, 0, IDX_REMOVE},
5503 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5504 {"skip", required_argument, 0, IDX_SKIP},
5505 {"limit", required_argument, 0, IDX_LIMIT},
5506 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5507 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5508 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5509 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5510 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5511 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5512 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5513 {"force", no_argument, 0, IDX_FORCE},
5514 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5515 {"restore", no_argument, 0, IDX_RESTORE},
5516 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5517 {"status", no_argument, 0, IDX_STATUS},
5518 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5519 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5520 {"loopback", no_argument, 0, IDX_LOOPBACK},
5521 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5522 {"session", required_argument, 0, IDX_SESSION},
5523 {"runtime", required_argument, 0, IDX_RUNTIME},
5524 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5525 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5526 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5527 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5528 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5529 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5530 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5531 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5532 {"rules-file", required_argument, 0, IDX_RP_FILE},
5533 {"outfile", required_argument, 0, IDX_OUTFILE},
5534 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5535 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5536 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5537 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5538 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5539 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5540 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5541 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5542 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5543 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5544 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5545 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5546 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5547 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5548 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5549 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5550 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5551 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5552 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5553 #ifdef HAVE_HWMON
5554 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5555 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5556 #ifdef HAVE_ADL
5557 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5558 #endif
5559 #endif // HAVE_HWMON
5560 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5561 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5562 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5563 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5564 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5565 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5566 {"seperator", required_argument, 0, IDX_SEPARATOR},
5567 {"separator", required_argument, 0, IDX_SEPARATOR},
5568 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5569 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5570 {"increment", no_argument, 0, IDX_INCREMENT},
5571 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5572 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5573 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5574 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5575 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5576 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5577 {0, 0, 0, 0}
5578 };
5579
5580 uint rp_files_cnt = 0;
5581
5582 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5583
5584 int option_index = 0;
5585 int c = -1;
5586
5587 optind = 1;
5588 optopt = 0;
5589
5590 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5591 {
5592 switch (c)
5593 {
5594 case IDX_HELP: usage = 1; break;
5595 case IDX_VERSION:
5596 case IDX_VERSION_LOWER: version = 1; break;
5597 case IDX_RESTORE: restore = 1; break;
5598 case IDX_SESSION: session = optarg; break;
5599 case IDX_SHOW: show = 1; break;
5600 case IDX_LEFT: left = 1; break;
5601 case '?': return (-1);
5602 }
5603 }
5604
5605 if (optopt != 0)
5606 {
5607 log_error ("ERROR: Invalid argument specified");
5608
5609 return (-1);
5610 }
5611
5612 /**
5613 * exit functions
5614 */
5615
5616 if (version)
5617 {
5618 log_info ("%s", VERSION_TAG);
5619
5620 return (0);
5621 }
5622
5623 if (usage)
5624 {
5625 usage_big_print (PROGNAME);
5626
5627 return (0);
5628 }
5629
5630 /**
5631 * session needs to be set, always!
5632 */
5633
5634 if (session == NULL) session = (char *) PROGNAME;
5635
5636 /**
5637 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5638 */
5639
5640 char *exec_path = get_exec_path ();
5641
5642 #ifdef LINUX
5643
5644 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5645 char *resolved_exec_path = realpath (exec_path, NULL);
5646
5647 char *install_dir = get_install_dir (resolved_exec_path);
5648 char *profile_dir = NULL;
5649 char *session_dir = NULL;
5650 char *shared_dir = NULL;
5651
5652 if (strcmp (install_dir, resolved_install_folder) == 0)
5653 {
5654 struct passwd *pw = getpwuid (getuid ());
5655
5656 const char *homedir = pw->pw_dir;
5657
5658 profile_dir = get_profile_dir (homedir);
5659 session_dir = get_session_dir (profile_dir);
5660 shared_dir = strdup (SHARED_FOLDER);
5661
5662 mkdir (profile_dir, 0700);
5663 mkdir (session_dir, 0700);
5664 }
5665 else
5666 {
5667 profile_dir = install_dir;
5668 session_dir = install_dir;
5669 shared_dir = install_dir;
5670 }
5671
5672 myfree (resolved_install_folder);
5673 myfree (resolved_exec_path);
5674
5675 #else
5676
5677 char *install_dir = get_install_dir (exec_path);
5678 char *profile_dir = install_dir;
5679 char *session_dir = install_dir;
5680 char *shared_dir = install_dir;
5681
5682 #endif
5683
5684 data.install_dir = install_dir;
5685 data.profile_dir = profile_dir;
5686 data.session_dir = session_dir;
5687 data.shared_dir = shared_dir;
5688
5689 myfree (exec_path);
5690
5691 /**
5692 * kernel cache, we need to make sure folder exist
5693 */
5694
5695 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5696
5697 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5698
5699 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5700
5701 mkdir (kernels_folder, 0700);
5702
5703 myfree (kernels_folder);
5704
5705 /**
5706 * session
5707 */
5708
5709 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5710
5711 data.session = session;
5712
5713 char *eff_restore_file = (char *) mymalloc (session_size);
5714 char *new_restore_file = (char *) mymalloc (session_size);
5715
5716 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5717 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5718
5719 data.eff_restore_file = eff_restore_file;
5720 data.new_restore_file = new_restore_file;
5721
5722 if (((show == 1) || (left == 1)) && (restore == 1))
5723 {
5724 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5725 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5726
5727 return (-1);
5728 }
5729
5730 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5731 if ((show == 1) || (left == 1))
5732 {
5733 restore_disable = 1;
5734
5735 restore = 0;
5736 }
5737
5738 data.restore_disable = restore_disable;
5739
5740 restore_data_t *rd = init_restore (argc, argv);
5741
5742 data.rd = rd;
5743
5744 /**
5745 * restore file
5746 */
5747
5748 if (restore == 1)
5749 {
5750 read_restore (eff_restore_file, rd);
5751
5752 if (rd->version_bin < RESTORE_MIN)
5753 {
5754 log_error ("ERROR: Incompatible restore-file version");
5755
5756 return (-1);
5757 }
5758
5759 myargc = rd->argc;
5760 myargv = rd->argv;
5761
5762 #ifdef _POSIX
5763 rd->pid = getpid ();
5764 #elif _WIN
5765 rd->pid = GetCurrentProcessId ();
5766 #endif
5767 }
5768
5769 uint hash_mode_chgd = 0;
5770 uint runtime_chgd = 0;
5771 uint kernel_loops_chgd = 0;
5772 uint kernel_accel_chgd = 0;
5773 uint attack_mode_chgd = 0;
5774 uint outfile_format_chgd = 0;
5775 uint rp_gen_seed_chgd = 0;
5776 uint remove_timer_chgd = 0;
5777 uint increment_min_chgd = 0;
5778 uint increment_max_chgd = 0;
5779 uint workload_profile_chgd = 0;
5780 uint opencl_vector_width_chgd = 0;
5781
5782 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5783 uint gpu_temp_retain_chgd = 0;
5784 uint gpu_temp_abort_chgd = 0;
5785 #endif
5786
5787 optind = 1;
5788 optopt = 0;
5789 option_index = 0;
5790
5791 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5792 {
5793 switch (c)
5794 {
5795 //case IDX_HELP: usage = 1; break;
5796 //case IDX_VERSION: version = 1; break;
5797 //case IDX_RESTORE: restore = 1; break;
5798 case IDX_QUIET: quiet = 1; break;
5799 //case IDX_SHOW: show = 1; break;
5800 case IDX_SHOW: break;
5801 //case IDX_LEFT: left = 1; break;
5802 case IDX_LEFT: break;
5803 case IDX_USERNAME: username = 1; break;
5804 case IDX_REMOVE: remove = 1; break;
5805 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5806 remove_timer_chgd = 1; break;
5807 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5808 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5809 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5810 case IDX_DEBUG_FILE: debug_file = optarg; break;
5811 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5812 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5813 case IDX_FORCE: force = 1; break;
5814 case IDX_SKIP: skip = atoll (optarg); break;
5815 case IDX_LIMIT: limit = atoll (optarg); break;
5816 case IDX_KEYSPACE: keyspace = 1; break;
5817 case IDX_BENCHMARK: benchmark = 1; break;
5818 case IDX_RESTORE: break;
5819 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5820 case IDX_STATUS: status = 1; break;
5821 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5822 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5823 case IDX_LOOPBACK: loopback = 1; break;
5824 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5825 //case IDX_SESSION: session = optarg; break;
5826 case IDX_SESSION: break;
5827 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5828 hash_mode_chgd = 1; break;
5829 case IDX_RUNTIME: runtime = atoi (optarg);
5830 runtime_chgd = 1; break;
5831 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5832 attack_mode_chgd = 1; break;
5833 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5834 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5835 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5836 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5837 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5838 rp_gen_seed_chgd = 1; break;
5839 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5840 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5841 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5842 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5843 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5844 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5845 case IDX_OUTFILE: outfile = optarg; break;
5846 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5847 outfile_format_chgd = 1; break;
5848 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5849 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5850 case IDX_HEX_CHARSET: hex_charset = 1; break;
5851 case IDX_HEX_SALT: hex_salt = 1; break;
5852 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5853 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5854 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5855 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5856 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5857 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5858 opencl_vector_width_chgd = 1; break;
5859 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5860 workload_profile_chgd = 1; break;
5861 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5862 kernel_accel_chgd = 1; break;
5863 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5864 kernel_loops_chgd = 1; break;
5865 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5866 #ifdef HAVE_HWMON
5867 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5868 #ifdef HAVE_ADL
5869 gpu_temp_abort_chgd = 1;
5870 #endif
5871 break;
5872 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5873 #ifdef HAVE_ADL
5874 gpu_temp_retain_chgd = 1;
5875 #endif
5876 break;
5877 #ifdef HAVE_ADL
5878 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5879 #endif
5880 #endif // HAVE_HWMON
5881 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5882 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5883 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5884 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5885 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5886 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5887 case IDX_SEPARATOR: separator = optarg[0]; break;
5888 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5889 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5890 case IDX_INCREMENT: increment = 1; break;
5891 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5892 increment_min_chgd = 1; break;
5893 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5894 increment_max_chgd = 1; break;
5895 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5896 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5897 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5898 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5899
5900 default:
5901 log_error ("ERROR: Invalid argument specified");
5902 return (-1);
5903 }
5904 }
5905
5906 if (optopt != 0)
5907 {
5908 log_error ("ERROR: Invalid argument specified");
5909
5910 return (-1);
5911 }
5912
5913 /**
5914 * Inform user things getting started,
5915 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5916 * - we do not need to check algorithm_pos
5917 */
5918
5919 if (quiet == 0)
5920 {
5921 if (benchmark == 1)
5922 {
5923 if (status_automat == 0)
5924 {
5925 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5926 log_info ("");
5927 }
5928 else
5929 {
5930 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5931 }
5932 }
5933 else if (restore == 1)
5934 {
5935 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5936 log_info ("");
5937 }
5938 else
5939 {
5940 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5941 log_info ("");
5942 }
5943 }
5944
5945 /**
5946 * sanity check
5947 */
5948
5949 if (attack_mode > 7)
5950 {
5951 log_error ("ERROR: Invalid attack-mode specified");
5952
5953 return (-1);
5954 }
5955
5956 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5957 {
5958 log_error ("ERROR: Invalid runtime specified");
5959
5960 return (-1);
5961 }
5962
5963 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5964 {
5965 log_error ("ERROR: Invalid hash-type specified");
5966
5967 return (-1);
5968 }
5969
5970 // renamed hash modes
5971
5972 if (hash_mode_chgd)
5973 {
5974 int n = -1;
5975
5976 switch (hash_mode)
5977 {
5978 case 123: n = 124;
5979 break;
5980 }
5981
5982 if (n >= 0)
5983 {
5984 log_error ("Old -m specified, use -m %d instead", n);
5985
5986 return (-1);
5987 }
5988 }
5989
5990 if (username == 1)
5991 {
5992 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5993 {
5994 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5995
5996 return (-1);
5997 }
5998 }
5999
6000 if (outfile_format > 16)
6001 {
6002 log_error ("ERROR: Invalid outfile-format specified");
6003
6004 return (-1);
6005 }
6006
6007 if (left == 1)
6008 {
6009 if (outfile_format_chgd == 1)
6010 {
6011 if (outfile_format > 1)
6012 {
6013 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6014
6015 return (-1);
6016 }
6017 }
6018 else
6019 {
6020 outfile_format = OUTFILE_FMT_HASH;
6021 }
6022 }
6023
6024 if (show == 1)
6025 {
6026 if (outfile_format_chgd == 1)
6027 {
6028 if ((outfile_format > 7) && (outfile_format < 16))
6029 {
6030 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6031
6032 return (-1);
6033 }
6034 }
6035 }
6036
6037 if (increment_min < INCREMENT_MIN)
6038 {
6039 log_error ("ERROR: Invalid increment-min specified");
6040
6041 return (-1);
6042 }
6043
6044 if (increment_max > INCREMENT_MAX)
6045 {
6046 log_error ("ERROR: Invalid increment-max specified");
6047
6048 return (-1);
6049 }
6050
6051 if (increment_min > increment_max)
6052 {
6053 log_error ("ERROR: Invalid increment-min specified");
6054
6055 return (-1);
6056 }
6057
6058 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6059 {
6060 log_error ("ERROR: increment is not allowed in attack-mode 0");
6061
6062 return (-1);
6063 }
6064
6065 if ((increment == 0) && (increment_min_chgd == 1))
6066 {
6067 log_error ("ERROR: increment-min is only supported together with increment switch");
6068
6069 return (-1);
6070 }
6071
6072 if ((increment == 0) && (increment_max_chgd == 1))
6073 {
6074 log_error ("ERROR: increment-max is only supported together with increment switch");
6075
6076 return (-1);
6077 }
6078
6079 if (rp_files_cnt && rp_gen)
6080 {
6081 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6082
6083 return (-1);
6084 }
6085
6086 if (rp_files_cnt || rp_gen)
6087 {
6088 if (attack_mode != ATTACK_MODE_STRAIGHT)
6089 {
6090 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6091
6092 return (-1);
6093 }
6094 }
6095
6096 if (rp_gen_func_min > rp_gen_func_max)
6097 {
6098 log_error ("ERROR: Invalid rp-gen-func-min specified");
6099
6100 return (-1);
6101 }
6102
6103 if (kernel_accel_chgd == 1)
6104 {
6105 if (force == 0)
6106 {
6107 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6108 log_info ("Please consider using the option -w instead");
6109 log_info ("You can use --force to override this but do not post error reports if you do so");
6110 log_info ("");
6111
6112 return (-1);
6113 }
6114
6115 if (kernel_accel < 1)
6116 {
6117 log_error ("ERROR: Invalid kernel-accel specified");
6118
6119 return (-1);
6120 }
6121
6122 if (kernel_accel > 1024)
6123 {
6124 log_error ("ERROR: Invalid kernel-accel specified");
6125
6126 return (-1);
6127 }
6128 }
6129
6130 if (kernel_loops_chgd == 1)
6131 {
6132 if (force == 0)
6133 {
6134 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6135 log_info ("Please consider using the option -w instead");
6136 log_info ("You can use --force to override this but do not post error reports if you do so");
6137 log_info ("");
6138
6139 return (-1);
6140 }
6141
6142 if (kernel_loops < 1)
6143 {
6144 log_error ("ERROR: Invalid kernel-loops specified");
6145
6146 return (-1);
6147 }
6148
6149 if (kernel_loops > 1024)
6150 {
6151 log_error ("ERROR: Invalid kernel-loops specified");
6152
6153 return (-1);
6154 }
6155 }
6156
6157 if ((workload_profile < 1) || (workload_profile > 4))
6158 {
6159 log_error ("ERROR: workload-profile %i not available", workload_profile);
6160
6161 return (-1);
6162 }
6163
6164 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6165 {
6166 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6167
6168 return (-1);
6169 }
6170
6171 if (show == 1 || left == 1)
6172 {
6173 attack_mode = ATTACK_MODE_NONE;
6174
6175 if (remove == 1)
6176 {
6177 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6178
6179 return (-1);
6180 }
6181
6182 if (potfile_disable == 1)
6183 {
6184 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6185
6186 return (-1);
6187 }
6188 }
6189
6190 uint attack_kern = ATTACK_KERN_NONE;
6191
6192 switch (attack_mode)
6193 {
6194 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6195 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6196 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6197 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6198 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6199 }
6200
6201 if (benchmark == 0)
6202 {
6203 if (keyspace == 1)
6204 {
6205 int num_additional_params = 1;
6206
6207 if (attack_kern == ATTACK_KERN_COMBI)
6208 {
6209 num_additional_params = 2;
6210 }
6211
6212 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6213
6214 if (keyspace_wordlist_specified == 0) optind--;
6215 }
6216
6217 if (attack_kern == ATTACK_KERN_NONE)
6218 {
6219 if ((optind + 1) != myargc)
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6227 {
6228 if ((optind + 1) > myargc)
6229 {
6230 usage_mini_print (myargv[0]);
6231
6232 return (-1);
6233 }
6234 }
6235 else if (attack_kern == ATTACK_KERN_COMBI)
6236 {
6237 if ((optind + 3) != myargc)
6238 {
6239 usage_mini_print (myargv[0]);
6240
6241 return (-1);
6242 }
6243 }
6244 else if (attack_kern == ATTACK_KERN_BF)
6245 {
6246 if ((optind + 1) > myargc)
6247 {
6248 usage_mini_print (myargv[0]);
6249
6250 return (-1);
6251 }
6252 }
6253 else
6254 {
6255 usage_mini_print (myargv[0]);
6256
6257 return (-1);
6258 }
6259 }
6260 else
6261 {
6262 if (myargv[optind] != 0)
6263 {
6264 log_error ("ERROR: Invalid argument for benchmark mode specified");
6265
6266 return (-1);
6267 }
6268
6269 if (attack_mode_chgd == 1)
6270 {
6271 if (attack_mode != ATTACK_MODE_BF)
6272 {
6273 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6274
6275 return (-1);
6276 }
6277 }
6278 }
6279
6280 if (skip != 0 && limit != 0)
6281 {
6282 limit += skip;
6283 }
6284
6285 if (keyspace == 1)
6286 {
6287 if (show == 1)
6288 {
6289 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6290
6291 return (-1);
6292 }
6293 else if (left == 1)
6294 {
6295 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6296
6297 return (-1);
6298 }
6299
6300 potfile_disable = 1;
6301
6302 restore_disable = 1;
6303
6304 restore = 0;
6305
6306 weak_hash_threshold = 0;
6307
6308 quiet = 1;
6309 }
6310
6311 if (remove_timer_chgd == 1)
6312 {
6313 if (remove == 0)
6314 {
6315 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6316
6317 return (-1);
6318 }
6319
6320 if (remove_timer < 1)
6321 {
6322 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6323
6324 return (-1);
6325 }
6326 }
6327
6328 if (loopback == 1)
6329 {
6330 if (attack_mode == ATTACK_MODE_STRAIGHT)
6331 {
6332 if ((rp_files_cnt == 0) && (rp_gen == 0))
6333 {
6334 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6335
6336 return (-1);
6337 }
6338 }
6339 else
6340 {
6341 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6342
6343 return (-1);
6344 }
6345 }
6346
6347 if (debug_mode > 0)
6348 {
6349 if (attack_mode != ATTACK_MODE_STRAIGHT)
6350 {
6351 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6352
6353 return (-1);
6354 }
6355
6356 if ((rp_files_cnt == 0) && (rp_gen == 0))
6357 {
6358 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6359
6360 return (-1);
6361 }
6362 }
6363
6364 if (debug_mode > 4)
6365 {
6366 log_error ("ERROR: Invalid debug-mode specified");
6367
6368 return (-1);
6369 }
6370
6371 if (debug_file != NULL)
6372 {
6373 if (debug_mode < 1)
6374 {
6375 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6376
6377 return (-1);
6378 }
6379 }
6380
6381 if (induction_dir != NULL)
6382 {
6383 if (attack_mode == ATTACK_MODE_BF)
6384 {
6385 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6386
6387 return (-1);
6388 }
6389 }
6390
6391 if (attack_mode != ATTACK_MODE_STRAIGHT)
6392 {
6393 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6394 {
6395 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6396
6397 return (-1);
6398 }
6399
6400 weak_hash_threshold = 0;
6401 }
6402
6403 /**
6404 * induction directory
6405 */
6406
6407 char *induction_directory = NULL;
6408
6409 if (attack_mode != ATTACK_MODE_BF)
6410 {
6411 if (induction_dir == NULL)
6412 {
6413 induction_directory = (char *) mymalloc (session_size);
6414
6415 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6416
6417 // create induction folder if it does not already exist
6418
6419 if (keyspace == 0)
6420 {
6421 if (rmdir (induction_directory) == -1)
6422 {
6423 if (errno == ENOENT)
6424 {
6425 // good, we can ignore
6426 }
6427 else if (errno == ENOTEMPTY)
6428 {
6429 char *induction_directory_mv = (char *) mymalloc (session_size);
6430
6431 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6432
6433 if (rename (induction_directory, induction_directory_mv) != 0)
6434 {
6435 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6436
6437 return (-1);
6438 }
6439 }
6440 else
6441 {
6442 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6443
6444 return (-1);
6445 }
6446 }
6447
6448 if (mkdir (induction_directory, 0700) == -1)
6449 {
6450 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6451
6452 return (-1);
6453 }
6454 }
6455 }
6456 else
6457 {
6458 induction_directory = induction_dir;
6459 }
6460 }
6461
6462 data.induction_directory = induction_directory;
6463
6464 /**
6465 * loopback
6466 */
6467
6468 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6469
6470 char *loopback_file = (char *) mymalloc (loopback_size);
6471
6472 /**
6473 * tuning db
6474 */
6475
6476 char tuning_db_file[256] = { 0 };
6477
6478 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6479
6480 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6481
6482 /**
6483 * outfile-check directory
6484 */
6485
6486 char *outfile_check_directory = NULL;
6487
6488 if (outfile_check_dir == NULL)
6489 {
6490 outfile_check_directory = (char *) mymalloc (session_size);
6491
6492 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6493 }
6494 else
6495 {
6496 outfile_check_directory = outfile_check_dir;
6497 }
6498
6499 data.outfile_check_directory = outfile_check_directory;
6500
6501 if (keyspace == 0)
6502 {
6503 struct stat outfile_check_stat;
6504
6505 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6506 {
6507 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6508
6509 if (is_dir == 0)
6510 {
6511 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6512
6513 return (-1);
6514 }
6515 }
6516 else if (outfile_check_dir == NULL)
6517 {
6518 if (mkdir (outfile_check_directory, 0700) == -1)
6519 {
6520 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6521
6522 return (-1);
6523 }
6524 }
6525 }
6526
6527 /**
6528 * special other stuff
6529 */
6530
6531 if (hash_mode == 9710)
6532 {
6533 outfile_format = 5;
6534 outfile_format_chgd = 1;
6535 }
6536
6537 if (hash_mode == 9810)
6538 {
6539 outfile_format = 5;
6540 outfile_format_chgd = 1;
6541 }
6542
6543 if (hash_mode == 10410)
6544 {
6545 outfile_format = 5;
6546 outfile_format_chgd = 1;
6547 }
6548
6549 /**
6550 * store stuff
6551 */
6552
6553 data.hash_mode = hash_mode;
6554 data.restore = restore;
6555 data.restore_timer = restore_timer;
6556 data.restore_disable = restore_disable;
6557 data.status = status;
6558 data.status_timer = status_timer;
6559 data.status_automat = status_automat;
6560 data.loopback = loopback;
6561 data.runtime = runtime;
6562 data.remove = remove;
6563 data.remove_timer = remove_timer;
6564 data.debug_mode = debug_mode;
6565 data.debug_file = debug_file;
6566 data.username = username;
6567 data.quiet = quiet;
6568 data.outfile = outfile;
6569 data.outfile_format = outfile_format;
6570 data.outfile_autohex = outfile_autohex;
6571 data.hex_charset = hex_charset;
6572 data.hex_salt = hex_salt;
6573 data.hex_wordlist = hex_wordlist;
6574 data.separator = separator;
6575 data.rp_files = rp_files;
6576 data.rp_files_cnt = rp_files_cnt;
6577 data.rp_gen = rp_gen;
6578 data.rp_gen_seed = rp_gen_seed;
6579 data.force = force;
6580 data.benchmark = benchmark;
6581 data.skip = skip;
6582 data.limit = limit;
6583 #ifdef HAVE_HWMON
6584 #ifdef HAVE_ADL
6585 data.powertune_enable = powertune_enable;
6586 #endif
6587 #endif
6588 data.logfile_disable = logfile_disable;
6589 data.truecrypt_keyfiles = truecrypt_keyfiles;
6590 data.veracrypt_keyfiles = veracrypt_keyfiles;
6591 data.veracrypt_pim = veracrypt_pim;
6592 data.scrypt_tmto = scrypt_tmto;
6593 data.workload_profile = workload_profile;
6594
6595 /**
6596 * cpu affinity
6597 */
6598
6599 if (cpu_affinity)
6600 {
6601 set_cpu_affinity (cpu_affinity);
6602 }
6603
6604 if (rp_gen_seed_chgd == 0)
6605 {
6606 srand (proc_start);
6607 }
6608 else
6609 {
6610 srand (rp_gen_seed);
6611 }
6612
6613 /**
6614 * logfile init
6615 */
6616
6617 if (logfile_disable == 0)
6618 {
6619 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6620
6621 char *logfile = (char *) mymalloc (logfile_size);
6622
6623 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6624
6625 data.logfile = logfile;
6626
6627 char *topid = logfile_generate_topid ();
6628
6629 data.topid = topid;
6630 }
6631
6632 // logfile_append() checks for logfile_disable internally to make it easier from here
6633
6634 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6635 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6636 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6637 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6638 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6639 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6640 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6641 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6643 #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));
6644
6645 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6646 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6647 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6648 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6649 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6650 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6651 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6652 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6653
6654 logfile_top_msg ("START");
6655
6656 logfile_top_uint (attack_mode);
6657 logfile_top_uint (attack_kern);
6658 logfile_top_uint (benchmark);
6659 logfile_top_uint (bitmap_min);
6660 logfile_top_uint (bitmap_max);
6661 logfile_top_uint (debug_mode);
6662 logfile_top_uint (force);
6663 logfile_top_uint (kernel_accel);
6664 logfile_top_uint (kernel_loops);
6665 logfile_top_uint (gpu_temp_disable);
6666 #ifdef HAVE_HWMON
6667 logfile_top_uint (gpu_temp_abort);
6668 logfile_top_uint (gpu_temp_retain);
6669 #endif
6670 logfile_top_uint (hash_mode);
6671 logfile_top_uint (hex_charset);
6672 logfile_top_uint (hex_salt);
6673 logfile_top_uint (hex_wordlist);
6674 logfile_top_uint (increment);
6675 logfile_top_uint (increment_max);
6676 logfile_top_uint (increment_min);
6677 logfile_top_uint (keyspace);
6678 logfile_top_uint (left);
6679 logfile_top_uint (logfile_disable);
6680 logfile_top_uint (loopback);
6681 logfile_top_uint (markov_classic);
6682 logfile_top_uint (markov_disable);
6683 logfile_top_uint (markov_threshold);
6684 logfile_top_uint (outfile_autohex);
6685 logfile_top_uint (outfile_check_timer);
6686 logfile_top_uint (outfile_format);
6687 logfile_top_uint (potfile_disable);
6688 logfile_top_string (potfile_path);
6689 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6690 logfile_top_uint (powertune_enable);
6691 #endif
6692 logfile_top_uint (scrypt_tmto);
6693 logfile_top_uint (quiet);
6694 logfile_top_uint (remove);
6695 logfile_top_uint (remove_timer);
6696 logfile_top_uint (restore);
6697 logfile_top_uint (restore_disable);
6698 logfile_top_uint (restore_timer);
6699 logfile_top_uint (rp_gen);
6700 logfile_top_uint (rp_gen_func_max);
6701 logfile_top_uint (rp_gen_func_min);
6702 logfile_top_uint (rp_gen_seed);
6703 logfile_top_uint (runtime);
6704 logfile_top_uint (segment_size);
6705 logfile_top_uint (show);
6706 logfile_top_uint (status);
6707 logfile_top_uint (status_automat);
6708 logfile_top_uint (status_timer);
6709 logfile_top_uint (usage);
6710 logfile_top_uint (username);
6711 logfile_top_uint (version);
6712 logfile_top_uint (weak_hash_threshold);
6713 logfile_top_uint (workload_profile);
6714 logfile_top_uint64 (limit);
6715 logfile_top_uint64 (skip);
6716 logfile_top_char (separator);
6717 logfile_top_string (cpu_affinity);
6718 logfile_top_string (custom_charset_1);
6719 logfile_top_string (custom_charset_2);
6720 logfile_top_string (custom_charset_3);
6721 logfile_top_string (custom_charset_4);
6722 logfile_top_string (debug_file);
6723 logfile_top_string (opencl_devices);
6724 logfile_top_string (opencl_platforms);
6725 logfile_top_string (opencl_device_types);
6726 logfile_top_uint (opencl_vector_width);
6727 logfile_top_string (induction_dir);
6728 logfile_top_string (markov_hcstat);
6729 logfile_top_string (outfile);
6730 logfile_top_string (outfile_check_dir);
6731 logfile_top_string (rule_buf_l);
6732 logfile_top_string (rule_buf_r);
6733 logfile_top_string (session);
6734 logfile_top_string (truecrypt_keyfiles);
6735 logfile_top_string (veracrypt_keyfiles);
6736 logfile_top_uint (veracrypt_pim);
6737
6738 /**
6739 * Init OpenCL library loader
6740 */
6741
6742 if (keyspace == 0)
6743 {
6744 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6745
6746 ocl_init (ocl);
6747
6748 data.ocl = ocl;
6749 }
6750
6751 /**
6752 * OpenCL platform selection
6753 */
6754
6755 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6756
6757 /**
6758 * OpenCL device selection
6759 */
6760
6761 u32 devices_filter = setup_devices_filter (opencl_devices);
6762
6763 /**
6764 * OpenCL device type selection
6765 */
6766
6767 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6768
6769 /**
6770 * benchmark
6771 */
6772
6773 if (benchmark == 1)
6774 {
6775 /**
6776 * disable useless stuff for benchmark
6777 */
6778
6779 status_timer = 0;
6780 restore_timer = 0;
6781 restore_disable = 1;
6782 potfile_disable = 1;
6783 weak_hash_threshold = 0;
6784 gpu_temp_disable = 1;
6785
6786 data.status_timer = status_timer;
6787 data.restore_timer = restore_timer;
6788 data.restore_disable = restore_disable;
6789
6790 /**
6791 * force attack mode to be bruteforce
6792 */
6793
6794 attack_mode = ATTACK_MODE_BF;
6795 attack_kern = ATTACK_KERN_BF;
6796
6797 if (workload_profile_chgd == 0)
6798 {
6799 workload_profile = 3;
6800
6801 data.workload_profile = workload_profile;
6802 }
6803 }
6804
6805 /**
6806 * config
6807 */
6808
6809 uint hash_type = 0;
6810 uint salt_type = 0;
6811 uint attack_exec = 0;
6812 uint opts_type = 0;
6813 uint kern_type = 0;
6814 uint dgst_size = 0;
6815 uint esalt_size = 0;
6816 uint opti_type = 0;
6817 uint dgst_pos0 = -1;
6818 uint dgst_pos1 = -1;
6819 uint dgst_pos2 = -1;
6820 uint dgst_pos3 = -1;
6821
6822 int (*parse_func) (char *, uint, hash_t *);
6823 int (*sort_by_digest) (const void *, const void *);
6824
6825 uint algorithm_pos = 0;
6826 uint algorithm_max = 1;
6827
6828 uint *algorithms = default_benchmark_algorithms;
6829
6830 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6831
6832 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6833 {
6834 /*
6835 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6836 * the following algos are skipped entirely
6837 */
6838
6839 if (algorithm_pos > 0)
6840 {
6841 local_free (rd);
6842
6843 rd = init_restore (argc, argv);
6844
6845 data.rd = rd;
6846 }
6847
6848 /**
6849 * update hash_mode in case of multihash benchmark
6850 */
6851
6852 if (benchmark == 1)
6853 {
6854 if (hash_mode_chgd == 0)
6855 {
6856 hash_mode = algorithms[algorithm_pos];
6857
6858 data.hash_mode = hash_mode;
6859 }
6860
6861 quiet = 1;
6862
6863 data.quiet = quiet;
6864 }
6865
6866 switch (hash_mode)
6867 {
6868 case 0: hash_type = HASH_TYPE_MD5;
6869 salt_type = SALT_TYPE_NONE;
6870 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6871 opts_type = OPTS_TYPE_PT_GENERATE_LE
6872 | OPTS_TYPE_PT_ADD80
6873 | OPTS_TYPE_PT_ADDBITS14;
6874 kern_type = KERN_TYPE_MD5;
6875 dgst_size = DGST_SIZE_4_4;
6876 parse_func = md5_parse_hash;
6877 sort_by_digest = sort_by_digest_4_4;
6878 opti_type = OPTI_TYPE_ZERO_BYTE
6879 | OPTI_TYPE_PRECOMPUTE_INIT
6880 | OPTI_TYPE_PRECOMPUTE_MERKLE
6881 | OPTI_TYPE_MEET_IN_MIDDLE
6882 | OPTI_TYPE_EARLY_SKIP
6883 | OPTI_TYPE_NOT_ITERATED
6884 | OPTI_TYPE_NOT_SALTED
6885 | OPTI_TYPE_RAW_HASH;
6886 dgst_pos0 = 0;
6887 dgst_pos1 = 3;
6888 dgst_pos2 = 2;
6889 dgst_pos3 = 1;
6890 break;
6891
6892 case 10: hash_type = HASH_TYPE_MD5;
6893 salt_type = SALT_TYPE_INTERN;
6894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6895 opts_type = OPTS_TYPE_PT_GENERATE_LE
6896 | OPTS_TYPE_ST_ADD80
6897 | OPTS_TYPE_ST_ADDBITS14;
6898 kern_type = KERN_TYPE_MD5_PWSLT;
6899 dgst_size = DGST_SIZE_4_4;
6900 parse_func = md5s_parse_hash;
6901 sort_by_digest = sort_by_digest_4_4;
6902 opti_type = OPTI_TYPE_ZERO_BYTE
6903 | OPTI_TYPE_PRECOMPUTE_INIT
6904 | OPTI_TYPE_PRECOMPUTE_MERKLE
6905 | OPTI_TYPE_MEET_IN_MIDDLE
6906 | OPTI_TYPE_EARLY_SKIP
6907 | OPTI_TYPE_NOT_ITERATED
6908 | OPTI_TYPE_APPENDED_SALT
6909 | OPTI_TYPE_RAW_HASH;
6910 dgst_pos0 = 0;
6911 dgst_pos1 = 3;
6912 dgst_pos2 = 2;
6913 dgst_pos3 = 1;
6914 break;
6915
6916 case 11: hash_type = HASH_TYPE_MD5;
6917 salt_type = SALT_TYPE_INTERN;
6918 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6919 opts_type = OPTS_TYPE_PT_GENERATE_LE
6920 | OPTS_TYPE_ST_ADD80
6921 | OPTS_TYPE_ST_ADDBITS14;
6922 kern_type = KERN_TYPE_MD5_PWSLT;
6923 dgst_size = DGST_SIZE_4_4;
6924 parse_func = joomla_parse_hash;
6925 sort_by_digest = sort_by_digest_4_4;
6926 opti_type = OPTI_TYPE_ZERO_BYTE
6927 | OPTI_TYPE_PRECOMPUTE_INIT
6928 | OPTI_TYPE_PRECOMPUTE_MERKLE
6929 | OPTI_TYPE_MEET_IN_MIDDLE
6930 | OPTI_TYPE_EARLY_SKIP
6931 | OPTI_TYPE_NOT_ITERATED
6932 | OPTI_TYPE_APPENDED_SALT
6933 | OPTI_TYPE_RAW_HASH;
6934 dgst_pos0 = 0;
6935 dgst_pos1 = 3;
6936 dgst_pos2 = 2;
6937 dgst_pos3 = 1;
6938 break;
6939
6940 case 12: hash_type = HASH_TYPE_MD5;
6941 salt_type = SALT_TYPE_INTERN;
6942 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6943 opts_type = OPTS_TYPE_PT_GENERATE_LE
6944 | OPTS_TYPE_ST_ADD80
6945 | OPTS_TYPE_ST_ADDBITS14;
6946 kern_type = KERN_TYPE_MD5_PWSLT;
6947 dgst_size = DGST_SIZE_4_4;
6948 parse_func = postgresql_parse_hash;
6949 sort_by_digest = sort_by_digest_4_4;
6950 opti_type = OPTI_TYPE_ZERO_BYTE
6951 | OPTI_TYPE_PRECOMPUTE_INIT
6952 | OPTI_TYPE_PRECOMPUTE_MERKLE
6953 | OPTI_TYPE_MEET_IN_MIDDLE
6954 | OPTI_TYPE_EARLY_SKIP
6955 | OPTI_TYPE_NOT_ITERATED
6956 | OPTI_TYPE_APPENDED_SALT
6957 | OPTI_TYPE_RAW_HASH;
6958 dgst_pos0 = 0;
6959 dgst_pos1 = 3;
6960 dgst_pos2 = 2;
6961 dgst_pos3 = 1;
6962 break;
6963
6964 case 20: hash_type = HASH_TYPE_MD5;
6965 salt_type = SALT_TYPE_INTERN;
6966 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6967 opts_type = OPTS_TYPE_PT_GENERATE_LE
6968 | OPTS_TYPE_PT_ADD80
6969 | OPTS_TYPE_PT_ADDBITS14;
6970 kern_type = KERN_TYPE_MD5_SLTPW;
6971 dgst_size = DGST_SIZE_4_4;
6972 parse_func = md5s_parse_hash;
6973 sort_by_digest = sort_by_digest_4_4;
6974 opti_type = OPTI_TYPE_ZERO_BYTE
6975 | OPTI_TYPE_PRECOMPUTE_INIT
6976 | OPTI_TYPE_PRECOMPUTE_MERKLE
6977 | OPTI_TYPE_EARLY_SKIP
6978 | OPTI_TYPE_NOT_ITERATED
6979 | OPTI_TYPE_PREPENDED_SALT
6980 | OPTI_TYPE_RAW_HASH;
6981 dgst_pos0 = 0;
6982 dgst_pos1 = 3;
6983 dgst_pos2 = 2;
6984 dgst_pos3 = 1;
6985 break;
6986
6987 case 21: hash_type = HASH_TYPE_MD5;
6988 salt_type = SALT_TYPE_INTERN;
6989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6990 opts_type = OPTS_TYPE_PT_GENERATE_LE
6991 | OPTS_TYPE_PT_ADD80
6992 | OPTS_TYPE_PT_ADDBITS14;
6993 kern_type = KERN_TYPE_MD5_SLTPW;
6994 dgst_size = DGST_SIZE_4_4;
6995 parse_func = osc_parse_hash;
6996 sort_by_digest = sort_by_digest_4_4;
6997 opti_type = OPTI_TYPE_ZERO_BYTE
6998 | OPTI_TYPE_PRECOMPUTE_INIT
6999 | OPTI_TYPE_PRECOMPUTE_MERKLE
7000 | OPTI_TYPE_EARLY_SKIP
7001 | OPTI_TYPE_NOT_ITERATED
7002 | OPTI_TYPE_PREPENDED_SALT
7003 | OPTI_TYPE_RAW_HASH;
7004 dgst_pos0 = 0;
7005 dgst_pos1 = 3;
7006 dgst_pos2 = 2;
7007 dgst_pos3 = 1;
7008 break;
7009
7010 case 22: hash_type = HASH_TYPE_MD5;
7011 salt_type = SALT_TYPE_EMBEDDED;
7012 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7013 opts_type = OPTS_TYPE_PT_GENERATE_LE
7014 | OPTS_TYPE_PT_ADD80
7015 | OPTS_TYPE_PT_ADDBITS14;
7016 kern_type = KERN_TYPE_MD5_SLTPW;
7017 dgst_size = DGST_SIZE_4_4;
7018 parse_func = netscreen_parse_hash;
7019 sort_by_digest = sort_by_digest_4_4;
7020 opti_type = OPTI_TYPE_ZERO_BYTE
7021 | OPTI_TYPE_PRECOMPUTE_INIT
7022 | OPTI_TYPE_PRECOMPUTE_MERKLE
7023 | OPTI_TYPE_EARLY_SKIP
7024 | OPTI_TYPE_NOT_ITERATED
7025 | OPTI_TYPE_PREPENDED_SALT
7026 | OPTI_TYPE_RAW_HASH;
7027 dgst_pos0 = 0;
7028 dgst_pos1 = 3;
7029 dgst_pos2 = 2;
7030 dgst_pos3 = 1;
7031 break;
7032
7033 case 23: hash_type = HASH_TYPE_MD5;
7034 salt_type = SALT_TYPE_EMBEDDED;
7035 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7036 opts_type = OPTS_TYPE_PT_GENERATE_LE
7037 | OPTS_TYPE_PT_ADD80
7038 | OPTS_TYPE_PT_ADDBITS14;
7039 kern_type = KERN_TYPE_MD5_SLTPW;
7040 dgst_size = DGST_SIZE_4_4;
7041 parse_func = skype_parse_hash;
7042 sort_by_digest = sort_by_digest_4_4;
7043 opti_type = OPTI_TYPE_ZERO_BYTE
7044 | OPTI_TYPE_PRECOMPUTE_INIT
7045 | OPTI_TYPE_PRECOMPUTE_MERKLE
7046 | OPTI_TYPE_EARLY_SKIP
7047 | OPTI_TYPE_NOT_ITERATED
7048 | OPTI_TYPE_PREPENDED_SALT
7049 | OPTI_TYPE_RAW_HASH;
7050 dgst_pos0 = 0;
7051 dgst_pos1 = 3;
7052 dgst_pos2 = 2;
7053 dgst_pos3 = 1;
7054 break;
7055
7056 case 30: hash_type = HASH_TYPE_MD5;
7057 salt_type = SALT_TYPE_INTERN;
7058 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7059 opts_type = OPTS_TYPE_PT_GENERATE_LE
7060 | OPTS_TYPE_PT_UNICODE
7061 | OPTS_TYPE_ST_ADD80
7062 | OPTS_TYPE_ST_ADDBITS14;
7063 kern_type = KERN_TYPE_MD5_PWUSLT;
7064 dgst_size = DGST_SIZE_4_4;
7065 parse_func = md5s_parse_hash;
7066 sort_by_digest = sort_by_digest_4_4;
7067 opti_type = OPTI_TYPE_ZERO_BYTE
7068 | OPTI_TYPE_PRECOMPUTE_INIT
7069 | OPTI_TYPE_PRECOMPUTE_MERKLE
7070 | OPTI_TYPE_MEET_IN_MIDDLE
7071 | OPTI_TYPE_EARLY_SKIP
7072 | OPTI_TYPE_NOT_ITERATED
7073 | OPTI_TYPE_APPENDED_SALT
7074 | OPTI_TYPE_RAW_HASH;
7075 dgst_pos0 = 0;
7076 dgst_pos1 = 3;
7077 dgst_pos2 = 2;
7078 dgst_pos3 = 1;
7079 break;
7080
7081 case 40: hash_type = HASH_TYPE_MD5;
7082 salt_type = SALT_TYPE_INTERN;
7083 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7084 opts_type = OPTS_TYPE_PT_GENERATE_LE
7085 | OPTS_TYPE_PT_ADD80
7086 | OPTS_TYPE_PT_ADDBITS14
7087 | OPTS_TYPE_PT_UNICODE;
7088 kern_type = KERN_TYPE_MD5_SLTPWU;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = md5s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_EARLY_SKIP
7096 | OPTI_TYPE_NOT_ITERATED
7097 | OPTI_TYPE_PREPENDED_SALT
7098 | OPTI_TYPE_RAW_HASH;
7099 dgst_pos0 = 0;
7100 dgst_pos1 = 3;
7101 dgst_pos2 = 2;
7102 dgst_pos3 = 1;
7103 break;
7104
7105 case 50: hash_type = HASH_TYPE_MD5;
7106 salt_type = SALT_TYPE_INTERN;
7107 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7108 opts_type = OPTS_TYPE_PT_GENERATE_LE
7109 | OPTS_TYPE_ST_ADD80
7110 | OPTS_TYPE_ST_ADDBITS14;
7111 kern_type = KERN_TYPE_HMACMD5_PW;
7112 dgst_size = DGST_SIZE_4_4;
7113 parse_func = hmacmd5_parse_hash;
7114 sort_by_digest = sort_by_digest_4_4;
7115 opti_type = OPTI_TYPE_ZERO_BYTE
7116 | OPTI_TYPE_NOT_ITERATED;
7117 dgst_pos0 = 0;
7118 dgst_pos1 = 3;
7119 dgst_pos2 = 2;
7120 dgst_pos3 = 1;
7121 break;
7122
7123 case 60: hash_type = HASH_TYPE_MD5;
7124 salt_type = SALT_TYPE_INTERN;
7125 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7126 opts_type = OPTS_TYPE_PT_GENERATE_LE
7127 | OPTS_TYPE_PT_ADD80
7128 | OPTS_TYPE_PT_ADDBITS14;
7129 kern_type = KERN_TYPE_HMACMD5_SLT;
7130 dgst_size = DGST_SIZE_4_4;
7131 parse_func = hmacmd5_parse_hash;
7132 sort_by_digest = sort_by_digest_4_4;
7133 opti_type = OPTI_TYPE_ZERO_BYTE
7134 | OPTI_TYPE_NOT_ITERATED;
7135 dgst_pos0 = 0;
7136 dgst_pos1 = 3;
7137 dgst_pos2 = 2;
7138 dgst_pos3 = 1;
7139 break;
7140
7141 case 100: hash_type = HASH_TYPE_SHA1;
7142 salt_type = SALT_TYPE_NONE;
7143 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7144 opts_type = OPTS_TYPE_PT_GENERATE_BE
7145 | OPTS_TYPE_PT_ADD80
7146 | OPTS_TYPE_PT_ADDBITS15;
7147 kern_type = KERN_TYPE_SHA1;
7148 dgst_size = DGST_SIZE_4_5;
7149 parse_func = sha1_parse_hash;
7150 sort_by_digest = sort_by_digest_4_5;
7151 opti_type = OPTI_TYPE_ZERO_BYTE
7152 | OPTI_TYPE_PRECOMPUTE_INIT
7153 | OPTI_TYPE_PRECOMPUTE_MERKLE
7154 | OPTI_TYPE_EARLY_SKIP
7155 | OPTI_TYPE_NOT_ITERATED
7156 | OPTI_TYPE_NOT_SALTED
7157 | OPTI_TYPE_RAW_HASH;
7158 dgst_pos0 = 3;
7159 dgst_pos1 = 4;
7160 dgst_pos2 = 2;
7161 dgst_pos3 = 1;
7162 break;
7163
7164 case 101: hash_type = HASH_TYPE_SHA1;
7165 salt_type = SALT_TYPE_NONE;
7166 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7167 opts_type = OPTS_TYPE_PT_GENERATE_BE
7168 | OPTS_TYPE_PT_ADD80
7169 | OPTS_TYPE_PT_ADDBITS15;
7170 kern_type = KERN_TYPE_SHA1;
7171 dgst_size = DGST_SIZE_4_5;
7172 parse_func = sha1b64_parse_hash;
7173 sort_by_digest = sort_by_digest_4_5;
7174 opti_type = OPTI_TYPE_ZERO_BYTE
7175 | OPTI_TYPE_PRECOMPUTE_INIT
7176 | OPTI_TYPE_PRECOMPUTE_MERKLE
7177 | OPTI_TYPE_EARLY_SKIP
7178 | OPTI_TYPE_NOT_ITERATED
7179 | OPTI_TYPE_NOT_SALTED
7180 | OPTI_TYPE_RAW_HASH;
7181 dgst_pos0 = 3;
7182 dgst_pos1 = 4;
7183 dgst_pos2 = 2;
7184 dgst_pos3 = 1;
7185 break;
7186
7187 case 110: hash_type = HASH_TYPE_SHA1;
7188 salt_type = SALT_TYPE_INTERN;
7189 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7190 opts_type = OPTS_TYPE_PT_GENERATE_BE
7191 | OPTS_TYPE_ST_ADD80
7192 | OPTS_TYPE_ST_ADDBITS15;
7193 kern_type = KERN_TYPE_SHA1_PWSLT;
7194 dgst_size = DGST_SIZE_4_5;
7195 parse_func = sha1s_parse_hash;
7196 sort_by_digest = sort_by_digest_4_5;
7197 opti_type = OPTI_TYPE_ZERO_BYTE
7198 | OPTI_TYPE_PRECOMPUTE_INIT
7199 | OPTI_TYPE_PRECOMPUTE_MERKLE
7200 | OPTI_TYPE_EARLY_SKIP
7201 | OPTI_TYPE_NOT_ITERATED
7202 | OPTI_TYPE_APPENDED_SALT
7203 | OPTI_TYPE_RAW_HASH;
7204 dgst_pos0 = 3;
7205 dgst_pos1 = 4;
7206 dgst_pos2 = 2;
7207 dgst_pos3 = 1;
7208 break;
7209
7210 case 111: hash_type = HASH_TYPE_SHA1;
7211 salt_type = SALT_TYPE_EMBEDDED;
7212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7213 opts_type = OPTS_TYPE_PT_GENERATE_BE
7214 | OPTS_TYPE_ST_ADD80
7215 | OPTS_TYPE_ST_ADDBITS15;
7216 kern_type = KERN_TYPE_SHA1_PWSLT;
7217 dgst_size = DGST_SIZE_4_5;
7218 parse_func = sha1b64s_parse_hash;
7219 sort_by_digest = sort_by_digest_4_5;
7220 opti_type = OPTI_TYPE_ZERO_BYTE
7221 | OPTI_TYPE_PRECOMPUTE_INIT
7222 | OPTI_TYPE_PRECOMPUTE_MERKLE
7223 | OPTI_TYPE_EARLY_SKIP
7224 | OPTI_TYPE_NOT_ITERATED
7225 | OPTI_TYPE_APPENDED_SALT
7226 | OPTI_TYPE_RAW_HASH;
7227 dgst_pos0 = 3;
7228 dgst_pos1 = 4;
7229 dgst_pos2 = 2;
7230 dgst_pos3 = 1;
7231 break;
7232
7233 case 112: hash_type = HASH_TYPE_SHA1;
7234 salt_type = SALT_TYPE_INTERN;
7235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7236 opts_type = OPTS_TYPE_PT_GENERATE_BE
7237 | OPTS_TYPE_ST_ADD80
7238 | OPTS_TYPE_ST_ADDBITS15
7239 | OPTS_TYPE_ST_HEX;
7240 kern_type = KERN_TYPE_SHA1_PWSLT;
7241 dgst_size = DGST_SIZE_4_5;
7242 parse_func = oracles_parse_hash;
7243 sort_by_digest = sort_by_digest_4_5;
7244 opti_type = OPTI_TYPE_ZERO_BYTE
7245 | OPTI_TYPE_PRECOMPUTE_INIT
7246 | OPTI_TYPE_PRECOMPUTE_MERKLE
7247 | OPTI_TYPE_EARLY_SKIP
7248 | OPTI_TYPE_NOT_ITERATED
7249 | OPTI_TYPE_APPENDED_SALT
7250 | OPTI_TYPE_RAW_HASH;
7251 dgst_pos0 = 3;
7252 dgst_pos1 = 4;
7253 dgst_pos2 = 2;
7254 dgst_pos3 = 1;
7255 break;
7256
7257 case 120: hash_type = HASH_TYPE_SHA1;
7258 salt_type = SALT_TYPE_INTERN;
7259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7260 opts_type = OPTS_TYPE_PT_GENERATE_BE
7261 | OPTS_TYPE_PT_ADD80
7262 | OPTS_TYPE_PT_ADDBITS15;
7263 kern_type = KERN_TYPE_SHA1_SLTPW;
7264 dgst_size = DGST_SIZE_4_5;
7265 parse_func = sha1s_parse_hash;
7266 sort_by_digest = sort_by_digest_4_5;
7267 opti_type = OPTI_TYPE_ZERO_BYTE
7268 | OPTI_TYPE_PRECOMPUTE_INIT
7269 | OPTI_TYPE_PRECOMPUTE_MERKLE
7270 | OPTI_TYPE_EARLY_SKIP
7271 | OPTI_TYPE_NOT_ITERATED
7272 | OPTI_TYPE_PREPENDED_SALT
7273 | OPTI_TYPE_RAW_HASH;
7274 dgst_pos0 = 3;
7275 dgst_pos1 = 4;
7276 dgst_pos2 = 2;
7277 dgst_pos3 = 1;
7278 break;
7279
7280 case 121: hash_type = HASH_TYPE_SHA1;
7281 salt_type = SALT_TYPE_INTERN;
7282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7283 opts_type = OPTS_TYPE_PT_GENERATE_BE
7284 | OPTS_TYPE_PT_ADD80
7285 | OPTS_TYPE_PT_ADDBITS15
7286 | OPTS_TYPE_ST_LOWER;
7287 kern_type = KERN_TYPE_SHA1_SLTPW;
7288 dgst_size = DGST_SIZE_4_5;
7289 parse_func = smf_parse_hash;
7290 sort_by_digest = sort_by_digest_4_5;
7291 opti_type = OPTI_TYPE_ZERO_BYTE
7292 | OPTI_TYPE_PRECOMPUTE_INIT
7293 | OPTI_TYPE_PRECOMPUTE_MERKLE
7294 | OPTI_TYPE_EARLY_SKIP
7295 | OPTI_TYPE_NOT_ITERATED
7296 | OPTI_TYPE_PREPENDED_SALT
7297 | OPTI_TYPE_RAW_HASH;
7298 dgst_pos0 = 3;
7299 dgst_pos1 = 4;
7300 dgst_pos2 = 2;
7301 dgst_pos3 = 1;
7302 break;
7303
7304 case 122: hash_type = HASH_TYPE_SHA1;
7305 salt_type = SALT_TYPE_EMBEDDED;
7306 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7307 opts_type = OPTS_TYPE_PT_GENERATE_BE
7308 | OPTS_TYPE_PT_ADD80
7309 | OPTS_TYPE_PT_ADDBITS15
7310 | OPTS_TYPE_ST_HEX;
7311 kern_type = KERN_TYPE_SHA1_SLTPW;
7312 dgst_size = DGST_SIZE_4_5;
7313 parse_func = osx1_parse_hash;
7314 sort_by_digest = sort_by_digest_4_5;
7315 opti_type = OPTI_TYPE_ZERO_BYTE
7316 | OPTI_TYPE_PRECOMPUTE_INIT
7317 | OPTI_TYPE_PRECOMPUTE_MERKLE
7318 | OPTI_TYPE_EARLY_SKIP
7319 | OPTI_TYPE_NOT_ITERATED
7320 | OPTI_TYPE_PREPENDED_SALT
7321 | OPTI_TYPE_RAW_HASH;
7322 dgst_pos0 = 3;
7323 dgst_pos1 = 4;
7324 dgst_pos2 = 2;
7325 dgst_pos3 = 1;
7326 break;
7327
7328 case 124: hash_type = HASH_TYPE_SHA1;
7329 salt_type = SALT_TYPE_EMBEDDED;
7330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7331 opts_type = OPTS_TYPE_PT_GENERATE_BE
7332 | OPTS_TYPE_PT_ADD80
7333 | OPTS_TYPE_PT_ADDBITS15;
7334 kern_type = KERN_TYPE_SHA1_SLTPW;
7335 dgst_size = DGST_SIZE_4_5;
7336 parse_func = djangosha1_parse_hash;
7337 sort_by_digest = sort_by_digest_4_5;
7338 opti_type = OPTI_TYPE_ZERO_BYTE
7339 | OPTI_TYPE_PRECOMPUTE_INIT
7340 | OPTI_TYPE_PRECOMPUTE_MERKLE
7341 | OPTI_TYPE_EARLY_SKIP
7342 | OPTI_TYPE_NOT_ITERATED
7343 | OPTI_TYPE_PREPENDED_SALT
7344 | OPTI_TYPE_RAW_HASH;
7345 dgst_pos0 = 3;
7346 dgst_pos1 = 4;
7347 dgst_pos2 = 2;
7348 dgst_pos3 = 1;
7349 break;
7350
7351 case 125: hash_type = HASH_TYPE_SHA1;
7352 salt_type = SALT_TYPE_EMBEDDED;
7353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7354 opts_type = OPTS_TYPE_PT_GENERATE_BE
7355 | OPTS_TYPE_PT_ADD80
7356 | OPTS_TYPE_PT_ADDBITS15
7357 | OPTS_TYPE_ST_HEX;
7358 kern_type = KERN_TYPE_SHA1_SLTPW;
7359 dgst_size = DGST_SIZE_4_5;
7360 parse_func = arubaos_parse_hash;
7361 sort_by_digest = sort_by_digest_4_5;
7362 opti_type = OPTI_TYPE_ZERO_BYTE
7363 | OPTI_TYPE_PRECOMPUTE_INIT
7364 | OPTI_TYPE_PRECOMPUTE_MERKLE
7365 | OPTI_TYPE_EARLY_SKIP
7366 | OPTI_TYPE_NOT_ITERATED
7367 | OPTI_TYPE_PREPENDED_SALT
7368 | OPTI_TYPE_RAW_HASH;
7369 dgst_pos0 = 3;
7370 dgst_pos1 = 4;
7371 dgst_pos2 = 2;
7372 dgst_pos3 = 1;
7373 break;
7374
7375 case 130: hash_type = HASH_TYPE_SHA1;
7376 salt_type = SALT_TYPE_INTERN;
7377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7378 opts_type = OPTS_TYPE_PT_GENERATE_BE
7379 | OPTS_TYPE_PT_UNICODE
7380 | OPTS_TYPE_ST_ADD80
7381 | OPTS_TYPE_ST_ADDBITS15;
7382 kern_type = KERN_TYPE_SHA1_PWUSLT;
7383 dgst_size = DGST_SIZE_4_5;
7384 parse_func = sha1s_parse_hash;
7385 sort_by_digest = sort_by_digest_4_5;
7386 opti_type = OPTI_TYPE_ZERO_BYTE
7387 | OPTI_TYPE_PRECOMPUTE_INIT
7388 | OPTI_TYPE_PRECOMPUTE_MERKLE
7389 | OPTI_TYPE_EARLY_SKIP
7390 | OPTI_TYPE_NOT_ITERATED
7391 | OPTI_TYPE_APPENDED_SALT
7392 | OPTI_TYPE_RAW_HASH;
7393 dgst_pos0 = 3;
7394 dgst_pos1 = 4;
7395 dgst_pos2 = 2;
7396 dgst_pos3 = 1;
7397 break;
7398
7399 case 131: hash_type = HASH_TYPE_SHA1;
7400 salt_type = SALT_TYPE_EMBEDDED;
7401 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7402 opts_type = OPTS_TYPE_PT_GENERATE_BE
7403 | OPTS_TYPE_PT_UNICODE
7404 | OPTS_TYPE_PT_UPPER
7405 | OPTS_TYPE_ST_ADD80
7406 | OPTS_TYPE_ST_ADDBITS15
7407 | OPTS_TYPE_ST_HEX;
7408 kern_type = KERN_TYPE_SHA1_PWUSLT;
7409 dgst_size = DGST_SIZE_4_5;
7410 parse_func = mssql2000_parse_hash;
7411 sort_by_digest = sort_by_digest_4_5;
7412 opti_type = OPTI_TYPE_ZERO_BYTE
7413 | OPTI_TYPE_PRECOMPUTE_INIT
7414 | OPTI_TYPE_PRECOMPUTE_MERKLE
7415 | OPTI_TYPE_EARLY_SKIP
7416 | OPTI_TYPE_NOT_ITERATED
7417 | OPTI_TYPE_APPENDED_SALT
7418 | OPTI_TYPE_RAW_HASH;
7419 dgst_pos0 = 3;
7420 dgst_pos1 = 4;
7421 dgst_pos2 = 2;
7422 dgst_pos3 = 1;
7423 break;
7424
7425 case 132: hash_type = HASH_TYPE_SHA1;
7426 salt_type = SALT_TYPE_EMBEDDED;
7427 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7428 opts_type = OPTS_TYPE_PT_GENERATE_BE
7429 | OPTS_TYPE_PT_UNICODE
7430 | OPTS_TYPE_ST_ADD80
7431 | OPTS_TYPE_ST_ADDBITS15
7432 | OPTS_TYPE_ST_HEX;
7433 kern_type = KERN_TYPE_SHA1_PWUSLT;
7434 dgst_size = DGST_SIZE_4_5;
7435 parse_func = mssql2005_parse_hash;
7436 sort_by_digest = sort_by_digest_4_5;
7437 opti_type = OPTI_TYPE_ZERO_BYTE
7438 | OPTI_TYPE_PRECOMPUTE_INIT
7439 | OPTI_TYPE_PRECOMPUTE_MERKLE
7440 | OPTI_TYPE_EARLY_SKIP
7441 | OPTI_TYPE_NOT_ITERATED
7442 | OPTI_TYPE_APPENDED_SALT
7443 | OPTI_TYPE_RAW_HASH;
7444 dgst_pos0 = 3;
7445 dgst_pos1 = 4;
7446 dgst_pos2 = 2;
7447 dgst_pos3 = 1;
7448 break;
7449
7450 case 133: hash_type = HASH_TYPE_SHA1;
7451 salt_type = SALT_TYPE_EMBEDDED;
7452 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7453 opts_type = OPTS_TYPE_PT_GENERATE_BE
7454 | OPTS_TYPE_PT_UNICODE
7455 | OPTS_TYPE_ST_ADD80
7456 | OPTS_TYPE_ST_ADDBITS15;
7457 kern_type = KERN_TYPE_SHA1_PWUSLT;
7458 dgst_size = DGST_SIZE_4_5;
7459 parse_func = peoplesoft_parse_hash;
7460 sort_by_digest = sort_by_digest_4_5;
7461 opti_type = OPTI_TYPE_ZERO_BYTE
7462 | OPTI_TYPE_PRECOMPUTE_INIT
7463 | OPTI_TYPE_PRECOMPUTE_MERKLE
7464 | OPTI_TYPE_EARLY_SKIP
7465 | OPTI_TYPE_NOT_ITERATED
7466 | OPTI_TYPE_APPENDED_SALT
7467 | OPTI_TYPE_RAW_HASH;
7468 dgst_pos0 = 3;
7469 dgst_pos1 = 4;
7470 dgst_pos2 = 2;
7471 dgst_pos3 = 1;
7472 break;
7473
7474 case 140: hash_type = HASH_TYPE_SHA1;
7475 salt_type = SALT_TYPE_INTERN;
7476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7477 opts_type = OPTS_TYPE_PT_GENERATE_BE
7478 | OPTS_TYPE_PT_ADD80
7479 | OPTS_TYPE_PT_ADDBITS15
7480 | OPTS_TYPE_PT_UNICODE;
7481 kern_type = KERN_TYPE_SHA1_SLTPWU;
7482 dgst_size = DGST_SIZE_4_5;
7483 parse_func = sha1s_parse_hash;
7484 sort_by_digest = sort_by_digest_4_5;
7485 opti_type = OPTI_TYPE_ZERO_BYTE
7486 | OPTI_TYPE_PRECOMPUTE_INIT
7487 | OPTI_TYPE_PRECOMPUTE_MERKLE
7488 | OPTI_TYPE_EARLY_SKIP
7489 | OPTI_TYPE_NOT_ITERATED
7490 | OPTI_TYPE_PREPENDED_SALT
7491 | OPTI_TYPE_RAW_HASH;
7492 dgst_pos0 = 3;
7493 dgst_pos1 = 4;
7494 dgst_pos2 = 2;
7495 dgst_pos3 = 1;
7496 break;
7497
7498 case 141: hash_type = HASH_TYPE_SHA1;
7499 salt_type = SALT_TYPE_EMBEDDED;
7500 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7501 opts_type = OPTS_TYPE_PT_GENERATE_BE
7502 | OPTS_TYPE_PT_ADD80
7503 | OPTS_TYPE_PT_ADDBITS15
7504 | OPTS_TYPE_PT_UNICODE
7505 | OPTS_TYPE_ST_BASE64;
7506 kern_type = KERN_TYPE_SHA1_SLTPWU;
7507 dgst_size = DGST_SIZE_4_5;
7508 parse_func = episerver_parse_hash;
7509 sort_by_digest = sort_by_digest_4_5;
7510 opti_type = OPTI_TYPE_ZERO_BYTE
7511 | OPTI_TYPE_PRECOMPUTE_INIT
7512 | OPTI_TYPE_PRECOMPUTE_MERKLE
7513 | OPTI_TYPE_EARLY_SKIP
7514 | OPTI_TYPE_NOT_ITERATED
7515 | OPTI_TYPE_PREPENDED_SALT
7516 | OPTI_TYPE_RAW_HASH;
7517 dgst_pos0 = 3;
7518 dgst_pos1 = 4;
7519 dgst_pos2 = 2;
7520 dgst_pos3 = 1;
7521 break;
7522
7523 case 150: hash_type = HASH_TYPE_SHA1;
7524 salt_type = SALT_TYPE_INTERN;
7525 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7526 opts_type = OPTS_TYPE_PT_GENERATE_BE
7527 | OPTS_TYPE_ST_ADD80
7528 | OPTS_TYPE_ST_ADDBITS15;
7529 kern_type = KERN_TYPE_HMACSHA1_PW;
7530 dgst_size = DGST_SIZE_4_5;
7531 parse_func = hmacsha1_parse_hash;
7532 sort_by_digest = sort_by_digest_4_5;
7533 opti_type = OPTI_TYPE_ZERO_BYTE
7534 | OPTI_TYPE_NOT_ITERATED;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 160: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_INTERN;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15;
7547 kern_type = KERN_TYPE_HMACSHA1_SLT;
7548 dgst_size = DGST_SIZE_4_5;
7549 parse_func = hmacsha1_parse_hash;
7550 sort_by_digest = sort_by_digest_4_5;
7551 opti_type = OPTI_TYPE_ZERO_BYTE
7552 | OPTI_TYPE_NOT_ITERATED;
7553 dgst_pos0 = 3;
7554 dgst_pos1 = 4;
7555 dgst_pos2 = 2;
7556 dgst_pos3 = 1;
7557 break;
7558
7559 case 190: hash_type = HASH_TYPE_SHA1;
7560 salt_type = SALT_TYPE_NONE;
7561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7562 opts_type = OPTS_TYPE_PT_GENERATE_BE
7563 | OPTS_TYPE_PT_ADD80
7564 | OPTS_TYPE_PT_ADDBITS15;
7565 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7566 dgst_size = DGST_SIZE_4_5;
7567 parse_func = sha1linkedin_parse_hash;
7568 sort_by_digest = sort_by_digest_4_5;
7569 opti_type = OPTI_TYPE_ZERO_BYTE
7570 | OPTI_TYPE_PRECOMPUTE_INIT
7571 | OPTI_TYPE_EARLY_SKIP
7572 | OPTI_TYPE_NOT_ITERATED
7573 | OPTI_TYPE_NOT_SALTED;
7574 dgst_pos0 = 0;
7575 dgst_pos1 = 4;
7576 dgst_pos2 = 3;
7577 dgst_pos3 = 2;
7578 break;
7579
7580 case 200: hash_type = HASH_TYPE_MYSQL;
7581 salt_type = SALT_TYPE_NONE;
7582 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7583 opts_type = 0;
7584 kern_type = KERN_TYPE_MYSQL;
7585 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7586 parse_func = mysql323_parse_hash;
7587 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7588 opti_type = OPTI_TYPE_ZERO_BYTE;
7589 dgst_pos0 = 0;
7590 dgst_pos1 = 1;
7591 dgst_pos2 = 2;
7592 dgst_pos3 = 3;
7593 break;
7594
7595 case 300: hash_type = HASH_TYPE_SHA1;
7596 salt_type = SALT_TYPE_NONE;
7597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7598 opts_type = OPTS_TYPE_PT_GENERATE_BE
7599 | OPTS_TYPE_PT_ADD80
7600 | OPTS_TYPE_PT_ADDBITS15;
7601 kern_type = KERN_TYPE_MYSQL41;
7602 dgst_size = DGST_SIZE_4_5;
7603 parse_func = sha1_parse_hash;
7604 sort_by_digest = sort_by_digest_4_5;
7605 opti_type = OPTI_TYPE_ZERO_BYTE
7606 | OPTI_TYPE_PRECOMPUTE_INIT
7607 | OPTI_TYPE_PRECOMPUTE_MERKLE
7608 | OPTI_TYPE_EARLY_SKIP
7609 | OPTI_TYPE_NOT_ITERATED
7610 | OPTI_TYPE_NOT_SALTED;
7611 dgst_pos0 = 3;
7612 dgst_pos1 = 4;
7613 dgst_pos2 = 2;
7614 dgst_pos3 = 1;
7615 break;
7616
7617 case 400: hash_type = HASH_TYPE_MD5;
7618 salt_type = SALT_TYPE_EMBEDDED;
7619 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7620 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7621 kern_type = KERN_TYPE_PHPASS;
7622 dgst_size = DGST_SIZE_4_4;
7623 parse_func = phpass_parse_hash;
7624 sort_by_digest = sort_by_digest_4_4;
7625 opti_type = OPTI_TYPE_ZERO_BYTE
7626 | OPTI_TYPE_SLOW_HASH_SIMD;
7627 dgst_pos0 = 0;
7628 dgst_pos1 = 1;
7629 dgst_pos2 = 2;
7630 dgst_pos3 = 3;
7631 break;
7632
7633 case 500: hash_type = HASH_TYPE_MD5;
7634 salt_type = SALT_TYPE_EMBEDDED;
7635 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7636 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7637 kern_type = KERN_TYPE_MD5CRYPT;
7638 dgst_size = DGST_SIZE_4_4;
7639 parse_func = md5crypt_parse_hash;
7640 sort_by_digest = sort_by_digest_4_4;
7641 opti_type = OPTI_TYPE_ZERO_BYTE;
7642 dgst_pos0 = 0;
7643 dgst_pos1 = 1;
7644 dgst_pos2 = 2;
7645 dgst_pos3 = 3;
7646 break;
7647
7648 case 501: hash_type = HASH_TYPE_MD5;
7649 salt_type = SALT_TYPE_EMBEDDED;
7650 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7651 opts_type = OPTS_TYPE_PT_GENERATE_LE
7652 | OPTS_TYPE_HASH_COPY;
7653 kern_type = KERN_TYPE_MD5CRYPT;
7654 dgst_size = DGST_SIZE_4_4;
7655 parse_func = juniper_parse_hash;
7656 sort_by_digest = sort_by_digest_4_4;
7657 opti_type = OPTI_TYPE_ZERO_BYTE;
7658 dgst_pos0 = 0;
7659 dgst_pos1 = 1;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 3;
7662 break;
7663
7664 case 900: hash_type = HASH_TYPE_MD4;
7665 salt_type = SALT_TYPE_NONE;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_LE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS14;
7670 kern_type = KERN_TYPE_MD4;
7671 dgst_size = DGST_SIZE_4_4;
7672 parse_func = md4_parse_hash;
7673 sort_by_digest = sort_by_digest_4_4;
7674 opti_type = OPTI_TYPE_ZERO_BYTE
7675 | OPTI_TYPE_PRECOMPUTE_INIT
7676 | OPTI_TYPE_PRECOMPUTE_MERKLE
7677 | OPTI_TYPE_MEET_IN_MIDDLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_NOT_SALTED
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 0;
7683 dgst_pos1 = 3;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 1000: hash_type = HASH_TYPE_MD4;
7689 salt_type = SALT_TYPE_NONE;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_LE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS14
7694 | OPTS_TYPE_PT_UNICODE;
7695 kern_type = KERN_TYPE_MD4_PWU;
7696 dgst_size = DGST_SIZE_4_4;
7697 parse_func = md4_parse_hash;
7698 sort_by_digest = sort_by_digest_4_4;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_PRECOMPUTE_INIT
7701 | OPTI_TYPE_PRECOMPUTE_MERKLE
7702 | OPTI_TYPE_MEET_IN_MIDDLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_NOT_SALTED
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 0;
7708 dgst_pos1 = 3;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 1100: hash_type = HASH_TYPE_MD4;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_LE
7717 | OPTS_TYPE_PT_ADD80
7718 | OPTS_TYPE_PT_ADDBITS14
7719 | OPTS_TYPE_PT_UNICODE
7720 | OPTS_TYPE_ST_ADD80
7721 | OPTS_TYPE_ST_UNICODE
7722 | OPTS_TYPE_ST_LOWER;
7723 kern_type = KERN_TYPE_MD44_PWUSLT;
7724 dgst_size = DGST_SIZE_4_4;
7725 parse_func = dcc_parse_hash;
7726 sort_by_digest = sort_by_digest_4_4;
7727 opti_type = OPTI_TYPE_ZERO_BYTE
7728 | OPTI_TYPE_PRECOMPUTE_INIT
7729 | OPTI_TYPE_PRECOMPUTE_MERKLE
7730 | OPTI_TYPE_EARLY_SKIP
7731 | OPTI_TYPE_NOT_ITERATED;
7732 dgst_pos0 = 0;
7733 dgst_pos1 = 3;
7734 dgst_pos2 = 2;
7735 dgst_pos3 = 1;
7736 break;
7737
7738 case 1400: hash_type = HASH_TYPE_SHA256;
7739 salt_type = SALT_TYPE_NONE;
7740 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7741 opts_type = OPTS_TYPE_PT_GENERATE_BE
7742 | OPTS_TYPE_PT_ADD80
7743 | OPTS_TYPE_PT_ADDBITS15;
7744 kern_type = KERN_TYPE_SHA256;
7745 dgst_size = DGST_SIZE_4_8;
7746 parse_func = sha256_parse_hash;
7747 sort_by_digest = sort_by_digest_4_8;
7748 opti_type = OPTI_TYPE_ZERO_BYTE
7749 | OPTI_TYPE_PRECOMPUTE_INIT
7750 | OPTI_TYPE_PRECOMPUTE_MERKLE
7751 | OPTI_TYPE_EARLY_SKIP
7752 | OPTI_TYPE_NOT_ITERATED
7753 | OPTI_TYPE_NOT_SALTED
7754 | OPTI_TYPE_RAW_HASH;
7755 dgst_pos0 = 3;
7756 dgst_pos1 = 7;
7757 dgst_pos2 = 2;
7758 dgst_pos3 = 6;
7759 break;
7760
7761 case 1410: hash_type = HASH_TYPE_SHA256;
7762 salt_type = SALT_TYPE_INTERN;
7763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7764 opts_type = OPTS_TYPE_PT_GENERATE_BE
7765 | OPTS_TYPE_ST_ADD80
7766 | OPTS_TYPE_ST_ADDBITS15;
7767 kern_type = KERN_TYPE_SHA256_PWSLT;
7768 dgst_size = DGST_SIZE_4_8;
7769 parse_func = sha256s_parse_hash;
7770 sort_by_digest = sort_by_digest_4_8;
7771 opti_type = OPTI_TYPE_ZERO_BYTE
7772 | OPTI_TYPE_PRECOMPUTE_INIT
7773 | OPTI_TYPE_PRECOMPUTE_MERKLE
7774 | OPTI_TYPE_EARLY_SKIP
7775 | OPTI_TYPE_NOT_ITERATED
7776 | OPTI_TYPE_APPENDED_SALT
7777 | OPTI_TYPE_RAW_HASH;
7778 dgst_pos0 = 3;
7779 dgst_pos1 = 7;
7780 dgst_pos2 = 2;
7781 dgst_pos3 = 6;
7782 break;
7783
7784 case 1420: hash_type = HASH_TYPE_SHA256;
7785 salt_type = SALT_TYPE_INTERN;
7786 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7787 opts_type = OPTS_TYPE_PT_GENERATE_BE
7788 | OPTS_TYPE_PT_ADD80
7789 | OPTS_TYPE_PT_ADDBITS15;
7790 kern_type = KERN_TYPE_SHA256_SLTPW;
7791 dgst_size = DGST_SIZE_4_8;
7792 parse_func = sha256s_parse_hash;
7793 sort_by_digest = sort_by_digest_4_8;
7794 opti_type = OPTI_TYPE_ZERO_BYTE
7795 | OPTI_TYPE_PRECOMPUTE_INIT
7796 | OPTI_TYPE_PRECOMPUTE_MERKLE
7797 | OPTI_TYPE_EARLY_SKIP
7798 | OPTI_TYPE_NOT_ITERATED
7799 | OPTI_TYPE_PREPENDED_SALT
7800 | OPTI_TYPE_RAW_HASH;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 7;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 6;
7805 break;
7806
7807 case 1421: hash_type = HASH_TYPE_SHA256;
7808 salt_type = SALT_TYPE_EMBEDDED;
7809 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_BE
7811 | OPTS_TYPE_PT_ADD80
7812 | OPTS_TYPE_PT_ADDBITS15;
7813 kern_type = KERN_TYPE_SHA256_SLTPW;
7814 dgst_size = DGST_SIZE_4_8;
7815 parse_func = hmailserver_parse_hash;
7816 sort_by_digest = sort_by_digest_4_8;
7817 opti_type = OPTI_TYPE_ZERO_BYTE
7818 | OPTI_TYPE_PRECOMPUTE_INIT
7819 | OPTI_TYPE_PRECOMPUTE_MERKLE
7820 | OPTI_TYPE_EARLY_SKIP
7821 | OPTI_TYPE_NOT_ITERATED
7822 | OPTI_TYPE_PREPENDED_SALT
7823 | OPTI_TYPE_RAW_HASH;
7824 dgst_pos0 = 3;
7825 dgst_pos1 = 7;
7826 dgst_pos2 = 2;
7827 dgst_pos3 = 6;
7828 break;
7829
7830 case 1430: hash_type = HASH_TYPE_SHA256;
7831 salt_type = SALT_TYPE_INTERN;
7832 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7833 opts_type = OPTS_TYPE_PT_GENERATE_BE
7834 | OPTS_TYPE_PT_UNICODE
7835 | OPTS_TYPE_ST_ADD80
7836 | OPTS_TYPE_ST_ADDBITS15;
7837 kern_type = KERN_TYPE_SHA256_PWUSLT;
7838 dgst_size = DGST_SIZE_4_8;
7839 parse_func = sha256s_parse_hash;
7840 sort_by_digest = sort_by_digest_4_8;
7841 opti_type = OPTI_TYPE_ZERO_BYTE
7842 | OPTI_TYPE_PRECOMPUTE_INIT
7843 | OPTI_TYPE_PRECOMPUTE_MERKLE
7844 | OPTI_TYPE_EARLY_SKIP
7845 | OPTI_TYPE_NOT_ITERATED
7846 | OPTI_TYPE_APPENDED_SALT
7847 | OPTI_TYPE_RAW_HASH;
7848 dgst_pos0 = 3;
7849 dgst_pos1 = 7;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 6;
7852 break;
7853
7854 case 1440: hash_type = HASH_TYPE_SHA256;
7855 salt_type = SALT_TYPE_INTERN;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_BE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS15
7860 | OPTS_TYPE_PT_UNICODE;
7861 kern_type = KERN_TYPE_SHA256_SLTPWU;
7862 dgst_size = DGST_SIZE_4_8;
7863 parse_func = sha256s_parse_hash;
7864 sort_by_digest = sort_by_digest_4_8;
7865 opti_type = OPTI_TYPE_ZERO_BYTE
7866 | OPTI_TYPE_PRECOMPUTE_INIT
7867 | OPTI_TYPE_PRECOMPUTE_MERKLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_PREPENDED_SALT
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 3;
7873 dgst_pos1 = 7;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 6;
7876 break;
7877
7878 case 1441: hash_type = HASH_TYPE_SHA256;
7879 salt_type = SALT_TYPE_EMBEDDED;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_BE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS15
7884 | OPTS_TYPE_PT_UNICODE
7885 | OPTS_TYPE_ST_BASE64;
7886 kern_type = KERN_TYPE_SHA256_SLTPWU;
7887 dgst_size = DGST_SIZE_4_8;
7888 parse_func = episerver4_parse_hash;
7889 sort_by_digest = sort_by_digest_4_8;
7890 opti_type = OPTI_TYPE_ZERO_BYTE
7891 | OPTI_TYPE_PRECOMPUTE_INIT
7892 | OPTI_TYPE_PRECOMPUTE_MERKLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_PREPENDED_SALT
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 3;
7898 dgst_pos1 = 7;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 6;
7901 break;
7902
7903 case 1450: hash_type = HASH_TYPE_SHA256;
7904 salt_type = SALT_TYPE_INTERN;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_BE
7907 | OPTS_TYPE_ST_ADD80;
7908 kern_type = KERN_TYPE_HMACSHA256_PW;
7909 dgst_size = DGST_SIZE_4_8;
7910 parse_func = hmacsha256_parse_hash;
7911 sort_by_digest = sort_by_digest_4_8;
7912 opti_type = OPTI_TYPE_ZERO_BYTE
7913 | OPTI_TYPE_NOT_ITERATED;
7914 dgst_pos0 = 3;
7915 dgst_pos1 = 7;
7916 dgst_pos2 = 2;
7917 dgst_pos3 = 6;
7918 break;
7919
7920 case 1460: hash_type = HASH_TYPE_SHA256;
7921 salt_type = SALT_TYPE_INTERN;
7922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7923 opts_type = OPTS_TYPE_PT_GENERATE_BE
7924 | OPTS_TYPE_PT_ADD80
7925 | OPTS_TYPE_PT_ADDBITS15;
7926 kern_type = KERN_TYPE_HMACSHA256_SLT;
7927 dgst_size = DGST_SIZE_4_8;
7928 parse_func = hmacsha256_parse_hash;
7929 sort_by_digest = sort_by_digest_4_8;
7930 opti_type = OPTI_TYPE_ZERO_BYTE
7931 | OPTI_TYPE_NOT_ITERATED;
7932 dgst_pos0 = 3;
7933 dgst_pos1 = 7;
7934 dgst_pos2 = 2;
7935 dgst_pos3 = 6;
7936 break;
7937
7938 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7939 salt_type = SALT_TYPE_EMBEDDED;
7940 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7941 opts_type = OPTS_TYPE_PT_GENERATE_LE
7942 | OPTS_TYPE_PT_BITSLICE;
7943 kern_type = KERN_TYPE_DESCRYPT;
7944 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7945 parse_func = descrypt_parse_hash;
7946 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7947 opti_type = OPTI_TYPE_ZERO_BYTE
7948 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7949 dgst_pos0 = 0;
7950 dgst_pos1 = 1;
7951 dgst_pos2 = 2;
7952 dgst_pos3 = 3;
7953 break;
7954
7955 case 1600: hash_type = HASH_TYPE_MD5;
7956 salt_type = SALT_TYPE_EMBEDDED;
7957 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7958 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7959 kern_type = KERN_TYPE_APR1CRYPT;
7960 dgst_size = DGST_SIZE_4_4;
7961 parse_func = md5apr1_parse_hash;
7962 sort_by_digest = sort_by_digest_4_4;
7963 opti_type = OPTI_TYPE_ZERO_BYTE;
7964 dgst_pos0 = 0;
7965 dgst_pos1 = 1;
7966 dgst_pos2 = 2;
7967 dgst_pos3 = 3;
7968 break;
7969
7970 case 1700: hash_type = HASH_TYPE_SHA512;
7971 salt_type = SALT_TYPE_NONE;
7972 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7973 opts_type = OPTS_TYPE_PT_GENERATE_BE
7974 | OPTS_TYPE_PT_ADD80
7975 | OPTS_TYPE_PT_ADDBITS15;
7976 kern_type = KERN_TYPE_SHA512;
7977 dgst_size = DGST_SIZE_8_8;
7978 parse_func = sha512_parse_hash;
7979 sort_by_digest = sort_by_digest_8_8;
7980 opti_type = OPTI_TYPE_ZERO_BYTE
7981 | OPTI_TYPE_PRECOMPUTE_INIT
7982 | OPTI_TYPE_PRECOMPUTE_MERKLE
7983 | OPTI_TYPE_EARLY_SKIP
7984 | OPTI_TYPE_NOT_ITERATED
7985 | OPTI_TYPE_NOT_SALTED
7986 | OPTI_TYPE_USES_BITS_64
7987 | OPTI_TYPE_RAW_HASH;
7988 dgst_pos0 = 14;
7989 dgst_pos1 = 15;
7990 dgst_pos2 = 6;
7991 dgst_pos3 = 7;
7992 break;
7993
7994 case 1710: hash_type = HASH_TYPE_SHA512;
7995 salt_type = SALT_TYPE_INTERN;
7996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7997 opts_type = OPTS_TYPE_PT_GENERATE_BE
7998 | OPTS_TYPE_ST_ADD80
7999 | OPTS_TYPE_ST_ADDBITS15;
8000 kern_type = KERN_TYPE_SHA512_PWSLT;
8001 dgst_size = DGST_SIZE_8_8;
8002 parse_func = sha512s_parse_hash;
8003 sort_by_digest = sort_by_digest_8_8;
8004 opti_type = OPTI_TYPE_ZERO_BYTE
8005 | OPTI_TYPE_PRECOMPUTE_INIT
8006 | OPTI_TYPE_PRECOMPUTE_MERKLE
8007 | OPTI_TYPE_EARLY_SKIP
8008 | OPTI_TYPE_NOT_ITERATED
8009 | OPTI_TYPE_APPENDED_SALT
8010 | OPTI_TYPE_USES_BITS_64
8011 | OPTI_TYPE_RAW_HASH;
8012 dgst_pos0 = 14;
8013 dgst_pos1 = 15;
8014 dgst_pos2 = 6;
8015 dgst_pos3 = 7;
8016 break;
8017
8018 case 1711: hash_type = HASH_TYPE_SHA512;
8019 salt_type = SALT_TYPE_EMBEDDED;
8020 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8021 opts_type = OPTS_TYPE_PT_GENERATE_BE
8022 | OPTS_TYPE_ST_ADD80
8023 | OPTS_TYPE_ST_ADDBITS15;
8024 kern_type = KERN_TYPE_SHA512_PWSLT;
8025 dgst_size = DGST_SIZE_8_8;
8026 parse_func = sha512b64s_parse_hash;
8027 sort_by_digest = sort_by_digest_8_8;
8028 opti_type = OPTI_TYPE_ZERO_BYTE
8029 | OPTI_TYPE_PRECOMPUTE_INIT
8030 | OPTI_TYPE_PRECOMPUTE_MERKLE
8031 | OPTI_TYPE_EARLY_SKIP
8032 | OPTI_TYPE_NOT_ITERATED
8033 | OPTI_TYPE_APPENDED_SALT
8034 | OPTI_TYPE_USES_BITS_64
8035 | OPTI_TYPE_RAW_HASH;
8036 dgst_pos0 = 14;
8037 dgst_pos1 = 15;
8038 dgst_pos2 = 6;
8039 dgst_pos3 = 7;
8040 break;
8041
8042 case 1720: hash_type = HASH_TYPE_SHA512;
8043 salt_type = SALT_TYPE_INTERN;
8044 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8045 opts_type = OPTS_TYPE_PT_GENERATE_BE
8046 | OPTS_TYPE_PT_ADD80
8047 | OPTS_TYPE_PT_ADDBITS15;
8048 kern_type = KERN_TYPE_SHA512_SLTPW;
8049 dgst_size = DGST_SIZE_8_8;
8050 parse_func = sha512s_parse_hash;
8051 sort_by_digest = sort_by_digest_8_8;
8052 opti_type = OPTI_TYPE_ZERO_BYTE
8053 | OPTI_TYPE_PRECOMPUTE_INIT
8054 | OPTI_TYPE_PRECOMPUTE_MERKLE
8055 | OPTI_TYPE_EARLY_SKIP
8056 | OPTI_TYPE_NOT_ITERATED
8057 | OPTI_TYPE_PREPENDED_SALT
8058 | OPTI_TYPE_USES_BITS_64
8059 | OPTI_TYPE_RAW_HASH;
8060 dgst_pos0 = 14;
8061 dgst_pos1 = 15;
8062 dgst_pos2 = 6;
8063 dgst_pos3 = 7;
8064 break;
8065
8066 case 1722: hash_type = HASH_TYPE_SHA512;
8067 salt_type = SALT_TYPE_EMBEDDED;
8068 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8069 opts_type = OPTS_TYPE_PT_GENERATE_BE
8070 | OPTS_TYPE_PT_ADD80
8071 | OPTS_TYPE_PT_ADDBITS15
8072 | OPTS_TYPE_ST_HEX;
8073 kern_type = KERN_TYPE_SHA512_SLTPW;
8074 dgst_size = DGST_SIZE_8_8;
8075 parse_func = osx512_parse_hash;
8076 sort_by_digest = sort_by_digest_8_8;
8077 opti_type = OPTI_TYPE_ZERO_BYTE
8078 | OPTI_TYPE_PRECOMPUTE_INIT
8079 | OPTI_TYPE_PRECOMPUTE_MERKLE
8080 | OPTI_TYPE_EARLY_SKIP
8081 | OPTI_TYPE_NOT_ITERATED
8082 | OPTI_TYPE_PREPENDED_SALT
8083 | OPTI_TYPE_USES_BITS_64
8084 | OPTI_TYPE_RAW_HASH;
8085 dgst_pos0 = 14;
8086 dgst_pos1 = 15;
8087 dgst_pos2 = 6;
8088 dgst_pos3 = 7;
8089 break;
8090
8091 case 1730: hash_type = HASH_TYPE_SHA512;
8092 salt_type = SALT_TYPE_INTERN;
8093 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8094 opts_type = OPTS_TYPE_PT_GENERATE_BE
8095 | OPTS_TYPE_PT_UNICODE
8096 | OPTS_TYPE_ST_ADD80
8097 | OPTS_TYPE_ST_ADDBITS15;
8098 kern_type = KERN_TYPE_SHA512_PWSLTU;
8099 dgst_size = DGST_SIZE_8_8;
8100 parse_func = sha512s_parse_hash;
8101 sort_by_digest = sort_by_digest_8_8;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_PRECOMPUTE_INIT
8104 | OPTI_TYPE_PRECOMPUTE_MERKLE
8105 | OPTI_TYPE_EARLY_SKIP
8106 | OPTI_TYPE_NOT_ITERATED
8107 | OPTI_TYPE_APPENDED_SALT
8108 | OPTI_TYPE_USES_BITS_64
8109 | OPTI_TYPE_RAW_HASH;
8110 dgst_pos0 = 14;
8111 dgst_pos1 = 15;
8112 dgst_pos2 = 6;
8113 dgst_pos3 = 7;
8114 break;
8115
8116 case 1731: hash_type = HASH_TYPE_SHA512;
8117 salt_type = SALT_TYPE_EMBEDDED;
8118 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8119 opts_type = OPTS_TYPE_PT_GENERATE_BE
8120 | OPTS_TYPE_PT_UNICODE
8121 | OPTS_TYPE_ST_ADD80
8122 | OPTS_TYPE_ST_ADDBITS15
8123 | OPTS_TYPE_ST_HEX;
8124 kern_type = KERN_TYPE_SHA512_PWSLTU;
8125 dgst_size = DGST_SIZE_8_8;
8126 parse_func = mssql2012_parse_hash;
8127 sort_by_digest = sort_by_digest_8_8;
8128 opti_type = OPTI_TYPE_ZERO_BYTE
8129 | OPTI_TYPE_PRECOMPUTE_INIT
8130 | OPTI_TYPE_PRECOMPUTE_MERKLE
8131 | OPTI_TYPE_EARLY_SKIP
8132 | OPTI_TYPE_NOT_ITERATED
8133 | OPTI_TYPE_APPENDED_SALT
8134 | OPTI_TYPE_USES_BITS_64
8135 | OPTI_TYPE_RAW_HASH;
8136 dgst_pos0 = 14;
8137 dgst_pos1 = 15;
8138 dgst_pos2 = 6;
8139 dgst_pos3 = 7;
8140 break;
8141
8142 case 1740: hash_type = HASH_TYPE_SHA512;
8143 salt_type = SALT_TYPE_INTERN;
8144 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8145 opts_type = OPTS_TYPE_PT_GENERATE_BE
8146 | OPTS_TYPE_PT_ADD80
8147 | OPTS_TYPE_PT_ADDBITS15
8148 | OPTS_TYPE_PT_UNICODE;
8149 kern_type = KERN_TYPE_SHA512_SLTPWU;
8150 dgst_size = DGST_SIZE_8_8;
8151 parse_func = sha512s_parse_hash;
8152 sort_by_digest = sort_by_digest_8_8;
8153 opti_type = OPTI_TYPE_ZERO_BYTE
8154 | OPTI_TYPE_PRECOMPUTE_INIT
8155 | OPTI_TYPE_PRECOMPUTE_MERKLE
8156 | OPTI_TYPE_EARLY_SKIP
8157 | OPTI_TYPE_NOT_ITERATED
8158 | OPTI_TYPE_PREPENDED_SALT
8159 | OPTI_TYPE_USES_BITS_64
8160 | OPTI_TYPE_RAW_HASH;
8161 dgst_pos0 = 14;
8162 dgst_pos1 = 15;
8163 dgst_pos2 = 6;
8164 dgst_pos3 = 7;
8165 break;
8166
8167 case 1750: hash_type = HASH_TYPE_SHA512;
8168 salt_type = SALT_TYPE_INTERN;
8169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8170 opts_type = OPTS_TYPE_PT_GENERATE_BE
8171 | OPTS_TYPE_ST_ADD80;
8172 kern_type = KERN_TYPE_HMACSHA512_PW;
8173 dgst_size = DGST_SIZE_8_8;
8174 parse_func = hmacsha512_parse_hash;
8175 sort_by_digest = sort_by_digest_8_8;
8176 opti_type = OPTI_TYPE_ZERO_BYTE
8177 | OPTI_TYPE_USES_BITS_64
8178 | OPTI_TYPE_NOT_ITERATED;
8179 dgst_pos0 = 14;
8180 dgst_pos1 = 15;
8181 dgst_pos2 = 6;
8182 dgst_pos3 = 7;
8183 break;
8184
8185 case 1760: hash_type = HASH_TYPE_SHA512;
8186 salt_type = SALT_TYPE_INTERN;
8187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8188 opts_type = OPTS_TYPE_PT_GENERATE_BE
8189 | OPTS_TYPE_PT_ADD80
8190 | OPTS_TYPE_PT_ADDBITS15;
8191 kern_type = KERN_TYPE_HMACSHA512_SLT;
8192 dgst_size = DGST_SIZE_8_8;
8193 parse_func = hmacsha512_parse_hash;
8194 sort_by_digest = sort_by_digest_8_8;
8195 opti_type = OPTI_TYPE_ZERO_BYTE
8196 | OPTI_TYPE_USES_BITS_64
8197 | OPTI_TYPE_NOT_ITERATED;
8198 dgst_pos0 = 14;
8199 dgst_pos1 = 15;
8200 dgst_pos2 = 6;
8201 dgst_pos3 = 7;
8202 break;
8203
8204 case 1800: hash_type = HASH_TYPE_SHA512;
8205 salt_type = SALT_TYPE_EMBEDDED;
8206 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8208 kern_type = KERN_TYPE_SHA512CRYPT;
8209 dgst_size = DGST_SIZE_8_8;
8210 parse_func = sha512crypt_parse_hash;
8211 sort_by_digest = sort_by_digest_8_8;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_USES_BITS_64;
8214 dgst_pos0 = 0;
8215 dgst_pos1 = 1;
8216 dgst_pos2 = 2;
8217 dgst_pos3 = 3;
8218 break;
8219
8220 case 2100: hash_type = HASH_TYPE_DCC2;
8221 salt_type = SALT_TYPE_EMBEDDED;
8222 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8223 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8224 | OPTS_TYPE_ST_LOWER
8225 | OPTS_TYPE_ST_UNICODE;
8226 kern_type = KERN_TYPE_DCC2;
8227 dgst_size = DGST_SIZE_4_4;
8228 parse_func = dcc2_parse_hash;
8229 sort_by_digest = sort_by_digest_4_4;
8230 opti_type = OPTI_TYPE_ZERO_BYTE
8231 | OPTI_TYPE_SLOW_HASH_SIMD;
8232 dgst_pos0 = 0;
8233 dgst_pos1 = 1;
8234 dgst_pos2 = 2;
8235 dgst_pos3 = 3;
8236 break;
8237
8238 case 2400: hash_type = HASH_TYPE_MD5;
8239 salt_type = SALT_TYPE_NONE;
8240 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8241 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8242 kern_type = KERN_TYPE_MD5PIX;
8243 dgst_size = DGST_SIZE_4_4;
8244 parse_func = md5pix_parse_hash;
8245 sort_by_digest = sort_by_digest_4_4;
8246 opti_type = OPTI_TYPE_ZERO_BYTE
8247 | OPTI_TYPE_PRECOMPUTE_INIT
8248 | OPTI_TYPE_PRECOMPUTE_MERKLE
8249 | OPTI_TYPE_EARLY_SKIP
8250 | OPTI_TYPE_NOT_ITERATED
8251 | OPTI_TYPE_NOT_SALTED;
8252 dgst_pos0 = 0;
8253 dgst_pos1 = 3;
8254 dgst_pos2 = 2;
8255 dgst_pos3 = 1;
8256 break;
8257
8258 case 2410: hash_type = HASH_TYPE_MD5;
8259 salt_type = SALT_TYPE_INTERN;
8260 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8261 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8262 kern_type = KERN_TYPE_MD5ASA;
8263 dgst_size = DGST_SIZE_4_4;
8264 parse_func = md5asa_parse_hash;
8265 sort_by_digest = sort_by_digest_4_4;
8266 opti_type = OPTI_TYPE_ZERO_BYTE
8267 | OPTI_TYPE_PRECOMPUTE_INIT
8268 | OPTI_TYPE_PRECOMPUTE_MERKLE
8269 | OPTI_TYPE_EARLY_SKIP
8270 | OPTI_TYPE_NOT_ITERATED;
8271 dgst_pos0 = 0;
8272 dgst_pos1 = 3;
8273 dgst_pos2 = 2;
8274 dgst_pos3 = 1;
8275 break;
8276
8277 case 2500: hash_type = HASH_TYPE_WPA;
8278 salt_type = SALT_TYPE_EMBEDDED;
8279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8280 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8281 kern_type = KERN_TYPE_WPA;
8282 dgst_size = DGST_SIZE_4_4;
8283 parse_func = wpa_parse_hash;
8284 sort_by_digest = sort_by_digest_4_4;
8285 opti_type = OPTI_TYPE_ZERO_BYTE
8286 | OPTI_TYPE_SLOW_HASH_SIMD;
8287 dgst_pos0 = 0;
8288 dgst_pos1 = 1;
8289 dgst_pos2 = 2;
8290 dgst_pos3 = 3;
8291 break;
8292
8293 case 2600: hash_type = HASH_TYPE_MD5;
8294 salt_type = SALT_TYPE_VIRTUAL;
8295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8296 opts_type = OPTS_TYPE_PT_GENERATE_LE
8297 | OPTS_TYPE_PT_ADD80
8298 | OPTS_TYPE_PT_ADDBITS14
8299 | OPTS_TYPE_ST_ADD80;
8300 kern_type = KERN_TYPE_MD55_PWSLT1;
8301 dgst_size = DGST_SIZE_4_4;
8302 parse_func = md5md5_parse_hash;
8303 sort_by_digest = sort_by_digest_4_4;
8304 opti_type = OPTI_TYPE_ZERO_BYTE
8305 | OPTI_TYPE_PRECOMPUTE_INIT
8306 | OPTI_TYPE_PRECOMPUTE_MERKLE
8307 | OPTI_TYPE_EARLY_SKIP;
8308 dgst_pos0 = 0;
8309 dgst_pos1 = 3;
8310 dgst_pos2 = 2;
8311 dgst_pos3 = 1;
8312 break;
8313
8314 case 2611: hash_type = HASH_TYPE_MD5;
8315 salt_type = SALT_TYPE_INTERN;
8316 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8317 opts_type = OPTS_TYPE_PT_GENERATE_LE
8318 | OPTS_TYPE_PT_ADD80
8319 | OPTS_TYPE_PT_ADDBITS14
8320 | OPTS_TYPE_ST_ADD80;
8321 kern_type = KERN_TYPE_MD55_PWSLT1;
8322 dgst_size = DGST_SIZE_4_4;
8323 parse_func = vb3_parse_hash;
8324 sort_by_digest = sort_by_digest_4_4;
8325 opti_type = OPTI_TYPE_ZERO_BYTE
8326 | OPTI_TYPE_PRECOMPUTE_INIT
8327 | OPTI_TYPE_PRECOMPUTE_MERKLE
8328 | OPTI_TYPE_EARLY_SKIP;
8329 dgst_pos0 = 0;
8330 dgst_pos1 = 3;
8331 dgst_pos2 = 2;
8332 dgst_pos3 = 1;
8333 break;
8334
8335 case 2612: hash_type = HASH_TYPE_MD5;
8336 salt_type = SALT_TYPE_EMBEDDED;
8337 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8338 opts_type = OPTS_TYPE_PT_GENERATE_LE
8339 | OPTS_TYPE_PT_ADD80
8340 | OPTS_TYPE_PT_ADDBITS14
8341 | OPTS_TYPE_ST_ADD80
8342 | OPTS_TYPE_ST_HEX;
8343 kern_type = KERN_TYPE_MD55_PWSLT1;
8344 dgst_size = DGST_SIZE_4_4;
8345 parse_func = phps_parse_hash;
8346 sort_by_digest = sort_by_digest_4_4;
8347 opti_type = OPTI_TYPE_ZERO_BYTE
8348 | OPTI_TYPE_PRECOMPUTE_INIT
8349 | OPTI_TYPE_PRECOMPUTE_MERKLE
8350 | OPTI_TYPE_EARLY_SKIP;
8351 dgst_pos0 = 0;
8352 dgst_pos1 = 3;
8353 dgst_pos2 = 2;
8354 dgst_pos3 = 1;
8355 break;
8356
8357 case 2711: hash_type = HASH_TYPE_MD5;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_LE
8361 | OPTS_TYPE_PT_ADD80
8362 | OPTS_TYPE_PT_ADDBITS14
8363 | OPTS_TYPE_ST_ADD80;
8364 kern_type = KERN_TYPE_MD55_PWSLT2;
8365 dgst_size = DGST_SIZE_4_4;
8366 parse_func = vb30_parse_hash;
8367 sort_by_digest = sort_by_digest_4_4;
8368 opti_type = OPTI_TYPE_ZERO_BYTE
8369 | OPTI_TYPE_PRECOMPUTE_INIT
8370 | OPTI_TYPE_EARLY_SKIP;
8371 dgst_pos0 = 0;
8372 dgst_pos1 = 3;
8373 dgst_pos2 = 2;
8374 dgst_pos3 = 1;
8375 break;
8376
8377 case 2811: hash_type = HASH_TYPE_MD5;
8378 salt_type = SALT_TYPE_INTERN;
8379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8380 opts_type = OPTS_TYPE_PT_GENERATE_LE
8381 | OPTS_TYPE_PT_ADD80
8382 | OPTS_TYPE_PT_ADDBITS14;
8383 kern_type = KERN_TYPE_MD55_SLTPW;
8384 dgst_size = DGST_SIZE_4_4;
8385 parse_func = ipb2_parse_hash;
8386 sort_by_digest = sort_by_digest_4_4;
8387 opti_type = OPTI_TYPE_ZERO_BYTE
8388 | OPTI_TYPE_PRECOMPUTE_INIT
8389 | OPTI_TYPE_EARLY_SKIP;
8390 dgst_pos0 = 0;
8391 dgst_pos1 = 3;
8392 dgst_pos2 = 2;
8393 dgst_pos3 = 1;
8394 break;
8395
8396 case 3000: hash_type = HASH_TYPE_LM;
8397 salt_type = SALT_TYPE_NONE;
8398 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8399 opts_type = OPTS_TYPE_PT_GENERATE_LE
8400 | OPTS_TYPE_PT_UPPER
8401 | OPTS_TYPE_PT_BITSLICE;
8402 kern_type = KERN_TYPE_LM;
8403 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8404 parse_func = lm_parse_hash;
8405 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8406 opti_type = OPTI_TYPE_ZERO_BYTE
8407 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8408 dgst_pos0 = 0;
8409 dgst_pos1 = 1;
8410 dgst_pos2 = 2;
8411 dgst_pos3 = 3;
8412 break;
8413
8414 case 3100: hash_type = HASH_TYPE_ORACLEH;
8415 salt_type = SALT_TYPE_INTERN;
8416 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8417 opts_type = OPTS_TYPE_PT_GENERATE_LE
8418 | OPTS_TYPE_PT_UPPER
8419 | OPTS_TYPE_ST_UPPER;
8420 kern_type = KERN_TYPE_ORACLEH;
8421 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8422 parse_func = oracleh_parse_hash;
8423 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8424 opti_type = OPTI_TYPE_ZERO_BYTE;
8425 dgst_pos0 = 0;
8426 dgst_pos1 = 1;
8427 dgst_pos2 = 2;
8428 dgst_pos3 = 3;
8429 break;
8430
8431 case 3200: hash_type = HASH_TYPE_BCRYPT;
8432 salt_type = SALT_TYPE_EMBEDDED;
8433 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8434 opts_type = OPTS_TYPE_PT_GENERATE_LE
8435 | OPTS_TYPE_ST_GENERATE_LE;
8436 kern_type = KERN_TYPE_BCRYPT;
8437 dgst_size = DGST_SIZE_4_6;
8438 parse_func = bcrypt_parse_hash;
8439 sort_by_digest = sort_by_digest_4_6;
8440 opti_type = OPTI_TYPE_ZERO_BYTE;
8441 dgst_pos0 = 0;
8442 dgst_pos1 = 1;
8443 dgst_pos2 = 2;
8444 dgst_pos3 = 3;
8445 break;
8446
8447 case 3710: hash_type = HASH_TYPE_MD5;
8448 salt_type = SALT_TYPE_INTERN;
8449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8450 opts_type = OPTS_TYPE_PT_GENERATE_LE
8451 | OPTS_TYPE_PT_ADD80
8452 | OPTS_TYPE_PT_ADDBITS14;
8453 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8454 dgst_size = DGST_SIZE_4_4;
8455 parse_func = md5s_parse_hash;
8456 sort_by_digest = sort_by_digest_4_4;
8457 opti_type = OPTI_TYPE_ZERO_BYTE
8458 | OPTI_TYPE_PRECOMPUTE_INIT
8459 | OPTI_TYPE_PRECOMPUTE_MERKLE
8460 | OPTI_TYPE_EARLY_SKIP;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 3711: hash_type = HASH_TYPE_MD5;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE
8471 | OPTS_TYPE_PT_ADD80
8472 | OPTS_TYPE_PT_ADDBITS14;
8473 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8474 dgst_size = DGST_SIZE_4_4;
8475 parse_func = mediawiki_b_parse_hash;
8476 sort_by_digest = sort_by_digest_4_4;
8477 opti_type = OPTI_TYPE_ZERO_BYTE
8478 | OPTI_TYPE_PRECOMPUTE_INIT
8479 | OPTI_TYPE_PRECOMPUTE_MERKLE
8480 | OPTI_TYPE_EARLY_SKIP;
8481 dgst_pos0 = 0;
8482 dgst_pos1 = 3;
8483 dgst_pos2 = 2;
8484 dgst_pos3 = 1;
8485 break;
8486
8487 case 3800: hash_type = HASH_TYPE_MD5;
8488 salt_type = SALT_TYPE_INTERN;
8489 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8490 opts_type = OPTS_TYPE_PT_GENERATE_LE
8491 | OPTS_TYPE_ST_ADDBITS14;
8492 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8493 dgst_size = DGST_SIZE_4_4;
8494 parse_func = md5s_parse_hash;
8495 sort_by_digest = sort_by_digest_4_4;
8496 opti_type = OPTI_TYPE_ZERO_BYTE
8497 | OPTI_TYPE_PRECOMPUTE_INIT
8498 | OPTI_TYPE_PRECOMPUTE_MERKLE
8499 | OPTI_TYPE_EARLY_SKIP
8500 | OPTI_TYPE_NOT_ITERATED
8501 | OPTI_TYPE_RAW_HASH;
8502 dgst_pos0 = 0;
8503 dgst_pos1 = 3;
8504 dgst_pos2 = 2;
8505 dgst_pos3 = 1;
8506 break;
8507
8508 case 4300: hash_type = HASH_TYPE_MD5;
8509 salt_type = SALT_TYPE_VIRTUAL;
8510 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8511 opts_type = OPTS_TYPE_PT_GENERATE_LE
8512 | OPTS_TYPE_PT_ADD80
8513 | OPTS_TYPE_PT_ADDBITS14
8514 | OPTS_TYPE_ST_ADD80;
8515 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8516 dgst_size = DGST_SIZE_4_4;
8517 parse_func = md5md5_parse_hash;
8518 sort_by_digest = sort_by_digest_4_4;
8519 opti_type = OPTI_TYPE_ZERO_BYTE
8520 | OPTI_TYPE_PRECOMPUTE_INIT
8521 | OPTI_TYPE_PRECOMPUTE_MERKLE
8522 | OPTI_TYPE_EARLY_SKIP;
8523 dgst_pos0 = 0;
8524 dgst_pos1 = 3;
8525 dgst_pos2 = 2;
8526 dgst_pos3 = 1;
8527 break;
8528
8529
8530 case 4400: hash_type = HASH_TYPE_MD5;
8531 salt_type = SALT_TYPE_NONE;
8532 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8533 opts_type = OPTS_TYPE_PT_GENERATE_BE
8534 | OPTS_TYPE_PT_ADD80
8535 | OPTS_TYPE_PT_ADDBITS15;
8536 kern_type = KERN_TYPE_MD5_SHA1;
8537 dgst_size = DGST_SIZE_4_4;
8538 parse_func = md5_parse_hash;
8539 sort_by_digest = sort_by_digest_4_4;
8540 opti_type = OPTI_TYPE_ZERO_BYTE
8541 | OPTI_TYPE_PRECOMPUTE_INIT
8542 | OPTI_TYPE_PRECOMPUTE_MERKLE
8543 | OPTI_TYPE_EARLY_SKIP
8544 | OPTI_TYPE_NOT_ITERATED
8545 | OPTI_TYPE_NOT_SALTED
8546 | OPTI_TYPE_RAW_HASH;
8547 dgst_pos0 = 0;
8548 dgst_pos1 = 3;
8549 dgst_pos2 = 2;
8550 dgst_pos3 = 1;
8551 break;
8552
8553 case 4500: hash_type = HASH_TYPE_SHA1;
8554 salt_type = SALT_TYPE_NONE;
8555 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8556 opts_type = OPTS_TYPE_PT_GENERATE_BE
8557 | OPTS_TYPE_PT_ADD80
8558 | OPTS_TYPE_PT_ADDBITS15;
8559 kern_type = KERN_TYPE_SHA11;
8560 dgst_size = DGST_SIZE_4_5;
8561 parse_func = sha1_parse_hash;
8562 sort_by_digest = sort_by_digest_4_5;
8563 opti_type = OPTI_TYPE_ZERO_BYTE
8564 | OPTI_TYPE_PRECOMPUTE_INIT
8565 | OPTI_TYPE_PRECOMPUTE_MERKLE
8566 | OPTI_TYPE_EARLY_SKIP
8567 | OPTI_TYPE_NOT_SALTED;
8568 dgst_pos0 = 3;
8569 dgst_pos1 = 4;
8570 dgst_pos2 = 2;
8571 dgst_pos3 = 1;
8572 break;
8573
8574 case 4700: hash_type = HASH_TYPE_SHA1;
8575 salt_type = SALT_TYPE_NONE;
8576 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8577 opts_type = OPTS_TYPE_PT_GENERATE_LE
8578 | OPTS_TYPE_PT_ADD80
8579 | OPTS_TYPE_PT_ADDBITS14;
8580 kern_type = KERN_TYPE_SHA1_MD5;
8581 dgst_size = DGST_SIZE_4_5;
8582 parse_func = sha1_parse_hash;
8583 sort_by_digest = sort_by_digest_4_5;
8584 opti_type = OPTI_TYPE_ZERO_BYTE
8585 | OPTI_TYPE_PRECOMPUTE_INIT
8586 | OPTI_TYPE_PRECOMPUTE_MERKLE
8587 | OPTI_TYPE_EARLY_SKIP
8588 | OPTI_TYPE_NOT_ITERATED
8589 | OPTI_TYPE_NOT_SALTED
8590 | OPTI_TYPE_RAW_HASH;
8591 dgst_pos0 = 3;
8592 dgst_pos1 = 4;
8593 dgst_pos2 = 2;
8594 dgst_pos3 = 1;
8595 break;
8596
8597 case 4800: hash_type = HASH_TYPE_MD5;
8598 salt_type = SALT_TYPE_EMBEDDED;
8599 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8600 opts_type = OPTS_TYPE_PT_GENERATE_LE
8601 | OPTS_TYPE_PT_ADDBITS14;
8602 kern_type = KERN_TYPE_MD5_CHAP;
8603 dgst_size = DGST_SIZE_4_4;
8604 parse_func = chap_parse_hash;
8605 sort_by_digest = sort_by_digest_4_4;
8606 opti_type = OPTI_TYPE_ZERO_BYTE
8607 | OPTI_TYPE_PRECOMPUTE_INIT
8608 | OPTI_TYPE_PRECOMPUTE_MERKLE
8609 | OPTI_TYPE_MEET_IN_MIDDLE
8610 | OPTI_TYPE_EARLY_SKIP
8611 | OPTI_TYPE_NOT_ITERATED
8612 | OPTI_TYPE_RAW_HASH;
8613 dgst_pos0 = 0;
8614 dgst_pos1 = 3;
8615 dgst_pos2 = 2;
8616 dgst_pos3 = 1;
8617 break;
8618
8619 case 4900: hash_type = HASH_TYPE_SHA1;
8620 salt_type = SALT_TYPE_INTERN;
8621 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8622 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8623 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8624 dgst_size = DGST_SIZE_4_5;
8625 parse_func = sha1s_parse_hash;
8626 sort_by_digest = sort_by_digest_4_5;
8627 opti_type = OPTI_TYPE_ZERO_BYTE
8628 | OPTI_TYPE_PRECOMPUTE_INIT
8629 | OPTI_TYPE_PRECOMPUTE_MERKLE
8630 | OPTI_TYPE_EARLY_SKIP;
8631 dgst_pos0 = 3;
8632 dgst_pos1 = 4;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 1;
8635 break;
8636
8637 case 5000: hash_type = HASH_TYPE_KECCAK;
8638 salt_type = SALT_TYPE_EMBEDDED;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD01;
8642 kern_type = KERN_TYPE_KECCAK;
8643 dgst_size = DGST_SIZE_8_25;
8644 parse_func = keccak_parse_hash;
8645 sort_by_digest = sort_by_digest_8_25;
8646 opti_type = OPTI_TYPE_ZERO_BYTE
8647 | OPTI_TYPE_USES_BITS_64
8648 | OPTI_TYPE_RAW_HASH;
8649 dgst_pos0 = 2;
8650 dgst_pos1 = 3;
8651 dgst_pos2 = 4;
8652 dgst_pos3 = 5;
8653 break;
8654
8655 case 5100: hash_type = HASH_TYPE_MD5H;
8656 salt_type = SALT_TYPE_NONE;
8657 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8658 opts_type = OPTS_TYPE_PT_GENERATE_LE
8659 | OPTS_TYPE_PT_ADD80
8660 | OPTS_TYPE_PT_ADDBITS14;
8661 kern_type = KERN_TYPE_MD5H;
8662 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8663 parse_func = md5half_parse_hash;
8664 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8665 opti_type = OPTI_TYPE_ZERO_BYTE
8666 | OPTI_TYPE_RAW_HASH;
8667 dgst_pos0 = 0;
8668 dgst_pos1 = 1;
8669 dgst_pos2 = 2;
8670 dgst_pos3 = 3;
8671 break;
8672
8673 case 5200: hash_type = HASH_TYPE_SHA256;
8674 salt_type = SALT_TYPE_EMBEDDED;
8675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8676 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8677 kern_type = KERN_TYPE_PSAFE3;
8678 dgst_size = DGST_SIZE_4_8;
8679 parse_func = psafe3_parse_hash;
8680 sort_by_digest = sort_by_digest_4_8;
8681 opti_type = OPTI_TYPE_ZERO_BYTE;
8682 dgst_pos0 = 0;
8683 dgst_pos1 = 1;
8684 dgst_pos2 = 2;
8685 dgst_pos3 = 3;
8686 break;
8687
8688 case 5300: hash_type = HASH_TYPE_MD5;
8689 salt_type = SALT_TYPE_EMBEDDED;
8690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8691 opts_type = OPTS_TYPE_PT_GENERATE_LE
8692 | OPTS_TYPE_ST_ADD80;
8693 kern_type = KERN_TYPE_IKEPSK_MD5;
8694 dgst_size = DGST_SIZE_4_4;
8695 parse_func = ikepsk_md5_parse_hash;
8696 sort_by_digest = sort_by_digest_4_4;
8697 opti_type = OPTI_TYPE_ZERO_BYTE;
8698 dgst_pos0 = 0;
8699 dgst_pos1 = 3;
8700 dgst_pos2 = 2;
8701 dgst_pos3 = 1;
8702 break;
8703
8704 case 5400: hash_type = HASH_TYPE_SHA1;
8705 salt_type = SALT_TYPE_EMBEDDED;
8706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8707 opts_type = OPTS_TYPE_PT_GENERATE_BE
8708 | OPTS_TYPE_ST_ADD80;
8709 kern_type = KERN_TYPE_IKEPSK_SHA1;
8710 dgst_size = DGST_SIZE_4_5;
8711 parse_func = ikepsk_sha1_parse_hash;
8712 sort_by_digest = sort_by_digest_4_5;
8713 opti_type = OPTI_TYPE_ZERO_BYTE;
8714 dgst_pos0 = 3;
8715 dgst_pos1 = 4;
8716 dgst_pos2 = 2;
8717 dgst_pos3 = 1;
8718 break;
8719
8720 case 5500: hash_type = HASH_TYPE_NETNTLM;
8721 salt_type = SALT_TYPE_EMBEDDED;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_LE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS14
8726 | OPTS_TYPE_PT_UNICODE
8727 | OPTS_TYPE_ST_HEX;
8728 kern_type = KERN_TYPE_NETNTLMv1;
8729 dgst_size = DGST_SIZE_4_4;
8730 parse_func = netntlmv1_parse_hash;
8731 sort_by_digest = sort_by_digest_4_4;
8732 opti_type = OPTI_TYPE_ZERO_BYTE
8733 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8734 dgst_pos0 = 0;
8735 dgst_pos1 = 1;
8736 dgst_pos2 = 2;
8737 dgst_pos3 = 3;
8738 break;
8739
8740 case 5600: hash_type = HASH_TYPE_MD5;
8741 salt_type = SALT_TYPE_EMBEDDED;
8742 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8743 opts_type = OPTS_TYPE_PT_GENERATE_LE
8744 | OPTS_TYPE_PT_ADD80
8745 | OPTS_TYPE_PT_ADDBITS14
8746 | OPTS_TYPE_PT_UNICODE;
8747 kern_type = KERN_TYPE_NETNTLMv2;
8748 dgst_size = DGST_SIZE_4_4;
8749 parse_func = netntlmv2_parse_hash;
8750 sort_by_digest = sort_by_digest_4_4;
8751 opti_type = OPTI_TYPE_ZERO_BYTE;
8752 dgst_pos0 = 0;
8753 dgst_pos1 = 3;
8754 dgst_pos2 = 2;
8755 dgst_pos3 = 1;
8756 break;
8757
8758 case 5700: hash_type = HASH_TYPE_SHA256;
8759 salt_type = SALT_TYPE_NONE;
8760 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8761 opts_type = OPTS_TYPE_PT_GENERATE_BE
8762 | OPTS_TYPE_PT_ADD80
8763 | OPTS_TYPE_PT_ADDBITS15;
8764 kern_type = KERN_TYPE_SHA256;
8765 dgst_size = DGST_SIZE_4_8;
8766 parse_func = cisco4_parse_hash;
8767 sort_by_digest = sort_by_digest_4_8;
8768 opti_type = OPTI_TYPE_ZERO_BYTE
8769 | OPTI_TYPE_PRECOMPUTE_INIT
8770 | OPTI_TYPE_PRECOMPUTE_MERKLE
8771 | OPTI_TYPE_EARLY_SKIP
8772 | OPTI_TYPE_NOT_ITERATED
8773 | OPTI_TYPE_NOT_SALTED
8774 | OPTI_TYPE_RAW_HASH;
8775 dgst_pos0 = 3;
8776 dgst_pos1 = 7;
8777 dgst_pos2 = 2;
8778 dgst_pos3 = 6;
8779 break;
8780
8781 case 5800: hash_type = HASH_TYPE_SHA1;
8782 salt_type = SALT_TYPE_INTERN;
8783 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8784 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8785 | OPTS_TYPE_ST_ADD80;
8786 kern_type = KERN_TYPE_ANDROIDPIN;
8787 dgst_size = DGST_SIZE_4_5;
8788 parse_func = androidpin_parse_hash;
8789 sort_by_digest = sort_by_digest_4_5;
8790 opti_type = OPTI_TYPE_ZERO_BYTE;
8791 dgst_pos0 = 0;
8792 dgst_pos1 = 1;
8793 dgst_pos2 = 2;
8794 dgst_pos3 = 3;
8795 break;
8796
8797 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8798 salt_type = SALT_TYPE_NONE;
8799 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8800 opts_type = OPTS_TYPE_PT_GENERATE_LE
8801 | OPTS_TYPE_PT_ADD80;
8802 kern_type = KERN_TYPE_RIPEMD160;
8803 dgst_size = DGST_SIZE_4_5;
8804 parse_func = ripemd160_parse_hash;
8805 sort_by_digest = sort_by_digest_4_5;
8806 opti_type = OPTI_TYPE_ZERO_BYTE;
8807 dgst_pos0 = 0;
8808 dgst_pos1 = 1;
8809 dgst_pos2 = 2;
8810 dgst_pos3 = 3;
8811 break;
8812
8813 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8814 salt_type = SALT_TYPE_NONE;
8815 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8816 opts_type = OPTS_TYPE_PT_GENERATE_BE
8817 | OPTS_TYPE_PT_ADD80;
8818 kern_type = KERN_TYPE_WHIRLPOOL;
8819 dgst_size = DGST_SIZE_4_16;
8820 parse_func = whirlpool_parse_hash;
8821 sort_by_digest = sort_by_digest_4_16;
8822 opti_type = OPTI_TYPE_ZERO_BYTE;
8823 dgst_pos0 = 0;
8824 dgst_pos1 = 1;
8825 dgst_pos2 = 2;
8826 dgst_pos3 = 3;
8827 break;
8828
8829 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8830 salt_type = SALT_TYPE_EMBEDDED;
8831 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8832 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8833 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8834 dgst_size = DGST_SIZE_4_5;
8835 parse_func = truecrypt_parse_hash_2k;
8836 sort_by_digest = sort_by_digest_4_5;
8837 opti_type = OPTI_TYPE_ZERO_BYTE;
8838 dgst_pos0 = 0;
8839 dgst_pos1 = 1;
8840 dgst_pos2 = 2;
8841 dgst_pos3 = 3;
8842 break;
8843
8844 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8845 salt_type = SALT_TYPE_EMBEDDED;
8846 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8847 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8848 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8849 dgst_size = DGST_SIZE_4_5;
8850 parse_func = truecrypt_parse_hash_2k;
8851 sort_by_digest = sort_by_digest_4_5;
8852 opti_type = OPTI_TYPE_ZERO_BYTE;
8853 dgst_pos0 = 0;
8854 dgst_pos1 = 1;
8855 dgst_pos2 = 2;
8856 dgst_pos3 = 3;
8857 break;
8858
8859 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8860 salt_type = SALT_TYPE_EMBEDDED;
8861 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8862 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8863 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8864 dgst_size = DGST_SIZE_4_5;
8865 parse_func = truecrypt_parse_hash_2k;
8866 sort_by_digest = sort_by_digest_4_5;
8867 opti_type = OPTI_TYPE_ZERO_BYTE;
8868 dgst_pos0 = 0;
8869 dgst_pos1 = 1;
8870 dgst_pos2 = 2;
8871 dgst_pos3 = 3;
8872 break;
8873
8874 case 6221: hash_type = HASH_TYPE_SHA512;
8875 salt_type = SALT_TYPE_EMBEDDED;
8876 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8877 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8878 kern_type = KERN_TYPE_TCSHA512_XTS512;
8879 dgst_size = DGST_SIZE_8_8;
8880 parse_func = truecrypt_parse_hash_1k;
8881 sort_by_digest = sort_by_digest_8_8;
8882 opti_type = OPTI_TYPE_ZERO_BYTE
8883 | OPTI_TYPE_USES_BITS_64;
8884 dgst_pos0 = 0;
8885 dgst_pos1 = 1;
8886 dgst_pos2 = 2;
8887 dgst_pos3 = 3;
8888 break;
8889
8890 case 6222: hash_type = HASH_TYPE_SHA512;
8891 salt_type = SALT_TYPE_EMBEDDED;
8892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8893 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8894 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8895 dgst_size = DGST_SIZE_8_8;
8896 parse_func = truecrypt_parse_hash_1k;
8897 sort_by_digest = sort_by_digest_8_8;
8898 opti_type = OPTI_TYPE_ZERO_BYTE
8899 | OPTI_TYPE_USES_BITS_64;
8900 dgst_pos0 = 0;
8901 dgst_pos1 = 1;
8902 dgst_pos2 = 2;
8903 dgst_pos3 = 3;
8904 break;
8905
8906 case 6223: hash_type = HASH_TYPE_SHA512;
8907 salt_type = SALT_TYPE_EMBEDDED;
8908 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8909 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8910 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8911 dgst_size = DGST_SIZE_8_8;
8912 parse_func = truecrypt_parse_hash_1k;
8913 sort_by_digest = sort_by_digest_8_8;
8914 opti_type = OPTI_TYPE_ZERO_BYTE
8915 | OPTI_TYPE_USES_BITS_64;
8916 dgst_pos0 = 0;
8917 dgst_pos1 = 1;
8918 dgst_pos2 = 2;
8919 dgst_pos3 = 3;
8920 break;
8921
8922 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8923 salt_type = SALT_TYPE_EMBEDDED;
8924 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8925 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8926 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8927 dgst_size = DGST_SIZE_4_8;
8928 parse_func = truecrypt_parse_hash_1k;
8929 sort_by_digest = sort_by_digest_4_8;
8930 opti_type = OPTI_TYPE_ZERO_BYTE;
8931 dgst_pos0 = 0;
8932 dgst_pos1 = 1;
8933 dgst_pos2 = 2;
8934 dgst_pos3 = 3;
8935 break;
8936
8937 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8938 salt_type = SALT_TYPE_EMBEDDED;
8939 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8940 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8941 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8942 dgst_size = DGST_SIZE_4_8;
8943 parse_func = truecrypt_parse_hash_1k;
8944 sort_by_digest = sort_by_digest_4_8;
8945 opti_type = OPTI_TYPE_ZERO_BYTE;
8946 dgst_pos0 = 0;
8947 dgst_pos1 = 1;
8948 dgst_pos2 = 2;
8949 dgst_pos3 = 3;
8950 break;
8951
8952 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8953 salt_type = SALT_TYPE_EMBEDDED;
8954 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8955 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8956 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8957 dgst_size = DGST_SIZE_4_8;
8958 parse_func = truecrypt_parse_hash_1k;
8959 sort_by_digest = sort_by_digest_4_8;
8960 opti_type = OPTI_TYPE_ZERO_BYTE;
8961 dgst_pos0 = 0;
8962 dgst_pos1 = 1;
8963 dgst_pos2 = 2;
8964 dgst_pos3 = 3;
8965 break;
8966
8967 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8968 salt_type = SALT_TYPE_EMBEDDED;
8969 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8970 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8971 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8972 dgst_size = DGST_SIZE_4_5;
8973 parse_func = truecrypt_parse_hash_1k;
8974 sort_by_digest = sort_by_digest_4_5;
8975 opti_type = OPTI_TYPE_ZERO_BYTE;
8976 dgst_pos0 = 0;
8977 dgst_pos1 = 1;
8978 dgst_pos2 = 2;
8979 dgst_pos3 = 3;
8980 break;
8981
8982 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8983 salt_type = SALT_TYPE_EMBEDDED;
8984 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8985 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8986 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8987 dgst_size = DGST_SIZE_4_5;
8988 parse_func = truecrypt_parse_hash_1k;
8989 sort_by_digest = sort_by_digest_4_5;
8990 opti_type = OPTI_TYPE_ZERO_BYTE;
8991 dgst_pos0 = 0;
8992 dgst_pos1 = 1;
8993 dgst_pos2 = 2;
8994 dgst_pos3 = 3;
8995 break;
8996
8997 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8998 salt_type = SALT_TYPE_EMBEDDED;
8999 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9000 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9001 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9002 dgst_size = DGST_SIZE_4_5;
9003 parse_func = truecrypt_parse_hash_1k;
9004 sort_by_digest = sort_by_digest_4_5;
9005 opti_type = OPTI_TYPE_ZERO_BYTE;
9006 dgst_pos0 = 0;
9007 dgst_pos1 = 1;
9008 dgst_pos2 = 2;
9009 dgst_pos3 = 3;
9010 break;
9011
9012 case 6300: hash_type = HASH_TYPE_MD5;
9013 salt_type = SALT_TYPE_EMBEDDED;
9014 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9015 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9016 kern_type = KERN_TYPE_MD5AIX;
9017 dgst_size = DGST_SIZE_4_4;
9018 parse_func = md5aix_parse_hash;
9019 sort_by_digest = sort_by_digest_4_4;
9020 opti_type = OPTI_TYPE_ZERO_BYTE;
9021 dgst_pos0 = 0;
9022 dgst_pos1 = 1;
9023 dgst_pos2 = 2;
9024 dgst_pos3 = 3;
9025 break;
9026
9027 case 6400: hash_type = HASH_TYPE_SHA256;
9028 salt_type = SALT_TYPE_EMBEDDED;
9029 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9030 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9031 kern_type = KERN_TYPE_SHA256AIX;
9032 dgst_size = DGST_SIZE_4_8;
9033 parse_func = sha256aix_parse_hash;
9034 sort_by_digest = sort_by_digest_4_8;
9035 opti_type = OPTI_TYPE_ZERO_BYTE;
9036 dgst_pos0 = 0;
9037 dgst_pos1 = 1;
9038 dgst_pos2 = 2;
9039 dgst_pos3 = 3;
9040 break;
9041
9042 case 6500: hash_type = HASH_TYPE_SHA512;
9043 salt_type = SALT_TYPE_EMBEDDED;
9044 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9045 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9046 kern_type = KERN_TYPE_SHA512AIX;
9047 dgst_size = DGST_SIZE_8_8;
9048 parse_func = sha512aix_parse_hash;
9049 sort_by_digest = sort_by_digest_8_8;
9050 opti_type = OPTI_TYPE_ZERO_BYTE
9051 | OPTI_TYPE_USES_BITS_64;
9052 dgst_pos0 = 0;
9053 dgst_pos1 = 1;
9054 dgst_pos2 = 2;
9055 dgst_pos3 = 3;
9056 break;
9057
9058 case 6600: hash_type = HASH_TYPE_AES;
9059 salt_type = SALT_TYPE_EMBEDDED;
9060 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9061 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9062 kern_type = KERN_TYPE_AGILEKEY;
9063 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9064 parse_func = agilekey_parse_hash;
9065 sort_by_digest = sort_by_digest_4_5;
9066 opti_type = OPTI_TYPE_ZERO_BYTE;
9067 dgst_pos0 = 0;
9068 dgst_pos1 = 1;
9069 dgst_pos2 = 2;
9070 dgst_pos3 = 3;
9071 break;
9072
9073 case 6700: hash_type = HASH_TYPE_SHA1;
9074 salt_type = SALT_TYPE_EMBEDDED;
9075 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9076 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9077 kern_type = KERN_TYPE_SHA1AIX;
9078 dgst_size = DGST_SIZE_4_5;
9079 parse_func = sha1aix_parse_hash;
9080 sort_by_digest = sort_by_digest_4_5;
9081 opti_type = OPTI_TYPE_ZERO_BYTE;
9082 dgst_pos0 = 0;
9083 dgst_pos1 = 1;
9084 dgst_pos2 = 2;
9085 dgst_pos3 = 3;
9086 break;
9087
9088 case 6800: hash_type = HASH_TYPE_AES;
9089 salt_type = SALT_TYPE_EMBEDDED;
9090 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9091 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9092 kern_type = KERN_TYPE_LASTPASS;
9093 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9094 parse_func = lastpass_parse_hash;
9095 sort_by_digest = sort_by_digest_4_8;
9096 opti_type = OPTI_TYPE_ZERO_BYTE;
9097 dgst_pos0 = 0;
9098 dgst_pos1 = 1;
9099 dgst_pos2 = 2;
9100 dgst_pos3 = 3;
9101 break;
9102
9103 case 6900: hash_type = HASH_TYPE_GOST;
9104 salt_type = SALT_TYPE_NONE;
9105 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9106 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9107 kern_type = KERN_TYPE_GOST;
9108 dgst_size = DGST_SIZE_4_8;
9109 parse_func = gost_parse_hash;
9110 sort_by_digest = sort_by_digest_4_8;
9111 opti_type = OPTI_TYPE_ZERO_BYTE;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7100: hash_type = HASH_TYPE_SHA512;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9122 kern_type = KERN_TYPE_PBKDF2_SHA512;
9123 dgst_size = DGST_SIZE_8_16;
9124 parse_func = sha512osx_parse_hash;
9125 sort_by_digest = sort_by_digest_8_16;
9126 opti_type = OPTI_TYPE_ZERO_BYTE
9127 | OPTI_TYPE_USES_BITS_64
9128 | OPTI_TYPE_SLOW_HASH_SIMD;
9129 dgst_pos0 = 0;
9130 dgst_pos1 = 1;
9131 dgst_pos2 = 2;
9132 dgst_pos3 = 3;
9133 break;
9134
9135 case 7200: hash_type = HASH_TYPE_SHA512;
9136 salt_type = SALT_TYPE_EMBEDDED;
9137 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9138 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9139 kern_type = KERN_TYPE_PBKDF2_SHA512;
9140 dgst_size = DGST_SIZE_8_16;
9141 parse_func = sha512grub_parse_hash;
9142 sort_by_digest = sort_by_digest_8_16;
9143 opti_type = OPTI_TYPE_ZERO_BYTE
9144 | OPTI_TYPE_USES_BITS_64
9145 | OPTI_TYPE_SLOW_HASH_SIMD;
9146 dgst_pos0 = 0;
9147 dgst_pos1 = 1;
9148 dgst_pos2 = 2;
9149 dgst_pos3 = 3;
9150 break;
9151
9152 case 7300: hash_type = HASH_TYPE_SHA1;
9153 salt_type = SALT_TYPE_EMBEDDED;
9154 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9155 opts_type = OPTS_TYPE_PT_GENERATE_BE
9156 | OPTS_TYPE_ST_ADD80
9157 | OPTS_TYPE_ST_ADDBITS15;
9158 kern_type = KERN_TYPE_RAKP;
9159 dgst_size = DGST_SIZE_4_5;
9160 parse_func = rakp_parse_hash;
9161 sort_by_digest = sort_by_digest_4_5;
9162 opti_type = OPTI_TYPE_ZERO_BYTE
9163 | OPTI_TYPE_NOT_ITERATED;
9164 dgst_pos0 = 3;
9165 dgst_pos1 = 4;
9166 dgst_pos2 = 2;
9167 dgst_pos3 = 1;
9168 break;
9169
9170 case 7400: hash_type = HASH_TYPE_SHA256;
9171 salt_type = SALT_TYPE_EMBEDDED;
9172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9173 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9174 kern_type = KERN_TYPE_SHA256CRYPT;
9175 dgst_size = DGST_SIZE_4_8;
9176 parse_func = sha256crypt_parse_hash;
9177 sort_by_digest = sort_by_digest_4_8;
9178 opti_type = OPTI_TYPE_ZERO_BYTE;
9179 dgst_pos0 = 0;
9180 dgst_pos1 = 1;
9181 dgst_pos2 = 2;
9182 dgst_pos3 = 3;
9183 break;
9184
9185 case 7500: hash_type = HASH_TYPE_KRB5PA;
9186 salt_type = SALT_TYPE_EMBEDDED;
9187 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9188 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9189 kern_type = KERN_TYPE_KRB5PA;
9190 dgst_size = DGST_SIZE_4_4;
9191 parse_func = krb5pa_parse_hash;
9192 sort_by_digest = sort_by_digest_4_4;
9193 opti_type = OPTI_TYPE_ZERO_BYTE
9194 | OPTI_TYPE_NOT_ITERATED;
9195 dgst_pos0 = 0;
9196 dgst_pos1 = 1;
9197 dgst_pos2 = 2;
9198 dgst_pos3 = 3;
9199 break;
9200
9201 case 7600: hash_type = HASH_TYPE_SHA1;
9202 salt_type = SALT_TYPE_INTERN;
9203 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9204 opts_type = OPTS_TYPE_PT_GENERATE_BE
9205 | OPTS_TYPE_PT_ADD80
9206 | OPTS_TYPE_PT_ADDBITS15;
9207 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9208 dgst_size = DGST_SIZE_4_5;
9209 parse_func = redmine_parse_hash;
9210 sort_by_digest = sort_by_digest_4_5;
9211 opti_type = OPTI_TYPE_ZERO_BYTE
9212 | OPTI_TYPE_PRECOMPUTE_INIT
9213 | OPTI_TYPE_EARLY_SKIP
9214 | OPTI_TYPE_NOT_ITERATED
9215 | OPTI_TYPE_PREPENDED_SALT;
9216 dgst_pos0 = 3;
9217 dgst_pos1 = 4;
9218 dgst_pos2 = 2;
9219 dgst_pos3 = 1;
9220 break;
9221
9222 case 7700: hash_type = HASH_TYPE_SAPB;
9223 salt_type = SALT_TYPE_EMBEDDED;
9224 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9225 opts_type = OPTS_TYPE_PT_GENERATE_LE
9226 | OPTS_TYPE_PT_UPPER
9227 | OPTS_TYPE_ST_UPPER;
9228 kern_type = KERN_TYPE_SAPB;
9229 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9230 parse_func = sapb_parse_hash;
9231 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9232 opti_type = OPTI_TYPE_ZERO_BYTE
9233 | OPTI_TYPE_PRECOMPUTE_INIT
9234 | OPTI_TYPE_NOT_ITERATED;
9235 dgst_pos0 = 0;
9236 dgst_pos1 = 1;
9237 dgst_pos2 = 2;
9238 dgst_pos3 = 3;
9239 break;
9240
9241 case 7800: hash_type = HASH_TYPE_SAPG;
9242 salt_type = SALT_TYPE_EMBEDDED;
9243 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9244 opts_type = OPTS_TYPE_PT_GENERATE_BE
9245 | OPTS_TYPE_ST_ADD80
9246 | OPTS_TYPE_ST_UPPER;
9247 kern_type = KERN_TYPE_SAPG;
9248 dgst_size = DGST_SIZE_4_5;
9249 parse_func = sapg_parse_hash;
9250 sort_by_digest = sort_by_digest_4_5;
9251 opti_type = OPTI_TYPE_ZERO_BYTE
9252 | OPTI_TYPE_PRECOMPUTE_INIT
9253 | OPTI_TYPE_NOT_ITERATED;
9254 dgst_pos0 = 3;
9255 dgst_pos1 = 4;
9256 dgst_pos2 = 2;
9257 dgst_pos3 = 1;
9258 break;
9259
9260 case 7900: hash_type = HASH_TYPE_SHA512;
9261 salt_type = SALT_TYPE_EMBEDDED;
9262 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9263 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9264 kern_type = KERN_TYPE_DRUPAL7;
9265 dgst_size = DGST_SIZE_8_8;
9266 parse_func = drupal7_parse_hash;
9267 sort_by_digest = sort_by_digest_8_8;
9268 opti_type = OPTI_TYPE_ZERO_BYTE
9269 | OPTI_TYPE_USES_BITS_64;
9270 dgst_pos0 = 0;
9271 dgst_pos1 = 1;
9272 dgst_pos2 = 2;
9273 dgst_pos3 = 3;
9274 break;
9275
9276 case 8000: hash_type = HASH_TYPE_SHA256;
9277 salt_type = SALT_TYPE_EMBEDDED;
9278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9279 opts_type = OPTS_TYPE_PT_GENERATE_BE
9280 | OPTS_TYPE_PT_UNICODE
9281 | OPTS_TYPE_ST_ADD80
9282 | OPTS_TYPE_ST_HEX;
9283 kern_type = KERN_TYPE_SYBASEASE;
9284 dgst_size = DGST_SIZE_4_8;
9285 parse_func = sybasease_parse_hash;
9286 sort_by_digest = sort_by_digest_4_8;
9287 opti_type = OPTI_TYPE_ZERO_BYTE
9288 | OPTI_TYPE_PRECOMPUTE_INIT
9289 | OPTI_TYPE_EARLY_SKIP
9290 | OPTI_TYPE_NOT_ITERATED
9291 | OPTI_TYPE_RAW_HASH;
9292 dgst_pos0 = 3;
9293 dgst_pos1 = 7;
9294 dgst_pos2 = 2;
9295 dgst_pos3 = 6;
9296 break;
9297
9298 case 8100: hash_type = HASH_TYPE_SHA1;
9299 salt_type = SALT_TYPE_EMBEDDED;
9300 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9301 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9302 kern_type = KERN_TYPE_NETSCALER;
9303 dgst_size = DGST_SIZE_4_5;
9304 parse_func = netscaler_parse_hash;
9305 sort_by_digest = sort_by_digest_4_5;
9306 opti_type = OPTI_TYPE_ZERO_BYTE
9307 | OPTI_TYPE_PRECOMPUTE_INIT
9308 | OPTI_TYPE_PRECOMPUTE_MERKLE
9309 | OPTI_TYPE_EARLY_SKIP
9310 | OPTI_TYPE_NOT_ITERATED
9311 | OPTI_TYPE_PREPENDED_SALT
9312 | OPTI_TYPE_RAW_HASH;
9313 dgst_pos0 = 3;
9314 dgst_pos1 = 4;
9315 dgst_pos2 = 2;
9316 dgst_pos3 = 1;
9317 break;
9318
9319 case 8200: hash_type = HASH_TYPE_SHA256;
9320 salt_type = SALT_TYPE_EMBEDDED;
9321 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9322 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9323 kern_type = KERN_TYPE_CLOUDKEY;
9324 dgst_size = DGST_SIZE_4_8;
9325 parse_func = cloudkey_parse_hash;
9326 sort_by_digest = sort_by_digest_4_8;
9327 opti_type = OPTI_TYPE_ZERO_BYTE;
9328 dgst_pos0 = 0;
9329 dgst_pos1 = 1;
9330 dgst_pos2 = 2;
9331 dgst_pos3 = 3;
9332 break;
9333
9334 case 8300: hash_type = HASH_TYPE_SHA1;
9335 salt_type = SALT_TYPE_EMBEDDED;
9336 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9337 opts_type = OPTS_TYPE_PT_GENERATE_BE
9338 | OPTS_TYPE_ST_HEX
9339 | OPTS_TYPE_ST_ADD80;
9340 kern_type = KERN_TYPE_NSEC3;
9341 dgst_size = DGST_SIZE_4_5;
9342 parse_func = nsec3_parse_hash;
9343 sort_by_digest = sort_by_digest_4_5;
9344 opti_type = OPTI_TYPE_ZERO_BYTE;
9345 dgst_pos0 = 3;
9346 dgst_pos1 = 4;
9347 dgst_pos2 = 2;
9348 dgst_pos3 = 1;
9349 break;
9350
9351 case 8400: hash_type = HASH_TYPE_SHA1;
9352 salt_type = SALT_TYPE_INTERN;
9353 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9354 opts_type = OPTS_TYPE_PT_GENERATE_BE
9355 | OPTS_TYPE_PT_ADD80
9356 | OPTS_TYPE_PT_ADDBITS15;
9357 kern_type = KERN_TYPE_WBB3;
9358 dgst_size = DGST_SIZE_4_5;
9359 parse_func = wbb3_parse_hash;
9360 sort_by_digest = sort_by_digest_4_5;
9361 opti_type = OPTI_TYPE_ZERO_BYTE
9362 | OPTI_TYPE_PRECOMPUTE_INIT
9363 | OPTI_TYPE_NOT_ITERATED;
9364 dgst_pos0 = 3;
9365 dgst_pos1 = 4;
9366 dgst_pos2 = 2;
9367 dgst_pos3 = 1;
9368 break;
9369
9370 case 8500: hash_type = HASH_TYPE_DESRACF;
9371 salt_type = SALT_TYPE_EMBEDDED;
9372 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9373 opts_type = OPTS_TYPE_PT_GENERATE_LE
9374 | OPTS_TYPE_ST_UPPER;
9375 kern_type = KERN_TYPE_RACF;
9376 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9377 parse_func = racf_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9379 opti_type = OPTI_TYPE_ZERO_BYTE
9380 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9381 dgst_pos0 = 0;
9382 dgst_pos1 = 1;
9383 dgst_pos2 = 2;
9384 dgst_pos3 = 3;
9385 break;
9386
9387 case 8600: hash_type = HASH_TYPE_LOTUS5;
9388 salt_type = SALT_TYPE_NONE;
9389 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9390 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9391 kern_type = KERN_TYPE_LOTUS5;
9392 dgst_size = DGST_SIZE_4_4;
9393 parse_func = lotus5_parse_hash;
9394 sort_by_digest = sort_by_digest_4_4;
9395 opti_type = OPTI_TYPE_EARLY_SKIP
9396 | OPTI_TYPE_NOT_ITERATED
9397 | OPTI_TYPE_NOT_SALTED
9398 | OPTI_TYPE_RAW_HASH;
9399 dgst_pos0 = 0;
9400 dgst_pos1 = 1;
9401 dgst_pos2 = 2;
9402 dgst_pos3 = 3;
9403 break;
9404
9405 case 8700: hash_type = HASH_TYPE_LOTUS6;
9406 salt_type = SALT_TYPE_EMBEDDED;
9407 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9408 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9409 kern_type = KERN_TYPE_LOTUS6;
9410 dgst_size = DGST_SIZE_4_4;
9411 parse_func = lotus6_parse_hash;
9412 sort_by_digest = sort_by_digest_4_4;
9413 opti_type = OPTI_TYPE_EARLY_SKIP
9414 | OPTI_TYPE_NOT_ITERATED
9415 | OPTI_TYPE_RAW_HASH;
9416 dgst_pos0 = 0;
9417 dgst_pos1 = 1;
9418 dgst_pos2 = 2;
9419 dgst_pos3 = 3;
9420 break;
9421
9422 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9423 salt_type = SALT_TYPE_EMBEDDED;
9424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9425 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9426 kern_type = KERN_TYPE_ANDROIDFDE;
9427 dgst_size = DGST_SIZE_4_4;
9428 parse_func = androidfde_parse_hash;
9429 sort_by_digest = sort_by_digest_4_4;
9430 opti_type = OPTI_TYPE_ZERO_BYTE;
9431 dgst_pos0 = 0;
9432 dgst_pos1 = 1;
9433 dgst_pos2 = 2;
9434 dgst_pos3 = 3;
9435 break;
9436
9437 case 8900: hash_type = HASH_TYPE_SCRYPT;
9438 salt_type = SALT_TYPE_EMBEDDED;
9439 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9440 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9441 kern_type = KERN_TYPE_SCRYPT;
9442 dgst_size = DGST_SIZE_4_8;
9443 parse_func = scrypt_parse_hash;
9444 sort_by_digest = sort_by_digest_4_8;
9445 opti_type = OPTI_TYPE_ZERO_BYTE;
9446 dgst_pos0 = 0;
9447 dgst_pos1 = 1;
9448 dgst_pos2 = 2;
9449 dgst_pos3 = 3;
9450 break;
9451
9452 case 9000: hash_type = HASH_TYPE_SHA1;
9453 salt_type = SALT_TYPE_EMBEDDED;
9454 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9455 opts_type = OPTS_TYPE_PT_GENERATE_LE
9456 | OPTS_TYPE_ST_GENERATE_LE;
9457 kern_type = KERN_TYPE_PSAFE2;
9458 dgst_size = DGST_SIZE_4_5;
9459 parse_func = psafe2_parse_hash;
9460 sort_by_digest = sort_by_digest_4_5;
9461 opti_type = OPTI_TYPE_ZERO_BYTE;
9462 dgst_pos0 = 0;
9463 dgst_pos1 = 1;
9464 dgst_pos2 = 2;
9465 dgst_pos3 = 3;
9466 break;
9467
9468 case 9100: hash_type = HASH_TYPE_LOTUS8;
9469 salt_type = SALT_TYPE_EMBEDDED;
9470 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9471 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9472 kern_type = KERN_TYPE_LOTUS8;
9473 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9474 parse_func = lotus8_parse_hash;
9475 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9476 opti_type = OPTI_TYPE_ZERO_BYTE;
9477 dgst_pos0 = 0;
9478 dgst_pos1 = 1;
9479 dgst_pos2 = 2;
9480 dgst_pos3 = 3;
9481 break;
9482
9483 case 9200: hash_type = HASH_TYPE_SHA256;
9484 salt_type = SALT_TYPE_EMBEDDED;
9485 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9486 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9487 kern_type = KERN_TYPE_PBKDF2_SHA256;
9488 dgst_size = DGST_SIZE_4_32;
9489 parse_func = cisco8_parse_hash;
9490 sort_by_digest = sort_by_digest_4_32;
9491 opti_type = OPTI_TYPE_ZERO_BYTE
9492 | OPTI_TYPE_SLOW_HASH_SIMD;
9493 dgst_pos0 = 0;
9494 dgst_pos1 = 1;
9495 dgst_pos2 = 2;
9496 dgst_pos3 = 3;
9497 break;
9498
9499 case 9300: hash_type = HASH_TYPE_SCRYPT;
9500 salt_type = SALT_TYPE_EMBEDDED;
9501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9503 kern_type = KERN_TYPE_SCRYPT;
9504 dgst_size = DGST_SIZE_4_8;
9505 parse_func = cisco9_parse_hash;
9506 sort_by_digest = sort_by_digest_4_8;
9507 opti_type = OPTI_TYPE_ZERO_BYTE;
9508 dgst_pos0 = 0;
9509 dgst_pos1 = 1;
9510 dgst_pos2 = 2;
9511 dgst_pos3 = 3;
9512 break;
9513
9514 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9515 salt_type = SALT_TYPE_EMBEDDED;
9516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9518 kern_type = KERN_TYPE_OFFICE2007;
9519 dgst_size = DGST_SIZE_4_4;
9520 parse_func = office2007_parse_hash;
9521 sort_by_digest = sort_by_digest_4_4;
9522 opti_type = OPTI_TYPE_ZERO_BYTE;
9523 dgst_pos0 = 0;
9524 dgst_pos1 = 1;
9525 dgst_pos2 = 2;
9526 dgst_pos3 = 3;
9527 break;
9528
9529 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9530 salt_type = SALT_TYPE_EMBEDDED;
9531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9533 kern_type = KERN_TYPE_OFFICE2010;
9534 dgst_size = DGST_SIZE_4_4;
9535 parse_func = office2010_parse_hash;
9536 sort_by_digest = sort_by_digest_4_4;
9537 opti_type = OPTI_TYPE_ZERO_BYTE;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9548 kern_type = KERN_TYPE_OFFICE2013;
9549 dgst_size = DGST_SIZE_4_4;
9550 parse_func = office2013_parse_hash;
9551 sort_by_digest = sort_by_digest_4_4;
9552 opti_type = OPTI_TYPE_ZERO_BYTE;
9553 dgst_pos0 = 0;
9554 dgst_pos1 = 1;
9555 dgst_pos2 = 2;
9556 dgst_pos3 = 3;
9557 break;
9558
9559 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9560 salt_type = SALT_TYPE_EMBEDDED;
9561 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9562 opts_type = OPTS_TYPE_PT_GENERATE_LE
9563 | OPTS_TYPE_PT_ADD80
9564 | OPTS_TYPE_PT_UNICODE;
9565 kern_type = KERN_TYPE_OLDOFFICE01;
9566 dgst_size = DGST_SIZE_4_4;
9567 parse_func = oldoffice01_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4;
9569 opti_type = OPTI_TYPE_ZERO_BYTE
9570 | OPTI_TYPE_PRECOMPUTE_INIT
9571 | OPTI_TYPE_NOT_ITERATED;
9572 dgst_pos0 = 0;
9573 dgst_pos1 = 1;
9574 dgst_pos2 = 2;
9575 dgst_pos3 = 3;
9576 break;
9577
9578 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9579 salt_type = SALT_TYPE_EMBEDDED;
9580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9581 opts_type = OPTS_TYPE_PT_GENERATE_LE
9582 | OPTS_TYPE_PT_ADD80;
9583 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9584 dgst_size = DGST_SIZE_4_4;
9585 parse_func = oldoffice01cm1_parse_hash;
9586 sort_by_digest = sort_by_digest_4_4;
9587 opti_type = OPTI_TYPE_ZERO_BYTE
9588 | OPTI_TYPE_PRECOMPUTE_INIT
9589 | OPTI_TYPE_NOT_ITERATED;
9590 dgst_pos0 = 0;
9591 dgst_pos1 = 1;
9592 dgst_pos2 = 2;
9593 dgst_pos3 = 3;
9594 break;
9595
9596 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9597 salt_type = SALT_TYPE_EMBEDDED;
9598 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9599 opts_type = OPTS_TYPE_PT_GENERATE_LE
9600 | OPTS_TYPE_PT_ADD80
9601 | OPTS_TYPE_PT_UNICODE
9602 | OPTS_TYPE_PT_NEVERCRACK;
9603 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9604 dgst_size = DGST_SIZE_4_4;
9605 parse_func = oldoffice01cm2_parse_hash;
9606 sort_by_digest = sort_by_digest_4_4;
9607 opti_type = OPTI_TYPE_ZERO_BYTE
9608 | OPTI_TYPE_PRECOMPUTE_INIT
9609 | OPTI_TYPE_NOT_ITERATED;
9610 dgst_pos0 = 0;
9611 dgst_pos1 = 1;
9612 dgst_pos2 = 2;
9613 dgst_pos3 = 3;
9614 break;
9615
9616 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9617 salt_type = SALT_TYPE_EMBEDDED;
9618 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9619 opts_type = OPTS_TYPE_PT_GENERATE_BE
9620 | OPTS_TYPE_PT_ADD80
9621 | OPTS_TYPE_PT_UNICODE;
9622 kern_type = KERN_TYPE_OLDOFFICE34;
9623 dgst_size = DGST_SIZE_4_4;
9624 parse_func = oldoffice34_parse_hash;
9625 sort_by_digest = sort_by_digest_4_4;
9626 opti_type = OPTI_TYPE_ZERO_BYTE
9627 | OPTI_TYPE_PRECOMPUTE_INIT
9628 | OPTI_TYPE_NOT_ITERATED;
9629 dgst_pos0 = 0;
9630 dgst_pos1 = 1;
9631 dgst_pos2 = 2;
9632 dgst_pos3 = 3;
9633 break;
9634
9635 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9636 salt_type = SALT_TYPE_EMBEDDED;
9637 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9638 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9639 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9640 dgst_size = DGST_SIZE_4_4;
9641 parse_func = oldoffice34cm1_parse_hash;
9642 sort_by_digest = sort_by_digest_4_4;
9643 opti_type = OPTI_TYPE_ZERO_BYTE
9644 | OPTI_TYPE_PRECOMPUTE_INIT
9645 | OPTI_TYPE_NOT_ITERATED;
9646 dgst_pos0 = 0;
9647 dgst_pos1 = 1;
9648 dgst_pos2 = 2;
9649 dgst_pos3 = 3;
9650 break;
9651
9652 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9653 salt_type = SALT_TYPE_EMBEDDED;
9654 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9655 opts_type = OPTS_TYPE_PT_GENERATE_BE
9656 | OPTS_TYPE_PT_ADD80
9657 | OPTS_TYPE_PT_UNICODE
9658 | OPTS_TYPE_PT_NEVERCRACK;
9659 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9660 dgst_size = DGST_SIZE_4_4;
9661 parse_func = oldoffice34cm2_parse_hash;
9662 sort_by_digest = sort_by_digest_4_4;
9663 opti_type = OPTI_TYPE_ZERO_BYTE
9664 | OPTI_TYPE_PRECOMPUTE_INIT
9665 | OPTI_TYPE_NOT_ITERATED;
9666 dgst_pos0 = 0;
9667 dgst_pos1 = 1;
9668 dgst_pos2 = 2;
9669 dgst_pos3 = 3;
9670 break;
9671
9672 case 9900: hash_type = HASH_TYPE_MD5;
9673 salt_type = SALT_TYPE_NONE;
9674 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9675 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9676 kern_type = KERN_TYPE_RADMIN2;
9677 dgst_size = DGST_SIZE_4_4;
9678 parse_func = radmin2_parse_hash;
9679 sort_by_digest = sort_by_digest_4_4;
9680 opti_type = OPTI_TYPE_ZERO_BYTE
9681 | OPTI_TYPE_PRECOMPUTE_INIT
9682 | OPTI_TYPE_EARLY_SKIP
9683 | OPTI_TYPE_NOT_ITERATED
9684 | OPTI_TYPE_NOT_SALTED;
9685 dgst_pos0 = 0;
9686 dgst_pos1 = 3;
9687 dgst_pos2 = 2;
9688 dgst_pos3 = 1;
9689 break;
9690
9691 case 10000: hash_type = HASH_TYPE_SHA256;
9692 salt_type = SALT_TYPE_EMBEDDED;
9693 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9694 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9695 kern_type = KERN_TYPE_PBKDF2_SHA256;
9696 dgst_size = DGST_SIZE_4_32;
9697 parse_func = djangopbkdf2_parse_hash;
9698 sort_by_digest = sort_by_digest_4_32;
9699 opti_type = OPTI_TYPE_ZERO_BYTE
9700 | OPTI_TYPE_SLOW_HASH_SIMD;
9701 dgst_pos0 = 0;
9702 dgst_pos1 = 1;
9703 dgst_pos2 = 2;
9704 dgst_pos3 = 3;
9705 break;
9706
9707 case 10100: hash_type = HASH_TYPE_SIPHASH;
9708 salt_type = SALT_TYPE_EMBEDDED;
9709 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9710 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9711 kern_type = KERN_TYPE_SIPHASH;
9712 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9713 parse_func = siphash_parse_hash;
9714 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9715 opti_type = OPTI_TYPE_ZERO_BYTE
9716 | OPTI_TYPE_NOT_ITERATED
9717 | OPTI_TYPE_RAW_HASH;
9718 dgst_pos0 = 0;
9719 dgst_pos1 = 1;
9720 dgst_pos2 = 2;
9721 dgst_pos3 = 3;
9722 break;
9723
9724 case 10200: hash_type = HASH_TYPE_MD5;
9725 salt_type = SALT_TYPE_EMBEDDED;
9726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9727 opts_type = OPTS_TYPE_PT_GENERATE_LE
9728 | OPTS_TYPE_ST_ADD80
9729 | OPTS_TYPE_ST_ADDBITS14;
9730 kern_type = KERN_TYPE_HMACMD5_PW;
9731 dgst_size = DGST_SIZE_4_4;
9732 parse_func = crammd5_parse_hash;
9733 sort_by_digest = sort_by_digest_4_4;
9734 opti_type = OPTI_TYPE_ZERO_BYTE
9735 | OPTI_TYPE_NOT_ITERATED;
9736 dgst_pos0 = 0;
9737 dgst_pos1 = 3;
9738 dgst_pos2 = 2;
9739 dgst_pos3 = 1;
9740 break;
9741
9742 case 10300: hash_type = HASH_TYPE_SHA1;
9743 salt_type = SALT_TYPE_EMBEDDED;
9744 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9745 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9746 kern_type = KERN_TYPE_SAPH_SHA1;
9747 dgst_size = DGST_SIZE_4_5;
9748 parse_func = saph_sha1_parse_hash;
9749 sort_by_digest = sort_by_digest_4_5;
9750 opti_type = OPTI_TYPE_ZERO_BYTE;
9751 dgst_pos0 = 0;
9752 dgst_pos1 = 1;
9753 dgst_pos2 = 2;
9754 dgst_pos3 = 3;
9755 break;
9756
9757 case 10400: hash_type = HASH_TYPE_PDFU16;
9758 salt_type = SALT_TYPE_EMBEDDED;
9759 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9760 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9761 kern_type = KERN_TYPE_PDF11;
9762 dgst_size = DGST_SIZE_4_4;
9763 parse_func = pdf11_parse_hash;
9764 sort_by_digest = sort_by_digest_4_4;
9765 opti_type = OPTI_TYPE_ZERO_BYTE
9766 | OPTI_TYPE_NOT_ITERATED;
9767 dgst_pos0 = 0;
9768 dgst_pos1 = 1;
9769 dgst_pos2 = 2;
9770 dgst_pos3 = 3;
9771 break;
9772
9773 case 10410: hash_type = HASH_TYPE_PDFU16;
9774 salt_type = SALT_TYPE_EMBEDDED;
9775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9776 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9777 kern_type = KERN_TYPE_PDF11CM1;
9778 dgst_size = DGST_SIZE_4_4;
9779 parse_func = pdf11cm1_parse_hash;
9780 sort_by_digest = sort_by_digest_4_4;
9781 opti_type = OPTI_TYPE_ZERO_BYTE
9782 | OPTI_TYPE_NOT_ITERATED;
9783 dgst_pos0 = 0;
9784 dgst_pos1 = 1;
9785 dgst_pos2 = 2;
9786 dgst_pos3 = 3;
9787 break;
9788
9789 case 10420: hash_type = HASH_TYPE_PDFU16;
9790 salt_type = SALT_TYPE_EMBEDDED;
9791 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9792 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9793 kern_type = KERN_TYPE_PDF11CM2;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = pdf11cm2_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_NOT_ITERATED;
9799 dgst_pos0 = 0;
9800 dgst_pos1 = 1;
9801 dgst_pos2 = 2;
9802 dgst_pos3 = 3;
9803 break;
9804
9805 case 10500: hash_type = HASH_TYPE_PDFU16;
9806 salt_type = SALT_TYPE_EMBEDDED;
9807 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9808 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9809 kern_type = KERN_TYPE_PDF14;
9810 dgst_size = DGST_SIZE_4_4;
9811 parse_func = pdf14_parse_hash;
9812 sort_by_digest = sort_by_digest_4_4;
9813 opti_type = OPTI_TYPE_ZERO_BYTE
9814 | OPTI_TYPE_NOT_ITERATED;
9815 dgst_pos0 = 0;
9816 dgst_pos1 = 1;
9817 dgst_pos2 = 2;
9818 dgst_pos3 = 3;
9819 break;
9820
9821 case 10600: hash_type = HASH_TYPE_SHA256;
9822 salt_type = SALT_TYPE_EMBEDDED;
9823 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9824 opts_type = OPTS_TYPE_PT_GENERATE_BE
9825 | OPTS_TYPE_ST_ADD80
9826 | OPTS_TYPE_ST_ADDBITS15
9827 | OPTS_TYPE_HASH_COPY;
9828 kern_type = KERN_TYPE_SHA256_PWSLT;
9829 dgst_size = DGST_SIZE_4_8;
9830 parse_func = pdf17l3_parse_hash;
9831 sort_by_digest = sort_by_digest_4_8;
9832 opti_type = OPTI_TYPE_ZERO_BYTE
9833 | OPTI_TYPE_PRECOMPUTE_INIT
9834 | OPTI_TYPE_PRECOMPUTE_MERKLE
9835 | OPTI_TYPE_EARLY_SKIP
9836 | OPTI_TYPE_NOT_ITERATED
9837 | OPTI_TYPE_APPENDED_SALT
9838 | OPTI_TYPE_RAW_HASH;
9839 dgst_pos0 = 3;
9840 dgst_pos1 = 7;
9841 dgst_pos2 = 2;
9842 dgst_pos3 = 6;
9843 break;
9844
9845 case 10700: hash_type = HASH_TYPE_PDFU32;
9846 salt_type = SALT_TYPE_EMBEDDED;
9847 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9848 opts_type = OPTS_TYPE_PT_GENERATE_LE
9849 | OPTS_TYPE_HASH_COPY;
9850 kern_type = KERN_TYPE_PDF17L8;
9851 dgst_size = DGST_SIZE_4_8;
9852 parse_func = pdf17l8_parse_hash;
9853 sort_by_digest = sort_by_digest_4_8;
9854 opti_type = OPTI_TYPE_ZERO_BYTE
9855 | OPTI_TYPE_NOT_ITERATED;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 10800: hash_type = HASH_TYPE_SHA384;
9863 salt_type = SALT_TYPE_NONE;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_BE
9866 | OPTS_TYPE_PT_ADD80
9867 | OPTS_TYPE_PT_ADDBITS15;
9868 kern_type = KERN_TYPE_SHA384;
9869 dgst_size = DGST_SIZE_8_8;
9870 parse_func = sha384_parse_hash;
9871 sort_by_digest = sort_by_digest_8_8;
9872 opti_type = OPTI_TYPE_ZERO_BYTE
9873 | OPTI_TYPE_PRECOMPUTE_INIT
9874 | OPTI_TYPE_PRECOMPUTE_MERKLE
9875 | OPTI_TYPE_EARLY_SKIP
9876 | OPTI_TYPE_NOT_ITERATED
9877 | OPTI_TYPE_NOT_SALTED
9878 | OPTI_TYPE_USES_BITS_64
9879 | OPTI_TYPE_RAW_HASH;
9880 dgst_pos0 = 6;
9881 dgst_pos1 = 7;
9882 dgst_pos2 = 4;
9883 dgst_pos3 = 5;
9884 break;
9885
9886 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9887 salt_type = SALT_TYPE_EMBEDDED;
9888 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9889 opts_type = OPTS_TYPE_PT_GENERATE_LE
9890 | OPTS_TYPE_ST_BASE64
9891 | OPTS_TYPE_HASH_COPY;
9892 kern_type = KERN_TYPE_PBKDF2_SHA256;
9893 dgst_size = DGST_SIZE_4_32;
9894 parse_func = pbkdf2_sha256_parse_hash;
9895 sort_by_digest = sort_by_digest_4_32;
9896 opti_type = OPTI_TYPE_ZERO_BYTE
9897 | OPTI_TYPE_SLOW_HASH_SIMD;
9898 dgst_pos0 = 0;
9899 dgst_pos1 = 1;
9900 dgst_pos2 = 2;
9901 dgst_pos3 = 3;
9902 break;
9903
9904 case 11000: hash_type = HASH_TYPE_MD5;
9905 salt_type = SALT_TYPE_INTERN;
9906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9907 opts_type = OPTS_TYPE_PT_GENERATE_LE
9908 | OPTS_TYPE_PT_ADD80;
9909 kern_type = KERN_TYPE_PRESTASHOP;
9910 dgst_size = DGST_SIZE_4_4;
9911 parse_func = prestashop_parse_hash;
9912 sort_by_digest = sort_by_digest_4_4;
9913 opti_type = OPTI_TYPE_ZERO_BYTE
9914 | OPTI_TYPE_PRECOMPUTE_INIT
9915 | OPTI_TYPE_NOT_ITERATED
9916 | OPTI_TYPE_PREPENDED_SALT;
9917 dgst_pos0 = 0;
9918 dgst_pos1 = 3;
9919 dgst_pos2 = 2;
9920 dgst_pos3 = 1;
9921 break;
9922
9923 case 11100: hash_type = HASH_TYPE_MD5;
9924 salt_type = SALT_TYPE_EMBEDDED;
9925 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9926 opts_type = OPTS_TYPE_PT_GENERATE_LE
9927 | OPTS_TYPE_ST_ADD80;
9928 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9929 dgst_size = DGST_SIZE_4_4;
9930 parse_func = postgresql_auth_parse_hash;
9931 sort_by_digest = sort_by_digest_4_4;
9932 opti_type = OPTI_TYPE_ZERO_BYTE
9933 | OPTI_TYPE_PRECOMPUTE_INIT
9934 | OPTI_TYPE_PRECOMPUTE_MERKLE
9935 | OPTI_TYPE_EARLY_SKIP;
9936 dgst_pos0 = 0;
9937 dgst_pos1 = 3;
9938 dgst_pos2 = 2;
9939 dgst_pos3 = 1;
9940 break;
9941
9942 case 11200: hash_type = HASH_TYPE_SHA1;
9943 salt_type = SALT_TYPE_EMBEDDED;
9944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9945 opts_type = OPTS_TYPE_PT_GENERATE_BE
9946 | OPTS_TYPE_PT_ADD80
9947 | OPTS_TYPE_ST_HEX;
9948 kern_type = KERN_TYPE_MYSQL_AUTH;
9949 dgst_size = DGST_SIZE_4_5;
9950 parse_func = mysql_auth_parse_hash;
9951 sort_by_digest = sort_by_digest_4_5;
9952 opti_type = OPTI_TYPE_ZERO_BYTE
9953 | OPTI_TYPE_EARLY_SKIP;
9954 dgst_pos0 = 3;
9955 dgst_pos1 = 4;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 1;
9958 break;
9959
9960 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9961 salt_type = SALT_TYPE_EMBEDDED;
9962 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_ST_HEX
9965 | OPTS_TYPE_ST_ADD80;
9966 kern_type = KERN_TYPE_BITCOIN_WALLET;
9967 dgst_size = DGST_SIZE_4_4;
9968 parse_func = bitcoin_wallet_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4;
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11400: hash_type = HASH_TYPE_MD5;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_PT_ADD80
9982 | OPTS_TYPE_HASH_COPY;
9983 kern_type = KERN_TYPE_SIP_AUTH;
9984 dgst_size = DGST_SIZE_4_4;
9985 parse_func = sip_auth_parse_hash;
9986 sort_by_digest = sort_by_digest_4_4;
9987 opti_type = OPTI_TYPE_ZERO_BYTE;
9988 dgst_pos0 = 0;
9989 dgst_pos1 = 3;
9990 dgst_pos2 = 2;
9991 dgst_pos3 = 1;
9992 break;
9993
9994 case 11500: hash_type = HASH_TYPE_CRC32;
9995 salt_type = SALT_TYPE_INTERN;
9996 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9997 opts_type = OPTS_TYPE_PT_GENERATE_LE
9998 | OPTS_TYPE_ST_GENERATE_LE
9999 | OPTS_TYPE_ST_HEX;
10000 kern_type = KERN_TYPE_CRC32;
10001 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10002 parse_func = crc32_parse_hash;
10003 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10004 opti_type = OPTI_TYPE_ZERO_BYTE;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 11600: hash_type = HASH_TYPE_AES;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_LE
10015 | OPTS_TYPE_PT_NEVERCRACK;
10016 kern_type = KERN_TYPE_SEVEN_ZIP;
10017 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10018 parse_func = seven_zip_parse_hash;
10019 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10020 opti_type = OPTI_TYPE_ZERO_BYTE;
10021 dgst_pos0 = 0;
10022 dgst_pos1 = 1;
10023 dgst_pos2 = 2;
10024 dgst_pos3 = 3;
10025 break;
10026
10027 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10028 salt_type = SALT_TYPE_NONE;
10029 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10030 opts_type = OPTS_TYPE_PT_GENERATE_LE
10031 | OPTS_TYPE_PT_ADD01;
10032 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10033 dgst_size = DGST_SIZE_4_8;
10034 parse_func = gost2012sbog_256_parse_hash;
10035 sort_by_digest = sort_by_digest_4_8;
10036 opti_type = OPTI_TYPE_ZERO_BYTE;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10044 salt_type = SALT_TYPE_NONE;
10045 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE
10047 | OPTS_TYPE_PT_ADD01;
10048 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10049 dgst_size = DGST_SIZE_4_16;
10050 parse_func = gost2012sbog_512_parse_hash;
10051 sort_by_digest = sort_by_digest_4_16;
10052 opti_type = OPTI_TYPE_ZERO_BYTE;
10053 dgst_pos0 = 0;
10054 dgst_pos1 = 1;
10055 dgst_pos2 = 2;
10056 dgst_pos3 = 3;
10057 break;
10058
10059 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10060 salt_type = SALT_TYPE_EMBEDDED;
10061 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10062 opts_type = OPTS_TYPE_PT_GENERATE_LE
10063 | OPTS_TYPE_ST_BASE64
10064 | OPTS_TYPE_HASH_COPY;
10065 kern_type = KERN_TYPE_PBKDF2_MD5;
10066 dgst_size = DGST_SIZE_4_32;
10067 parse_func = pbkdf2_md5_parse_hash;
10068 sort_by_digest = sort_by_digest_4_32;
10069 opti_type = OPTI_TYPE_ZERO_BYTE
10070 | OPTI_TYPE_SLOW_HASH_SIMD;
10071 dgst_pos0 = 0;
10072 dgst_pos1 = 1;
10073 dgst_pos2 = 2;
10074 dgst_pos3 = 3;
10075 break;
10076
10077 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10078 salt_type = SALT_TYPE_EMBEDDED;
10079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10080 opts_type = OPTS_TYPE_PT_GENERATE_LE
10081 | OPTS_TYPE_ST_BASE64
10082 | OPTS_TYPE_HASH_COPY;
10083 kern_type = KERN_TYPE_PBKDF2_SHA1;
10084 dgst_size = DGST_SIZE_4_32;
10085 parse_func = pbkdf2_sha1_parse_hash;
10086 sort_by_digest = sort_by_digest_4_32;
10087 opti_type = OPTI_TYPE_ZERO_BYTE
10088 | OPTI_TYPE_SLOW_HASH_SIMD;
10089 dgst_pos0 = 0;
10090 dgst_pos1 = 1;
10091 dgst_pos2 = 2;
10092 dgst_pos3 = 3;
10093 break;
10094
10095 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10096 salt_type = SALT_TYPE_EMBEDDED;
10097 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10098 opts_type = OPTS_TYPE_PT_GENERATE_LE
10099 | OPTS_TYPE_ST_BASE64
10100 | OPTS_TYPE_HASH_COPY;
10101 kern_type = KERN_TYPE_PBKDF2_SHA512;
10102 dgst_size = DGST_SIZE_8_16;
10103 parse_func = pbkdf2_sha512_parse_hash;
10104 sort_by_digest = sort_by_digest_8_16;
10105 opti_type = OPTI_TYPE_ZERO_BYTE
10106 | OPTI_TYPE_USES_BITS_64
10107 | OPTI_TYPE_SLOW_HASH_SIMD;
10108 dgst_pos0 = 0;
10109 dgst_pos1 = 1;
10110 dgst_pos2 = 2;
10111 dgst_pos3 = 3;
10112 break;
10113
10114 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10115 salt_type = SALT_TYPE_EMBEDDED;
10116 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10117 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10118 kern_type = KERN_TYPE_ECRYPTFS;
10119 dgst_size = DGST_SIZE_8_8;
10120 parse_func = ecryptfs_parse_hash;
10121 sort_by_digest = sort_by_digest_8_8;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_USES_BITS_64;
10124 dgst_pos0 = 0;
10125 dgst_pos1 = 1;
10126 dgst_pos2 = 2;
10127 dgst_pos3 = 3;
10128 break;
10129
10130 case 12300: hash_type = HASH_TYPE_ORACLET;
10131 salt_type = SALT_TYPE_EMBEDDED;
10132 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10133 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10134 kern_type = KERN_TYPE_ORACLET;
10135 dgst_size = DGST_SIZE_8_16;
10136 parse_func = oraclet_parse_hash;
10137 sort_by_digest = sort_by_digest_8_16;
10138 opti_type = OPTI_TYPE_ZERO_BYTE
10139 | OPTI_TYPE_USES_BITS_64;
10140 dgst_pos0 = 0;
10141 dgst_pos1 = 1;
10142 dgst_pos2 = 2;
10143 dgst_pos3 = 3;
10144 break;
10145
10146 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10147 salt_type = SALT_TYPE_EMBEDDED;
10148 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10149 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10150 kern_type = KERN_TYPE_BSDICRYPT;
10151 dgst_size = DGST_SIZE_4_4;
10152 parse_func = bsdicrypt_parse_hash;
10153 sort_by_digest = sort_by_digest_4_4;
10154 opti_type = OPTI_TYPE_ZERO_BYTE
10155 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10156 dgst_pos0 = 0;
10157 dgst_pos1 = 1;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 3;
10160 break;
10161
10162 case 12500: hash_type = HASH_TYPE_RAR3HP;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10166 kern_type = KERN_TYPE_RAR3;
10167 dgst_size = DGST_SIZE_4_4;
10168 parse_func = rar3hp_parse_hash;
10169 sort_by_digest = sort_by_digest_4_4;
10170 opti_type = OPTI_TYPE_ZERO_BYTE;
10171 dgst_pos0 = 0;
10172 dgst_pos1 = 1;
10173 dgst_pos2 = 2;
10174 dgst_pos3 = 3;
10175 break;
10176
10177 case 12600: hash_type = HASH_TYPE_SHA256;
10178 salt_type = SALT_TYPE_INTERN;
10179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10180 opts_type = OPTS_TYPE_PT_GENERATE_BE
10181 | OPTS_TYPE_PT_ADD80;
10182 kern_type = KERN_TYPE_CF10;
10183 dgst_size = DGST_SIZE_4_8;
10184 parse_func = cf10_parse_hash;
10185 sort_by_digest = sort_by_digest_4_8;
10186 opti_type = OPTI_TYPE_ZERO_BYTE
10187 | OPTI_TYPE_PRECOMPUTE_INIT
10188 | OPTI_TYPE_EARLY_SKIP
10189 | OPTI_TYPE_NOT_ITERATED;
10190 dgst_pos0 = 3;
10191 dgst_pos1 = 7;
10192 dgst_pos2 = 2;
10193 dgst_pos3 = 6;
10194 break;
10195
10196 case 12700: hash_type = HASH_TYPE_AES;
10197 salt_type = SALT_TYPE_EMBEDDED;
10198 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10199 opts_type = OPTS_TYPE_PT_GENERATE_LE
10200 | OPTS_TYPE_HASH_COPY;
10201 kern_type = KERN_TYPE_MYWALLET;
10202 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10203 parse_func = mywallet_parse_hash;
10204 sort_by_digest = sort_by_digest_4_5;
10205 opti_type = OPTI_TYPE_ZERO_BYTE;
10206 dgst_pos0 = 0;
10207 dgst_pos1 = 1;
10208 dgst_pos2 = 2;
10209 dgst_pos3 = 3;
10210 break;
10211
10212 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10213 salt_type = SALT_TYPE_EMBEDDED;
10214 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10215 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10216 kern_type = KERN_TYPE_MS_DRSR;
10217 dgst_size = DGST_SIZE_4_8;
10218 parse_func = ms_drsr_parse_hash;
10219 sort_by_digest = sort_by_digest_4_8;
10220 opti_type = OPTI_TYPE_ZERO_BYTE;
10221 dgst_pos0 = 0;
10222 dgst_pos1 = 1;
10223 dgst_pos2 = 2;
10224 dgst_pos3 = 3;
10225 break;
10226
10227 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10228 salt_type = SALT_TYPE_EMBEDDED;
10229 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10230 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10231 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10232 dgst_size = DGST_SIZE_4_8;
10233 parse_func = androidfde_samsung_parse_hash;
10234 sort_by_digest = sort_by_digest_4_8;
10235 opti_type = OPTI_TYPE_ZERO_BYTE;
10236 dgst_pos0 = 0;
10237 dgst_pos1 = 1;
10238 dgst_pos2 = 2;
10239 dgst_pos3 = 3;
10240 break;
10241
10242 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10243 salt_type = SALT_TYPE_EMBEDDED;
10244 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10246 kern_type = KERN_TYPE_RAR5;
10247 dgst_size = DGST_SIZE_4_4;
10248 parse_func = rar5_parse_hash;
10249 sort_by_digest = sort_by_digest_4_4;
10250 opti_type = OPTI_TYPE_ZERO_BYTE;
10251 dgst_pos0 = 0;
10252 dgst_pos1 = 1;
10253 dgst_pos2 = 2;
10254 dgst_pos3 = 3;
10255 break;
10256
10257 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10258 salt_type = SALT_TYPE_EMBEDDED;
10259 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10260 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10261 kern_type = KERN_TYPE_KRB5TGS;
10262 dgst_size = DGST_SIZE_4_4;
10263 parse_func = krb5tgs_parse_hash;
10264 sort_by_digest = sort_by_digest_4_4;
10265 opti_type = OPTI_TYPE_ZERO_BYTE
10266 | OPTI_TYPE_NOT_ITERATED;
10267 dgst_pos0 = 0;
10268 dgst_pos1 = 1;
10269 dgst_pos2 = 2;
10270 dgst_pos3 = 3;
10271 break;
10272
10273 case 13200: hash_type = HASH_TYPE_AES;
10274 salt_type = SALT_TYPE_EMBEDDED;
10275 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10276 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10277 kern_type = KERN_TYPE_AXCRYPT;
10278 dgst_size = DGST_SIZE_4_4;
10279 parse_func = axcrypt_parse_hash;
10280 sort_by_digest = sort_by_digest_4_4;
10281 opti_type = OPTI_TYPE_ZERO_BYTE;
10282 dgst_pos0 = 0;
10283 dgst_pos1 = 1;
10284 dgst_pos2 = 2;
10285 dgst_pos3 = 3;
10286 break;
10287
10288 case 13300: hash_type = HASH_TYPE_SHA1;
10289 salt_type = SALT_TYPE_NONE;
10290 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10291 opts_type = OPTS_TYPE_PT_GENERATE_BE
10292 | OPTS_TYPE_PT_ADD80
10293 | OPTS_TYPE_PT_ADDBITS15;
10294 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10295 dgst_size = DGST_SIZE_4_5;
10296 parse_func = sha1axcrypt_parse_hash;
10297 sort_by_digest = sort_by_digest_4_5;
10298 opti_type = OPTI_TYPE_ZERO_BYTE
10299 | OPTI_TYPE_PRECOMPUTE_INIT
10300 | OPTI_TYPE_EARLY_SKIP
10301 | OPTI_TYPE_NOT_ITERATED
10302 | OPTI_TYPE_NOT_SALTED;
10303 dgst_pos0 = 0;
10304 dgst_pos1 = 4;
10305 dgst_pos2 = 3;
10306 dgst_pos3 = 2;
10307 break;
10308
10309 case 13400: hash_type = HASH_TYPE_AES;
10310 salt_type = SALT_TYPE_EMBEDDED;
10311 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10312 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10313 kern_type = KERN_TYPE_KEEPASS;
10314 dgst_size = DGST_SIZE_4_4;
10315 parse_func = keepass_parse_hash;
10316 sort_by_digest = sort_by_digest_4_4;
10317 opti_type = OPTI_TYPE_ZERO_BYTE;
10318 dgst_pos0 = 0;
10319 dgst_pos1 = 1;
10320 dgst_pos2 = 2;
10321 dgst_pos3 = 3;
10322 break;
10323
10324 case 13500: hash_type = HASH_TYPE_SHA1;
10325 salt_type = SALT_TYPE_EMBEDDED;
10326 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10327 opts_type = OPTS_TYPE_PT_GENERATE_BE
10328 | OPTS_TYPE_PT_UNICODE
10329 | OPTS_TYPE_PT_ADD80;
10330 kern_type = KERN_TYPE_PSTOKEN;
10331 dgst_size = DGST_SIZE_4_5;
10332 parse_func = pstoken_parse_hash;
10333 sort_by_digest = sort_by_digest_4_5;
10334 opti_type = OPTI_TYPE_ZERO_BYTE
10335 | OPTI_TYPE_PRECOMPUTE_INIT
10336 | OPTI_TYPE_EARLY_SKIP
10337 | OPTI_TYPE_NOT_ITERATED
10338 | OPTI_TYPE_PREPENDED_SALT
10339 | OPTI_TYPE_RAW_HASH;
10340 dgst_pos0 = 3;
10341 dgst_pos1 = 4;
10342 dgst_pos2 = 2;
10343 dgst_pos3 = 1;
10344 break;
10345
10346 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10347 salt_type = SALT_TYPE_EMBEDDED;
10348 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10349 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10350 kern_type = KERN_TYPE_ZIP2;
10351 dgst_size = DGST_SIZE_4_4;
10352 parse_func = zip2_parse_hash;
10353 sort_by_digest = sort_by_digest_4_4;
10354 opti_type = OPTI_TYPE_ZERO_BYTE;
10355 dgst_pos0 = 0;
10356 dgst_pos1 = 1;
10357 dgst_pos2 = 2;
10358 dgst_pos3 = 3;
10359 break;
10360
10361 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10362 salt_type = SALT_TYPE_EMBEDDED;
10363 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10364 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10365 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10366 dgst_size = DGST_SIZE_4_5;
10367 parse_func = veracrypt_parse_hash_655331;
10368 sort_by_digest = sort_by_digest_4_5;
10369 opti_type = OPTI_TYPE_ZERO_BYTE;
10370 dgst_pos0 = 0;
10371 dgst_pos1 = 1;
10372 dgst_pos2 = 2;
10373 dgst_pos3 = 3;
10374 break;
10375
10376 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10377 salt_type = SALT_TYPE_EMBEDDED;
10378 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10379 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10380 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10381 dgst_size = DGST_SIZE_4_5;
10382 parse_func = veracrypt_parse_hash_655331;
10383 sort_by_digest = sort_by_digest_4_5;
10384 opti_type = OPTI_TYPE_ZERO_BYTE;
10385 dgst_pos0 = 0;
10386 dgst_pos1 = 1;
10387 dgst_pos2 = 2;
10388 dgst_pos3 = 3;
10389 break;
10390
10391 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10392 salt_type = SALT_TYPE_EMBEDDED;
10393 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10395 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10396 dgst_size = DGST_SIZE_4_5;
10397 parse_func = veracrypt_parse_hash_655331;
10398 sort_by_digest = sort_by_digest_4_5;
10399 opti_type = OPTI_TYPE_ZERO_BYTE;
10400 dgst_pos0 = 0;
10401 dgst_pos1 = 1;
10402 dgst_pos2 = 2;
10403 dgst_pos3 = 3;
10404 break;
10405
10406 case 13721: hash_type = HASH_TYPE_SHA512;
10407 salt_type = SALT_TYPE_EMBEDDED;
10408 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10409 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10410 kern_type = KERN_TYPE_TCSHA512_XTS512;
10411 dgst_size = DGST_SIZE_8_8;
10412 parse_func = veracrypt_parse_hash_500000;
10413 sort_by_digest = sort_by_digest_8_8;
10414 opti_type = OPTI_TYPE_ZERO_BYTE
10415 | OPTI_TYPE_USES_BITS_64;
10416 dgst_pos0 = 0;
10417 dgst_pos1 = 1;
10418 dgst_pos2 = 2;
10419 dgst_pos3 = 3;
10420 break;
10421
10422 case 13722: hash_type = HASH_TYPE_SHA512;
10423 salt_type = SALT_TYPE_EMBEDDED;
10424 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10425 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10426 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10427 dgst_size = DGST_SIZE_8_8;
10428 parse_func = veracrypt_parse_hash_500000;
10429 sort_by_digest = sort_by_digest_8_8;
10430 opti_type = OPTI_TYPE_ZERO_BYTE
10431 | OPTI_TYPE_USES_BITS_64;
10432 dgst_pos0 = 0;
10433 dgst_pos1 = 1;
10434 dgst_pos2 = 2;
10435 dgst_pos3 = 3;
10436 break;
10437
10438 case 13723: hash_type = HASH_TYPE_SHA512;
10439 salt_type = SALT_TYPE_EMBEDDED;
10440 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10441 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10442 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10443 dgst_size = DGST_SIZE_8_8;
10444 parse_func = veracrypt_parse_hash_500000;
10445 sort_by_digest = sort_by_digest_8_8;
10446 opti_type = OPTI_TYPE_ZERO_BYTE
10447 | OPTI_TYPE_USES_BITS_64;
10448 dgst_pos0 = 0;
10449 dgst_pos1 = 1;
10450 dgst_pos2 = 2;
10451 dgst_pos3 = 3;
10452 break;
10453
10454 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10455 salt_type = SALT_TYPE_EMBEDDED;
10456 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10457 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10458 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10459 dgst_size = DGST_SIZE_4_8;
10460 parse_func = veracrypt_parse_hash_500000;
10461 sort_by_digest = sort_by_digest_4_8;
10462 opti_type = OPTI_TYPE_ZERO_BYTE;
10463 dgst_pos0 = 0;
10464 dgst_pos1 = 1;
10465 dgst_pos2 = 2;
10466 dgst_pos3 = 3;
10467 break;
10468
10469 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10470 salt_type = SALT_TYPE_EMBEDDED;
10471 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10472 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10473 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10474 dgst_size = DGST_SIZE_4_8;
10475 parse_func = veracrypt_parse_hash_500000;
10476 sort_by_digest = sort_by_digest_4_8;
10477 opti_type = OPTI_TYPE_ZERO_BYTE;
10478 dgst_pos0 = 0;
10479 dgst_pos1 = 1;
10480 dgst_pos2 = 2;
10481 dgst_pos3 = 3;
10482 break;
10483
10484 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10485 salt_type = SALT_TYPE_EMBEDDED;
10486 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10487 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10488 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10489 dgst_size = DGST_SIZE_4_8;
10490 parse_func = veracrypt_parse_hash_500000;
10491 sort_by_digest = sort_by_digest_4_8;
10492 opti_type = OPTI_TYPE_ZERO_BYTE;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 1;
10495 dgst_pos2 = 2;
10496 dgst_pos3 = 3;
10497 break;
10498
10499 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10504 dgst_size = DGST_SIZE_4_5;
10505 parse_func = veracrypt_parse_hash_327661;
10506 sort_by_digest = sort_by_digest_4_5;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10518 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10519 dgst_size = DGST_SIZE_4_5;
10520 parse_func = veracrypt_parse_hash_327661;
10521 sort_by_digest = sort_by_digest_4_5;
10522 opti_type = OPTI_TYPE_ZERO_BYTE;
10523 dgst_pos0 = 0;
10524 dgst_pos1 = 1;
10525 dgst_pos2 = 2;
10526 dgst_pos3 = 3;
10527 break;
10528
10529 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10530 salt_type = SALT_TYPE_EMBEDDED;
10531 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10532 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10533 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10534 dgst_size = DGST_SIZE_4_5;
10535 parse_func = veracrypt_parse_hash_327661;
10536 sort_by_digest = sort_by_digest_4_5;
10537 opti_type = OPTI_TYPE_ZERO_BYTE;
10538 dgst_pos0 = 0;
10539 dgst_pos1 = 1;
10540 dgst_pos2 = 2;
10541 dgst_pos3 = 3;
10542 break;
10543
10544 case 13751: hash_type = HASH_TYPE_SHA256;
10545 salt_type = SALT_TYPE_EMBEDDED;
10546 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10547 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10548 kern_type = KERN_TYPE_VCSHA256_XTS512;
10549 dgst_size = DGST_SIZE_4_8;
10550 parse_func = veracrypt_parse_hash_500000;
10551 sort_by_digest = sort_by_digest_4_8;
10552 opti_type = OPTI_TYPE_ZERO_BYTE;
10553 dgst_pos0 = 0;
10554 dgst_pos1 = 1;
10555 dgst_pos2 = 2;
10556 dgst_pos3 = 3;
10557 break;
10558
10559 case 13752: hash_type = HASH_TYPE_SHA256;
10560 salt_type = SALT_TYPE_EMBEDDED;
10561 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10562 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10563 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10564 dgst_size = DGST_SIZE_4_8;
10565 parse_func = veracrypt_parse_hash_500000;
10566 sort_by_digest = sort_by_digest_4_8;
10567 opti_type = OPTI_TYPE_ZERO_BYTE;
10568 dgst_pos0 = 0;
10569 dgst_pos1 = 1;
10570 dgst_pos2 = 2;
10571 dgst_pos3 = 3;
10572 break;
10573
10574 case 13753: hash_type = HASH_TYPE_SHA256;
10575 salt_type = SALT_TYPE_EMBEDDED;
10576 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10577 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10578 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10579 dgst_size = DGST_SIZE_4_8;
10580 parse_func = veracrypt_parse_hash_500000;
10581 sort_by_digest = sort_by_digest_4_8;
10582 opti_type = OPTI_TYPE_ZERO_BYTE;
10583 dgst_pos0 = 0;
10584 dgst_pos1 = 1;
10585 dgst_pos2 = 2;
10586 dgst_pos3 = 3;
10587 break;
10588
10589 case 13761: hash_type = HASH_TYPE_SHA256;
10590 salt_type = SALT_TYPE_EMBEDDED;
10591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10592 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10593 kern_type = KERN_TYPE_VCSHA256_XTS512;
10594 dgst_size = DGST_SIZE_4_8;
10595 parse_func = veracrypt_parse_hash_200000;
10596 sort_by_digest = sort_by_digest_4_8;
10597 opti_type = OPTI_TYPE_ZERO_BYTE;
10598 dgst_pos0 = 0;
10599 dgst_pos1 = 1;
10600 dgst_pos2 = 2;
10601 dgst_pos3 = 3;
10602 break;
10603
10604 case 13762: hash_type = HASH_TYPE_SHA256;
10605 salt_type = SALT_TYPE_EMBEDDED;
10606 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10607 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10608 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10609 dgst_size = DGST_SIZE_4_8;
10610 parse_func = veracrypt_parse_hash_200000;
10611 sort_by_digest = sort_by_digest_4_8;
10612 opti_type = OPTI_TYPE_ZERO_BYTE;
10613 dgst_pos0 = 0;
10614 dgst_pos1 = 1;
10615 dgst_pos2 = 2;
10616 dgst_pos3 = 3;
10617 break;
10618
10619 case 13763: hash_type = HASH_TYPE_SHA256;
10620 salt_type = SALT_TYPE_EMBEDDED;
10621 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10622 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10623 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10624 dgst_size = DGST_SIZE_4_8;
10625 parse_func = veracrypt_parse_hash_200000;
10626 sort_by_digest = sort_by_digest_4_8;
10627 opti_type = OPTI_TYPE_ZERO_BYTE;
10628 dgst_pos0 = 0;
10629 dgst_pos1 = 1;
10630 dgst_pos2 = 2;
10631 dgst_pos3 = 3;
10632 break;
10633
10634
10635 default: usage_mini_print (PROGNAME); return (-1);
10636 }
10637
10638 /**
10639 * parser
10640 */
10641
10642 data.parse_func = parse_func;
10643
10644 /**
10645 * misc stuff
10646 */
10647
10648 if (hex_salt)
10649 {
10650 if (salt_type == SALT_TYPE_INTERN)
10651 {
10652 opts_type |= OPTS_TYPE_ST_HEX;
10653 }
10654 else
10655 {
10656 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10657
10658 return (-1);
10659 }
10660 }
10661
10662 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10663 | (salt_type == SALT_TYPE_EXTERN)
10664 | (salt_type == SALT_TYPE_EMBEDDED)
10665 | (salt_type == SALT_TYPE_VIRTUAL));
10666
10667 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10668
10669 data.hash_type = hash_type;
10670 data.attack_mode = attack_mode;
10671 data.attack_kern = attack_kern;
10672 data.attack_exec = attack_exec;
10673 data.kern_type = kern_type;
10674 data.opts_type = opts_type;
10675 data.dgst_size = dgst_size;
10676 data.salt_type = salt_type;
10677 data.isSalted = isSalted;
10678 data.sort_by_digest = sort_by_digest;
10679 data.dgst_pos0 = dgst_pos0;
10680 data.dgst_pos1 = dgst_pos1;
10681 data.dgst_pos2 = dgst_pos2;
10682 data.dgst_pos3 = dgst_pos3;
10683
10684 esalt_size = 0;
10685
10686 switch (hash_mode)
10687 {
10688 case 2500: esalt_size = sizeof (wpa_t); break;
10689 case 5300: esalt_size = sizeof (ikepsk_t); break;
10690 case 5400: esalt_size = sizeof (ikepsk_t); break;
10691 case 5500: esalt_size = sizeof (netntlm_t); break;
10692 case 5600: esalt_size = sizeof (netntlm_t); break;
10693 case 6211: esalt_size = sizeof (tc_t); break;
10694 case 6212: esalt_size = sizeof (tc_t); break;
10695 case 6213: esalt_size = sizeof (tc_t); break;
10696 case 6221: esalt_size = sizeof (tc_t); break;
10697 case 6222: esalt_size = sizeof (tc_t); break;
10698 case 6223: esalt_size = sizeof (tc_t); break;
10699 case 6231: esalt_size = sizeof (tc_t); break;
10700 case 6232: esalt_size = sizeof (tc_t); break;
10701 case 6233: esalt_size = sizeof (tc_t); break;
10702 case 6241: esalt_size = sizeof (tc_t); break;
10703 case 6242: esalt_size = sizeof (tc_t); break;
10704 case 6243: esalt_size = sizeof (tc_t); break;
10705 case 6600: esalt_size = sizeof (agilekey_t); break;
10706 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10707 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10708 case 7300: esalt_size = sizeof (rakp_t); break;
10709 case 7500: esalt_size = sizeof (krb5pa_t); break;
10710 case 8200: esalt_size = sizeof (cloudkey_t); break;
10711 case 8800: esalt_size = sizeof (androidfde_t); break;
10712 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10713 case 9400: esalt_size = sizeof (office2007_t); break;
10714 case 9500: esalt_size = sizeof (office2010_t); break;
10715 case 9600: esalt_size = sizeof (office2013_t); break;
10716 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10717 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10718 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10719 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10720 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10721 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10722 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10723 case 10200: esalt_size = sizeof (cram_md5_t); break;
10724 case 10400: esalt_size = sizeof (pdf_t); break;
10725 case 10410: esalt_size = sizeof (pdf_t); break;
10726 case 10420: esalt_size = sizeof (pdf_t); break;
10727 case 10500: esalt_size = sizeof (pdf_t); break;
10728 case 10600: esalt_size = sizeof (pdf_t); break;
10729 case 10700: esalt_size = sizeof (pdf_t); break;
10730 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10731 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10732 case 11400: esalt_size = sizeof (sip_t); break;
10733 case 11600: esalt_size = sizeof (seven_zip_t); break;
10734 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10735 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10736 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10737 case 13000: esalt_size = sizeof (rar5_t); break;
10738 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10739 case 13400: esalt_size = sizeof (keepass_t); break;
10740 case 13500: esalt_size = sizeof (pstoken_t); break;
10741 case 13600: esalt_size = sizeof (zip2_t); break;
10742 case 13711: esalt_size = sizeof (tc_t); break;
10743 case 13712: esalt_size = sizeof (tc_t); break;
10744 case 13713: esalt_size = sizeof (tc_t); break;
10745 case 13721: esalt_size = sizeof (tc_t); break;
10746 case 13722: esalt_size = sizeof (tc_t); break;
10747 case 13723: esalt_size = sizeof (tc_t); break;
10748 case 13731: esalt_size = sizeof (tc_t); break;
10749 case 13732: esalt_size = sizeof (tc_t); break;
10750 case 13733: esalt_size = sizeof (tc_t); break;
10751 case 13741: esalt_size = sizeof (tc_t); break;
10752 case 13742: esalt_size = sizeof (tc_t); break;
10753 case 13743: esalt_size = sizeof (tc_t); break;
10754 case 13751: esalt_size = sizeof (tc_t); break;
10755 case 13752: esalt_size = sizeof (tc_t); break;
10756 case 13753: esalt_size = sizeof (tc_t); break;
10757 case 13761: esalt_size = sizeof (tc_t); break;
10758 case 13762: esalt_size = sizeof (tc_t); break;
10759 case 13763: esalt_size = sizeof (tc_t); break;
10760 }
10761
10762 data.esalt_size = esalt_size;
10763
10764 /**
10765 * choose dictionary parser
10766 */
10767
10768 if (hash_type == HASH_TYPE_LM)
10769 {
10770 get_next_word_func = get_next_word_lm;
10771 }
10772 else if (opts_type & OPTS_TYPE_PT_UPPER)
10773 {
10774 get_next_word_func = get_next_word_uc;
10775 }
10776 else
10777 {
10778 get_next_word_func = get_next_word_std;
10779 }
10780
10781 /**
10782 * dictstat
10783 */
10784
10785 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10786
10787 #ifdef _POSIX
10788 size_t dictstat_nmemb = 0;
10789 #endif
10790
10791 #ifdef _WIN
10792 uint dictstat_nmemb = 0;
10793 #endif
10794
10795 char dictstat[256] = { 0 };
10796
10797 FILE *dictstat_fp = NULL;
10798
10799 if (keyspace == 0)
10800 {
10801 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10802
10803 dictstat_fp = fopen (dictstat, "rb");
10804
10805 if (dictstat_fp)
10806 {
10807 #ifdef _POSIX
10808 struct stat tmpstat;
10809
10810 fstat (fileno (dictstat_fp), &tmpstat);
10811 #endif
10812
10813 #ifdef _WIN
10814 struct stat64 tmpstat;
10815
10816 _fstat64 (fileno (dictstat_fp), &tmpstat);
10817 #endif
10818
10819 if (tmpstat.st_mtime < COMPTIME)
10820 {
10821 /* with v0.15 the format changed so we have to ensure user is using a good version
10822 since there is no version-header in the dictstat file */
10823
10824 fclose (dictstat_fp);
10825
10826 unlink (dictstat);
10827 }
10828 else
10829 {
10830 while (!feof (dictstat_fp))
10831 {
10832 dictstat_t d;
10833
10834 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10835
10836 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10837
10838 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10839 {
10840 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10841
10842 return -1;
10843 }
10844 }
10845
10846 fclose (dictstat_fp);
10847 }
10848 }
10849 }
10850
10851 /**
10852 * potfile
10853 */
10854
10855 char potfile[256] = { 0 };
10856
10857 if (potfile_path == NULL)
10858 {
10859 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10860 }
10861 else
10862 {
10863 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10864 }
10865
10866 data.pot_fp = NULL;
10867
10868 FILE *out_fp = NULL;
10869 FILE *pot_fp = NULL;
10870
10871 if (show == 1 || left == 1)
10872 {
10873 pot_fp = fopen (potfile, "rb");
10874
10875 if (pot_fp == NULL)
10876 {
10877 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10878
10879 return (-1);
10880 }
10881
10882 if (outfile != NULL)
10883 {
10884 if ((out_fp = fopen (outfile, "ab")) == NULL)
10885 {
10886 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10887
10888 fclose (pot_fp);
10889
10890 return (-1);
10891 }
10892 }
10893 else
10894 {
10895 out_fp = stdout;
10896 }
10897 }
10898 else
10899 {
10900 if (potfile_disable == 0)
10901 {
10902 pot_fp = fopen (potfile, "ab");
10903
10904 if (pot_fp == NULL)
10905 {
10906 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10907
10908 return (-1);
10909 }
10910
10911 data.pot_fp = pot_fp;
10912 }
10913 }
10914
10915 pot_t *pot = NULL;
10916
10917 uint pot_cnt = 0;
10918 uint pot_avail = 0;
10919
10920 if (show == 1 || left == 1)
10921 {
10922 SUPPRESS_OUTPUT = 1;
10923
10924 pot_avail = count_lines (pot_fp);
10925
10926 rewind (pot_fp);
10927
10928 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10929
10930 uint pot_hashes_avail = 0;
10931
10932 uint line_num = 0;
10933
10934 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10935
10936 while (!feof (pot_fp))
10937 {
10938 line_num++;
10939
10940 int line_len = fgetl (pot_fp, line_buf);
10941
10942 if (line_len == 0) continue;
10943
10944 char *plain_buf = line_buf + line_len;
10945
10946 pot_t *pot_ptr = &pot[pot_cnt];
10947
10948 hash_t *hashes_buf = &pot_ptr->hash;
10949
10950 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10951 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10952
10953 if (pot_cnt == pot_hashes_avail)
10954 {
10955 uint pos = 0;
10956
10957 for (pos = 0; pos < INCR_POT; pos++)
10958 {
10959 if ((pot_cnt + pos) >= pot_avail) break;
10960
10961 pot_t *tmp_pot = &pot[pot_cnt + pos];
10962
10963 hash_t *tmp_hash = &tmp_pot->hash;
10964
10965 tmp_hash->digest = mymalloc (dgst_size);
10966
10967 if (isSalted)
10968 {
10969 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10970 }
10971
10972 if (esalt_size)
10973 {
10974 tmp_hash->esalt = mymalloc (esalt_size);
10975 }
10976
10977 pot_hashes_avail++;
10978 }
10979 }
10980
10981 int plain_len = 0;
10982
10983 int parser_status;
10984
10985 int iter = MAX_CUT_TRIES;
10986
10987 do
10988 {
10989 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10990 {
10991 if (line_buf[i] == ':')
10992 {
10993 line_len--;
10994
10995 break;
10996 }
10997 }
10998
10999 if (data.hash_mode != 2500)
11000 {
11001 parser_status = parse_func (line_buf, line_len, hashes_buf);
11002 }
11003 else
11004 {
11005 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11006
11007 if (line_len > max_salt_size)
11008 {
11009 parser_status = PARSER_GLOBAL_LENGTH;
11010 }
11011 else
11012 {
11013 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11014
11015 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11016
11017 hashes_buf->salt->salt_len = line_len;
11018
11019 parser_status = PARSER_OK;
11020 }
11021 }
11022
11023 // if NOT parsed without error, we add the ":" to the plain
11024
11025 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11026 {
11027 plain_len++;
11028 plain_buf--;
11029 }
11030
11031 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11032
11033 if (parser_status < PARSER_GLOBAL_ZERO)
11034 {
11035 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11036
11037 continue;
11038 }
11039
11040 if (plain_len >= 255) continue;
11041
11042 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11043
11044 pot_ptr->plain_len = plain_len;
11045
11046 pot_cnt++;
11047 }
11048
11049 myfree (line_buf);
11050
11051 fclose (pot_fp);
11052
11053 SUPPRESS_OUTPUT = 0;
11054
11055 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11056 }
11057
11058 /**
11059 * word len
11060 */
11061
11062 uint pw_min = PW_MIN;
11063 uint pw_max = PW_MAX;
11064
11065 switch (hash_mode)
11066 {
11067 case 125: if (pw_max > 32) pw_max = 32;
11068 break;
11069 case 400: if (pw_max > 40) pw_max = 40;
11070 break;
11071 case 500: if (pw_max > 16) pw_max = 16;
11072 break;
11073 case 1500: if (pw_max > 8) pw_max = 8;
11074 break;
11075 case 1600: if (pw_max > 16) pw_max = 16;
11076 break;
11077 case 1800: if (pw_max > 16) pw_max = 16;
11078 break;
11079 case 2100: if (pw_max > 16) pw_max = 16;
11080 break;
11081 case 2500: if (pw_min < 8) pw_min = 8;
11082 break;
11083 case 3000: if (pw_max > 7) pw_max = 7;
11084 break;
11085 case 5200: if (pw_max > 24) pw_max = 24;
11086 break;
11087 case 5800: if (pw_max > 16) pw_max = 16;
11088 break;
11089 case 6300: if (pw_max > 16) pw_max = 16;
11090 break;
11091 case 7400: if (pw_max > 16) pw_max = 16;
11092 break;
11093 case 7900: if (pw_max > 48) pw_max = 48;
11094 break;
11095 case 8500: if (pw_max > 8) pw_max = 8;
11096 break;
11097 case 8600: if (pw_max > 16) pw_max = 16;
11098 break;
11099 case 9710: pw_min = 5;
11100 pw_max = 5;
11101 break;
11102 case 9810: pw_min = 5;
11103 pw_max = 5;
11104 break;
11105 case 10410: pw_min = 5;
11106 pw_max = 5;
11107 break;
11108 case 10300: if (pw_max < 3) pw_min = 3;
11109 if (pw_max > 40) pw_max = 40;
11110 break;
11111 case 10500: if (pw_max < 3) pw_min = 3;
11112 if (pw_max > 40) pw_max = 40;
11113 break;
11114 case 10700: if (pw_max > 16) pw_max = 16;
11115 break;
11116 case 11300: if (pw_max > 40) pw_max = 40;
11117 break;
11118 case 11600: if (pw_max > 32) pw_max = 32;
11119 break;
11120 case 12500: if (pw_max > 20) pw_max = 20;
11121 break;
11122 case 12800: if (pw_max > 24) pw_max = 24;
11123 break;
11124 }
11125
11126 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11127 {
11128 switch (attack_kern)
11129 {
11130 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11131 break;
11132 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11133 break;
11134 }
11135 }
11136
11137 /**
11138 * charsets : keep them together for more easy maintainnce
11139 */
11140
11141 cs_t mp_sys[6] = { { { 0 }, 0 } };
11142 cs_t mp_usr[4] = { { { 0 }, 0 } };
11143
11144 mp_setup_sys (mp_sys);
11145
11146 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11147 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11148 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11149 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11150
11151 /**
11152 * load hashes, part I: find input mode, count hashes
11153 */
11154
11155 uint hashlist_mode = 0;
11156 uint hashlist_format = HLFMT_HASHCAT;
11157
11158 uint hashes_avail = 0;
11159
11160 if (benchmark == 0)
11161 {
11162 struct stat f;
11163
11164 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11165
11166 if ((hash_mode == 2500) ||
11167 (hash_mode == 5200) ||
11168 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11169 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11170 (hash_mode == 9000))
11171 {
11172 hashlist_mode = HL_MODE_ARG;
11173
11174 char *hashfile = myargv[optind];
11175
11176 data.hashfile = hashfile;
11177
11178 logfile_top_var_string ("target", hashfile);
11179 }
11180
11181 if (hashlist_mode == HL_MODE_ARG)
11182 {
11183 if (hash_mode == 2500)
11184 {
11185 struct stat st;
11186
11187 if (stat (data.hashfile, &st) == -1)
11188 {
11189 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11190
11191 return (-1);
11192 }
11193
11194 hashes_avail = st.st_size / sizeof (hccap_t);
11195 }
11196 else
11197 {
11198 hashes_avail = 1;
11199 }
11200 }
11201 else if (hashlist_mode == HL_MODE_FILE)
11202 {
11203 char *hashfile = myargv[optind];
11204
11205 data.hashfile = hashfile;
11206
11207 logfile_top_var_string ("target", hashfile);
11208
11209 FILE *fp = NULL;
11210
11211 if ((fp = fopen (hashfile, "rb")) == NULL)
11212 {
11213 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11214
11215 return (-1);
11216 }
11217
11218 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11219
11220 hashes_avail = count_lines (fp);
11221
11222 rewind (fp);
11223
11224 if (hashes_avail == 0)
11225 {
11226 log_error ("ERROR: hashfile is empty or corrupt");
11227
11228 fclose (fp);
11229
11230 return (-1);
11231 }
11232
11233 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11234
11235 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11236 {
11237 log_error ("ERROR: remove not supported in native hashfile-format mode");
11238
11239 fclose (fp);
11240
11241 return (-1);
11242 }
11243
11244 fclose (fp);
11245 }
11246 }
11247 else
11248 {
11249 hashlist_mode = HL_MODE_ARG;
11250
11251 hashes_avail = 1;
11252 }
11253
11254 if (hash_mode == 3000) hashes_avail *= 2;
11255
11256 data.hashlist_mode = hashlist_mode;
11257 data.hashlist_format = hashlist_format;
11258
11259 logfile_top_uint (hashlist_mode);
11260 logfile_top_uint (hashlist_format);
11261
11262 /**
11263 * load hashes, part II: allocate required memory, set pointers
11264 */
11265
11266 hash_t *hashes_buf = NULL;
11267 void *digests_buf = NULL;
11268 salt_t *salts_buf = NULL;
11269 void *esalts_buf = NULL;
11270
11271 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11272
11273 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11274
11275 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11276 {
11277 u32 hash_pos;
11278
11279 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11280 {
11281 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11282
11283 hashes_buf[hash_pos].hash_info = hash_info;
11284
11285 if (username && (remove || show || left))
11286 {
11287 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11288 }
11289
11290 if (benchmark)
11291 {
11292 hash_info->orighash = (char *) mymalloc (256);
11293 }
11294 }
11295 }
11296
11297 if (isSalted)
11298 {
11299 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11300
11301 if (esalt_size)
11302 {
11303 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11304 }
11305 }
11306 else
11307 {
11308 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11309 }
11310
11311 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11312 {
11313 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11314
11315 if (isSalted)
11316 {
11317 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11318
11319 if (esalt_size)
11320 {
11321 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11322 }
11323 }
11324 else
11325 {
11326 hashes_buf[hash_pos].salt = &salts_buf[0];
11327 }
11328 }
11329
11330 /**
11331 * load hashes, part III: parse hashes or generate them if benchmark
11332 */
11333
11334 uint hashes_cnt = 0;
11335
11336 if (benchmark == 0)
11337 {
11338 if (keyspace == 1)
11339 {
11340 // useless to read hash file for keyspace, cheat a little bit w/ optind
11341 }
11342 else if (hashes_avail == 0)
11343 {
11344 }
11345 else if (hashlist_mode == HL_MODE_ARG)
11346 {
11347 char *input_buf = myargv[optind];
11348
11349 uint input_len = strlen (input_buf);
11350
11351 logfile_top_var_string ("target", input_buf);
11352
11353 char *hash_buf = NULL;
11354 int hash_len = 0;
11355
11356 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11357
11358 bool hash_fmt_error = 0;
11359
11360 if (hash_len < 1) hash_fmt_error = 1;
11361 if (hash_buf == NULL) hash_fmt_error = 1;
11362
11363 if (hash_fmt_error)
11364 {
11365 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11366 }
11367 else
11368 {
11369 if (opts_type & OPTS_TYPE_HASH_COPY)
11370 {
11371 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11372
11373 hash_info_tmp->orighash = mystrdup (hash_buf);
11374 }
11375
11376 if (isSalted)
11377 {
11378 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11379 }
11380
11381 int parser_status = PARSER_OK;
11382
11383 if (hash_mode == 2500)
11384 {
11385 if (hash_len == 0)
11386 {
11387 log_error ("ERROR: hccap file not specified");
11388
11389 return (-1);
11390 }
11391
11392 hashlist_mode = HL_MODE_FILE;
11393
11394 data.hashlist_mode = hashlist_mode;
11395
11396 FILE *fp = fopen (hash_buf, "rb");
11397
11398 if (fp == NULL)
11399 {
11400 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11401
11402 return (-1);
11403 }
11404
11405 if (hashes_avail < 1)
11406 {
11407 log_error ("ERROR: hccap file is empty or corrupt");
11408
11409 fclose (fp);
11410
11411 return (-1);
11412 }
11413
11414 uint hccap_size = sizeof (hccap_t);
11415
11416 char *in = (char *) mymalloc (hccap_size);
11417
11418 while (!feof (fp))
11419 {
11420 int n = fread (in, hccap_size, 1, fp);
11421
11422 if (n != 1)
11423 {
11424 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11425
11426 break;
11427 }
11428
11429 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11430
11431 if (parser_status != PARSER_OK)
11432 {
11433 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11434
11435 continue;
11436 }
11437
11438 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11439
11440 if ((show == 1) || (left == 1))
11441 {
11442 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11443
11444 char *salt_ptr = (char *) tmp_salt->salt_buf;
11445
11446 int cur_pos = tmp_salt->salt_len;
11447 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11448
11449 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11450
11451 // do the appending task
11452
11453 snprintf (salt_ptr + cur_pos,
11454 rem_len,
11455 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11456 wpa->orig_mac1[0],
11457 wpa->orig_mac1[1],
11458 wpa->orig_mac1[2],
11459 wpa->orig_mac1[3],
11460 wpa->orig_mac1[4],
11461 wpa->orig_mac1[5],
11462 wpa->orig_mac2[0],
11463 wpa->orig_mac2[1],
11464 wpa->orig_mac2[2],
11465 wpa->orig_mac2[3],
11466 wpa->orig_mac2[4],
11467 wpa->orig_mac2[5]);
11468
11469 // memset () the remaining part of the salt
11470
11471 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11472 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11473
11474 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11475
11476 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11477 }
11478
11479 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);
11480 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);
11481
11482 hashes_cnt++;
11483 }
11484
11485 fclose (fp);
11486
11487 myfree (in);
11488 }
11489 else if (hash_mode == 3000)
11490 {
11491 if (hash_len == 32)
11492 {
11493 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11494
11495 hash_t *lm_hash_left = NULL;
11496
11497 if (parser_status == PARSER_OK)
11498 {
11499 lm_hash_left = &hashes_buf[hashes_cnt];
11500
11501 hashes_cnt++;
11502 }
11503 else
11504 {
11505 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11506 }
11507
11508 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11509
11510 hash_t *lm_hash_right = NULL;
11511
11512 if (parser_status == PARSER_OK)
11513 {
11514 lm_hash_right = &hashes_buf[hashes_cnt];
11515
11516 hashes_cnt++;
11517 }
11518 else
11519 {
11520 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11521 }
11522
11523 // show / left
11524
11525 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11526 {
11527 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);
11528 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);
11529 }
11530 }
11531 else
11532 {
11533 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11534
11535 if (parser_status == PARSER_OK)
11536 {
11537 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11538 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11539 }
11540
11541 if (parser_status == PARSER_OK)
11542 {
11543 hashes_cnt++;
11544 }
11545 else
11546 {
11547 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11548 }
11549 }
11550 }
11551 else
11552 {
11553 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11554
11555 if (parser_status == PARSER_OK)
11556 {
11557 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11558 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11559 }
11560
11561 if (parser_status == PARSER_OK)
11562 {
11563 hashes_cnt++;
11564 }
11565 else
11566 {
11567 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11568 }
11569 }
11570 }
11571 }
11572 else if (hashlist_mode == HL_MODE_FILE)
11573 {
11574 char *hashfile = data.hashfile;
11575
11576 FILE *fp;
11577
11578 if ((fp = fopen (hashfile, "rb")) == NULL)
11579 {
11580 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11581
11582 return (-1);
11583 }
11584
11585 uint line_num = 0;
11586
11587 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11588
11589 while (!feof (fp))
11590 {
11591 line_num++;
11592
11593 int line_len = fgetl (fp, line_buf);
11594
11595 if (line_len == 0) continue;
11596
11597 char *hash_buf = NULL;
11598 int hash_len = 0;
11599
11600 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11601
11602 bool hash_fmt_error = 0;
11603
11604 if (hash_len < 1) hash_fmt_error = 1;
11605 if (hash_buf == NULL) hash_fmt_error = 1;
11606
11607 if (hash_fmt_error)
11608 {
11609 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11610
11611 continue;
11612 }
11613
11614 if (username)
11615 {
11616 char *user_buf = NULL;
11617 int user_len = 0;
11618
11619 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11620
11621 if (remove || show)
11622 {
11623 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11624
11625 *user = (user_t *) mymalloc (sizeof (user_t));
11626
11627 user_t *user_ptr = *user;
11628
11629 if (user_buf != NULL)
11630 {
11631 user_ptr->user_name = mystrdup (user_buf);
11632 }
11633 else
11634 {
11635 user_ptr->user_name = mystrdup ("");
11636 }
11637
11638 user_ptr->user_len = user_len;
11639 }
11640 }
11641
11642 if (opts_type & OPTS_TYPE_HASH_COPY)
11643 {
11644 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11645
11646 hash_info_tmp->orighash = mystrdup (hash_buf);
11647 }
11648
11649 if (isSalted)
11650 {
11651 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11652 }
11653
11654 if (hash_mode == 3000)
11655 {
11656 if (hash_len == 32)
11657 {
11658 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11659
11660 if (parser_status < PARSER_GLOBAL_ZERO)
11661 {
11662 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11663
11664 continue;
11665 }
11666
11667 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11668
11669 hashes_cnt++;
11670
11671 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11672
11673 if (parser_status < PARSER_GLOBAL_ZERO)
11674 {
11675 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11676
11677 continue;
11678 }
11679
11680 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11681
11682 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);
11683
11684 hashes_cnt++;
11685
11686 // show / left
11687
11688 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);
11689 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);
11690 }
11691 else
11692 {
11693 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11694
11695 if (parser_status < PARSER_GLOBAL_ZERO)
11696 {
11697 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11698
11699 continue;
11700 }
11701
11702 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);
11703
11704 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11705 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11706
11707 hashes_cnt++;
11708 }
11709 }
11710 else
11711 {
11712 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11713
11714 if (parser_status < PARSER_GLOBAL_ZERO)
11715 {
11716 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11717
11718 continue;
11719 }
11720
11721 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);
11722
11723 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11724 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11725
11726 hashes_cnt++;
11727 }
11728 }
11729
11730 myfree (line_buf);
11731
11732 fclose (fp);
11733
11734 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11735
11736 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11737 }
11738 }
11739 else
11740 {
11741 if (isSalted)
11742 {
11743 hashes_buf[0].salt->salt_len = 8;
11744
11745 // special salt handling
11746
11747 switch (hash_mode)
11748 {
11749 case 1500: hashes_buf[0].salt->salt_len = 2;
11750 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11751 break;
11752 case 1731: hashes_buf[0].salt->salt_len = 4;
11753 break;
11754 case 2410: hashes_buf[0].salt->salt_len = 4;
11755 break;
11756 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11757 break;
11758 case 3100: hashes_buf[0].salt->salt_len = 1;
11759 break;
11760 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11761 break;
11762 case 5800: hashes_buf[0].salt->salt_len = 16;
11763 break;
11764 case 6800: hashes_buf[0].salt->salt_len = 32;
11765 break;
11766 case 8400: hashes_buf[0].salt->salt_len = 40;
11767 break;
11768 case 8800: hashes_buf[0].salt->salt_len = 16;
11769 break;
11770 case 8900: hashes_buf[0].salt->salt_len = 16;
11771 hashes_buf[0].salt->scrypt_N = 1024;
11772 hashes_buf[0].salt->scrypt_r = 1;
11773 hashes_buf[0].salt->scrypt_p = 1;
11774 break;
11775 case 9100: hashes_buf[0].salt->salt_len = 16;
11776 break;
11777 case 9300: hashes_buf[0].salt->salt_len = 14;
11778 hashes_buf[0].salt->scrypt_N = 16384;
11779 hashes_buf[0].salt->scrypt_r = 1;
11780 hashes_buf[0].salt->scrypt_p = 1;
11781 break;
11782 case 9400: hashes_buf[0].salt->salt_len = 16;
11783 break;
11784 case 9500: hashes_buf[0].salt->salt_len = 16;
11785 break;
11786 case 9600: hashes_buf[0].salt->salt_len = 16;
11787 break;
11788 case 9700: hashes_buf[0].salt->salt_len = 16;
11789 break;
11790 case 9710: hashes_buf[0].salt->salt_len = 16;
11791 break;
11792 case 9720: hashes_buf[0].salt->salt_len = 16;
11793 break;
11794 case 9800: hashes_buf[0].salt->salt_len = 16;
11795 break;
11796 case 9810: hashes_buf[0].salt->salt_len = 16;
11797 break;
11798 case 9820: hashes_buf[0].salt->salt_len = 16;
11799 break;
11800 case 10300: hashes_buf[0].salt->salt_len = 12;
11801 break;
11802 case 11500: hashes_buf[0].salt->salt_len = 4;
11803 break;
11804 case 11600: hashes_buf[0].salt->salt_len = 4;
11805 break;
11806 case 12400: hashes_buf[0].salt->salt_len = 4;
11807 break;
11808 case 12500: hashes_buf[0].salt->salt_len = 8;
11809 break;
11810 case 12600: hashes_buf[0].salt->salt_len = 64;
11811 break;
11812 }
11813
11814 // special esalt handling
11815
11816 switch (hash_mode)
11817 {
11818 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11819 break;
11820 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11821 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11822 break;
11823 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11824 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11825 break;
11826 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11827 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11828 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11829 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11830 break;
11831 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11832 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11833 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11834 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11835 break;
11836 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11837 break;
11838 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11839 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11840 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11841 break;
11842 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11843 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11844 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11845 break;
11846 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11847 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11848 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11849 break;
11850 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11851 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11852 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11853 break;
11854 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11855 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11856 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11857 break;
11858 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11859 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11860 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11861 break;
11862 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11863 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11864 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11865 break;
11866 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11867 break;
11868 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11869 break;
11870 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11871 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11872 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11873 break;
11874 }
11875 }
11876
11877 // set hashfile
11878
11879 switch (hash_mode)
11880 {
11881 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11882 break;
11883 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11884 break;
11885 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11886 break;
11887 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11888 break;
11889 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11890 break;
11891 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11892 break;
11893 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11894 break;
11895 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11896 break;
11897 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11898 break;
11899 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11900 break;
11901 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11902 break;
11903 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11904 break;
11905 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11906 break;
11907 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11908 break;
11909 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11910 break;
11911 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11912 break;
11913 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11914 break;
11915 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11916 break;
11917 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11918 break;
11919 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11920 break;
11921 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11924 break;
11925 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11926 break;
11927 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11928 break;
11929 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11930 break;
11931 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11932 break;
11933 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11934 break;
11935 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11936 break;
11937 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11938 break;
11939 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11940 break;
11941 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11942 break;
11943 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11944 break;
11945 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11946 break;
11947 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11948 break;
11949 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11950 break;
11951 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11952 break;
11953 }
11954
11955 // set default iterations
11956
11957 switch (hash_mode)
11958 {
11959 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11960 break;
11961 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11962 break;
11963 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11964 break;
11965 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11966 break;
11967 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11968 break;
11969 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11970 break;
11971 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11972 break;
11973 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11974 break;
11975 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11976 break;
11977 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11978 break;
11979 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11980 break;
11981 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11982 break;
11983 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11984 break;
11985 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11986 break;
11987 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11988 break;
11989 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11990 break;
11991 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11992 break;
11993 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11994 break;
11995 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11996 break;
11997 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11998 break;
11999 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12000 break;
12001 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12002 break;
12003 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12004 break;
12005 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12006 break;
12007 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12008 break;
12009 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12010 break;
12011 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12012 break;
12013 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12014 break;
12015 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12016 break;
12017 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12018 break;
12019 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12020 break;
12021 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12022 break;
12023 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12024 break;
12025 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12026 break;
12027 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12028 break;
12029 case 8900: hashes_buf[0].salt->salt_iter = 1;
12030 break;
12031 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12032 break;
12033 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12034 break;
12035 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12036 break;
12037 case 9300: hashes_buf[0].salt->salt_iter = 1;
12038 break;
12039 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12040 break;
12041 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12042 break;
12043 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12044 break;
12045 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12046 break;
12047 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12048 break;
12049 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12050 break;
12051 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12052 break;
12053 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12054 break;
12055 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12056 break;
12057 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12058 break;
12059 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12060 break;
12061 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12062 break;
12063 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12064 break;
12065 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12066 break;
12067 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12068 break;
12069 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12070 break;
12071 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12072 break;
12073 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12074 break;
12075 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12076 break;
12077 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12078 break;
12079 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12080 break;
12081 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12082 break;
12083 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12084 break;
12085 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12086 break;
12087 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12088 break;
12089 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12090 break;
12091 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12092 break;
12093 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12094 break;
12095 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12096 break;
12097 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12098 break;
12099 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12100 break;
12101 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12102 break;
12103 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12104 break;
12105 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12106 break;
12107 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12108 break;
12109 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12110 break;
12111 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12112 break;
12113 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12114 break;
12115 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12116 break;
12117 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12118 break;
12119 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12120 break;
12121 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12122 break;
12123 }
12124
12125 hashes_cnt = 1;
12126 }
12127
12128 if (show == 1 || left == 1)
12129 {
12130 for (uint i = 0; i < pot_cnt; i++)
12131 {
12132 pot_t *pot_ptr = &pot[i];
12133
12134 hash_t *hashes_buf = &pot_ptr->hash;
12135
12136 local_free (hashes_buf->digest);
12137
12138 if (isSalted)
12139 {
12140 local_free (hashes_buf->salt);
12141 }
12142 }
12143
12144 local_free (pot);
12145
12146 if (data.quiet == 0) log_info_nn ("");
12147
12148 return (0);
12149 }
12150
12151 if (keyspace == 0)
12152 {
12153 if (hashes_cnt == 0)
12154 {
12155 log_error ("ERROR: No hashes loaded");
12156
12157 return (-1);
12158 }
12159 }
12160
12161 /**
12162 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12163 */
12164
12165 if (data.outfile != NULL)
12166 {
12167 if (data.hashfile != NULL)
12168 {
12169 #ifdef _POSIX
12170 struct stat tmpstat_outfile;
12171 struct stat tmpstat_hashfile;
12172 #endif
12173
12174 #ifdef _WIN
12175 struct stat64 tmpstat_outfile;
12176 struct stat64 tmpstat_hashfile;
12177 #endif
12178
12179 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12180
12181 if (tmp_outfile_fp)
12182 {
12183 #ifdef _POSIX
12184 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12185 #endif
12186
12187 #ifdef _WIN
12188 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12189 #endif
12190
12191 fclose (tmp_outfile_fp);
12192 }
12193
12194 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12195
12196 if (tmp_hashfile_fp)
12197 {
12198 #ifdef _POSIX
12199 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12200 #endif
12201
12202 #ifdef _WIN
12203 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12204 #endif
12205
12206 fclose (tmp_hashfile_fp);
12207 }
12208
12209 if (tmp_outfile_fp && tmp_outfile_fp)
12210 {
12211 tmpstat_outfile.st_mode = 0;
12212 tmpstat_outfile.st_nlink = 0;
12213 tmpstat_outfile.st_uid = 0;
12214 tmpstat_outfile.st_gid = 0;
12215 tmpstat_outfile.st_rdev = 0;
12216 tmpstat_outfile.st_atime = 0;
12217
12218 tmpstat_hashfile.st_mode = 0;
12219 tmpstat_hashfile.st_nlink = 0;
12220 tmpstat_hashfile.st_uid = 0;
12221 tmpstat_hashfile.st_gid = 0;
12222 tmpstat_hashfile.st_rdev = 0;
12223 tmpstat_hashfile.st_atime = 0;
12224
12225 #ifdef _POSIX
12226 tmpstat_outfile.st_blksize = 0;
12227 tmpstat_outfile.st_blocks = 0;
12228
12229 tmpstat_hashfile.st_blksize = 0;
12230 tmpstat_hashfile.st_blocks = 0;
12231 #endif
12232
12233 #ifdef _POSIX
12234 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12235 {
12236 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12237
12238 return (-1);
12239 }
12240 #endif
12241
12242 #ifdef _WIN
12243 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12244 {
12245 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12246
12247 return (-1);
12248 }
12249 #endif
12250 }
12251 }
12252 }
12253
12254 /**
12255 * Remove duplicates
12256 */
12257
12258 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12259
12260 if (isSalted)
12261 {
12262 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12263 }
12264 else
12265 {
12266 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12267 }
12268
12269 uint hashes_cnt_orig = hashes_cnt;
12270
12271 hashes_cnt = 1;
12272
12273 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12274 {
12275 if (isSalted)
12276 {
12277 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12278 {
12279 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12280 }
12281 }
12282 else
12283 {
12284 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12285 }
12286
12287 if (hashes_pos > hashes_cnt)
12288 {
12289 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12290 }
12291
12292 hashes_cnt++;
12293 }
12294
12295 /**
12296 * Potfile removes
12297 */
12298
12299 uint potfile_remove_cracks = 0;
12300
12301 if (potfile_disable == 0)
12302 {
12303 hash_t hash_buf;
12304
12305 hash_buf.digest = mymalloc (dgst_size);
12306 hash_buf.salt = NULL;
12307 hash_buf.esalt = NULL;
12308 hash_buf.hash_info = NULL;
12309 hash_buf.cracked = 0;
12310
12311 if (isSalted)
12312 {
12313 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12314 }
12315
12316 if (esalt_size)
12317 {
12318 hash_buf.esalt = mymalloc (esalt_size);
12319 }
12320
12321 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12322
12323 // no solution for these special hash types (for instane because they use hashfile in output etc)
12324 if ((hash_mode != 5200) &&
12325 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12326 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12327 (hash_mode != 9000))
12328 {
12329 FILE *fp = fopen (potfile, "rb");
12330
12331 if (fp != NULL)
12332 {
12333 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12334
12335 // to be safe work with a copy (because of line_len loop, i etc)
12336 // moved up here because it's easier to handle continue case
12337 // it's just 64kb
12338
12339 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12340
12341 while (!feof (fp))
12342 {
12343 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12344
12345 if (ptr == NULL) break;
12346
12347 int line_len = strlen (line_buf);
12348
12349 if (line_len == 0) continue;
12350
12351 int iter = MAX_CUT_TRIES;
12352
12353 for (int i = line_len - 1; i && iter; i--, line_len--)
12354 {
12355 if (line_buf[i] != ':') continue;
12356
12357 if (isSalted)
12358 {
12359 memset (hash_buf.salt, 0, sizeof (salt_t));
12360 }
12361
12362 hash_t *found = NULL;
12363
12364 if (hash_mode == 6800)
12365 {
12366 if (i < 64) // 64 = 16 * uint in salt_buf[]
12367 {
12368 // manipulate salt_buf
12369 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12370
12371 hash_buf.salt->salt_len = i;
12372
12373 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12374 }
12375 }
12376 else if (hash_mode == 2500)
12377 {
12378 if (i < 64) // 64 = 16 * uint in salt_buf[]
12379 {
12380 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12381 // manipulate salt_buf
12382
12383 memcpy (line_buf_cpy, line_buf, i);
12384
12385 char *mac2_pos = strrchr (line_buf_cpy, ':');
12386
12387 if (mac2_pos == NULL) continue;
12388
12389 mac2_pos[0] = 0;
12390 mac2_pos++;
12391
12392 if (strlen (mac2_pos) != 12) continue;
12393
12394 char *mac1_pos = strrchr (line_buf_cpy, ':');
12395
12396 if (mac1_pos == NULL) continue;
12397
12398 mac1_pos[0] = 0;
12399 mac1_pos++;
12400
12401 if (strlen (mac1_pos) != 12) continue;
12402
12403 uint essid_length = mac1_pos - line_buf_cpy - 1;
12404
12405 // here we need the ESSID
12406 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12407
12408 hash_buf.salt->salt_len = essid_length;
12409
12410 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12411
12412 if (found)
12413 {
12414 wpa_t *wpa = (wpa_t *) found->esalt;
12415
12416 // compare hex string(s) vs binary MAC address(es)
12417
12418 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12419 {
12420 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12421 {
12422 found = NULL;
12423
12424 break;
12425 }
12426 }
12427
12428 // early skip ;)
12429 if (!found) continue;
12430
12431 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12432 {
12433 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12434 {
12435 found = NULL;
12436
12437 break;
12438 }
12439 }
12440 }
12441 }
12442 }
12443 else
12444 {
12445 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12446
12447 if (parser_status == PARSER_OK)
12448 {
12449 if (isSalted)
12450 {
12451 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12452 }
12453 else
12454 {
12455 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12456 }
12457 }
12458 }
12459
12460 if (found == NULL) continue;
12461
12462 if (!found->cracked) potfile_remove_cracks++;
12463
12464 found->cracked = 1;
12465
12466 if (found) break;
12467
12468 iter--;
12469 }
12470 }
12471
12472 myfree (line_buf_cpy);
12473
12474 myfree (line_buf);
12475
12476 fclose (fp);
12477 }
12478 }
12479
12480 if (esalt_size)
12481 {
12482 local_free (hash_buf.esalt);
12483 }
12484
12485 if (isSalted)
12486 {
12487 local_free (hash_buf.salt);
12488 }
12489
12490 local_free (hash_buf.digest);
12491 }
12492
12493 /**
12494 * Now generate all the buffers required for later
12495 */
12496
12497 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12498
12499 salt_t *salts_buf_new = NULL;
12500 void *esalts_buf_new = NULL;
12501
12502 if (isSalted)
12503 {
12504 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12505
12506 if (esalt_size)
12507 {
12508 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12509 }
12510 }
12511 else
12512 {
12513 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12514 }
12515
12516 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12517
12518 uint digests_cnt = hashes_cnt;
12519 uint digests_done = 0;
12520
12521 size_t size_digests = digests_cnt * dgst_size;
12522 size_t size_shown = digests_cnt * sizeof (uint);
12523
12524 uint *digests_shown = (uint *) mymalloc (size_shown);
12525 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12526
12527 uint salts_cnt = 0;
12528 uint salts_done = 0;
12529
12530 hashinfo_t **hash_info = NULL;
12531
12532 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12533 {
12534 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12535
12536 if (username && (remove || show))
12537 {
12538 uint user_pos;
12539
12540 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12541 {
12542 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12543
12544 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12545 }
12546 }
12547 }
12548
12549 uint *salts_shown = (uint *) mymalloc (size_shown);
12550
12551 salt_t *salt_buf;
12552
12553 {
12554 // copied from inner loop
12555
12556 salt_buf = &salts_buf_new[salts_cnt];
12557
12558 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12559
12560 if (esalt_size)
12561 {
12562 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12563 }
12564
12565 salt_buf->digests_cnt = 0;
12566 salt_buf->digests_done = 0;
12567 salt_buf->digests_offset = 0;
12568
12569 salts_cnt++;
12570 }
12571
12572 if (hashes_buf[0].cracked == 1)
12573 {
12574 digests_shown[0] = 1;
12575
12576 digests_done++;
12577
12578 salt_buf->digests_done++;
12579 }
12580
12581 salt_buf->digests_cnt++;
12582
12583 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12584
12585 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12586 {
12587 hash_info[0] = hashes_buf[0].hash_info;
12588 }
12589
12590 // copy from inner loop
12591
12592 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12593 {
12594 if (isSalted)
12595 {
12596 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12597 {
12598 salt_buf = &salts_buf_new[salts_cnt];
12599
12600 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12601
12602 if (esalt_size)
12603 {
12604 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12605 }
12606
12607 salt_buf->digests_cnt = 0;
12608 salt_buf->digests_done = 0;
12609 salt_buf->digests_offset = hashes_pos;
12610
12611 salts_cnt++;
12612 }
12613 }
12614
12615 if (hashes_buf[hashes_pos].cracked == 1)
12616 {
12617 digests_shown[hashes_pos] = 1;
12618
12619 digests_done++;
12620
12621 salt_buf->digests_done++;
12622 }
12623
12624 salt_buf->digests_cnt++;
12625
12626 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12627
12628 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12629 {
12630 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12631 }
12632 }
12633
12634 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12635 {
12636 salt_t *salt_buf = &salts_buf_new[salt_pos];
12637
12638 if (salt_buf->digests_done == salt_buf->digests_cnt)
12639 {
12640 salts_shown[salt_pos] = 1;
12641
12642 salts_done++;
12643 }
12644
12645 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12646 }
12647
12648 local_free (digests_buf);
12649 local_free (salts_buf);
12650 local_free (esalts_buf);
12651
12652 digests_buf = digests_buf_new;
12653 salts_buf = salts_buf_new;
12654 esalts_buf = esalts_buf_new;
12655
12656 local_free (hashes_buf);
12657
12658 /**
12659 * special modification not set from parser
12660 */
12661
12662 switch (hash_mode)
12663 {
12664 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12665 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12666 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12667 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12668 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12669 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12670 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12671 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12672 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12673 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12674 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12675 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12676 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12677 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12678 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12679 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12680 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12681 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12682 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12683 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12684 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12685 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12686 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12687 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12688 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12689 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12690 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12691 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12692 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12693 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12694 }
12695
12696 if (truecrypt_keyfiles)
12697 {
12698 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12699
12700 char *keyfiles = strdup (truecrypt_keyfiles);
12701
12702 char *keyfile = strtok (keyfiles, ",");
12703
12704 do
12705 {
12706 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12707
12708 } while ((keyfile = strtok (NULL, ",")) != NULL);
12709
12710 free (keyfiles);
12711 }
12712
12713 if (veracrypt_keyfiles)
12714 {
12715 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12716
12717 char *keyfiles = strdup (veracrypt_keyfiles);
12718
12719 char *keyfile = strtok (keyfiles, ",");
12720
12721 do
12722 {
12723 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12724
12725 } while ((keyfile = strtok (NULL, ",")) != NULL);
12726
12727 free (keyfiles);
12728 }
12729
12730 data.digests_cnt = digests_cnt;
12731 data.digests_done = digests_done;
12732 data.digests_buf = digests_buf;
12733 data.digests_shown = digests_shown;
12734 data.digests_shown_tmp = digests_shown_tmp;
12735
12736 data.salts_cnt = salts_cnt;
12737 data.salts_done = salts_done;
12738 data.salts_buf = salts_buf;
12739 data.salts_shown = salts_shown;
12740
12741 data.esalts_buf = esalts_buf;
12742 data.hash_info = hash_info;
12743
12744 /**
12745 * Automatic Optimizers
12746 */
12747
12748 if (salts_cnt == 1)
12749 opti_type |= OPTI_TYPE_SINGLE_SALT;
12750
12751 if (digests_cnt == 1)
12752 opti_type |= OPTI_TYPE_SINGLE_HASH;
12753
12754 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12755 opti_type |= OPTI_TYPE_NOT_ITERATED;
12756
12757 if (attack_mode == ATTACK_MODE_BF)
12758 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12759
12760 data.opti_type = opti_type;
12761
12762 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12763 {
12764 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12765 {
12766 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12767 {
12768 if (opts_type & OPTS_TYPE_ST_ADD80)
12769 {
12770 opts_type &= ~OPTS_TYPE_ST_ADD80;
12771 opts_type |= OPTS_TYPE_PT_ADD80;
12772 }
12773
12774 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12775 {
12776 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12777 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12778 }
12779
12780 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12781 {
12782 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12783 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12784 }
12785 }
12786 }
12787 }
12788
12789 /**
12790 * Some algorithm, like descrypt, can benefit from JIT compilation
12791 */
12792
12793 int force_jit_compilation = -1;
12794
12795 if (hash_mode == 8900)
12796 {
12797 force_jit_compilation = 8900;
12798 }
12799 else if (hash_mode == 9300)
12800 {
12801 force_jit_compilation = 8900;
12802 }
12803 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12804 {
12805 force_jit_compilation = 1500;
12806 }
12807
12808 /**
12809 * generate bitmap tables
12810 */
12811
12812 const uint bitmap_shift1 = 5;
12813 const uint bitmap_shift2 = 13;
12814
12815 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12816
12817 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12818 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12819 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12820 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12821 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12822 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12823 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12824 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12825
12826 uint bitmap_bits;
12827 uint bitmap_nums;
12828 uint bitmap_mask;
12829 uint bitmap_size;
12830
12831 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12832 {
12833 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12834
12835 bitmap_nums = 1 << bitmap_bits;
12836
12837 bitmap_mask = bitmap_nums - 1;
12838
12839 bitmap_size = bitmap_nums * sizeof (uint);
12840
12841 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12842
12843 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;
12844 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;
12845
12846 break;
12847 }
12848
12849 bitmap_nums = 1 << bitmap_bits;
12850
12851 bitmap_mask = bitmap_nums - 1;
12852
12853 bitmap_size = bitmap_nums * sizeof (uint);
12854
12855 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);
12856 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);
12857
12858 /**
12859 * prepare quick rule
12860 */
12861
12862 data.rule_buf_l = rule_buf_l;
12863 data.rule_buf_r = rule_buf_r;
12864
12865 int rule_len_l = (int) strlen (rule_buf_l);
12866 int rule_len_r = (int) strlen (rule_buf_r);
12867
12868 data.rule_len_l = rule_len_l;
12869 data.rule_len_r = rule_len_r;
12870
12871 /**
12872 * load rules
12873 */
12874
12875 uint *all_kernel_rules_cnt = NULL;
12876
12877 kernel_rule_t **all_kernel_rules_buf = NULL;
12878
12879 if (rp_files_cnt)
12880 {
12881 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12882
12883 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12884 }
12885
12886 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12887
12888 int rule_len = 0;
12889
12890 for (uint i = 0; i < rp_files_cnt; i++)
12891 {
12892 uint kernel_rules_avail = 0;
12893
12894 uint kernel_rules_cnt = 0;
12895
12896 kernel_rule_t *kernel_rules_buf = NULL;
12897
12898 char *rp_file = rp_files[i];
12899
12900 char in[BLOCK_SIZE] = { 0 };
12901 char out[BLOCK_SIZE] = { 0 };
12902
12903 FILE *fp = NULL;
12904
12905 uint rule_line = 0;
12906
12907 if ((fp = fopen (rp_file, "rb")) == NULL)
12908 {
12909 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12910
12911 return (-1);
12912 }
12913
12914 while (!feof (fp))
12915 {
12916 memset (rule_buf, 0, HCBUFSIZ);
12917
12918 rule_len = fgetl (fp, rule_buf);
12919
12920 rule_line++;
12921
12922 if (rule_len == 0) continue;
12923
12924 if (rule_buf[0] == '#') continue;
12925
12926 if (kernel_rules_avail == kernel_rules_cnt)
12927 {
12928 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12929
12930 kernel_rules_avail += INCR_RULES;
12931 }
12932
12933 memset (in, 0, BLOCK_SIZE);
12934 memset (out, 0, BLOCK_SIZE);
12935
12936 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12937
12938 if (result == -1)
12939 {
12940 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12941
12942 continue;
12943 }
12944
12945 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12946 {
12947 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12948
12949 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12950
12951 continue;
12952 }
12953
12954 /* its so slow
12955 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12956 {
12957 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12958
12959 continue;
12960 }
12961 */
12962
12963 kernel_rules_cnt++;
12964 }
12965
12966 fclose (fp);
12967
12968 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12969
12970 all_kernel_rules_buf[i] = kernel_rules_buf;
12971 }
12972
12973 /**
12974 * merge rules or automatic rule generator
12975 */
12976
12977 uint kernel_rules_cnt = 0;
12978
12979 kernel_rule_t *kernel_rules_buf = NULL;
12980
12981 if (attack_mode == ATTACK_MODE_STRAIGHT)
12982 {
12983 if (rp_files_cnt)
12984 {
12985 kernel_rules_cnt = 1;
12986
12987 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12988
12989 repeats[0] = kernel_rules_cnt;
12990
12991 for (uint i = 0; i < rp_files_cnt; i++)
12992 {
12993 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12994
12995 repeats[i + 1] = kernel_rules_cnt;
12996 }
12997
12998 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12999
13000 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13001
13002 for (uint i = 0; i < kernel_rules_cnt; i++)
13003 {
13004 uint out_pos = 0;
13005
13006 kernel_rule_t *out = &kernel_rules_buf[i];
13007
13008 for (uint j = 0; j < rp_files_cnt; j++)
13009 {
13010 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13011 uint in_pos;
13012
13013 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13014
13015 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13016 {
13017 if (out_pos == RULES_MAX - 1)
13018 {
13019 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13020
13021 break;
13022 }
13023
13024 out->cmds[out_pos] = in->cmds[in_pos];
13025 }
13026 }
13027 }
13028
13029 local_free (repeats);
13030 }
13031 else if (rp_gen)
13032 {
13033 uint kernel_rules_avail = 0;
13034
13035 while (kernel_rules_cnt < rp_gen)
13036 {
13037 if (kernel_rules_avail == kernel_rules_cnt)
13038 {
13039 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13040
13041 kernel_rules_avail += INCR_RULES;
13042 }
13043
13044 memset (rule_buf, 0, HCBUFSIZ);
13045
13046 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13047
13048 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13049
13050 kernel_rules_cnt++;
13051 }
13052 }
13053 }
13054
13055 myfree (rule_buf);
13056
13057 /**
13058 * generate NOP rules
13059 */
13060
13061 if (kernel_rules_cnt == 0)
13062 {
13063 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13064
13065 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13066
13067 kernel_rules_cnt++;
13068 }
13069
13070 data.kernel_rules_cnt = kernel_rules_cnt;
13071 data.kernel_rules_buf = kernel_rules_buf;
13072
13073 /**
13074 * OpenCL platforms: detect
13075 */
13076
13077 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13078 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13079
13080 cl_uint platforms_cnt = 0;
13081 cl_uint platform_devices_cnt = 0;
13082
13083 if (keyspace == 0)
13084 {
13085 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13086
13087 if (platforms_cnt == 0)
13088 {
13089 log_info ("");
13090 log_info ("ATTENTION! No OpenCL compatible platform found");
13091 log_info ("");
13092 log_info ("You're probably missing the OpenCL runtime installation");
13093 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13094 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13095 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13096 log_info ("");
13097
13098 return (-1);
13099 }
13100
13101 if (opencl_platforms_filter != (uint) -1)
13102 {
13103 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13104
13105 if (opencl_platforms_filter > platform_cnt_mask)
13106 {
13107 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13108
13109 return (-1);
13110 }
13111 }
13112 }
13113
13114 /**
13115 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13116 */
13117
13118 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13119 {
13120 cl_platform_id platform = platforms[platform_id];
13121
13122 char platform_vendor[INFOSZ] = { 0 };
13123
13124 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13125
13126 #ifdef HAVE_HWMON
13127 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13128 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13129 {
13130 // make sure that we do not directly control the fan for NVidia
13131
13132 gpu_temp_retain = 0;
13133
13134 data.gpu_temp_retain = gpu_temp_retain;
13135 }
13136 #endif // HAVE_NVML || HAVE_NVAPI
13137 #endif
13138 }
13139
13140 /**
13141 * OpenCL device types:
13142 * 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.
13143 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13144 */
13145
13146 if (opencl_device_types == NULL)
13147 {
13148 cl_device_type device_types_all = 0;
13149
13150 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13151 {
13152 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13153
13154 cl_platform_id platform = platforms[platform_id];
13155
13156 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13157
13158 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13159 {
13160 cl_device_id device = platform_devices[platform_devices_id];
13161
13162 cl_device_type device_type;
13163
13164 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13165
13166 device_types_all |= device_type;
13167 }
13168 }
13169
13170 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13171 {
13172 device_types_filter |= CL_DEVICE_TYPE_CPU;
13173 }
13174 }
13175
13176 /**
13177 * OpenCL devices: simply push all devices from all platforms into the same device array
13178 */
13179
13180 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13181
13182 data.devices_param = devices_param;
13183
13184 uint devices_cnt = 0;
13185
13186 uint devices_active = 0;
13187
13188 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13189 {
13190 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13191
13192 cl_platform_id platform = platforms[platform_id];
13193
13194 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13195
13196 char platform_vendor[INFOSZ] = { 0 };
13197
13198 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13199
13200 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13201 // this causes trouble with vendor id based macros
13202 // we'll assign generic to those without special optimization available
13203
13204 cl_uint vendor_id = 0;
13205
13206 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13207 {
13208 vendor_id = VENDOR_ID_AMD;
13209 }
13210 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13211 {
13212 vendor_id = VENDOR_ID_APPLE;
13213 }
13214 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13215 {
13216 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13217 }
13218 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13219 {
13220 vendor_id = VENDOR_ID_INTEL_SDK;
13221 }
13222 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13223 {
13224 vendor_id = VENDOR_ID_MESA;
13225 }
13226 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13227 {
13228 vendor_id = VENDOR_ID_NV;
13229 }
13230 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13231 {
13232 vendor_id = VENDOR_ID_POCL;
13233 }
13234 else
13235 {
13236 vendor_id = VENDOR_ID_GENERIC;
13237 }
13238
13239 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13240 {
13241 size_t param_value_size = 0;
13242
13243 const uint device_id = devices_cnt;
13244
13245 hc_device_param_t *device_param = &data.devices_param[device_id];
13246
13247 device_param->vendor_id = vendor_id;
13248
13249 device_param->device = platform_devices[platform_devices_id];
13250
13251 device_param->device_id = device_id;
13252
13253 device_param->platform_devices_id = platform_devices_id;
13254
13255 // device_type
13256
13257 cl_device_type device_type;
13258
13259 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13260
13261 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13262
13263 device_param->device_type = device_type;
13264
13265 // device_name
13266
13267 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13268
13269 char *device_name = (char *) mymalloc (param_value_size);
13270
13271 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13272
13273 device_param->device_name = device_name;
13274
13275 // tuning db
13276
13277 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13278
13279 // device_version
13280
13281 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13282
13283 char *device_version = (char *) mymalloc (param_value_size);
13284
13285 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13286
13287 device_param->device_version = device_version;
13288
13289 // device_opencl_version
13290
13291 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13292
13293 char *device_opencl_version = (char *) mymalloc (param_value_size);
13294
13295 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13296
13297 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13298
13299 myfree (device_opencl_version);
13300
13301 // vector_width
13302
13303 cl_uint vector_width;
13304
13305 if (opencl_vector_width_chgd == 0)
13306 {
13307 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13308 {
13309 if (opti_type & OPTI_TYPE_USES_BITS_64)
13310 {
13311 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13312 }
13313 else
13314 {
13315 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13316 }
13317 }
13318 else
13319 {
13320 vector_width = (cl_uint) tuningdb_entry->vector_width;
13321 }
13322 }
13323 else
13324 {
13325 vector_width = opencl_vector_width;
13326 }
13327
13328 if (vector_width > 16) vector_width = 16;
13329
13330 device_param->vector_width = vector_width;
13331
13332 // max_compute_units
13333
13334 cl_uint device_processors;
13335
13336 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13337
13338 device_param->device_processors = device_processors;
13339
13340 // device_maxmem_alloc
13341 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13342
13343 cl_ulong device_maxmem_alloc;
13344
13345 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13346
13347 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13348
13349 // device_global_mem
13350
13351 cl_ulong device_global_mem;
13352
13353 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13354
13355 device_param->device_global_mem = device_global_mem;
13356
13357 // max_work_group_size
13358
13359 size_t device_maxworkgroup_size;
13360
13361 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13362
13363 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13364
13365 // max_clock_frequency
13366
13367 cl_uint device_maxclock_frequency;
13368
13369 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13370
13371 device_param->device_maxclock_frequency = device_maxclock_frequency;
13372
13373 // device_endian_little
13374
13375 cl_bool device_endian_little;
13376
13377 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13378
13379 if (device_endian_little == CL_FALSE)
13380 {
13381 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13382
13383 device_param->skipped = 1;
13384 }
13385
13386 // device_available
13387
13388 cl_bool device_available;
13389
13390 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13391
13392 if (device_available == CL_FALSE)
13393 {
13394 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13395
13396 device_param->skipped = 1;
13397 }
13398
13399 // device_compiler_available
13400
13401 cl_bool device_compiler_available;
13402
13403 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13404
13405 if (device_compiler_available == CL_FALSE)
13406 {
13407 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13408
13409 device_param->skipped = 1;
13410 }
13411
13412 // device_execution_capabilities
13413
13414 cl_device_exec_capabilities device_execution_capabilities;
13415
13416 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13417
13418 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13419 {
13420 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13421
13422 device_param->skipped = 1;
13423 }
13424
13425 // device_extensions
13426
13427 size_t device_extensions_size;
13428
13429 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13430
13431 char *device_extensions = mymalloc (device_extensions_size + 1);
13432
13433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13434
13435 if (strstr (device_extensions, "base_atomics") == 0)
13436 {
13437 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13438
13439 device_param->skipped = 1;
13440 }
13441
13442 if (strstr (device_extensions, "byte_addressable_store") == 0)
13443 {
13444 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13445
13446 device_param->skipped = 1;
13447 }
13448
13449 myfree (device_extensions);
13450
13451 // device_local_mem_size
13452
13453 cl_ulong device_local_mem_size;
13454
13455 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13456
13457 if (device_local_mem_size < 32768)
13458 {
13459 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13460
13461 device_param->skipped = 1;
13462 }
13463
13464
13465 // skipped
13466
13467 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13468 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13469
13470 // driver_version
13471
13472 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13473
13474 char *driver_version = (char *) mymalloc (param_value_size);
13475
13476 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13477
13478 device_param->driver_version = driver_version;
13479
13480 // device_name_chksum
13481
13482 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13483
13484 #if __x86_64__
13485 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);
13486 #else
13487 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);
13488 #endif
13489
13490 uint device_name_digest[4] = { 0 };
13491
13492 md5_64 ((uint *) device_name_chksum, device_name_digest);
13493
13494 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13495
13496 device_param->device_name_chksum = device_name_chksum;
13497
13498 // device_processor_cores
13499
13500 if (device_type & CL_DEVICE_TYPE_CPU)
13501 {
13502 cl_uint device_processor_cores = 1;
13503
13504 device_param->device_processor_cores = device_processor_cores;
13505 }
13506
13507 if (device_type & CL_DEVICE_TYPE_GPU)
13508 {
13509 if (vendor_id == VENDOR_ID_AMD)
13510 {
13511 cl_uint device_processor_cores = 0;
13512
13513 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13514
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13516
13517 device_param->device_processor_cores = device_processor_cores;
13518 }
13519 else if (vendor_id == VENDOR_ID_NV)
13520 {
13521 cl_uint kernel_exec_timeout = 0;
13522
13523 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13524
13525 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13526
13527 device_param->kernel_exec_timeout = kernel_exec_timeout;
13528
13529 cl_uint device_processor_cores = 0;
13530
13531 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13532
13533 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13534
13535 device_param->device_processor_cores = device_processor_cores;
13536
13537 cl_uint sm_minor = 0;
13538 cl_uint sm_major = 0;
13539
13540 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13541 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13542
13543 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13544 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13545
13546 device_param->sm_minor = sm_minor;
13547 device_param->sm_major = sm_major;
13548 }
13549 else
13550 {
13551 cl_uint device_processor_cores = 1;
13552
13553 device_param->device_processor_cores = device_processor_cores;
13554 }
13555 }
13556
13557 // display results
13558
13559 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13560 {
13561 if (status_automat == 0)
13562 {
13563 if (device_param->skipped == 0)
13564 {
13565 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13566 device_id + 1,
13567 device_name,
13568 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13569 (unsigned int) (device_global_mem / 1024 / 1024),
13570 (unsigned int) (device_maxclock_frequency),
13571 (unsigned int) device_processors);
13572 }
13573 else
13574 {
13575 log_info ("Device #%u: %s, skipped",
13576 device_id + 1,
13577 device_name);
13578 }
13579 }
13580 }
13581
13582 // common driver check
13583
13584 if (device_param->skipped == 0)
13585 {
13586 if (device_type & CL_DEVICE_TYPE_GPU)
13587 {
13588 if (vendor_id == VENDOR_ID_AMD)
13589 {
13590 int catalyst_check = (force == 1) ? 0 : 1;
13591
13592 int catalyst_warn = 0;
13593
13594 int catalyst_broken = 0;
13595
13596 if (catalyst_check == 1)
13597 {
13598 catalyst_warn = 1;
13599
13600 // v14.9 and higher
13601 if (atoi (device_param->driver_version) >= 1573)
13602 {
13603 catalyst_warn = 0;
13604 }
13605
13606 catalyst_check = 0;
13607 }
13608
13609 if (catalyst_broken == 1)
13610 {
13611 log_info ("");
13612 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13613 log_info ("It will pass over cracked hashes and does not report them as cracked");
13614 log_info ("You are STRONGLY encouraged not to use it");
13615 log_info ("You can use --force to override this but do not post error reports if you do so");
13616 log_info ("");
13617
13618 return (-1);
13619 }
13620
13621 if (catalyst_warn == 1)
13622 {
13623 log_info ("");
13624 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13625 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13626 log_info ("See hashcat's homepage for official supported catalyst drivers");
13627 #ifdef _WIN
13628 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13629 #endif
13630 log_info ("You can use --force to override this but do not post error reports if you do so");
13631 log_info ("");
13632
13633 return (-1);
13634 }
13635 }
13636 else if (vendor_id == VENDOR_ID_NV)
13637 {
13638 if (device_param->kernel_exec_timeout != 0)
13639 {
13640 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);
13641 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13642 }
13643 }
13644 }
13645
13646 if (device_type & CL_DEVICE_TYPE_CPU)
13647 {
13648 if (vendor_id == VENDOR_ID_AMD)
13649 {
13650 if (force == 0)
13651 {
13652 log_info ("");
13653 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13654 log_info ("You are STRONGLY encouraged not to use it");
13655 log_info ("You can use --force to override this but do not post error reports if you do so");
13656 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13657 log_info ("");
13658
13659 return (-1);
13660 }
13661 }
13662 }
13663
13664 /**
13665 * kernel accel and loops tuning db adjustment
13666 */
13667
13668 device_param->kernel_accel_min = 1;
13669 device_param->kernel_accel_max = 1024;
13670
13671 device_param->kernel_loops_min = 1;
13672 device_param->kernel_loops_max = 1024;
13673
13674 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13675
13676 if (tuningdb_entry)
13677 {
13678 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13679 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13680
13681 if (_kernel_accel)
13682 {
13683 device_param->kernel_accel_min = _kernel_accel;
13684 device_param->kernel_accel_max = _kernel_accel;
13685 }
13686
13687 if (_kernel_loops)
13688 {
13689 if (workload_profile == 1)
13690 {
13691 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13692 }
13693 else if (workload_profile == 2)
13694 {
13695 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13696 }
13697
13698 device_param->kernel_loops_min = _kernel_loops;
13699 device_param->kernel_loops_max = _kernel_loops;
13700 }
13701 }
13702
13703 // commandline parameters overwrite tuningdb entries
13704
13705 if (kernel_accel)
13706 {
13707 device_param->kernel_accel_min = kernel_accel;
13708 device_param->kernel_accel_max = kernel_accel;
13709 }
13710
13711 if (kernel_loops)
13712 {
13713 device_param->kernel_loops_min = kernel_loops;
13714 device_param->kernel_loops_max = kernel_loops;
13715 }
13716
13717 /**
13718 * activate device
13719 */
13720
13721 devices_active++;
13722 }
13723
13724 // next please
13725
13726 devices_cnt++;
13727 }
13728 }
13729
13730 if (keyspace == 0 && devices_active == 0)
13731 {
13732 log_error ("ERROR: No devices found/left");
13733
13734 return (-1);
13735 }
13736
13737 // 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)
13738
13739 if (devices_filter != (uint) -1)
13740 {
13741 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13742
13743 if (devices_filter > devices_cnt_mask)
13744 {
13745 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13746
13747 return (-1);
13748 }
13749 }
13750
13751 data.devices_cnt = devices_cnt;
13752
13753 data.devices_active = devices_active;
13754
13755 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13756 {
13757 if (status_automat == 0)
13758 {
13759 log_info ("");
13760 }
13761 }
13762
13763 /**
13764 * HM devices: init
13765 */
13766
13767 #ifdef HAVE_HWMON
13768 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13769 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13770 #endif
13771
13772 #ifdef HAVE_ADL
13773 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13774 #endif
13775
13776 if (gpu_temp_disable == 0)
13777 {
13778 #if defined(WIN) && defined(HAVE_NVAPI)
13779 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13780
13781 if (nvapi_init (nvapi) == 0)
13782 data.hm_nv = nvapi;
13783
13784 if (data.hm_nv)
13785 {
13786 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13787 {
13788 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13789
13790 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13791
13792 int tmp_out = 0;
13793
13794 for (int i = 0; i < tmp_in; i++)
13795 {
13796 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13797 }
13798
13799 for (int i = 0; i < tmp_out; i++)
13800 {
13801 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13802
13803 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13804
13805 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;
13806 }
13807 }
13808 }
13809 #endif // WIN && HAVE_NVAPI
13810
13811 #if defined(LINUX) && defined(HAVE_NVML)
13812 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13813
13814 if (nvml_init (nvml) == 0)
13815 data.hm_nv = nvml;
13816
13817 if (data.hm_nv)
13818 {
13819 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13820 {
13821 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13822
13823 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13824
13825 int tmp_out = 0;
13826
13827 for (int i = 0; i < tmp_in; i++)
13828 {
13829 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13830 }
13831
13832 for (int i = 0; i < tmp_out; i++)
13833 {
13834 unsigned int speed;
13835
13836 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;
13837 }
13838 }
13839 }
13840 #endif // LINUX && HAVE_NVML
13841
13842 data.hm_amd = NULL;
13843
13844 #ifdef HAVE_ADL
13845 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13846
13847 if (adl_init (adl) == 0)
13848 data.hm_amd = adl;
13849
13850 if (data.hm_amd)
13851 {
13852 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13853 {
13854 // total number of adapters
13855
13856 int hm_adapters_num;
13857
13858 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13859
13860 // adapter info
13861
13862 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13863
13864 if (lpAdapterInfo == NULL) return (-1);
13865
13866 // get a list (of ids of) valid/usable adapters
13867
13868 int num_adl_adapters = 0;
13869
13870 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13871
13872 if (num_adl_adapters > 0)
13873 {
13874 hc_thread_mutex_lock (mux_adl);
13875
13876 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13877
13878 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13879
13880 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13881 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13882
13883 hc_thread_mutex_unlock (mux_adl);
13884 }
13885
13886 myfree (valid_adl_device_list);
13887 myfree (lpAdapterInfo);
13888 }
13889 }
13890 #endif // HAVE_ADL
13891
13892 if (data.hm_amd == NULL && data.hm_nv == NULL)
13893 {
13894 gpu_temp_disable = 1;
13895 }
13896 }
13897
13898 /**
13899 * OpenCL devices: allocate buffer for device specific information
13900 */
13901
13902 #ifdef HAVE_HWMON
13903 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13904
13905 #ifdef HAVE_ADL
13906 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13907
13908 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13909 #endif // ADL
13910 #endif
13911
13912 /**
13913 * enable custom signal handler(s)
13914 */
13915
13916 if (benchmark == 0)
13917 {
13918 hc_signal (sigHandler_default);
13919 }
13920 else
13921 {
13922 hc_signal (sigHandler_benchmark);
13923 }
13924
13925 /**
13926 * User-defined GPU temp handling
13927 */
13928
13929 #ifdef HAVE_HWMON
13930 if (gpu_temp_disable == 1)
13931 {
13932 gpu_temp_abort = 0;
13933 gpu_temp_retain = 0;
13934 }
13935
13936 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13937 {
13938 if (gpu_temp_abort < gpu_temp_retain)
13939 {
13940 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13941
13942 return (-1);
13943 }
13944 }
13945
13946 data.gpu_temp_disable = gpu_temp_disable;
13947 data.gpu_temp_abort = gpu_temp_abort;
13948 data.gpu_temp_retain = gpu_temp_retain;
13949 #endif
13950
13951 /**
13952 * inform the user
13953 */
13954
13955 if (data.quiet == 0)
13956 {
13957 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13958
13959 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);
13960
13961 if (attack_mode == ATTACK_MODE_STRAIGHT)
13962 {
13963 log_info ("Rules: %u", kernel_rules_cnt);
13964 }
13965
13966 if (opti_type)
13967 {
13968 log_info ("Applicable Optimizers:");
13969
13970 for (uint i = 0; i < 32; i++)
13971 {
13972 const uint opti_bit = 1u << i;
13973
13974 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13975 }
13976 }
13977
13978 /**
13979 * Watchdog and Temperature balance
13980 */
13981
13982 #ifdef HAVE_HWMON
13983 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13984 {
13985 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13986 }
13987
13988 if (gpu_temp_abort == 0)
13989 {
13990 log_info ("Watchdog: Temperature abort trigger disabled");
13991 }
13992 else
13993 {
13994 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13995 }
13996
13997 if (gpu_temp_retain == 0)
13998 {
13999 log_info ("Watchdog: Temperature retain trigger disabled");
14000 }
14001 else
14002 {
14003 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14004 }
14005
14006 if (data.quiet == 0) log_info ("");
14007 #endif
14008 }
14009
14010 /**
14011 * HM devices: copy
14012 */
14013
14014 if (gpu_temp_disable == 0)
14015 {
14016 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14017 {
14018 hc_device_param_t *device_param = &data.devices_param[device_id];
14019
14020 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14021
14022 if (device_param->skipped) continue;
14023
14024 const uint platform_devices_id = device_param->platform_devices_id;
14025
14026 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14027 if (device_param->vendor_id == VENDOR_ID_NV)
14028 {
14029 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14030 }
14031 #endif
14032
14033 #ifdef HAVE_ADL
14034 if (device_param->vendor_id == VENDOR_ID_AMD)
14035 {
14036 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14037 }
14038 #endif
14039 }
14040 }
14041
14042 /*
14043 * Temporary fix:
14044 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14045 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14046 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14047 * Driver / ADL bug?
14048 */
14049
14050 #ifdef HAVE_ADL
14051 if (powertune_enable == 1)
14052 {
14053 hc_thread_mutex_lock (mux_adl);
14054
14055 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14056 {
14057 hc_device_param_t *device_param = &data.devices_param[device_id];
14058
14059 if (device_param->skipped) continue;
14060
14061 if (data.hm_device[device_id].od_version == 6)
14062 {
14063 // set powertune value only
14064
14065 int powertune_supported = 0;
14066
14067 int ADL_rc = 0;
14068
14069 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14070 {
14071 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14072
14073 return (-1);
14074 }
14075
14076 if (powertune_supported != 0)
14077 {
14078 // powertune set
14079 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14080
14081 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14082 {
14083 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14084
14085 return (-1);
14086 }
14087
14088 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14089 {
14090 log_error ("ERROR: Failed to set new ADL PowerControl values");
14091
14092 return (-1);
14093 }
14094 }
14095 }
14096 }
14097
14098 hc_thread_mutex_unlock (mux_adl);
14099 }
14100 #endif // HAVE_ADK
14101 #endif // HAVE_HWMON
14102
14103 #ifdef DEBUG
14104 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14105 #endif
14106
14107 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14108
14109 uint kernel_power_all = 0;
14110
14111 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14112 {
14113 /**
14114 * host buffer
14115 */
14116
14117 hc_device_param_t *device_param = &data.devices_param[device_id];
14118
14119 if (device_param->skipped) continue;
14120
14121 /**
14122 * device properties
14123 */
14124
14125 const char *device_name_chksum = device_param->device_name_chksum;
14126 const u32 device_processors = device_param->device_processors;
14127 const u32 device_processor_cores = device_param->device_processor_cores;
14128
14129 /**
14130 * create context for each device
14131 */
14132
14133 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14134
14135 /**
14136 * create command-queue
14137 */
14138
14139 // not supported with NV
14140 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14141
14142 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14143
14144 /**
14145 * kernel threads: some algorithms need a fixed kernel-threads count
14146 * because of shared memory usage or bitslice
14147 * there needs to be some upper limit, otherwise there's too much overhead
14148 */
14149
14150 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14151
14152 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14153 {
14154 kernel_threads = KERNEL_THREADS_MAX_CPU;
14155 }
14156
14157 if (hash_mode == 1500) kernel_threads = 64; // DES
14158 if (hash_mode == 3000) kernel_threads = 64; // DES
14159 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14160 if (hash_mode == 7500) kernel_threads = 64; // RC4
14161 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14162 if (hash_mode == 9700) kernel_threads = 64; // RC4
14163 if (hash_mode == 9710) kernel_threads = 64; // RC4
14164 if (hash_mode == 9800) kernel_threads = 64; // RC4
14165 if (hash_mode == 9810) kernel_threads = 64; // RC4
14166 if (hash_mode == 10400) kernel_threads = 64; // RC4
14167 if (hash_mode == 10410) kernel_threads = 64; // RC4
14168 if (hash_mode == 10500) kernel_threads = 64; // RC4
14169 if (hash_mode == 13100) kernel_threads = 64; // RC4
14170
14171 /**
14172 * create input buffers on device : calculate size of fixed memory buffers
14173 */
14174
14175 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14176 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14177
14178 device_param->size_root_css = size_root_css;
14179 device_param->size_markov_css = size_markov_css;
14180
14181 size_t size_results = sizeof (uint);
14182
14183 device_param->size_results = size_results;
14184
14185 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14186 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14187
14188 size_t size_plains = digests_cnt * sizeof (plain_t);
14189 size_t size_salts = salts_cnt * sizeof (salt_t);
14190 size_t size_esalts = salts_cnt * esalt_size;
14191
14192 device_param->size_plains = size_plains;
14193 device_param->size_digests = size_digests;
14194 device_param->size_shown = size_shown;
14195 device_param->size_salts = size_salts;
14196
14197 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14198 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14199 size_t size_tm = 32 * sizeof (bs_word_t);
14200
14201 // scryptV stuff
14202
14203 size_t size_scryptV = 1;
14204
14205 if ((hash_mode == 8900) || (hash_mode == 9300))
14206 {
14207 uint tmto_start = 0;
14208 uint tmto_stop = 10;
14209
14210 if (scrypt_tmto)
14211 {
14212 tmto_start = scrypt_tmto;
14213 }
14214 else
14215 {
14216 // in case the user did not specify the tmto manually
14217 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14218 // but set the lower end only in case the user has a device with too less memory
14219
14220 if (hash_mode == 8900)
14221 {
14222 if (device_param->vendor_id == VENDOR_ID_AMD)
14223 {
14224 tmto_start = 1;
14225 }
14226 else if (device_param->vendor_id == VENDOR_ID_NV)
14227 {
14228 tmto_start = 2;
14229 }
14230 }
14231 else if (hash_mode == 9300)
14232 {
14233 if (device_param->vendor_id == VENDOR_ID_AMD)
14234 {
14235 tmto_start = 2;
14236 }
14237 else if (device_param->vendor_id == VENDOR_ID_NV)
14238 {
14239 tmto_start = 2;
14240 }
14241 }
14242 }
14243
14244 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14245 {
14246 // TODO: in theory the following calculation needs to be done per salt, not global
14247 // we assume all hashes have the same scrypt settings
14248
14249 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14250
14251 size_scryptV /= 1 << tmto;
14252
14253 size_scryptV *= device_processors * device_processor_cores;
14254
14255 if (size_scryptV > device_param->device_maxmem_alloc)
14256 {
14257 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14258
14259 continue;
14260 }
14261
14262 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14263 {
14264 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14265 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14266 }
14267
14268 break;
14269 }
14270
14271 if (data.salts_buf[0].scrypt_phy == 0)
14272 {
14273 log_error ("ERROR: can't allocate enough device memory");
14274
14275 return -1;
14276 }
14277
14278 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14279 }
14280
14281 /**
14282 * some algorithms need a fixed kernel-loops count
14283 */
14284
14285 if (hash_mode == 1500)
14286 {
14287 const u32 kernel_loops_fixed = 1024;
14288
14289 device_param->kernel_loops_min = kernel_loops_fixed;
14290 device_param->kernel_loops_max = kernel_loops_fixed;
14291 }
14292
14293 if (hash_mode == 3000)
14294 {
14295 const u32 kernel_loops_fixed = 1024;
14296
14297 device_param->kernel_loops_min = kernel_loops_fixed;
14298 device_param->kernel_loops_max = kernel_loops_fixed;
14299 }
14300
14301 if (hash_mode == 8900)
14302 {
14303 const u32 kernel_loops_fixed = 1;
14304
14305 device_param->kernel_loops_min = kernel_loops_fixed;
14306 device_param->kernel_loops_max = kernel_loops_fixed;
14307 }
14308
14309 if (hash_mode == 9300)
14310 {
14311 const u32 kernel_loops_fixed = 1;
14312
14313 device_param->kernel_loops_min = kernel_loops_fixed;
14314 device_param->kernel_loops_max = kernel_loops_fixed;
14315 }
14316
14317 if (hash_mode == 12500)
14318 {
14319 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14320
14321 device_param->kernel_loops_min = kernel_loops_fixed;
14322 device_param->kernel_loops_max = kernel_loops_fixed;
14323 }
14324
14325 /**
14326 * some algorithms have a maximum kernel-loops count
14327 */
14328
14329 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14330 {
14331 u32 innerloop_cnt = 0;
14332
14333 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14334 {
14335 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14336 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14337 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14338 }
14339 else
14340 {
14341 innerloop_cnt = data.salts_buf[0].salt_iter;
14342 }
14343
14344 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14345 (innerloop_cnt <= device_param->kernel_loops_max))
14346 {
14347 device_param->kernel_loops_max = innerloop_cnt;
14348 }
14349 }
14350
14351 u32 kernel_accel_min = device_param->kernel_accel_min;
14352 u32 kernel_accel_max = device_param->kernel_accel_max;
14353
14354 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14355
14356 size_t size_pws = 4;
14357 size_t size_tmps = 4;
14358 size_t size_hooks = 4;
14359
14360 while (kernel_accel_max >= kernel_accel_min)
14361 {
14362 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14363
14364 // size_pws
14365
14366 size_pws = kernel_power_max * sizeof (pw_t);
14367
14368 // size_tmps
14369
14370 switch (hash_mode)
14371 {
14372 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14373 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14374 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14375 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14376 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14377 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14378 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14379 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14380 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14381 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14382 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14383 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14384 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14385 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14386 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14387 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14388 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14389 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14390 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14391 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14392 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14393 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14394 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14395 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14396 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14397 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14398 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14399 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14400 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14401 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14402 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14403 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14404 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14405 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14406 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14407 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14408 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14409 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14410 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14411 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14412 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14413 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14414 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14415 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14416 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14417 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14418 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14419 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14420 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14421 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14422 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14423 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14424 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14425 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14426 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14427 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14428 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14429 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14430 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14431 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14432 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14433 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14434 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14435 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14436 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14437 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14438 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14439 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14440 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14441 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14442 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14443 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14444 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14445 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14446 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14447 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14448 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14452 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14453 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14454 };
14455
14456 // size_hooks
14457
14458 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14459 {
14460 // none yet
14461 }
14462
14463 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14464 // if not, decrease amplifier and try again
14465
14466 int skip = 0;
14467
14468 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14469 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14470 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14471
14472 if (( bitmap_size
14473 + bitmap_size
14474 + bitmap_size
14475 + bitmap_size
14476 + bitmap_size
14477 + bitmap_size
14478 + bitmap_size
14479 + bitmap_size
14480 + size_bfs
14481 + size_combs
14482 + size_digests
14483 + size_esalts
14484 + size_hooks
14485 + size_markov_css
14486 + size_plains
14487 + size_pws
14488 + size_pws // not a bug
14489 + size_results
14490 + size_root_css
14491 + size_rules
14492 + size_rules_c
14493 + size_salts
14494 + size_scryptV
14495 + size_shown
14496 + size_tm
14497 + size_tmps) > device_param->device_global_mem) skip = 1;
14498
14499 if (skip == 1)
14500 {
14501 kernel_accel_max--;
14502
14503 continue;
14504 }
14505
14506 break;
14507 }
14508
14509 /*
14510 if (kernel_accel_max == 0)
14511 {
14512 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14513
14514 return -1;
14515 }
14516 */
14517
14518 device_param->kernel_accel_min = kernel_accel_min;
14519 device_param->kernel_accel_max = kernel_accel_max;
14520
14521 /*
14522 if (kernel_accel_max < kernel_accel)
14523 {
14524 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14525
14526 device_param->kernel_accel = kernel_accel_max;
14527 }
14528 */
14529
14530 device_param->size_bfs = size_bfs;
14531 device_param->size_combs = size_combs;
14532 device_param->size_rules = size_rules;
14533 device_param->size_rules_c = size_rules_c;
14534 device_param->size_pws = size_pws;
14535 device_param->size_tmps = size_tmps;
14536 device_param->size_hooks = size_hooks;
14537
14538 // do not confuse kernel_accel_max with kernel_accel here
14539
14540 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14541
14542 device_param->kernel_threads = kernel_threads;
14543 device_param->kernel_power_user = kernel_power;
14544
14545 kernel_power_all += kernel_power;
14546
14547 /**
14548 * default building options
14549 */
14550
14551 char build_opts[1024] = { 0 };
14552
14553 // we don't have sm_* on vendors not NV but it doesn't matter
14554
14555 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14556
14557 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14558 {
14559 // we do vectorizing much better than the auto-vectorizer
14560
14561 char build_opts_new[1024] = { 0 };
14562
14563 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14564
14565 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14566 }
14567
14568 #ifdef DEBUG
14569 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14570 #endif
14571
14572 /**
14573 * main kernel
14574 */
14575
14576 {
14577 /**
14578 * kernel source filename
14579 */
14580
14581 char source_file[256] = { 0 };
14582
14583 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14584
14585 struct stat sst;
14586
14587 if (stat (source_file, &sst) == -1)
14588 {
14589 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14590
14591 return -1;
14592 }
14593
14594 /**
14595 * kernel cached filename
14596 */
14597
14598 char cached_file[256] = { 0 };
14599
14600 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14601
14602 int cached = 1;
14603
14604 struct stat cst;
14605
14606 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14607 {
14608 cached = 0;
14609 }
14610
14611 /**
14612 * kernel compile or load
14613 */
14614
14615 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14616
14617 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14618
14619 if (force_jit_compilation == -1)
14620 {
14621 if (cached == 0)
14622 {
14623 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14624
14625 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14626
14627 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14628
14629 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14630
14631 #ifdef DEBUG
14632 size_t build_log_size = 0;
14633
14634 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14635
14636 if (build_log_size > 1)
14637 {
14638 char *build_log = (char *) malloc (build_log_size + 1);
14639
14640 memset (build_log, 0, build_log_size + 1);
14641
14642 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14643
14644 puts (build_log);
14645
14646 free (build_log);
14647 }
14648 #endif
14649
14650 if (rc != 0)
14651 {
14652 device_param->skipped = true;
14653
14654 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14655
14656 continue;
14657 }
14658
14659 size_t binary_size;
14660
14661 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14662
14663 u8 *binary = (u8 *) mymalloc (binary_size);
14664
14665 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14666
14667 writeProgramBin (cached_file, binary, binary_size);
14668
14669 local_free (binary);
14670 }
14671 else
14672 {
14673 #ifdef DEBUG
14674 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14675 #endif
14676
14677 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14678
14679 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14680
14681 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14682 }
14683 }
14684 else
14685 {
14686 #ifdef DEBUG
14687 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14688 #endif
14689
14690 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14691
14692 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14693
14694 char build_opts_update[1024] = { 0 };
14695
14696 if (force_jit_compilation == 1500)
14697 {
14698 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14699 }
14700 else if (force_jit_compilation == 8900)
14701 {
14702 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);
14703 }
14704 else
14705 {
14706 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14707 }
14708
14709 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14710
14711 #ifdef DEBUG
14712 size_t build_log_size = 0;
14713
14714 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14715
14716 if (build_log_size > 1)
14717 {
14718 char *build_log = (char *) malloc (build_log_size + 1);
14719
14720 memset (build_log, 0, build_log_size + 1);
14721
14722 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14723
14724 puts (build_log);
14725
14726 free (build_log);
14727 }
14728 #endif
14729
14730 if (rc != 0)
14731 {
14732 device_param->skipped = true;
14733
14734 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14735 }
14736 }
14737
14738 local_free (kernel_lengths);
14739 local_free (kernel_sources[0]);
14740 local_free (kernel_sources);
14741 }
14742
14743 /**
14744 * word generator kernel
14745 */
14746
14747 if (attack_mode != ATTACK_MODE_STRAIGHT)
14748 {
14749 /**
14750 * kernel mp source filename
14751 */
14752
14753 char source_file[256] = { 0 };
14754
14755 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14756
14757 struct stat sst;
14758
14759 if (stat (source_file, &sst) == -1)
14760 {
14761 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14762
14763 return -1;
14764 }
14765
14766 /**
14767 * kernel mp cached filename
14768 */
14769
14770 char cached_file[256] = { 0 };
14771
14772 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14773
14774 int cached = 1;
14775
14776 struct stat cst;
14777
14778 if (stat (cached_file, &cst) == -1)
14779 {
14780 cached = 0;
14781 }
14782
14783 /**
14784 * kernel compile or load
14785 */
14786
14787 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14788
14789 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14790
14791 if (cached == 0)
14792 {
14793 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14794 if (quiet == 0) log_info ("");
14795
14796 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14797
14798 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14799
14800 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14801
14802 if (rc != 0)
14803 {
14804 device_param->skipped = true;
14805
14806 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14807
14808 continue;
14809 }
14810
14811 size_t binary_size;
14812
14813 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14814
14815 u8 *binary = (u8 *) mymalloc (binary_size);
14816
14817 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14818
14819 writeProgramBin (cached_file, binary, binary_size);
14820
14821 local_free (binary);
14822 }
14823 else
14824 {
14825 #ifdef DEBUG
14826 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14827 #endif
14828
14829 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14830
14831 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14832
14833 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14834 }
14835
14836 local_free (kernel_lengths);
14837 local_free (kernel_sources[0]);
14838 local_free (kernel_sources);
14839 }
14840
14841 /**
14842 * amplifier kernel
14843 */
14844
14845 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14846 {
14847
14848 }
14849 else
14850 {
14851 /**
14852 * kernel amp source filename
14853 */
14854
14855 char source_file[256] = { 0 };
14856
14857 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14858
14859 struct stat sst;
14860
14861 if (stat (source_file, &sst) == -1)
14862 {
14863 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14864
14865 return -1;
14866 }
14867
14868 /**
14869 * kernel amp cached filename
14870 */
14871
14872 char cached_file[256] = { 0 };
14873
14874 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14875
14876 int cached = 1;
14877
14878 struct stat cst;
14879
14880 if (stat (cached_file, &cst) == -1)
14881 {
14882 cached = 0;
14883 }
14884
14885 /**
14886 * kernel compile or load
14887 */
14888
14889 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14890
14891 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14892
14893 if (cached == 0)
14894 {
14895 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14896 if (quiet == 0) log_info ("");
14897
14898 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14899
14900 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14901
14902 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14903
14904 if (rc != 0)
14905 {
14906 device_param->skipped = true;
14907
14908 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14909
14910 continue;
14911 }
14912
14913 size_t binary_size;
14914
14915 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14916
14917 u8 *binary = (u8 *) mymalloc (binary_size);
14918
14919 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14920
14921 writeProgramBin (cached_file, binary, binary_size);
14922
14923 local_free (binary);
14924 }
14925 else
14926 {
14927 #ifdef DEBUG
14928 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14929 #endif
14930
14931 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14932
14933 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14934
14935 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14936 }
14937
14938 local_free (kernel_lengths);
14939 local_free (kernel_sources[0]);
14940 local_free (kernel_sources);
14941 }
14942
14943 // some algorithm collide too fast, make that impossible
14944
14945 if (benchmark == 1)
14946 {
14947 ((uint *) digests_buf)[0] = -1;
14948 ((uint *) digests_buf)[1] = -1;
14949 ((uint *) digests_buf)[2] = -1;
14950 ((uint *) digests_buf)[3] = -1;
14951 }
14952
14953 /**
14954 * global buffers
14955 */
14956
14957 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14958 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14959 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14960 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14961 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14962 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14963 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14964 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14965 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14966 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14967 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14968 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14969 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14970 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14971 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14972 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14973 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14974 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14975
14976 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);
14977 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);
14978 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);
14979 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);
14980 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);
14981 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);
14982 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);
14983 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);
14984 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14985 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14986 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14987
14988 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14989 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14990 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14991 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14992 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14993 run_kernel_bzero (device_param, device_param->d_result, size_results);
14994
14995 /**
14996 * special buffers
14997 */
14998
14999 if (attack_kern == ATTACK_KERN_STRAIGHT)
15000 {
15001 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15002 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15003
15004 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15005
15006 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15007 }
15008 else if (attack_kern == ATTACK_KERN_COMBI)
15009 {
15010 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15011 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15012 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15013 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15014
15015 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15016 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15017 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15018 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15019 }
15020 else if (attack_kern == ATTACK_KERN_BF)
15021 {
15022 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15023 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15024 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15025 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15026 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15027
15028 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15029 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15030 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15031 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15032 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15033 }
15034
15035 if (size_esalts)
15036 {
15037 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15038
15039 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15040 }
15041
15042 /**
15043 * main host data
15044 */
15045
15046 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15047
15048 device_param->pws_buf = pws_buf;
15049
15050 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15051
15052 device_param->combs_buf = combs_buf;
15053
15054 void *hooks_buf = mymalloc (size_hooks);
15055
15056 device_param->hooks_buf = hooks_buf;
15057
15058 /**
15059 * kernel args
15060 */
15061
15062 device_param->kernel_params_buf32[21] = bitmap_mask;
15063 device_param->kernel_params_buf32[22] = bitmap_shift1;
15064 device_param->kernel_params_buf32[23] = bitmap_shift2;
15065 device_param->kernel_params_buf32[24] = 0; // salt_pos
15066 device_param->kernel_params_buf32[25] = 0; // loop_pos
15067 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15068 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15069 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15070 device_param->kernel_params_buf32[29] = 0; // digests_offset
15071 device_param->kernel_params_buf32[30] = 0; // combs_mode
15072 device_param->kernel_params_buf32[31] = 0; // gid_max
15073
15074 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15075 ? &device_param->d_pws_buf
15076 : &device_param->d_pws_amp_buf;
15077 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15078 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15079 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15080 device_param->kernel_params[ 4] = &device_param->d_tmps;
15081 device_param->kernel_params[ 5] = &device_param->d_hooks;
15082 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15083 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15084 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15085 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15086 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15087 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15088 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15089 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15090 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15091 device_param->kernel_params[15] = &device_param->d_digests_buf;
15092 device_param->kernel_params[16] = &device_param->d_digests_shown;
15093 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15094 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15095 device_param->kernel_params[19] = &device_param->d_result;
15096 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15097 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15098 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15099 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15100 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15101 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15102 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15103 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15104 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15105 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15106 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15107 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15108
15109 device_param->kernel_params_mp_buf64[3] = 0;
15110 device_param->kernel_params_mp_buf32[4] = 0;
15111 device_param->kernel_params_mp_buf32[5] = 0;
15112 device_param->kernel_params_mp_buf32[6] = 0;
15113 device_param->kernel_params_mp_buf32[7] = 0;
15114 device_param->kernel_params_mp_buf32[8] = 0;
15115
15116 device_param->kernel_params_mp[0] = NULL;
15117 device_param->kernel_params_mp[1] = NULL;
15118 device_param->kernel_params_mp[2] = NULL;
15119 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15120 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15121 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15122 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15123 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15124 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15125
15126 device_param->kernel_params_mp_l_buf64[3] = 0;
15127 device_param->kernel_params_mp_l_buf32[4] = 0;
15128 device_param->kernel_params_mp_l_buf32[5] = 0;
15129 device_param->kernel_params_mp_l_buf32[6] = 0;
15130 device_param->kernel_params_mp_l_buf32[7] = 0;
15131 device_param->kernel_params_mp_l_buf32[8] = 0;
15132 device_param->kernel_params_mp_l_buf32[9] = 0;
15133
15134 device_param->kernel_params_mp_l[0] = NULL;
15135 device_param->kernel_params_mp_l[1] = NULL;
15136 device_param->kernel_params_mp_l[2] = NULL;
15137 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15138 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15139 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15140 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15141 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15142 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15143 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15144
15145 device_param->kernel_params_mp_r_buf64[3] = 0;
15146 device_param->kernel_params_mp_r_buf32[4] = 0;
15147 device_param->kernel_params_mp_r_buf32[5] = 0;
15148 device_param->kernel_params_mp_r_buf32[6] = 0;
15149 device_param->kernel_params_mp_r_buf32[7] = 0;
15150 device_param->kernel_params_mp_r_buf32[8] = 0;
15151
15152 device_param->kernel_params_mp_r[0] = NULL;
15153 device_param->kernel_params_mp_r[1] = NULL;
15154 device_param->kernel_params_mp_r[2] = NULL;
15155 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15156 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15157 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15158 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15159 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15160 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15161
15162 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15163 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15164
15165 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15166 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15167 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15168 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15169 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15170 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15171 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15172
15173 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15174 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15175
15176 /**
15177 * kernel name
15178 */
15179
15180 size_t kernel_wgs_tmp;
15181
15182 char kernel_name[64] = { 0 };
15183
15184 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15185 {
15186 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15187 {
15188 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15189
15190 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15191
15192 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15193
15194 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15195
15196 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15197
15198 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15199 }
15200 else
15201 {
15202 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15203
15204 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15205
15206 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15207
15208 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15209
15210 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15211
15212 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15213 }
15214
15215 if (data.attack_mode == ATTACK_MODE_BF)
15216 {
15217 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15218 {
15219 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15220
15221 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15222
15223 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);
15224 }
15225 }
15226 }
15227 else
15228 {
15229 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15230
15231 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15232
15233 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15234
15235 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15236
15237 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15238
15239 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15240
15241 if (opts_type & OPTS_TYPE_HOOK12)
15242 {
15243 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15244
15245 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15246
15247 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);
15248 }
15249
15250 if (opts_type & OPTS_TYPE_HOOK23)
15251 {
15252 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15253
15254 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15255
15256 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);
15257 }
15258 }
15259
15260 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);
15261 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);
15262 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);
15263
15264 for (uint i = 0; i <= 20; i++)
15265 {
15266 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15267 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15268 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15269
15270 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15271 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15272 }
15273
15274 for (uint i = 21; i <= 31; i++)
15275 {
15276 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15277 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15278 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15279
15280 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15281 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15282 }
15283
15284 if (attack_mode == ATTACK_MODE_BF)
15285 {
15286 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15287 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15288
15289 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);
15290 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);
15291
15292 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15293 {
15294 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15295 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15296 }
15297 }
15298 else if (attack_mode == ATTACK_MODE_HYBRID1)
15299 {
15300 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15301
15302 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);
15303 }
15304 else if (attack_mode == ATTACK_MODE_HYBRID2)
15305 {
15306 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15307
15308 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);
15309 }
15310
15311 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15312 {
15313 // nothing to do
15314 }
15315 else
15316 {
15317 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15318
15319 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);
15320 }
15321
15322 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15323 {
15324 // nothing to do
15325 }
15326 else
15327 {
15328 for (uint i = 0; i < 5; i++)
15329 {
15330 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15331 }
15332
15333 for (uint i = 5; i < 7; i++)
15334 {
15335 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15336 }
15337 }
15338
15339 // maybe this has been updated by clGetKernelWorkGroupInfo()
15340 // value can only be decreased, so we don't need to reallocate buffers
15341
15342 device_param->kernel_threads = kernel_threads;
15343
15344 /**
15345 * Store initial fanspeed if gpu_temp_retain is enabled
15346 */
15347
15348 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15349 int gpu_temp_retain_set = 0;
15350
15351 if (gpu_temp_disable == 0)
15352 {
15353 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15354 {
15355 hc_thread_mutex_lock (mux_adl);
15356
15357 if (data.hm_device[device_id].fan_supported == 1)
15358 {
15359 if (gpu_temp_retain_chgd == 0)
15360 {
15361 uint cur_temp = 0;
15362 uint default_temp = 0;
15363
15364 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);
15365
15366 if (ADL_rc == ADL_OK)
15367 {
15368 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15369
15370 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15371
15372 // special case with multi gpu setups: always use minimum retain
15373
15374 if (gpu_temp_retain_set == 0)
15375 {
15376 gpu_temp_retain = gpu_temp_retain_target;
15377 gpu_temp_retain_set = 1;
15378 }
15379 else
15380 {
15381 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15382 }
15383
15384 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15385 }
15386 }
15387
15388 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15389
15390 temp_retain_fanspeed_value[device_id] = fan_speed;
15391
15392 if (fan_speed == -1)
15393 {
15394 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15395
15396 temp_retain_fanspeed_value[device_id] = 0;
15397 }
15398 }
15399
15400 hc_thread_mutex_unlock (mux_adl);
15401 }
15402 }
15403
15404 /**
15405 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15406 */
15407
15408 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15409 {
15410 hc_thread_mutex_lock (mux_adl);
15411
15412 if (data.hm_device[device_id].od_version == 6)
15413 {
15414 int ADL_rc;
15415
15416 // check powertune capabilities first, if not available then skip device
15417
15418 int powertune_supported = 0;
15419
15420 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15421 {
15422 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15423
15424 return (-1);
15425 }
15426
15427 if (powertune_supported != 0)
15428 {
15429 // powercontrol settings
15430
15431 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15432
15433 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15434 {
15435 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15436 }
15437
15438 if (ADL_rc != ADL_OK)
15439 {
15440 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15441
15442 return (-1);
15443 }
15444
15445 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15446 {
15447 log_error ("ERROR: Failed to set new ADL PowerControl values");
15448
15449 return (-1);
15450 }
15451
15452 // clocks
15453
15454 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15455
15456 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15457
15458 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)
15459 {
15460 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15461
15462 return (-1);
15463 }
15464
15465 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15466
15467 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15468
15469 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15470 {
15471 log_error ("ERROR: Failed to get ADL device capabilities");
15472
15473 return (-1);
15474 }
15475
15476 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15477 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15478
15479 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15480 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15481
15482 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15483 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15484
15485 // warning if profile has too low max values
15486
15487 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15488 {
15489 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15490 }
15491
15492 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15493 {
15494 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15495 }
15496
15497 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15498
15499 performance_state->iNumberOfPerformanceLevels = 2;
15500
15501 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15502 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15503 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15504 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15505
15506 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)
15507 {
15508 log_info ("ERROR: Failed to set ADL performance state");
15509
15510 return (-1);
15511 }
15512
15513 local_free (performance_state);
15514 }
15515 }
15516
15517 hc_thread_mutex_unlock (mux_adl);
15518 }
15519 #endif // HAVE_HWMON && HAVE_ADL
15520 }
15521
15522 data.kernel_power_all = kernel_power_all;
15523
15524 if (data.quiet == 0) log_info_nn ("");
15525
15526 /**
15527 * In benchmark-mode, inform user which algorithm is checked
15528 */
15529
15530 if (benchmark == 1)
15531 {
15532 if (status_automat == 0)
15533 {
15534 quiet = 0;
15535
15536 data.quiet = quiet;
15537
15538 char *hash_type = strhashtype (data.hash_mode); // not a bug
15539
15540 log_info ("Hashtype: %s", hash_type);
15541 log_info ("");
15542 }
15543 }
15544
15545 /**
15546 * keep track of the progress
15547 */
15548
15549 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15550 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15551 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15552
15553 /**
15554 * open filehandles
15555 */
15556
15557 #if _WIN
15558 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15559 {
15560 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15561
15562 return (-1);
15563 }
15564
15565 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15566 {
15567 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15568
15569 return (-1);
15570 }
15571
15572 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15573 {
15574 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15575
15576 return (-1);
15577 }
15578 #endif
15579
15580 /**
15581 * dictionary pad
15582 */
15583
15584 segment_size *= (1024 * 1024);
15585
15586 data.segment_size = segment_size;
15587
15588 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15589
15590 wl_data->buf = (char *) mymalloc (segment_size);
15591 wl_data->avail = segment_size;
15592 wl_data->incr = segment_size;
15593 wl_data->cnt = 0;
15594 wl_data->pos = 0;
15595
15596 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15597
15598 data.wordlist_mode = wordlist_mode;
15599
15600 cs_t *css_buf = NULL;
15601 uint css_cnt = 0;
15602 uint dictcnt = 0;
15603 uint maskcnt = 1;
15604 char **masks = NULL;
15605 char **dictfiles = NULL;
15606
15607 uint mask_from_file = 0;
15608
15609 if (attack_mode == ATTACK_MODE_STRAIGHT)
15610 {
15611 if (wordlist_mode == WL_MODE_FILE)
15612 {
15613 int wls_left = myargc - (optind + 1);
15614
15615 for (int i = 0; i < wls_left; i++)
15616 {
15617 char *l0_filename = myargv[optind + 1 + i];
15618
15619 struct stat l0_stat;
15620
15621 if (stat (l0_filename, &l0_stat) == -1)
15622 {
15623 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15624
15625 return (-1);
15626 }
15627
15628 uint is_dir = S_ISDIR (l0_stat.st_mode);
15629
15630 if (is_dir == 0)
15631 {
15632 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15633
15634 dictcnt++;
15635
15636 dictfiles[dictcnt - 1] = l0_filename;
15637 }
15638 else
15639 {
15640 // do not allow --keyspace w/ a directory
15641
15642 if (keyspace == 1)
15643 {
15644 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15645
15646 return (-1);
15647 }
15648
15649 char **dictionary_files = NULL;
15650
15651 dictionary_files = scan_directory (l0_filename);
15652
15653 if (dictionary_files != NULL)
15654 {
15655 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15656
15657 for (int d = 0; dictionary_files[d] != NULL; d++)
15658 {
15659 char *l1_filename = dictionary_files[d];
15660
15661 struct stat l1_stat;
15662
15663 if (stat (l1_filename, &l1_stat) == -1)
15664 {
15665 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15666
15667 return (-1);
15668 }
15669
15670 if (S_ISREG (l1_stat.st_mode))
15671 {
15672 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15673
15674 dictcnt++;
15675
15676 dictfiles[dictcnt - 1] = strdup (l1_filename);
15677 }
15678 }
15679 }
15680
15681 local_free (dictionary_files);
15682 }
15683 }
15684
15685 if (dictcnt < 1)
15686 {
15687 log_error ("ERROR: No usable dictionary file found.");
15688
15689 return (-1);
15690 }
15691 }
15692 else if (wordlist_mode == WL_MODE_STDIN)
15693 {
15694 dictcnt = 1;
15695 }
15696 }
15697 else if (attack_mode == ATTACK_MODE_COMBI)
15698 {
15699 // display
15700
15701 char *dictfile1 = myargv[optind + 1 + 0];
15702 char *dictfile2 = myargv[optind + 1 + 1];
15703
15704 // find the bigger dictionary and use as base
15705
15706 FILE *fp1 = NULL;
15707 FILE *fp2 = NULL;
15708
15709 struct stat tmp_stat;
15710
15711 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15712 {
15713 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15714
15715 return (-1);
15716 }
15717
15718 if (stat (dictfile1, &tmp_stat) == -1)
15719 {
15720 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15721
15722 fclose (fp1);
15723
15724 return (-1);
15725 }
15726
15727 if (S_ISDIR (tmp_stat.st_mode))
15728 {
15729 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15730
15731 fclose (fp1);
15732
15733 return (-1);
15734 }
15735
15736 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15737 {
15738 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15739
15740 fclose (fp1);
15741
15742 return (-1);
15743 }
15744
15745 if (stat (dictfile2, &tmp_stat) == -1)
15746 {
15747 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15748
15749 fclose (fp1);
15750 fclose (fp2);
15751
15752 return (-1);
15753 }
15754
15755 if (S_ISDIR (tmp_stat.st_mode))
15756 {
15757 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15758
15759 fclose (fp1);
15760 fclose (fp2);
15761
15762 return (-1);
15763 }
15764
15765 data.combs_cnt = 1;
15766
15767 data.quiet = 1;
15768
15769 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15770
15771 data.quiet = quiet;
15772
15773 if (words1_cnt == 0)
15774 {
15775 log_error ("ERROR: %s: empty file", dictfile1);
15776
15777 fclose (fp1);
15778 fclose (fp2);
15779
15780 return (-1);
15781 }
15782
15783 data.combs_cnt = 1;
15784
15785 data.quiet = 1;
15786
15787 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15788
15789 data.quiet = quiet;
15790
15791 if (words2_cnt == 0)
15792 {
15793 log_error ("ERROR: %s: empty file", dictfile2);
15794
15795 fclose (fp1);
15796 fclose (fp2);
15797
15798 return (-1);
15799 }
15800
15801 fclose (fp1);
15802 fclose (fp2);
15803
15804 data.dictfile = dictfile1;
15805 data.dictfile2 = dictfile2;
15806
15807 if (words1_cnt >= words2_cnt)
15808 {
15809 data.combs_cnt = words2_cnt;
15810 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15811
15812 dictfiles = &data.dictfile;
15813
15814 dictcnt = 1;
15815 }
15816 else
15817 {
15818 data.combs_cnt = words1_cnt;
15819 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15820
15821 dictfiles = &data.dictfile2;
15822
15823 dictcnt = 1;
15824
15825 // we also have to switch wordlist related rules!
15826
15827 char *tmpc = data.rule_buf_l;
15828
15829 data.rule_buf_l = data.rule_buf_r;
15830 data.rule_buf_r = tmpc;
15831
15832 int tmpi = data.rule_len_l;
15833
15834 data.rule_len_l = data.rule_len_r;
15835 data.rule_len_r = tmpi;
15836 }
15837 }
15838 else if (attack_mode == ATTACK_MODE_BF)
15839 {
15840 char *mask = NULL;
15841
15842 maskcnt = 0;
15843
15844 if (benchmark == 0)
15845 {
15846 mask = myargv[optind + 1];
15847
15848 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15849
15850 if ((optind + 2) <= myargc)
15851 {
15852 struct stat file_stat;
15853
15854 if (stat (mask, &file_stat) == -1)
15855 {
15856 maskcnt = 1;
15857
15858 masks[maskcnt - 1] = mystrdup (mask);
15859 }
15860 else
15861 {
15862 int wls_left = myargc - (optind + 1);
15863
15864 uint masks_avail = INCR_MASKS;
15865
15866 for (int i = 0; i < wls_left; i++)
15867 {
15868 if (i != 0)
15869 {
15870 mask = myargv[optind + 1 + i];
15871
15872 if (stat (mask, &file_stat) == -1)
15873 {
15874 log_error ("ERROR: %s: %s", mask, strerror (errno));
15875
15876 return (-1);
15877 }
15878 }
15879
15880 uint is_file = S_ISREG (file_stat.st_mode);
15881
15882 if (is_file == 1)
15883 {
15884 FILE *mask_fp;
15885
15886 if ((mask_fp = fopen (mask, "r")) == NULL)
15887 {
15888 log_error ("ERROR: %s: %s", mask, strerror (errno));
15889
15890 return (-1);
15891 }
15892
15893 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15894
15895 while (!feof (mask_fp))
15896 {
15897 memset (line_buf, 0, HCBUFSIZ);
15898
15899 int line_len = fgetl (mask_fp, line_buf);
15900
15901 if (line_len == 0) continue;
15902
15903 if (line_buf[0] == '#') continue;
15904
15905 if (masks_avail == maskcnt)
15906 {
15907 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15908
15909 masks_avail += INCR_MASKS;
15910 }
15911
15912 masks[maskcnt] = mystrdup (line_buf);
15913
15914 maskcnt++;
15915 }
15916
15917 myfree (line_buf);
15918
15919 fclose (mask_fp);
15920 }
15921 else
15922 {
15923 log_error ("ERROR: %s: unsupported file-type", mask);
15924
15925 return (-1);
15926 }
15927 }
15928
15929 mask_from_file = 1;
15930 }
15931 }
15932 else
15933 {
15934 custom_charset_1 = (char *) "?l?d?u";
15935 custom_charset_2 = (char *) "?l?d";
15936 custom_charset_3 = (char *) "?l?d*!$@_";
15937
15938 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15939 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15940 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15941
15942 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15943
15944 wordlist_mode = WL_MODE_MASK;
15945
15946 data.wordlist_mode = wordlist_mode;
15947
15948 increment = 1;
15949
15950 maskcnt = 1;
15951 }
15952 }
15953 else
15954 {
15955 /**
15956 * generate full masks and charsets
15957 */
15958
15959 masks = (char **) mymalloc (sizeof (char *));
15960
15961 switch (hash_mode)
15962 {
15963 case 1731: pw_min = 5;
15964 pw_max = 5;
15965 mask = mystrdup ("?b?b?b?b?b");
15966 break;
15967 case 12500: pw_min = 5;
15968 pw_max = 5;
15969 mask = mystrdup ("?b?b?b?b?b");
15970 break;
15971 default: pw_min = 7;
15972 pw_max = 7;
15973 mask = mystrdup ("?b?b?b?b?b?b?b");
15974 break;
15975 }
15976
15977 maskcnt = 1;
15978
15979 masks[maskcnt - 1] = mystrdup (mask);
15980
15981 wordlist_mode = WL_MODE_MASK;
15982
15983 data.wordlist_mode = wordlist_mode;
15984
15985 increment = 1;
15986 }
15987
15988 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15989
15990 if (increment)
15991 {
15992 if (increment_min > pw_min) pw_min = increment_min;
15993
15994 if (increment_max < pw_max) pw_max = increment_max;
15995 }
15996 }
15997 else if (attack_mode == ATTACK_MODE_HYBRID1)
15998 {
15999 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16000
16001 // display
16002
16003 char *mask = myargv[myargc - 1];
16004
16005 maskcnt = 0;
16006
16007 masks = (char **) mymalloc (1 * sizeof (char *));
16008
16009 // mod
16010
16011 struct stat file_stat;
16012
16013 if (stat (mask, &file_stat) == -1)
16014 {
16015 maskcnt = 1;
16016
16017 masks[maskcnt - 1] = mystrdup (mask);
16018 }
16019 else
16020 {
16021 uint is_file = S_ISREG (file_stat.st_mode);
16022
16023 if (is_file == 1)
16024 {
16025 FILE *mask_fp;
16026
16027 if ((mask_fp = fopen (mask, "r")) == NULL)
16028 {
16029 log_error ("ERROR: %s: %s", mask, strerror (errno));
16030
16031 return (-1);
16032 }
16033
16034 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16035
16036 uint masks_avail = 1;
16037
16038 while (!feof (mask_fp))
16039 {
16040 memset (line_buf, 0, HCBUFSIZ);
16041
16042 int line_len = fgetl (mask_fp, line_buf);
16043
16044 if (line_len == 0) continue;
16045
16046 if (line_buf[0] == '#') continue;
16047
16048 if (masks_avail == maskcnt)
16049 {
16050 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16051
16052 masks_avail += INCR_MASKS;
16053 }
16054
16055 masks[maskcnt] = mystrdup (line_buf);
16056
16057 maskcnt++;
16058 }
16059
16060 myfree (line_buf);
16061
16062 fclose (mask_fp);
16063
16064 mask_from_file = 1;
16065 }
16066 else
16067 {
16068 maskcnt = 1;
16069
16070 masks[maskcnt - 1] = mystrdup (mask);
16071 }
16072 }
16073
16074 // base
16075
16076 int wls_left = myargc - (optind + 2);
16077
16078 for (int i = 0; i < wls_left; i++)
16079 {
16080 char *filename = myargv[optind + 1 + i];
16081
16082 struct stat file_stat;
16083
16084 if (stat (filename, &file_stat) == -1)
16085 {
16086 log_error ("ERROR: %s: %s", filename, strerror (errno));
16087
16088 return (-1);
16089 }
16090
16091 uint is_dir = S_ISDIR (file_stat.st_mode);
16092
16093 if (is_dir == 0)
16094 {
16095 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16096
16097 dictcnt++;
16098
16099 dictfiles[dictcnt - 1] = filename;
16100 }
16101 else
16102 {
16103 // do not allow --keyspace w/ a directory
16104
16105 if (keyspace == 1)
16106 {
16107 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16108
16109 return (-1);
16110 }
16111
16112 char **dictionary_files = NULL;
16113
16114 dictionary_files = scan_directory (filename);
16115
16116 if (dictionary_files != NULL)
16117 {
16118 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16119
16120 for (int d = 0; dictionary_files[d] != NULL; d++)
16121 {
16122 char *l1_filename = dictionary_files[d];
16123
16124 struct stat l1_stat;
16125
16126 if (stat (l1_filename, &l1_stat) == -1)
16127 {
16128 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16129
16130 return (-1);
16131 }
16132
16133 if (S_ISREG (l1_stat.st_mode))
16134 {
16135 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16136
16137 dictcnt++;
16138
16139 dictfiles[dictcnt - 1] = strdup (l1_filename);
16140 }
16141 }
16142 }
16143
16144 local_free (dictionary_files);
16145 }
16146 }
16147
16148 if (dictcnt < 1)
16149 {
16150 log_error ("ERROR: No usable dictionary file found.");
16151
16152 return (-1);
16153 }
16154
16155 if (increment)
16156 {
16157 maskcnt = 0;
16158
16159 uint mask_min = increment_min; // we can't reject smaller masks here
16160 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16161
16162 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16163 {
16164 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16165
16166 if (cur_mask == NULL) break;
16167
16168 masks[maskcnt] = cur_mask;
16169
16170 maskcnt++;
16171
16172 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16173 }
16174 }
16175 }
16176 else if (attack_mode == ATTACK_MODE_HYBRID2)
16177 {
16178 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16179
16180 // display
16181
16182 char *mask = myargv[optind + 1 + 0];
16183
16184 maskcnt = 0;
16185
16186 masks = (char **) mymalloc (1 * sizeof (char *));
16187
16188 // mod
16189
16190 struct stat file_stat;
16191
16192 if (stat (mask, &file_stat) == -1)
16193 {
16194 maskcnt = 1;
16195
16196 masks[maskcnt - 1] = mystrdup (mask);
16197 }
16198 else
16199 {
16200 uint is_file = S_ISREG (file_stat.st_mode);
16201
16202 if (is_file == 1)
16203 {
16204 FILE *mask_fp;
16205
16206 if ((mask_fp = fopen (mask, "r")) == NULL)
16207 {
16208 log_error ("ERROR: %s: %s", mask, strerror (errno));
16209
16210 return (-1);
16211 }
16212
16213 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16214
16215 uint masks_avail = 1;
16216
16217 while (!feof (mask_fp))
16218 {
16219 memset (line_buf, 0, HCBUFSIZ);
16220
16221 int line_len = fgetl (mask_fp, line_buf);
16222
16223 if (line_len == 0) continue;
16224
16225 if (line_buf[0] == '#') continue;
16226
16227 if (masks_avail == maskcnt)
16228 {
16229 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16230
16231 masks_avail += INCR_MASKS;
16232 }
16233
16234 masks[maskcnt] = mystrdup (line_buf);
16235
16236 maskcnt++;
16237 }
16238
16239 myfree (line_buf);
16240
16241 fclose (mask_fp);
16242
16243 mask_from_file = 1;
16244 }
16245 else
16246 {
16247 maskcnt = 1;
16248
16249 masks[maskcnt - 1] = mystrdup (mask);
16250 }
16251 }
16252
16253 // base
16254
16255 int wls_left = myargc - (optind + 2);
16256
16257 for (int i = 0; i < wls_left; i++)
16258 {
16259 char *filename = myargv[optind + 2 + i];
16260
16261 struct stat file_stat;
16262
16263 if (stat (filename, &file_stat) == -1)
16264 {
16265 log_error ("ERROR: %s: %s", filename, strerror (errno));
16266
16267 return (-1);
16268 }
16269
16270 uint is_dir = S_ISDIR (file_stat.st_mode);
16271
16272 if (is_dir == 0)
16273 {
16274 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16275
16276 dictcnt++;
16277
16278 dictfiles[dictcnt - 1] = filename;
16279 }
16280 else
16281 {
16282 // do not allow --keyspace w/ a directory
16283
16284 if (keyspace == 1)
16285 {
16286 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16287
16288 return (-1);
16289 }
16290
16291 char **dictionary_files = NULL;
16292
16293 dictionary_files = scan_directory (filename);
16294
16295 if (dictionary_files != NULL)
16296 {
16297 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16298
16299 for (int d = 0; dictionary_files[d] != NULL; d++)
16300 {
16301 char *l1_filename = dictionary_files[d];
16302
16303 struct stat l1_stat;
16304
16305 if (stat (l1_filename, &l1_stat) == -1)
16306 {
16307 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16308
16309 return (-1);
16310 }
16311
16312 if (S_ISREG (l1_stat.st_mode))
16313 {
16314 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16315
16316 dictcnt++;
16317
16318 dictfiles[dictcnt - 1] = strdup (l1_filename);
16319 }
16320 }
16321 }
16322
16323 local_free (dictionary_files);
16324 }
16325 }
16326
16327 if (dictcnt < 1)
16328 {
16329 log_error ("ERROR: No usable dictionary file found.");
16330
16331 return (-1);
16332 }
16333
16334 if (increment)
16335 {
16336 maskcnt = 0;
16337
16338 uint mask_min = increment_min; // we can't reject smaller masks here
16339 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16340
16341 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16342 {
16343 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16344
16345 if (cur_mask == NULL) break;
16346
16347 masks[maskcnt] = cur_mask;
16348
16349 maskcnt++;
16350
16351 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16352 }
16353 }
16354 }
16355
16356 data.pw_min = pw_min;
16357 data.pw_max = pw_max;
16358
16359 /**
16360 * weak hash check
16361 */
16362
16363 if (weak_hash_threshold >= salts_cnt)
16364 {
16365 hc_device_param_t *device_param = NULL;
16366
16367 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16368 {
16369 device_param = &data.devices_param[device_id];
16370
16371 if (device_param->skipped) continue;
16372
16373 break;
16374 }
16375
16376 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16377
16378 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16379 {
16380 weak_hash_check (device_param, salt_pos);
16381 }
16382
16383 // Display hack, guarantee that there is at least one \r before real start
16384
16385 //if (data.quiet == 0) log_info ("");
16386 }
16387
16388 /**
16389 * status and monitor threads
16390 */
16391
16392 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16393
16394 hc_thread_t i_thread = 0;
16395
16396 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16397 {
16398 hc_thread_create (i_thread, thread_keypress, &benchmark);
16399 }
16400
16401 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16402
16403 uint ni_threads_cnt = 0;
16404
16405 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16406
16407 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16408
16409 ni_threads_cnt++;
16410
16411 /**
16412 * Outfile remove
16413 */
16414
16415 if (keyspace == 0)
16416 {
16417 if (outfile_check_timer != 0)
16418 {
16419 if (data.outfile_check_directory != NULL)
16420 {
16421 if ((hash_mode != 5200) &&
16422 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16423 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16424 (hash_mode != 9000))
16425 {
16426 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16427
16428 ni_threads_cnt++;
16429 }
16430 else
16431 {
16432 outfile_check_timer = 0;
16433 }
16434 }
16435 else
16436 {
16437 outfile_check_timer = 0;
16438 }
16439 }
16440 }
16441
16442 /**
16443 * Inform the user if we got some hashes remove because of the pot file remove feature
16444 */
16445
16446 if (data.quiet == 0)
16447 {
16448 if (potfile_remove_cracks > 0)
16449 {
16450 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16451 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16452 }
16453 }
16454
16455 data.outfile_check_timer = outfile_check_timer;
16456
16457 /**
16458 * main loop
16459 */
16460
16461 char **induction_dictionaries = NULL;
16462
16463 int induction_dictionaries_cnt = 0;
16464
16465 hcstat_table_t *root_table_buf = NULL;
16466 hcstat_table_t *markov_table_buf = NULL;
16467
16468 uint initial_restore_done = 0;
16469
16470 data.maskcnt = maskcnt;
16471
16472 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16473 {
16474 if (data.devices_status == STATUS_CRACKED) break;
16475
16476 data.devices_status = STATUS_INIT;
16477
16478 if (maskpos > rd->maskpos)
16479 {
16480 rd->dictpos = 0;
16481 }
16482
16483 rd->maskpos = maskpos;
16484 data.maskpos = maskpos;
16485
16486 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16487 {
16488 char *mask = masks[maskpos];
16489
16490 if (mask_from_file == 1)
16491 {
16492 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16493
16494 char *str_ptr;
16495 uint str_pos;
16496
16497 uint mask_offset = 0;
16498
16499 uint separator_cnt;
16500
16501 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16502 {
16503 str_ptr = strstr (mask + mask_offset, ",");
16504
16505 if (str_ptr == NULL) break;
16506
16507 str_pos = str_ptr - mask;
16508
16509 // escaped separator, i.e. "\,"
16510
16511 if (str_pos > 0)
16512 {
16513 if (mask[str_pos - 1] == '\\')
16514 {
16515 separator_cnt --;
16516
16517 mask_offset = str_pos + 1;
16518
16519 continue;
16520 }
16521 }
16522
16523 // reset the offset
16524
16525 mask_offset = 0;
16526
16527 mask[str_pos] = '\0';
16528
16529 switch (separator_cnt)
16530 {
16531 case 0:
16532 mp_reset_usr (mp_usr, 0);
16533
16534 custom_charset_1 = mask;
16535 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16536 break;
16537
16538 case 1:
16539 mp_reset_usr (mp_usr, 1);
16540
16541 custom_charset_2 = mask;
16542 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16543 break;
16544
16545 case 2:
16546 mp_reset_usr (mp_usr, 2);
16547
16548 custom_charset_3 = mask;
16549 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16550 break;
16551
16552 case 3:
16553 mp_reset_usr (mp_usr, 3);
16554
16555 custom_charset_4 = mask;
16556 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16557 break;
16558 }
16559
16560 mask = mask + str_pos + 1;
16561 }
16562 }
16563
16564 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16565 {
16566 if (maskpos > 0)
16567 {
16568 local_free (css_buf);
16569 local_free (data.root_css_buf);
16570 local_free (data.markov_css_buf);
16571
16572 local_free (masks[maskpos - 1]);
16573 }
16574
16575 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16576
16577 data.mask = mask;
16578 data.css_cnt = css_cnt;
16579 data.css_buf = css_buf;
16580
16581 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16582
16583 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16584
16585 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16586 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16587
16588 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16589
16590 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16591
16592 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16593 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16594
16595 data.root_css_buf = root_css_buf;
16596 data.markov_css_buf = markov_css_buf;
16597
16598 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16599
16600 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16601
16602 local_free (root_table_buf);
16603 local_free (markov_table_buf);
16604
16605 // args
16606
16607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16608 {
16609 hc_device_param_t *device_param = &data.devices_param[device_id];
16610
16611 if (device_param->skipped) continue;
16612
16613 device_param->kernel_params_mp[0] = &device_param->d_combs;
16614 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16615 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16616
16617 device_param->kernel_params_mp_buf64[3] = 0;
16618 device_param->kernel_params_mp_buf32[4] = css_cnt;
16619 device_param->kernel_params_mp_buf32[5] = 0;
16620 device_param->kernel_params_mp_buf32[6] = 0;
16621 device_param->kernel_params_mp_buf32[7] = 0;
16622
16623 if (attack_mode == ATTACK_MODE_HYBRID1)
16624 {
16625 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16626 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16627 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16628 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16629 }
16630 else if (attack_mode == ATTACK_MODE_HYBRID2)
16631 {
16632 device_param->kernel_params_mp_buf32[5] = 0;
16633 device_param->kernel_params_mp_buf32[6] = 0;
16634 device_param->kernel_params_mp_buf32[7] = 0;
16635 }
16636
16637 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]);
16638 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]);
16639 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]);
16640
16641 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);
16642 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);
16643 }
16644 }
16645 else if (attack_mode == ATTACK_MODE_BF)
16646 {
16647 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16648
16649 if (increment)
16650 {
16651 for (uint i = 0; i < dictcnt; i++)
16652 {
16653 local_free (dictfiles[i]);
16654 }
16655
16656 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16657 {
16658 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16659
16660 if (l1_filename == NULL) break;
16661
16662 dictcnt++;
16663
16664 dictfiles[dictcnt - 1] = l1_filename;
16665 }
16666 }
16667 else
16668 {
16669 dictcnt++;
16670
16671 dictfiles[dictcnt - 1] = mask;
16672 }
16673
16674 if (dictcnt == 0)
16675 {
16676 log_error ("ERROR: Mask is too small");
16677
16678 return (-1);
16679 }
16680 }
16681 }
16682
16683 free (induction_dictionaries);
16684
16685 // induction_dictionaries_cnt = 0; // implied
16686
16687 if (attack_mode != ATTACK_MODE_BF)
16688 {
16689 if (keyspace == 0)
16690 {
16691 induction_dictionaries = scan_directory (induction_directory);
16692
16693 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16694 }
16695 }
16696
16697 if (induction_dictionaries_cnt)
16698 {
16699 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16700 }
16701
16702 /**
16703 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16704 */
16705 if (keyspace == 1)
16706 {
16707 if ((maskcnt > 1) || (dictcnt > 1))
16708 {
16709 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16710
16711 return (-1);
16712 }
16713 }
16714
16715 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16716 {
16717 char *subid = logfile_generate_subid ();
16718
16719 data.subid = subid;
16720
16721 logfile_sub_msg ("START");
16722
16723 data.devices_status = STATUS_INIT;
16724
16725 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16726 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16727 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16728
16729 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16730
16731 data.cpt_pos = 0;
16732
16733 data.cpt_start = time (NULL);
16734
16735 data.cpt_total = 0;
16736
16737 if (data.restore == 0)
16738 {
16739 rd->words_cur = skip;
16740
16741 skip = 0;
16742
16743 data.skip = 0;
16744 }
16745
16746 data.ms_paused = 0;
16747
16748 data.words_cur = rd->words_cur;
16749
16750 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16751 {
16752 hc_device_param_t *device_param = &data.devices_param[device_id];
16753
16754 if (device_param->skipped) continue;
16755
16756 device_param->speed_pos = 0;
16757
16758 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16759 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16760
16761 device_param->exec_pos = 0;
16762
16763 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16764
16765 device_param->kernel_power = device_param->kernel_power_user;
16766
16767 device_param->outerloop_pos = 0;
16768 device_param->outerloop_left = 0;
16769 device_param->innerloop_pos = 0;
16770 device_param->innerloop_left = 0;
16771
16772 // some more resets:
16773
16774 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16775
16776 device_param->pws_cnt = 0;
16777
16778 device_param->words_off = 0;
16779 device_param->words_done = 0;
16780 }
16781
16782 data.kernel_power_div = 0;
16783
16784 // figure out some workload
16785
16786 if (attack_mode == ATTACK_MODE_STRAIGHT)
16787 {
16788 if (data.wordlist_mode == WL_MODE_FILE)
16789 {
16790 char *dictfile = NULL;
16791
16792 if (induction_dictionaries_cnt)
16793 {
16794 dictfile = induction_dictionaries[0];
16795 }
16796 else
16797 {
16798 dictfile = dictfiles[dictpos];
16799 }
16800
16801 data.dictfile = dictfile;
16802
16803 logfile_sub_string (dictfile);
16804
16805 for (uint i = 0; i < rp_files_cnt; i++)
16806 {
16807 logfile_sub_var_string ("rulefile", rp_files[i]);
16808 }
16809
16810 FILE *fd2 = fopen (dictfile, "rb");
16811
16812 if (fd2 == NULL)
16813 {
16814 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16815
16816 return (-1);
16817 }
16818
16819 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16820
16821 fclose (fd2);
16822
16823 if (data.words_cnt == 0)
16824 {
16825 if (data.devices_status == STATUS_CRACKED) break;
16826 if (data.devices_status == STATUS_ABORTED) break;
16827
16828 dictpos++;
16829
16830 continue;
16831 }
16832 }
16833 }
16834 else if (attack_mode == ATTACK_MODE_COMBI)
16835 {
16836 char *dictfile = data.dictfile;
16837 char *dictfile2 = data.dictfile2;
16838
16839 logfile_sub_string (dictfile);
16840 logfile_sub_string (dictfile2);
16841
16842 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16843 {
16844 FILE *fd2 = fopen (dictfile, "rb");
16845
16846 if (fd2 == NULL)
16847 {
16848 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16849
16850 return (-1);
16851 }
16852
16853 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16854
16855 fclose (fd2);
16856 }
16857 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16858 {
16859 FILE *fd2 = fopen (dictfile2, "rb");
16860
16861 if (fd2 == NULL)
16862 {
16863 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16864
16865 return (-1);
16866 }
16867
16868 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16869
16870 fclose (fd2);
16871 }
16872
16873 if (data.words_cnt == 0)
16874 {
16875 if (data.devices_status == STATUS_CRACKED) break;
16876 if (data.devices_status == STATUS_ABORTED) break;
16877
16878 dictpos++;
16879
16880 continue;
16881 }
16882 }
16883 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16884 {
16885 char *dictfile = NULL;
16886
16887 if (induction_dictionaries_cnt)
16888 {
16889 dictfile = induction_dictionaries[0];
16890 }
16891 else
16892 {
16893 dictfile = dictfiles[dictpos];
16894 }
16895
16896 data.dictfile = dictfile;
16897
16898 char *mask = data.mask;
16899
16900 logfile_sub_string (dictfile);
16901 logfile_sub_string (mask);
16902
16903 FILE *fd2 = fopen (dictfile, "rb");
16904
16905 if (fd2 == NULL)
16906 {
16907 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16908
16909 return (-1);
16910 }
16911
16912 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16913
16914 fclose (fd2);
16915
16916 if (data.words_cnt == 0)
16917 {
16918 if (data.devices_status == STATUS_CRACKED) break;
16919 if (data.devices_status == STATUS_ABORTED) break;
16920
16921 dictpos++;
16922
16923 continue;
16924 }
16925 }
16926 else if (attack_mode == ATTACK_MODE_BF)
16927 {
16928 local_free (css_buf);
16929 local_free (data.root_css_buf);
16930 local_free (data.markov_css_buf);
16931
16932 char *mask = dictfiles[dictpos];
16933
16934 logfile_sub_string (mask);
16935
16936 // base
16937
16938 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16939
16940 if (opts_type & OPTS_TYPE_PT_UNICODE)
16941 {
16942 uint css_cnt_unicode = css_cnt * 2;
16943
16944 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16945
16946 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16947 {
16948 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16949
16950 css_buf_unicode[j + 1].cs_buf[0] = 0;
16951 css_buf_unicode[j + 1].cs_len = 1;
16952 }
16953
16954 free (css_buf);
16955
16956 css_buf = css_buf_unicode;
16957 css_cnt = css_cnt_unicode;
16958 }
16959
16960 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16961
16962 uint mask_min = pw_min;
16963 uint mask_max = pw_max;
16964
16965 if (opts_type & OPTS_TYPE_PT_UNICODE)
16966 {
16967 mask_min *= 2;
16968 mask_max *= 2;
16969 }
16970
16971 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16972 {
16973 if (css_cnt < mask_min)
16974 {
16975 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16976 }
16977
16978 if (css_cnt > mask_max)
16979 {
16980 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16981 }
16982
16983 // skip to next mask
16984
16985 dictpos++;
16986
16987 rd->dictpos = dictpos;
16988
16989 logfile_sub_msg ("STOP");
16990
16991 continue;
16992 }
16993
16994 uint save_css_cnt = css_cnt;
16995
16996 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16997 {
16998 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16999 {
17000 uint salt_len = (uint) data.salts_buf[0].salt_len;
17001 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17002
17003 uint css_cnt_salt = css_cnt + salt_len;
17004
17005 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17006
17007 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17008
17009 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17010 {
17011 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17012 css_buf_salt[j].cs_len = 1;
17013 }
17014
17015 free (css_buf);
17016
17017 css_buf = css_buf_salt;
17018 css_cnt = css_cnt_salt;
17019 }
17020 }
17021
17022 data.mask = mask;
17023 data.css_cnt = css_cnt;
17024 data.css_buf = css_buf;
17025
17026 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17027
17028 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17029
17030 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17031
17032 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17033 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17034
17035 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17036
17037 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17038
17039 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17040 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17041
17042 data.root_css_buf = root_css_buf;
17043 data.markov_css_buf = markov_css_buf;
17044
17045 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17046
17047 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17048
17049 local_free (root_table_buf);
17050 local_free (markov_table_buf);
17051
17052 // copy + args
17053
17054 uint css_cnt_l = css_cnt;
17055 uint css_cnt_r;
17056
17057 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17058 {
17059 if (save_css_cnt < 6)
17060 {
17061 css_cnt_r = 1;
17062 }
17063 else if (save_css_cnt == 6)
17064 {
17065 css_cnt_r = 2;
17066 }
17067 else
17068 {
17069 if (opts_type & OPTS_TYPE_PT_UNICODE)
17070 {
17071 if (save_css_cnt == 8 || save_css_cnt == 10)
17072 {
17073 css_cnt_r = 2;
17074 }
17075 else
17076 {
17077 css_cnt_r = 4;
17078 }
17079 }
17080 else
17081 {
17082 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17083 {
17084 css_cnt_r = 3;
17085 }
17086 else
17087 {
17088 css_cnt_r = 4;
17089 }
17090 }
17091 }
17092 }
17093 else
17094 {
17095 css_cnt_r = 1;
17096
17097 /* unfinished code?
17098 int sum = css_buf[css_cnt_r - 1].cs_len;
17099
17100 for (uint i = 1; i < 4 && i < css_cnt; i++)
17101 {
17102 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17103
17104 css_cnt_r++;
17105
17106 sum *= css_buf[css_cnt_r - 1].cs_len;
17107 }
17108 */
17109 }
17110
17111 css_cnt_l -= css_cnt_r;
17112
17113 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17114
17115 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17116 {
17117 hc_device_param_t *device_param = &data.devices_param[device_id];
17118
17119 if (device_param->skipped) continue;
17120
17121 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17122 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17123 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17124
17125 device_param->kernel_params_mp_l_buf64[3] = 0;
17126 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17127 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17128 device_param->kernel_params_mp_l_buf32[6] = 0;
17129 device_param->kernel_params_mp_l_buf32[7] = 0;
17130 device_param->kernel_params_mp_l_buf32[8] = 0;
17131
17132 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17133 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17134 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17135 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17136
17137 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17138 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17139 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17140
17141 device_param->kernel_params_mp_r_buf64[3] = 0;
17142 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17143 device_param->kernel_params_mp_r_buf32[5] = 0;
17144 device_param->kernel_params_mp_r_buf32[6] = 0;
17145 device_param->kernel_params_mp_r_buf32[7] = 0;
17146
17147 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]);
17148 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]);
17149 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]);
17150
17151 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]);
17152 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]);
17153 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]);
17154
17155 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);
17156 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);
17157 }
17158 }
17159
17160 u64 words_base = data.words_cnt;
17161
17162 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17163 {
17164 if (data.kernel_rules_cnt)
17165 {
17166 words_base /= data.kernel_rules_cnt;
17167 }
17168 }
17169 else if (data.attack_kern == ATTACK_KERN_COMBI)
17170 {
17171 if (data.combs_cnt)
17172 {
17173 words_base /= data.combs_cnt;
17174 }
17175 }
17176 else if (data.attack_kern == ATTACK_KERN_BF)
17177 {
17178 if (data.bfs_cnt)
17179 {
17180 words_base /= data.bfs_cnt;
17181 }
17182 }
17183
17184 data.words_base = words_base;
17185
17186 if (keyspace == 1)
17187 {
17188 log_info ("%llu", (unsigned long long int) words_base);
17189
17190 return (0);
17191 }
17192
17193 if (data.words_cur > data.words_base)
17194 {
17195 log_error ("ERROR: restore value greater keyspace");
17196
17197 return (-1);
17198 }
17199
17200 if (data.words_cur)
17201 {
17202 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17203 {
17204 for (uint i = 0; i < data.salts_cnt; i++)
17205 {
17206 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17207 }
17208 }
17209 else if (data.attack_kern == ATTACK_KERN_COMBI)
17210 {
17211 for (uint i = 0; i < data.salts_cnt; i++)
17212 {
17213 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17214 }
17215 }
17216 else if (data.attack_kern == ATTACK_KERN_BF)
17217 {
17218 for (uint i = 0; i < data.salts_cnt; i++)
17219 {
17220 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17221 }
17222 }
17223 }
17224
17225 /*
17226 * Inform user about possible slow speeds
17227 */
17228
17229 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17230 {
17231 if (data.words_base < kernel_power_all)
17232 {
17233 if (quiet == 0)
17234 {
17235 log_info ("ATTENTION!");
17236 log_info (" The wordlist or mask you are using is too small.");
17237 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17238 log_info (" The cracking speed will drop.");
17239 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17240 log_info ("");
17241 }
17242 }
17243 }
17244
17245 /*
17246 * Update loopback file
17247 */
17248
17249 if (loopback == 1)
17250 {
17251 time_t now;
17252
17253 time (&now);
17254
17255 uint random_num = get_random_num (0, 9999);
17256
17257 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17258
17259 data.loopback_file = loopback_file;
17260 }
17261
17262 /*
17263 * Update dictionary statistic
17264 */
17265
17266 if (keyspace == 0)
17267 {
17268 dictstat_fp = fopen (dictstat, "wb");
17269
17270 if (dictstat_fp)
17271 {
17272 lock_file (dictstat_fp);
17273
17274 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17275
17276 fclose (dictstat_fp);
17277 }
17278 }
17279
17280 data.devices_status = STATUS_RUNNING;
17281
17282 if (initial_restore_done == 0)
17283 {
17284 if (data.restore_disable == 0) cycle_restore ();
17285
17286 initial_restore_done = 1;
17287 }
17288
17289 hc_timer_set (&data.timer_running);
17290
17291 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17292 {
17293 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17294 {
17295 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17296 if (quiet == 0) fflush (stdout);
17297 }
17298 }
17299 else if (wordlist_mode == WL_MODE_STDIN)
17300 {
17301 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17302 if (data.quiet == 0) log_info ("");
17303 }
17304
17305 time_t runtime_start;
17306
17307 time (&runtime_start);
17308
17309 data.runtime_start = runtime_start;
17310
17311 /**
17312 * create cracker threads
17313 */
17314
17315 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17316
17317 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17318 {
17319 hc_device_param_t *device_param = &devices_param[device_id];
17320
17321 if (wordlist_mode == WL_MODE_STDIN)
17322 {
17323 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17324 }
17325 else
17326 {
17327 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17328 }
17329 }
17330
17331 // wait for crack threads to exit
17332
17333 hc_thread_wait (data.devices_cnt, c_threads);
17334
17335 local_free (c_threads);
17336
17337 data.restore = 0;
17338
17339 // finalize task
17340
17341 logfile_sub_var_uint ("status-after-work", data.devices_status);
17342
17343 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17344
17345 if (data.devices_status == STATUS_CRACKED) break;
17346 if (data.devices_status == STATUS_ABORTED) break;
17347
17348 if (data.devices_status == STATUS_BYPASS)
17349 {
17350 data.devices_status = STATUS_RUNNING;
17351 }
17352
17353 if (induction_dictionaries_cnt)
17354 {
17355 unlink (induction_dictionaries[0]);
17356 }
17357
17358 free (induction_dictionaries);
17359
17360 if (attack_mode != ATTACK_MODE_BF)
17361 {
17362 induction_dictionaries = scan_directory (induction_directory);
17363
17364 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17365 }
17366
17367 if (benchmark == 0)
17368 {
17369 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17370 {
17371 if (quiet == 0) clear_prompt ();
17372
17373 if (quiet == 0) log_info ("");
17374
17375 if (status == 1)
17376 {
17377 status_display ();
17378 }
17379 else
17380 {
17381 if (quiet == 0) status_display ();
17382 }
17383
17384 if (quiet == 0) log_info ("");
17385 }
17386 }
17387
17388 if (attack_mode == ATTACK_MODE_BF)
17389 {
17390 dictpos++;
17391
17392 rd->dictpos = dictpos;
17393 }
17394 else
17395 {
17396 if (induction_dictionaries_cnt)
17397 {
17398 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17399 }
17400 else
17401 {
17402 dictpos++;
17403
17404 rd->dictpos = dictpos;
17405 }
17406 }
17407
17408 time_t runtime_stop;
17409
17410 time (&runtime_stop);
17411
17412 data.runtime_stop = runtime_stop;
17413
17414 logfile_sub_uint (runtime_start);
17415 logfile_sub_uint (runtime_stop);
17416
17417 logfile_sub_msg ("STOP");
17418
17419 global_free (subid);
17420 }
17421
17422 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17423
17424 if (data.devices_status == STATUS_CRACKED) break;
17425 if (data.devices_status == STATUS_ABORTED) break;
17426 if (data.devices_status == STATUS_QUIT) break;
17427
17428 if (data.devices_status == STATUS_BYPASS)
17429 {
17430 data.devices_status = STATUS_RUNNING;
17431 }
17432 }
17433
17434 // 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
17435
17436 if (attack_mode == ATTACK_MODE_STRAIGHT)
17437 {
17438 if (data.wordlist_mode == WL_MODE_FILE)
17439 {
17440 if (data.dictfile == NULL)
17441 {
17442 if (dictfiles != NULL)
17443 {
17444 data.dictfile = dictfiles[0];
17445
17446 hc_timer_set (&data.timer_running);
17447 }
17448 }
17449 }
17450 }
17451 // NOTE: combi is okay because it is already set beforehand
17452 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17453 {
17454 if (data.dictfile == NULL)
17455 {
17456 if (dictfiles != NULL)
17457 {
17458 hc_timer_set (&data.timer_running);
17459
17460 data.dictfile = dictfiles[0];
17461 }
17462 }
17463 }
17464 else if (attack_mode == ATTACK_MODE_BF)
17465 {
17466 if (data.mask == NULL)
17467 {
17468 hc_timer_set (&data.timer_running);
17469
17470 data.mask = masks[0];
17471 }
17472 }
17473
17474 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17475 {
17476 data.devices_status = STATUS_EXHAUSTED;
17477 }
17478
17479 // if cracked / aborted remove last induction dictionary
17480
17481 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17482 {
17483 struct stat induct_stat;
17484
17485 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17486 {
17487 unlink (induction_dictionaries[file_pos]);
17488 }
17489 }
17490
17491 // wait for non-interactive threads
17492
17493 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17494 {
17495 hc_thread_wait (1, &ni_threads[thread_idx]);
17496 }
17497
17498 local_free (ni_threads);
17499
17500 // wait for interactive threads
17501
17502 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17503 {
17504 hc_thread_wait (1, &i_thread);
17505 }
17506
17507 // we dont need restore file anymore
17508 if (data.restore_disable == 0)
17509 {
17510 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17511 {
17512 unlink (eff_restore_file);
17513 unlink (new_restore_file);
17514 }
17515 else
17516 {
17517 cycle_restore ();
17518 }
17519 }
17520
17521 // finally save left hashes
17522
17523 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17524 {
17525 save_hash ();
17526 }
17527
17528 /**
17529 * Clean up
17530 */
17531
17532 if (benchmark == 1)
17533 {
17534 status_benchmark ();
17535
17536 if (status_automat == 0)
17537 {
17538 log_info ("");
17539 }
17540 }
17541 else
17542 {
17543 if (quiet == 0) clear_prompt ();
17544
17545 if (quiet == 0) log_info ("");
17546
17547 if (status == 1)
17548 {
17549 status_display ();
17550 }
17551 else
17552 {
17553 if (quiet == 0) status_display ();
17554 }
17555
17556 if (quiet == 0) log_info ("");
17557 }
17558
17559 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17560 {
17561 hc_device_param_t *device_param = &data.devices_param[device_id];
17562
17563 if (device_param->skipped) continue;
17564
17565 local_free (device_param->combs_buf);
17566
17567 local_free (device_param->hooks_buf);
17568
17569 local_free (device_param->device_name);
17570
17571 local_free (device_param->device_name_chksum);
17572
17573 local_free (device_param->device_version);
17574
17575 local_free (device_param->driver_version);
17576
17577 if (device_param->pws_buf) myfree (device_param->pws_buf);
17578 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17579 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17580 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17581 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17582 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17583 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17584 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17585 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17586 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17587 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17588 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17589 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17590 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17591 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17592 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17593 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17594 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17595 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17596 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17597 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17598 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17599 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17600 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17601 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17602 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17603 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17604 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17605 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17606
17607 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17608 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17609 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17610 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17611 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17612 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17613 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17614 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17615 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17616 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17617
17618 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17619 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17620 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17621
17622 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17623 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17624 }
17625
17626 // reset default fan speed
17627
17628 #ifdef HAVE_HWMON
17629 if (gpu_temp_disable == 0)
17630 {
17631 #ifdef HAVE_ADL
17632 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17633 {
17634 hc_thread_mutex_lock (mux_adl);
17635
17636 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17637 {
17638 hc_device_param_t *device_param = &data.devices_param[device_id];
17639
17640 if (device_param->skipped) continue;
17641
17642 if (data.hm_device[device_id].fan_supported == 1)
17643 {
17644 int fanspeed = temp_retain_fanspeed_value[device_id];
17645
17646 if (fanspeed == -1) continue;
17647
17648 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17649
17650 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17651 }
17652 }
17653
17654 hc_thread_mutex_unlock (mux_adl);
17655 }
17656 #endif // HAVE_ADL
17657 }
17658
17659 #ifdef HAVE_ADL
17660 // reset power tuning
17661
17662 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17663 {
17664 hc_thread_mutex_lock (mux_adl);
17665
17666 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17667 {
17668 hc_device_param_t *device_param = &data.devices_param[device_id];
17669
17670 if (device_param->skipped) continue;
17671
17672 if (data.hm_device[device_id].od_version == 6)
17673 {
17674 // check powertune capabilities first, if not available then skip device
17675
17676 int powertune_supported = 0;
17677
17678 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17679 {
17680 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17681
17682 return (-1);
17683 }
17684
17685 if (powertune_supported != 0)
17686 {
17687 // powercontrol settings
17688
17689 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)
17690 {
17691 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17692
17693 return (-1);
17694 }
17695
17696 // clocks
17697
17698 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17699
17700 performance_state->iNumberOfPerformanceLevels = 2;
17701
17702 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17703 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17704 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17705 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17706
17707 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)
17708 {
17709 log_info ("ERROR: Failed to restore ADL performance state");
17710
17711 return (-1);
17712 }
17713
17714 local_free (performance_state);
17715 }
17716 }
17717 }
17718
17719 hc_thread_mutex_unlock (mux_adl);
17720 }
17721 #endif // HAVE_ADL
17722
17723 if (gpu_temp_disable == 0)
17724 {
17725 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17726 if (data.hm_nv)
17727 {
17728 #if defined(LINUX) && defined(HAVE_NVML)
17729
17730 hm_NVML_nvmlShutdown (data.hm_nv);
17731
17732 nvml_close (data.hm_nv);
17733
17734 #elif defined(WIN) && (HAVE_NVAPI)
17735
17736 hm_NvAPI_Unload (data.hm_nv);
17737
17738 nvapi_close (data.hm_nv);
17739
17740 #endif
17741
17742 data.hm_nv = NULL;
17743 }
17744 #endif
17745
17746 #ifdef HAVE_ADL
17747 if (data.hm_amd)
17748 {
17749 hm_ADL_Main_Control_Destroy (data.hm_amd);
17750
17751 adl_close (data.hm_amd);
17752 data.hm_amd = NULL;
17753 }
17754 #endif
17755 }
17756 #endif // HAVE_HWMON
17757
17758 // free memory
17759
17760 local_free (masks);
17761
17762 local_free (dictstat_base);
17763
17764 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17765 {
17766 pot_t *pot_ptr = &pot[pot_pos];
17767
17768 hash_t *hash = &pot_ptr->hash;
17769
17770 local_free (hash->digest);
17771
17772 if (isSalted)
17773 {
17774 local_free (hash->salt);
17775 }
17776 }
17777
17778 local_free (pot);
17779
17780 local_free (all_kernel_rules_cnt);
17781 local_free (all_kernel_rules_buf);
17782
17783 local_free (wl_data->buf);
17784 local_free (wl_data);
17785
17786 local_free (bitmap_s1_a);
17787 local_free (bitmap_s1_b);
17788 local_free (bitmap_s1_c);
17789 local_free (bitmap_s1_d);
17790 local_free (bitmap_s2_a);
17791 local_free (bitmap_s2_b);
17792 local_free (bitmap_s2_c);
17793 local_free (bitmap_s2_d);
17794
17795 #ifdef HAVE_HWMON
17796 local_free (temp_retain_fanspeed_value);
17797 #ifdef HAVE_ADL
17798 local_free (od_clock_mem_status);
17799 local_free (od_power_control_status);
17800 #endif // ADL
17801 #endif
17802
17803 global_free (devices_param);
17804
17805 global_free (kernel_rules_buf);
17806
17807 global_free (root_css_buf);
17808 global_free (markov_css_buf);
17809
17810 global_free (digests_buf);
17811 global_free (digests_shown);
17812 global_free (digests_shown_tmp);
17813
17814 global_free (salts_buf);
17815 global_free (salts_shown);
17816
17817 global_free (esalts_buf);
17818
17819 global_free (words_progress_done);
17820 global_free (words_progress_rejected);
17821 global_free (words_progress_restored);
17822
17823 if (pot_fp) fclose (pot_fp);
17824
17825 if (data.devices_status == STATUS_QUIT) break;
17826 }
17827
17828 // destroy others mutex
17829
17830 hc_thread_mutex_delete (mux_dispatcher);
17831 hc_thread_mutex_delete (mux_counter);
17832 hc_thread_mutex_delete (mux_display);
17833 hc_thread_mutex_delete (mux_adl);
17834
17835 // free memory
17836
17837 local_free (eff_restore_file);
17838 local_free (new_restore_file);
17839
17840 local_free (rd);
17841
17842 // tuning db
17843
17844 tuning_db_destroy (tuning_db);
17845
17846 // loopback
17847
17848 local_free (loopback_file);
17849
17850 if (loopback == 1) unlink (loopback_file);
17851
17852 // induction directory
17853
17854 if (induction_dir == NULL)
17855 {
17856 if (attack_mode != ATTACK_MODE_BF)
17857 {
17858 if (rmdir (induction_directory) == -1)
17859 {
17860 if (errno == ENOENT)
17861 {
17862 // good, we can ignore
17863 }
17864 else if (errno == ENOTEMPTY)
17865 {
17866 // good, we can ignore
17867 }
17868 else
17869 {
17870 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17871
17872 return (-1);
17873 }
17874 }
17875
17876 local_free (induction_directory);
17877 }
17878 }
17879
17880 // outfile-check directory
17881
17882 if (outfile_check_dir == NULL)
17883 {
17884 if (rmdir (outfile_check_directory) == -1)
17885 {
17886 if (errno == ENOENT)
17887 {
17888 // good, we can ignore
17889 }
17890 else if (errno == ENOTEMPTY)
17891 {
17892 // good, we can ignore
17893 }
17894 else
17895 {
17896 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17897
17898 return (-1);
17899 }
17900 }
17901
17902 local_free (outfile_check_directory);
17903 }
17904
17905 time_t proc_stop;
17906
17907 time (&proc_stop);
17908
17909 logfile_top_uint (proc_start);
17910 logfile_top_uint (proc_stop);
17911
17912 logfile_top_msg ("STOP");
17913
17914 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17915 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17916
17917 if (data.ocl) ocl_close (data.ocl);
17918
17919 if (data.devices_status == STATUS_ABORTED) return 2;
17920 if (data.devices_status == STATUS_QUIT) return 2;
17921 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17922 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17923 if (data.devices_status == STATUS_CRACKED) return 0;
17924
17925 return -1;
17926 }
Hashcat additions to support pwdhash