projects / hashcat.git / blob
? search:


216d5de31483f6c3ec2b0f34ba318c5b44d6ab06
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
432 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
433 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
434 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happened then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 hc_thread_mutex_lock (mux_display);
2219
2220 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2221 {
2222 data.digests_shown[hash_pos] = 1;
2223
2224 data.digests_done++;
2225
2226 cpt_cracked++;
2227
2228 salt_buf->digests_done++;
2229
2230 if (salt_buf->digests_done == salt_buf->digests_cnt)
2231 {
2232 data.salts_shown[salt_pos] = 1;
2233
2234 data.salts_done++;
2235 }
2236 }
2237
2238 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2239
2240 hc_thread_mutex_unlock (mux_display);
2241
2242 check_hash (device_param, &cracked[i]);
2243 }
2244
2245 myfree (cracked);
2246
2247 if (cpt_cracked > 0)
2248 {
2249 hc_thread_mutex_lock (mux_display);
2250
2251 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2252 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2253
2254 data.cpt_pos++;
2255
2256 data.cpt_total += cpt_cracked;
2257
2258 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2259
2260 hc_thread_mutex_unlock (mux_display);
2261 }
2262
2263 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2264 {
2265 // we need to reset cracked state on the device
2266 // otherwise host thinks again and again the hash was cracked
2267 // and returns invalid password each time
2268
2269 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2270
2271 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2272 }
2273
2274 num_cracked = 0;
2275
2276 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2277 }
2278 }
2279
2280 static void save_hash ()
2281 {
2282 char *hashfile = data.hashfile;
2283
2284 char new_hashfile[256] = { 0 };
2285 char old_hashfile[256] = { 0 };
2286
2287 snprintf (new_hashfile, 255, "%s.new", hashfile);
2288 snprintf (old_hashfile, 255, "%s.old", hashfile);
2289
2290 unlink (new_hashfile);
2291
2292 char separator = data.separator;
2293
2294 FILE *fp = fopen (new_hashfile, "wb");
2295
2296 if (fp == NULL)
2297 {
2298 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2299
2300 exit (-1);
2301 }
2302
2303 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2304 {
2305 if (data.salts_shown[salt_pos] == 1) continue;
2306
2307 salt_t *salt_buf = &data.salts_buf[salt_pos];
2308
2309 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2310 {
2311 uint idx = salt_buf->digests_offset + digest_pos;
2312
2313 if (data.digests_shown[idx] == 1) continue;
2314
2315 if (data.hash_mode != 2500)
2316 {
2317 char out_buf[HCBUFSIZ] = { 0 };
2318
2319 if (data.username == 1)
2320 {
2321 user_t *user = data.hash_info[idx]->user;
2322
2323 uint i;
2324
2325 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2326
2327 fputc (separator, fp);
2328 }
2329
2330 ascii_digest (out_buf, salt_pos, digest_pos);
2331
2332 fputs (out_buf, fp);
2333
2334 log_out (fp, "");
2335 }
2336 else
2337 {
2338 hccap_t hccap;
2339
2340 to_hccap_t (&hccap, salt_pos, digest_pos);
2341
2342 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2343 }
2344 }
2345 }
2346
2347 fflush (fp);
2348
2349 fclose (fp);
2350
2351 unlink (old_hashfile);
2352
2353 if (rename (hashfile, old_hashfile) != 0)
2354 {
2355 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2356
2357 exit (-1);
2358 }
2359
2360 unlink (hashfile);
2361
2362 if (rename (new_hashfile, hashfile) != 0)
2363 {
2364 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2365
2366 exit (-1);
2367 }
2368
2369 unlink (old_hashfile);
2370 }
2371
2372 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2373 {
2374 // function called only in case kernel_power_all > words_left
2375
2376 float kernel_power_div = (float) (total_left) / kernel_power_all;
2377
2378 kernel_power_div += kernel_power_div / 100;
2379
2380 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2381
2382 while (kernel_power_new < total_left)
2383 {
2384 kernel_power_div += kernel_power_div / 100;
2385
2386 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2387 }
2388
2389 if (data.quiet == 0)
2390 {
2391 clear_prompt ();
2392
2393 //log_info ("");
2394
2395 log_info ("INFO: approaching final keyspace, workload adjusted");
2396 log_info ("");
2397
2398 fprintf (stdout, "%s", PROMPT);
2399
2400 fflush (stdout);
2401 }
2402
2403 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2404
2405 return kernel_power_div;
2406 }
2407
2408 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2409 {
2410 uint num_elements = num;
2411
2412 device_param->kernel_params_buf32[30] = data.combs_mode;
2413 device_param->kernel_params_buf32[31] = num;
2414
2415 uint kernel_threads = device_param->kernel_threads;
2416
2417 while (num_elements % kernel_threads) num_elements++;
2418
2419 cl_kernel kernel = NULL;
2420
2421 switch (kern_run)
2422 {
2423 case KERN_RUN_1: kernel = device_param->kernel1; break;
2424 case KERN_RUN_12: kernel = device_param->kernel12; break;
2425 case KERN_RUN_2: kernel = device_param->kernel2; break;
2426 case KERN_RUN_23: kernel = device_param->kernel23; break;
2427 case KERN_RUN_3: kernel = device_param->kernel3; break;
2428 }
2429
2430 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2431 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2432 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2433 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2434 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2435 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2436 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2437 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2438 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2439 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2440 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2441
2442 cl_event event;
2443
2444 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2445 {
2446 const size_t global_work_size[3] = { num_elements, 32, 1 };
2447 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2448
2449 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2450 }
2451 else
2452 {
2453 if (kern_run == KERN_RUN_2)
2454 {
2455 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2456 {
2457 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2458 }
2459 }
2460
2461 while (num_elements % kernel_threads) num_elements++;
2462
2463 const size_t global_work_size[3] = { num_elements, 1, 1 };
2464 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2465
2466 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2467 }
2468
2469 hc_clFlush (data.ocl, device_param->command_queue);
2470
2471 hc_clWaitForEvents (data.ocl, 1, &event);
2472
2473 if (event_update)
2474 {
2475 cl_ulong time_start;
2476 cl_ulong time_end;
2477
2478 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2479 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2480
2481 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2482
2483 uint exec_pos = device_param->exec_pos;
2484
2485 device_param->exec_ms[exec_pos] = exec_time;
2486
2487 exec_pos++;
2488
2489 if (exec_pos == EXEC_CACHE)
2490 {
2491 exec_pos = 0;
2492 }
2493
2494 device_param->exec_pos = exec_pos;
2495 }
2496
2497 hc_clReleaseEvent (data.ocl, event);
2498
2499 hc_clFinish (data.ocl, device_param->command_queue);
2500 }
2501
2502 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2503 {
2504 uint num_elements = num;
2505
2506 switch (kern_run)
2507 {
2508 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2509 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2510 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2511 }
2512
2513 // causes problems with special threads like in bcrypt
2514 // const uint kernel_threads = device_param->kernel_threads;
2515
2516 uint kernel_threads = device_param->kernel_threads;
2517
2518 while (num_elements % kernel_threads) num_elements++;
2519
2520 cl_kernel kernel = NULL;
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2525 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2526 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2527 }
2528
2529 switch (kern_run)
2530 {
2531 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2537 break;
2538 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2544 break;
2545 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2546 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2547 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2548 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2549 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2550 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2551 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2552 break;
2553 }
2554
2555 const size_t global_work_size[3] = { num_elements, 1, 1 };
2556 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2557
2558 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2559
2560 hc_clFlush (data.ocl, device_param->command_queue);
2561
2562 hc_clFinish (data.ocl, device_param->command_queue);
2563 }
2564
2565 static void run_kernel_tm (hc_device_param_t *device_param)
2566 {
2567 const uint num_elements = 1024; // fixed
2568
2569 uint kernel_threads = 32;
2570
2571 cl_kernel kernel = device_param->kernel_tm;
2572
2573 const size_t global_work_size[3] = { num_elements, 1, 1 };
2574 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2575
2576 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2577
2578 hc_clFlush (data.ocl, device_param->command_queue);
2579
2580 hc_clFinish (data.ocl, device_param->command_queue);
2581 }
2582
2583 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2584 {
2585 uint num_elements = num;
2586
2587 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2588 device_param->kernel_params_amp_buf32[6] = num_elements;
2589
2590 // causes problems with special threads like in bcrypt
2591 // const uint kernel_threads = device_param->kernel_threads;
2592
2593 uint kernel_threads = device_param->kernel_threads;
2594
2595 while (num_elements % kernel_threads) num_elements++;
2596
2597 cl_kernel kernel = device_param->kernel_amp;
2598
2599 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2600 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2601
2602 const size_t global_work_size[3] = { num_elements, 1, 1 };
2603 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2604
2605 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2606
2607 hc_clFlush (data.ocl, device_param->command_queue);
2608
2609 hc_clFinish (data.ocl, device_param->command_queue);
2610 }
2611
2612 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2613 {
2614 int rc = -1;
2615
2616 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2617 {
2618 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2619
2620 const cl_uchar zero = 0;
2621
2622 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2623 }
2624
2625 if (rc != 0)
2626 {
2627 // NOTE: clEnqueueFillBuffer () always fails with -59
2628 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2629 // How's that possible, OpenCL 1.2 support is advertised??
2630 // We need to workaround...
2631
2632 #define FILLSZ 0x100000
2633
2634 char *tmp = (char *) mymalloc (FILLSZ);
2635
2636 for (size_t i = 0; i < size; i += FILLSZ)
2637 {
2638 const size_t left = size - i;
2639
2640 const size_t fillsz = MIN (FILLSZ, left);
2641
2642 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2643 }
2644
2645 myfree (tmp);
2646 }
2647 }
2648
2649 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2650 {
2651 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2652 {
2653 if (attack_mode == ATTACK_MODE_BF)
2654 {
2655 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2656 {
2657 const uint size_tm = 32 * sizeof (bs_word_t);
2658
2659 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2660
2661 run_kernel_tm (device_param);
2662
2663 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2664 }
2665 }
2666
2667 if (highest_pw_len < 16)
2668 {
2669 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2670 }
2671 else if (highest_pw_len < 32)
2672 {
2673 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2674 }
2675 else
2676 {
2677 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2678 }
2679 }
2680 else
2681 {
2682 run_kernel_amp (device_param, pws_cnt);
2683
2684 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2685
2686 if (opts_type & OPTS_TYPE_HOOK12)
2687 {
2688 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2689 }
2690
2691 uint iter = salt_buf->salt_iter;
2692
2693 uint loop_step = device_param->kernel_loops;
2694
2695 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2696 {
2697 uint loop_left = iter - loop_pos;
2698
2699 loop_left = MIN (loop_left, loop_step);
2700
2701 device_param->kernel_params_buf32[25] = loop_pos;
2702 device_param->kernel_params_buf32[26] = loop_left;
2703
2704 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2705
2706 if (data.devices_status == STATUS_CRACKED) break;
2707 if (data.devices_status == STATUS_ABORTED) break;
2708 if (data.devices_status == STATUS_QUIT) break;
2709
2710 /**
2711 * speed
2712 */
2713
2714 const float iter_part = (float) (loop_pos + loop_left) / iter;
2715
2716 const u64 perf_sum_all = pws_cnt * iter_part;
2717
2718 double speed_ms;
2719
2720 hc_timer_get (device_param->timer_speed, speed_ms);
2721
2722 const u32 speed_pos = device_param->speed_pos;
2723
2724 device_param->speed_cnt[speed_pos] = perf_sum_all;
2725
2726 device_param->speed_ms[speed_pos] = speed_ms;
2727
2728 if (data.benchmark == 1)
2729 {
2730 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2731 }
2732 }
2733
2734 if (opts_type & OPTS_TYPE_HOOK23)
2735 {
2736 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2737
2738 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2739
2740 // do something with data
2741
2742 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2743 }
2744
2745 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2746 }
2747 }
2748
2749 static int run_rule_engine (const int rule_len, const char *rule_buf)
2750 {
2751 if (rule_len == 0)
2752 {
2753 return 0;
2754 }
2755 else if (rule_len == 1)
2756 {
2757 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2758 }
2759
2760 return 1;
2761 }
2762
2763 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2764 {
2765 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2766 {
2767 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2768 }
2769 else if (data.attack_kern == ATTACK_KERN_COMBI)
2770 {
2771 if (data.attack_mode == ATTACK_MODE_COMBI)
2772 {
2773 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2774 {
2775 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2776 {
2777 for (u32 i = 0; i < pws_cnt; i++)
2778 {
2779 const u32 pw_len = device_param->pws_buf[i].pw_len;
2780
2781 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2782
2783 ptr[pw_len] = 0x01;
2784 }
2785 }
2786 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2787 {
2788 for (u32 i = 0; i < pws_cnt; i++)
2789 {
2790 const u32 pw_len = device_param->pws_buf[i].pw_len;
2791
2792 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2793
2794 ptr[pw_len] = 0x80;
2795 }
2796 }
2797 }
2798 }
2799 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2800 {
2801 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2802 {
2803 for (u32 i = 0; i < pws_cnt; i++)
2804 {
2805 const u32 pw_len = device_param->pws_buf[i].pw_len;
2806
2807 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2808
2809 ptr[pw_len] = 0x01;
2810 }
2811 }
2812 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2813 {
2814 for (u32 i = 0; i < pws_cnt; i++)
2815 {
2816 const u32 pw_len = device_param->pws_buf[i].pw_len;
2817
2818 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2819
2820 ptr[pw_len] = 0x80;
2821 }
2822 }
2823 }
2824
2825 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2826 }
2827 else if (data.attack_kern == ATTACK_KERN_BF)
2828 {
2829 const u64 off = device_param->words_off;
2830
2831 device_param->kernel_params_mp_l_buf64[3] = off;
2832
2833 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2834 }
2835 }
2836
2837 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2838 {
2839 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2840
2841 device_param->kernel_params_buf32[25] = 0;
2842 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2843 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2844
2845 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2846 {
2847 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2848 }
2849 else
2850 {
2851 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2852 }
2853
2854 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2855
2856 return exec_ms_prev;
2857 }
2858
2859 static void autotune (hc_device_param_t *device_param)
2860 {
2861 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2862
2863 const u32 kernel_accel_min = device_param->kernel_accel_min;
2864 const u32 kernel_accel_max = device_param->kernel_accel_max;
2865
2866 const u32 kernel_loops_min = device_param->kernel_loops_min;
2867 const u32 kernel_loops_max = device_param->kernel_loops_max;
2868
2869 u32 kernel_accel = kernel_accel_min;
2870 u32 kernel_loops = kernel_loops_min;
2871
2872 // in this case the user specified a fixed -u and -n on the commandline
2873 // no way to tune anything
2874 // but we need to run a few caching rounds
2875
2876 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2877 {
2878 try_run (device_param, kernel_accel, kernel_loops);
2879 try_run (device_param, kernel_accel, kernel_loops);
2880 try_run (device_param, kernel_accel, kernel_loops);
2881 try_run (device_param, kernel_accel, kernel_loops);
2882
2883 device_param->kernel_accel = kernel_accel;
2884 device_param->kernel_loops = kernel_loops;
2885
2886 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2887
2888 device_param->kernel_power = kernel_power;
2889
2890 return;
2891 }
2892
2893 // from here it's clear we are allowed to autotune
2894 // so let's init some fake words
2895
2896 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2897
2898 for (u32 i = 0; i < kernel_power_max; i++)
2899 {
2900 device_param->pws_buf[i].i[0] = i;
2901 device_param->pws_buf[i].i[1] = 0x01234567;
2902 device_param->pws_buf[i].pw_len = 7;
2903 }
2904
2905 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2906
2907 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2908 {
2909 run_kernel_amp (device_param, kernel_power_max);
2910 }
2911
2912 #define VERIFIER_CNT 1
2913
2914 // first find out highest kernel-loops that stays below target_ms
2915
2916 if (kernel_loops_min < kernel_loops_max)
2917 {
2918 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2919 {
2920 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2921
2922 for (int i = 0; i < VERIFIER_CNT; i++)
2923 {
2924 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2925
2926 exec_ms = MIN (exec_ms, exec_ms_v);
2927 }
2928
2929 if (exec_ms < target_ms) break;
2930 }
2931 }
2932
2933 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2934
2935 #define STEPS_CNT 10
2936
2937 if (kernel_accel_min < kernel_accel_max)
2938 {
2939 for (int i = 0; i < STEPS_CNT; i++)
2940 {
2941 const u32 kernel_accel_try = 1 << i;
2942
2943 if (kernel_accel_try < kernel_accel_min) continue;
2944 if (kernel_accel_try > kernel_accel_max) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms > target_ms) break;
2956
2957 kernel_accel = kernel_accel_try;
2958 }
2959 }
2960
2961 // at this point we want to know the actual runtime for the following reason:
2962 // we need a reference for the balancing loop following up, and this
2963 // the balancing loop can have an effect that the creates a new opportunity, for example:
2964 // if the target is 95 ms and the current runtime is 48ms the above loop
2965 // stopped the execution because the previous exec_ms was > 95ms
2966 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2967 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2968
2969 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2970
2971 for (int i = 0; i < VERIFIER_CNT; i++)
2972 {
2973 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2974
2975 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2976 }
2977
2978 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2979 {
2980 for (u32 f = 2; f < 1024; f++)
2981 {
2982 const u32 kernel_accel_try = kernel_accel * f;
2983 const u32 kernel_loops_try = kernel_loops / f;
2984
2985 if (kernel_accel_try > kernel_accel_max) break;
2986 if (kernel_loops_try < kernel_loops_min) break;
2987
2988 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2989
2990 for (int i = 0; i < VERIFIER_CNT; i++)
2991 {
2992 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2993
2994 exec_ms = MIN (exec_ms, exec_ms_v);
2995 }
2996
2997 if (exec_ms < exec_ms_pre_final)
2998 {
2999 exec_ms_pre_final = exec_ms;
3000
3001 kernel_accel = kernel_accel_try;
3002 kernel_loops = kernel_loops_try;
3003 }
3004 }
3005 }
3006
3007 const double exec_left = target_ms / exec_ms_pre_final;
3008
3009 const double accel_left = kernel_accel_max / kernel_accel;
3010
3011 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3012
3013 if (exec_accel_min >= 1.0)
3014 {
3015 // this is safe to not overflow kernel_accel_max because of accel_left
3016
3017 kernel_accel = (double) kernel_accel * exec_accel_min;
3018 }
3019
3020 // reset them fake words
3021
3022 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3023
3024 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3025 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
3026
3027 // reset timer
3028
3029 device_param->exec_pos = 0;
3030
3031 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3032
3033 // store
3034
3035 device_param->kernel_accel = kernel_accel;
3036 device_param->kernel_loops = kernel_loops;
3037
3038 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3039
3040 device_param->kernel_power = kernel_power;
3041
3042 #ifdef DEBUG
3043
3044 if (data.quiet == 0)
3045 {
3046 clear_prompt ();
3047
3048 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3049 "Device #%u: autotuned kernel-loops to %u\n",
3050 device_param->device_id + 1, kernel_accel,
3051 device_param->device_id + 1, kernel_loops);
3052
3053 fprintf (stdout, "%s", PROMPT);
3054
3055 fflush (stdout);
3056 }
3057
3058 #endif
3059 }
3060
3061 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3062 {
3063 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3064
3065 // init speed timer
3066
3067 uint speed_pos = device_param->speed_pos;
3068
3069 #ifdef _POSIX
3070 if (device_param->timer_speed.tv_sec == 0)
3071 {
3072 hc_timer_set (&device_param->timer_speed);
3073 }
3074 #endif
3075
3076 #ifdef _WIN
3077 if (device_param->timer_speed.QuadPart == 0)
3078 {
3079 hc_timer_set (&device_param->timer_speed);
3080 }
3081 #endif
3082
3083 // find higest password length, this is for optimization stuff
3084
3085 uint highest_pw_len = 0;
3086
3087 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3088 {
3089 }
3090 else if (data.attack_kern == ATTACK_KERN_COMBI)
3091 {
3092 }
3093 else if (data.attack_kern == ATTACK_KERN_BF)
3094 {
3095 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3096 + device_param->kernel_params_mp_l_buf32[5];
3097 }
3098
3099 // iteration type
3100
3101 uint innerloop_step = 0;
3102 uint innerloop_cnt = 0;
3103
3104 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3105 else innerloop_step = 1;
3106
3107 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3108 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3109 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3110
3111 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3112
3113 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3114 {
3115 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3116
3117 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3118
3119 if (data.devices_status == STATUS_CRACKED) break;
3120 if (data.devices_status == STATUS_ABORTED) break;
3121 if (data.devices_status == STATUS_QUIT) break;
3122 if (data.devices_status == STATUS_BYPASS) break;
3123
3124 salt_t *salt_buf = &data.salts_buf[salt_pos];
3125
3126 device_param->kernel_params_buf32[24] = salt_pos;
3127 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3128 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3129
3130 FILE *combs_fp = device_param->combs_fp;
3131
3132 if (data.attack_mode == ATTACK_MODE_COMBI)
3133 {
3134 rewind (combs_fp);
3135 }
3136
3137 // innerloops
3138
3139 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3140 {
3141 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3142
3143 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3144
3145 if (data.devices_status == STATUS_CRACKED) break;
3146 if (data.devices_status == STATUS_ABORTED) break;
3147 if (data.devices_status == STATUS_QUIT) break;
3148 if (data.devices_status == STATUS_BYPASS) break;
3149
3150 uint innerloop_left = innerloop_cnt - innerloop_pos;
3151
3152 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3153
3154 device_param->innerloop_pos = innerloop_pos;
3155 device_param->innerloop_left = innerloop_left;
3156
3157 device_param->kernel_params_buf32[27] = innerloop_left;
3158
3159 // i think we can get rid of this
3160 if (innerloop_left == 0)
3161 {
3162 puts ("bug, how should this happen????\n");
3163
3164 continue;
3165 }
3166
3167 if (data.salts_shown[salt_pos] == 1)
3168 {
3169 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3170
3171 continue;
3172 }
3173
3174 // initialize amplifiers
3175
3176 if (data.attack_mode == ATTACK_MODE_COMBI)
3177 {
3178 uint i = 0;
3179
3180 while (i < innerloop_left)
3181 {
3182 if (feof (combs_fp)) break;
3183
3184 int line_len = fgetl (combs_fp, line_buf);
3185
3186 if (line_len >= PW_MAX1) continue;
3187
3188 line_len = convert_from_hex (line_buf, line_len);
3189
3190 char *line_buf_new = line_buf;
3191
3192 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3193 {
3194 char rule_buf_out[BLOCK_SIZE] = { 0 };
3195
3196 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3197
3198 if (rule_len_out < 0)
3199 {
3200 data.words_progress_rejected[salt_pos] += pws_cnt;
3201
3202 continue;
3203 }
3204
3205 line_len = rule_len_out;
3206
3207 line_buf_new = rule_buf_out;
3208 }
3209
3210 line_len = MIN (line_len, PW_DICTMAX);
3211
3212 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3213
3214 memcpy (ptr, line_buf_new, line_len);
3215
3216 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3217
3218 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3219 {
3220 uppercase (ptr, line_len);
3221 }
3222
3223 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3224 {
3225 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3226 {
3227 ptr[line_len] = 0x80;
3228 }
3229
3230 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3231 {
3232 ptr[line_len] = 0x01;
3233 }
3234 }
3235
3236 device_param->combs_buf[i].pw_len = line_len;
3237
3238 i++;
3239 }
3240
3241 for (uint j = i; j < innerloop_left; j++)
3242 {
3243 device_param->combs_buf[j].i[0] = 0;
3244 device_param->combs_buf[j].i[1] = 0;
3245 device_param->combs_buf[j].i[2] = 0;
3246 device_param->combs_buf[j].i[3] = 0;
3247 device_param->combs_buf[j].i[4] = 0;
3248 device_param->combs_buf[j].i[5] = 0;
3249 device_param->combs_buf[j].i[6] = 0;
3250 device_param->combs_buf[j].i[7] = 0;
3251
3252 device_param->combs_buf[j].pw_len = 0;
3253 }
3254
3255 innerloop_left = i;
3256 }
3257 else if (data.attack_mode == ATTACK_MODE_BF)
3258 {
3259 u64 off = innerloop_pos;
3260
3261 device_param->kernel_params_mp_r_buf64[3] = off;
3262
3263 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3264 }
3265 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3266 {
3267 u64 off = innerloop_pos;
3268
3269 device_param->kernel_params_mp_buf64[3] = off;
3270
3271 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3272 }
3273 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3274 {
3275 u64 off = innerloop_pos;
3276
3277 device_param->kernel_params_mp_buf64[3] = off;
3278
3279 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3280 }
3281
3282 // copy amplifiers
3283
3284 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3285 {
3286 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, innerloop_pos * sizeof (kernel_rule_t), 0, innerloop_left * sizeof (kernel_rule_t), 0, NULL, NULL);
3287 }
3288 else if (data.attack_mode == ATTACK_MODE_COMBI)
3289 {
3290 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_combs_c, CL_TRUE, 0, innerloop_left * sizeof (comb_t), device_param->combs_buf, 0, NULL, NULL);
3291 }
3292 else if (data.attack_mode == ATTACK_MODE_BF)
3293 {
3294 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_bfs, device_param->d_bfs_c, 0, 0, innerloop_left * sizeof (bf_t), 0, NULL, NULL);
3295 }
3296 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3297 {
3298 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3299 }
3300 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3301 {
3302 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_combs, device_param->d_combs_c, 0, 0, innerloop_left * sizeof (comb_t), 0, NULL, NULL);
3303 }
3304
3305 if (data.benchmark == 1)
3306 {
3307 hc_timer_set (&device_param->timer_speed);
3308 }
3309
3310 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3311
3312 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3313
3314 if (data.devices_status == STATUS_CRACKED) break;
3315 if (data.devices_status == STATUS_ABORTED) break;
3316 if (data.devices_status == STATUS_QUIT) break;
3317
3318 /**
3319 * result
3320 */
3321
3322 check_cracked (device_param, salt_pos);
3323
3324 /**
3325 * progress
3326 */
3327
3328 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3329
3330 hc_thread_mutex_lock (mux_counter);
3331
3332 data.words_progress_done[salt_pos] += perf_sum_all;
3333
3334 hc_thread_mutex_unlock (mux_counter);
3335
3336 /**
3337 * speed
3338 */
3339
3340 double speed_ms;
3341
3342 hc_timer_get (device_param->timer_speed, speed_ms);
3343
3344 hc_timer_set (&device_param->timer_speed);
3345
3346 // current speed
3347
3348 //hc_thread_mutex_lock (mux_display);
3349
3350 device_param->speed_cnt[speed_pos] = perf_sum_all;
3351
3352 device_param->speed_ms[speed_pos] = speed_ms;
3353
3354 //hc_thread_mutex_unlock (mux_display);
3355
3356 speed_pos++;
3357
3358 if (speed_pos == SPEED_CACHE)
3359 {
3360 speed_pos = 0;
3361 }
3362
3363 /**
3364 * benchmark
3365 */
3366
3367 if (data.benchmark == 1) break;
3368 }
3369 }
3370
3371 device_param->speed_pos = speed_pos;
3372
3373 myfree (line_buf);
3374 }
3375
3376 static void load_segment (wl_data_t *wl_data, FILE *fd)
3377 {
3378 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3379
3380 wl_data->pos = 0;
3381
3382 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3383
3384 wl_data->buf[wl_data->cnt] = 0;
3385
3386 if (wl_data->cnt == 0) return;
3387
3388 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3389
3390 while (!feof (fd))
3391 {
3392 if (wl_data->cnt == wl_data->avail)
3393 {
3394 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3395
3396 wl_data->avail += wl_data->incr;
3397 }
3398
3399 const int c = fgetc (fd);
3400
3401 if (c == EOF) break;
3402
3403 wl_data->buf[wl_data->cnt] = (char) c;
3404
3405 wl_data->cnt++;
3406
3407 if (c == '\n') break;
3408 }
3409
3410 // ensure stream ends with a newline
3411
3412 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3413 {
3414 wl_data->cnt++;
3415
3416 wl_data->buf[wl_data->cnt - 1] = '\n';
3417 }
3418
3419 return;
3420 }
3421
3422 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3423 {
3424 char *ptr = buf;
3425
3426 for (u32 i = 0; i < sz; i++, ptr++)
3427 {
3428 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3429
3430 if (i == 7)
3431 {
3432 *off = i;
3433 *len = i;
3434
3435 return;
3436 }
3437
3438 if (*ptr != '\n') continue;
3439
3440 *off = i + 1;
3441
3442 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3443
3444 *len = i;
3445
3446 return;
3447 }
3448
3449 *off = sz;
3450 *len = sz;
3451 }
3452
3453 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3454 {
3455 char *ptr = buf;
3456
3457 for (u32 i = 0; i < sz; i++, ptr++)
3458 {
3459 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3460
3461 if (*ptr != '\n') continue;
3462
3463 *off = i + 1;
3464
3465 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3466
3467 *len = i;
3468
3469 return;
3470 }
3471
3472 *off = sz;
3473 *len = sz;
3474 }
3475
3476 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3477 {
3478 char *ptr = buf;
3479
3480 for (u32 i = 0; i < sz; i++, ptr++)
3481 {
3482 if (*ptr != '\n') continue;
3483
3484 *off = i + 1;
3485
3486 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3487
3488 *len = i;
3489
3490 return;
3491 }
3492
3493 *off = sz;
3494 *len = sz;
3495 }
3496
3497 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3498 {
3499 while (wl_data->pos < wl_data->cnt)
3500 {
3501 uint off;
3502 uint len;
3503
3504 char *ptr = wl_data->buf + wl_data->pos;
3505
3506 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3507
3508 wl_data->pos += off;
3509
3510 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3511 {
3512 char rule_buf_out[BLOCK_SIZE] = { 0 };
3513
3514 int rule_len_out = -1;
3515
3516 if (len < BLOCK_SIZE)
3517 {
3518 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3519 }
3520
3521 if (rule_len_out < 0)
3522 {
3523 continue;
3524 }
3525
3526 if (rule_len_out > PW_MAX)
3527 {
3528 continue;
3529 }
3530 }
3531 else
3532 {
3533 if (len > PW_MAX)
3534 {
3535 continue;
3536 }
3537 }
3538
3539 *out_buf = ptr;
3540 *out_len = len;
3541
3542 return;
3543 }
3544
3545 if (feof (fd))
3546 {
3547 fprintf (stderr, "BUG feof()!!\n");
3548
3549 return;
3550 }
3551
3552 load_segment (wl_data, fd);
3553
3554 get_next_word (wl_data, fd, out_buf, out_len);
3555 }
3556
3557 #ifdef _POSIX
3558 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3559 #endif
3560
3561 #ifdef _WIN
3562 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3563 #endif
3564 {
3565 hc_signal (NULL);
3566
3567 dictstat_t d;
3568
3569 d.cnt = 0;
3570
3571 #ifdef _POSIX
3572 fstat (fileno (fd), &d.stat);
3573 #endif
3574
3575 #ifdef _WIN
3576 _fstat64 (fileno (fd), &d.stat);
3577 #endif
3578
3579 d.stat.st_mode = 0;
3580 d.stat.st_nlink = 0;
3581 d.stat.st_uid = 0;
3582 d.stat.st_gid = 0;
3583 d.stat.st_rdev = 0;
3584 d.stat.st_atime = 0;
3585
3586 #ifdef _POSIX
3587 d.stat.st_blksize = 0;
3588 d.stat.st_blocks = 0;
3589 #endif
3590
3591 if (d.stat.st_size == 0) return 0;
3592
3593 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3594
3595 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3596 {
3597 if (d_cache)
3598 {
3599 u64 cnt = d_cache->cnt;
3600
3601 u64 keyspace = cnt;
3602
3603 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3604 {
3605 keyspace *= data.kernel_rules_cnt;
3606 }
3607 else if (data.attack_kern == ATTACK_KERN_COMBI)
3608 {
3609 keyspace *= data.combs_cnt;
3610 }
3611
3612 if (data.quiet == 0) log_info ("Cache-hit dictionary stats %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) d.stat.st_size, (unsigned long long int) cnt, (unsigned long long int) keyspace);
3613 if (data.quiet == 0) log_info ("");
3614
3615 hc_signal (sigHandler_default);
3616
3617 return (keyspace);
3618 }
3619 }
3620
3621 time_t now = 0;
3622 time_t prev = 0;
3623
3624 u64 comp = 0;
3625 u64 cnt = 0;
3626 u64 cnt2 = 0;
3627
3628 while (!feof (fd))
3629 {
3630 load_segment (wl_data, fd);
3631
3632 comp += wl_data->cnt;
3633
3634 u32 i = 0;
3635
3636 while (i < wl_data->cnt)
3637 {
3638 u32 len;
3639 u32 off;
3640
3641 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3642
3643 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3644 {
3645 char rule_buf_out[BLOCK_SIZE] = { 0 };
3646
3647 int rule_len_out = -1;
3648
3649 if (len < BLOCK_SIZE)
3650 {
3651 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3652 }
3653
3654 if (rule_len_out < 0)
3655 {
3656 len = PW_MAX1;
3657 }
3658 else
3659 {
3660 len = rule_len_out;
3661 }
3662 }
3663
3664 if (len < PW_MAX1)
3665 {
3666 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3667 {
3668 cnt += data.kernel_rules_cnt;
3669 }
3670 else if (data.attack_kern == ATTACK_KERN_COMBI)
3671 {
3672 cnt += data.combs_cnt;
3673 }
3674
3675 d.cnt++;
3676 }
3677
3678 i += off;
3679
3680 cnt2++;
3681 }
3682
3683 time (&now);
3684
3685 if ((now - prev) == 0) continue;
3686
3687 float percent = (float) comp / (float) d.stat.st_size;
3688
3689 if (data.quiet == 0) log_info_nn ("Generating dictionary stats for %s: %llu bytes (%.2f%%), %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, percent * 100, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3690
3691 time (&prev);
3692 }
3693
3694 if (data.quiet == 0) log_info ("Generated dictionary stats for %s: %llu bytes, %llu words, %llu keyspace", dictfile, (unsigned long long int) comp, (unsigned long long int) cnt2, (unsigned long long int) cnt);
3695 if (data.quiet == 0) log_info ("");
3696
3697 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3698
3699 hc_signal (sigHandler_default);
3700
3701 return (cnt);
3702 }
3703
3704 static void *thread_monitor (void *p)
3705 {
3706 uint runtime_check = 0;
3707 uint remove_check = 0;
3708 uint status_check = 0;
3709 uint restore_check = 0;
3710
3711 uint restore_left = data.restore_timer;
3712 uint remove_left = data.remove_timer;
3713 uint status_left = data.status_timer;
3714
3715 #ifdef HAVE_HWMON
3716 uint hwmon_check = 0;
3717
3718 // these variables are mainly used for fan control (AMD only)
3719
3720 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3721
3722 // temperature controller "loopback" values
3723
3724 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3725 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3726
3727 #ifdef HAVE_ADL
3728 int temp_threshold = 1; // degrees celcius
3729
3730 int fan_speed_min = 15; // in percentage
3731 int fan_speed_max = 100;
3732 #endif // HAVE_ADL
3733
3734 time_t last_temp_check_time;
3735 #endif // HAVE_HWMON
3736
3737 uint sleep_time = 1;
3738
3739 if (data.runtime)
3740 {
3741 runtime_check = 1;
3742 }
3743
3744 if (data.restore_timer)
3745 {
3746 restore_check = 1;
3747 }
3748
3749 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3750 {
3751 remove_check = 1;
3752 }
3753
3754 if (data.status == 1)
3755 {
3756 status_check = 1;
3757 }
3758
3759 #ifdef HAVE_HWMON
3760 if (data.gpu_temp_disable == 0)
3761 {
3762 time (&last_temp_check_time);
3763
3764 hwmon_check = 1;
3765 }
3766 #endif
3767
3768 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3769 {
3770 #ifdef HAVE_HWMON
3771 if (hwmon_check == 0)
3772 #endif
3773 return (p);
3774 }
3775
3776 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3777 {
3778 hc_sleep (sleep_time);
3779
3780 if (data.devices_status != STATUS_RUNNING) continue;
3781
3782 #ifdef HAVE_HWMON
3783 if (hwmon_check == 1)
3784 {
3785 hc_thread_mutex_lock (mux_adl);
3786
3787 time_t temp_check_time;
3788
3789 time (&temp_check_time);
3790
3791 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3792
3793 if (Ta == 0) Ta = 1;
3794
3795 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3796 {
3797 hc_device_param_t *device_param = &data.devices_param[device_id];
3798
3799 if (device_param->skipped) continue;
3800
3801 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3802
3803 const int temperature = hm_get_temperature_with_device_id (device_id);
3804
3805 if (temperature > (int) data.gpu_temp_abort)
3806 {
3807 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3808
3809 if (data.devices_status != STATUS_QUIT) myabort ();
3810
3811 break;
3812 }
3813
3814 #ifdef HAVE_ADL
3815 const int gpu_temp_retain = data.gpu_temp_retain;
3816
3817 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3818 {
3819 if (data.hm_device[device_id].fan_supported == 1)
3820 {
3821 int temp_cur = temperature;
3822
3823 int temp_diff_new = gpu_temp_retain - temp_cur;
3824
3825 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3826
3827 // calculate Ta value (time difference in seconds between the last check and this check)
3828
3829 last_temp_check_time = temp_check_time;
3830
3831 float Kp = 1.8;
3832 float Ki = 0.005;
3833 float Kd = 6;
3834
3835 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3836
3837 int fan_diff_required = (int) (Kp * (float)temp_diff_new + Ki * Ta * (float)temp_diff_sum[device_id] + Kd * ((float)(temp_diff_new - temp_diff_old[device_id])) / Ta);
3838
3839 if (abs (fan_diff_required) >= temp_threshold)
3840 {
3841 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3842
3843 int fan_speed_level = fan_speed_cur;
3844
3845 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3846
3847 int fan_speed_new = fan_speed_level - fan_diff_required;
3848
3849 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3850 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3851
3852 if (fan_speed_new != fan_speed_cur)
3853 {
3854 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3855 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3856
3857 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3858 {
3859 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3860
3861 fan_speed_chgd[device_id] = 1;
3862 }
3863
3864 temp_diff_old[device_id] = temp_diff_new;
3865 }
3866 }
3867 }
3868 }
3869 #endif // HAVE_ADL
3870 }
3871
3872 hc_thread_mutex_unlock (mux_adl);
3873 }
3874 #endif // HAVE_HWMON
3875
3876 if (restore_check == 1)
3877 {
3878 restore_left--;
3879
3880 if (restore_left == 0)
3881 {
3882 if (data.restore_disable == 0) cycle_restore ();
3883
3884 restore_left = data.restore_timer;
3885 }
3886 }
3887
3888 if ((runtime_check == 1) && (data.runtime_start > 0))
3889 {
3890 time_t runtime_cur;
3891
3892 time (&runtime_cur);
3893
3894 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3895
3896 if (runtime_left <= 0)
3897 {
3898 if (data.benchmark == 0)
3899 {
3900 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3901 }
3902
3903 if (data.devices_status != STATUS_QUIT) myabort ();
3904 }
3905 }
3906
3907 if (remove_check == 1)
3908 {
3909 remove_left--;
3910
3911 if (remove_left == 0)
3912 {
3913 if (data.digests_saved != data.digests_done)
3914 {
3915 data.digests_saved = data.digests_done;
3916
3917 save_hash ();
3918 }
3919
3920 remove_left = data.remove_timer;
3921 }
3922 }
3923
3924 if (status_check == 1)
3925 {
3926 status_left--;
3927
3928 if (status_left == 0)
3929 {
3930 //hc_thread_mutex_lock (mux_display);
3931
3932 if (data.quiet == 0) clear_prompt ();
3933
3934 if (data.quiet == 0) log_info ("");
3935
3936 status_display ();
3937
3938 if (data.quiet == 0) log_info ("");
3939
3940 //hc_thread_mutex_unlock (mux_display);
3941
3942 status_left = data.status_timer;
3943 }
3944 }
3945 }
3946
3947 #ifdef HAVE_HWMON
3948 myfree (fan_speed_chgd);
3949
3950 myfree (temp_diff_old);
3951 myfree (temp_diff_sum);
3952 #endif
3953
3954 p = NULL;
3955
3956 return (p);
3957 }
3958
3959 static void *thread_outfile_remove (void *p)
3960 {
3961 // some hash-dependent constants
3962 char *outfile_dir = data.outfile_check_directory;
3963 uint dgst_size = data.dgst_size;
3964 uint isSalted = data.isSalted;
3965 uint esalt_size = data.esalt_size;
3966 uint hash_mode = data.hash_mode;
3967
3968 uint outfile_check_timer = data.outfile_check_timer;
3969
3970 char separator = data.separator;
3971
3972 // some hash-dependent functions
3973 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3974 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3975
3976 // buffers
3977 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3978
3979 hash_buf.digest = mymalloc (dgst_size);
3980
3981 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3982
3983 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3984
3985 uint digest_buf[64] = { 0 };
3986
3987 outfile_data_t *out_info = NULL;
3988
3989 char **out_files = NULL;
3990
3991 time_t folder_mtime = 0;
3992
3993 int out_cnt = 0;
3994
3995 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3996
3997 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3998 {
3999 hc_sleep (1);
4000
4001 if (data.devices_status != STATUS_RUNNING) continue;
4002
4003 check_left--;
4004
4005 if (check_left == 0)
4006 {
4007 struct stat outfile_check_stat;
4008
4009 if (stat (outfile_dir, &outfile_check_stat) == 0)
4010 {
4011 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4012
4013 if (is_dir == 1)
4014 {
4015 if (outfile_check_stat.st_mtime > folder_mtime)
4016 {
4017 char **out_files_new = scan_directory (outfile_dir);
4018
4019 int out_cnt_new = count_dictionaries (out_files_new);
4020
4021 outfile_data_t *out_info_new = NULL;
4022
4023 if (out_cnt_new > 0)
4024 {
4025 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4026
4027 for (int i = 0; i < out_cnt_new; i++)
4028 {
4029 out_info_new[i].file_name = out_files_new[i];
4030
4031 // check if there are files that we have seen/checked before (and not changed)
4032
4033 for (int j = 0; j < out_cnt; j++)
4034 {
4035 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4036 {
4037 struct stat outfile_stat;
4038
4039 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4040 {
4041 if (outfile_stat.st_ctime == out_info[j].ctime)
4042 {
4043 out_info_new[i].ctime = out_info[j].ctime;
4044 out_info_new[i].seek = out_info[j].seek;
4045 }
4046 }
4047 }
4048 }
4049 }
4050 }
4051
4052 local_free (out_info);
4053 local_free (out_files);
4054
4055 out_files = out_files_new;
4056 out_cnt = out_cnt_new;
4057 out_info = out_info_new;
4058
4059 folder_mtime = outfile_check_stat.st_mtime;
4060 }
4061
4062 for (int j = 0; j < out_cnt; j++)
4063 {
4064 FILE *fp = fopen (out_info[j].file_name, "rb");
4065
4066 if (fp != NULL)
4067 {
4068 //hc_thread_mutex_lock (mux_display);
4069
4070 #ifdef _POSIX
4071 struct stat outfile_stat;
4072
4073 fstat (fileno (fp), &outfile_stat);
4074 #endif
4075
4076 #ifdef _WIN
4077 struct stat64 outfile_stat;
4078
4079 _fstat64 (fileno (fp), &outfile_stat);
4080 #endif
4081
4082 if (outfile_stat.st_ctime > out_info[j].ctime)
4083 {
4084 out_info[j].ctime = outfile_stat.st_ctime;
4085 out_info[j].seek = 0;
4086 }
4087
4088 fseek (fp, out_info[j].seek, SEEK_SET);
4089
4090 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4091
4092 while (!feof (fp))
4093 {
4094 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4095
4096 if (ptr == NULL) break;
4097
4098 int line_len = strlen (line_buf);
4099
4100 if (line_len <= 0) continue;
4101
4102 int iter = MAX_CUT_TRIES;
4103
4104 for (uint i = line_len - 1; i && iter; i--, line_len--)
4105 {
4106 if (line_buf[i] != separator) continue;
4107
4108 int parser_status = PARSER_OK;
4109
4110 if ((hash_mode != 2500) && (hash_mode != 6800))
4111 {
4112 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4113 }
4114
4115 uint found = 0;
4116
4117 if (parser_status == PARSER_OK)
4118 {
4119 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4120 {
4121 if (data.salts_shown[salt_pos] == 1) continue;
4122
4123 salt_t *salt_buf = &data.salts_buf[salt_pos];
4124
4125 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4126 {
4127 uint idx = salt_buf->digests_offset + digest_pos;
4128
4129 if (data.digests_shown[idx] == 1) continue;
4130
4131 uint cracked = 0;
4132
4133 if (hash_mode == 6800)
4134 {
4135 if (i == salt_buf->salt_len)
4136 {
4137 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4138 }
4139 }
4140 else if (hash_mode == 2500)
4141 {
4142 // BSSID : MAC1 : MAC2 (:plain)
4143 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4144 {
4145 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4146
4147 if (!cracked) continue;
4148
4149 // now compare MAC1 and MAC2 too, since we have this additional info
4150 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4151 char *mac2_pos = mac1_pos + 12 + 1;
4152
4153 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4154 wpa_t *wpa = &wpas[salt_pos];
4155
4156 // compare hex string(s) vs binary MAC address(es)
4157
4158 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4159 {
4160 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4161 {
4162 cracked = 0;
4163
4164 break;
4165 }
4166 }
4167
4168 // early skip ;)
4169 if (!cracked) continue;
4170
4171 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4172 {
4173 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4174 {
4175 cracked = 0;
4176
4177 break;
4178 }
4179 }
4180 }
4181 }
4182 else
4183 {
4184 char *digests_buf_ptr = (char *) data.digests_buf;
4185
4186 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4187
4188 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4189 }
4190
4191 if (cracked == 1)
4192 {
4193 found = 1;
4194
4195 data.digests_shown[idx] = 1;
4196
4197 data.digests_done++;
4198
4199 salt_buf->digests_done++;
4200
4201 if (salt_buf->digests_done == salt_buf->digests_cnt)
4202 {
4203 data.salts_shown[salt_pos] = 1;
4204
4205 data.salts_done++;
4206
4207 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4208 }
4209 }
4210 }
4211
4212 if (data.devices_status == STATUS_CRACKED) break;
4213 }
4214 }
4215
4216 if (found) break;
4217
4218 if (data.devices_status == STATUS_CRACKED) break;
4219
4220 iter--;
4221 }
4222
4223 if (data.devices_status == STATUS_CRACKED) break;
4224 }
4225
4226 myfree (line_buf);
4227
4228 out_info[j].seek = ftell (fp);
4229
4230 //hc_thread_mutex_unlock (mux_display);
4231
4232 fclose (fp);
4233 }
4234 }
4235 }
4236 }
4237
4238 check_left = outfile_check_timer;
4239 }
4240 }
4241
4242 if (esalt_size) local_free (hash_buf.esalt);
4243
4244 if (isSalted) local_free (hash_buf.salt);
4245
4246 local_free (hash_buf.digest);
4247
4248 local_free (out_info);
4249
4250 local_free (out_files);
4251
4252 p = NULL;
4253
4254 return (p);
4255 }
4256
4257 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4258 {
4259 if (device_param->pws_cnt < device_param->kernel_power)
4260 {
4261 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4262
4263 u8 *ptr = (u8 *) pw->i;
4264
4265 memcpy (ptr, pw_buf, pw_len);
4266
4267 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4268
4269 pw->pw_len = pw_len;
4270
4271 device_param->pws_cnt++;
4272 }
4273 else
4274 {
4275 fprintf (stderr, "BUG pw_add()!!\n");
4276
4277 return;
4278 }
4279 }
4280
4281 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4282 {
4283 hc_thread_mutex_lock (mux_dispatcher);
4284
4285 const u64 words_cur = data.words_cur;
4286 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4287
4288 device_param->words_off = words_cur;
4289
4290 const u64 words_left = words_base - words_cur;
4291
4292 if (allow_div)
4293 {
4294 if (data.kernel_power_all > words_left)
4295 {
4296 if (data.kernel_power_div == 0)
4297 {
4298 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4299 }
4300 }
4301
4302 if (data.kernel_power_div)
4303 {
4304 if (device_param->kernel_power == device_param->kernel_power_user)
4305 {
4306 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4307
4308 if (kernel_power_new < device_param->kernel_power)
4309 {
4310 device_param->kernel_power = kernel_power_new;
4311 }
4312 }
4313 }
4314 }
4315
4316 const uint kernel_power = device_param->kernel_power;
4317
4318 uint work = MIN (words_left, kernel_power);
4319
4320 work = MIN (work, max);
4321
4322 data.words_cur += work;
4323
4324 hc_thread_mutex_unlock (mux_dispatcher);
4325
4326 return work;
4327 }
4328
4329 static void *thread_calc_stdin (void *p)
4330 {
4331 hc_device_param_t *device_param = (hc_device_param_t *) p;
4332
4333 if (device_param->skipped) return NULL;
4334
4335 autotune (device_param);
4336
4337 char *buf = (char *) mymalloc (HCBUFSIZ);
4338
4339 const uint attack_kern = data.attack_kern;
4340
4341 const uint kernel_power = device_param->kernel_power;
4342
4343 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4344 {
4345 hc_thread_mutex_lock (mux_dispatcher);
4346
4347 if (feof (stdin) != 0)
4348 {
4349 hc_thread_mutex_unlock (mux_dispatcher);
4350
4351 break;
4352 }
4353
4354 uint words_cur = 0;
4355
4356 while (words_cur < kernel_power)
4357 {
4358 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4359
4360 if (line_buf == NULL) break;
4361
4362 uint line_len = in_superchop (line_buf);
4363
4364 line_len = convert_from_hex (line_buf, line_len);
4365
4366 // post-process rule engine
4367
4368 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4369 {
4370 char rule_buf_out[BLOCK_SIZE] = { 0 };
4371
4372 int rule_len_out = -1;
4373
4374 if (line_len < BLOCK_SIZE)
4375 {
4376 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4377 }
4378
4379 if (rule_len_out < 0) continue;
4380
4381 line_buf = rule_buf_out;
4382 line_len = rule_len_out;
4383 }
4384
4385 if (line_len > PW_MAX)
4386 {
4387 continue;
4388 }
4389
4390 if (attack_kern == ATTACK_KERN_STRAIGHT)
4391 {
4392 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4393 {
4394 hc_thread_mutex_lock (mux_counter);
4395
4396 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4397 {
4398 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4399 }
4400
4401 hc_thread_mutex_unlock (mux_counter);
4402
4403 continue;
4404 }
4405 }
4406 else if (attack_kern == ATTACK_KERN_COMBI)
4407 {
4408 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4409 // since we still need to combine the plains
4410
4411 if (line_len > data.pw_max)
4412 {
4413 hc_thread_mutex_lock (mux_counter);
4414
4415 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4416 {
4417 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4418 }
4419
4420 hc_thread_mutex_unlock (mux_counter);
4421
4422 continue;
4423 }
4424 }
4425
4426 pw_add (device_param, (u8 *) line_buf, line_len);
4427
4428 words_cur++;
4429
4430 if (data.devices_status == STATUS_CRACKED) break;
4431 if (data.devices_status == STATUS_ABORTED) break;
4432 if (data.devices_status == STATUS_QUIT) break;
4433 if (data.devices_status == STATUS_BYPASS) break;
4434 }
4435
4436 hc_thread_mutex_unlock (mux_dispatcher);
4437
4438 if (data.devices_status == STATUS_CRACKED) break;
4439 if (data.devices_status == STATUS_ABORTED) break;
4440 if (data.devices_status == STATUS_QUIT) break;
4441 if (data.devices_status == STATUS_BYPASS) break;
4442
4443 // flush
4444
4445 const uint pws_cnt = device_param->pws_cnt;
4446
4447 if (pws_cnt)
4448 {
4449 run_copy (device_param, pws_cnt);
4450
4451 run_cracker (device_param, pws_cnt);
4452
4453 device_param->pws_cnt = 0;
4454
4455 /*
4456 still required?
4457 if (attack_kern == ATTACK_KERN_STRAIGHT)
4458 {
4459 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4460 }
4461 else if (attack_kern == ATTACK_KERN_COMBI)
4462 {
4463 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4464 }
4465 */
4466 }
4467 }
4468
4469 device_param->kernel_accel = 0;
4470 device_param->kernel_loops = 0;
4471
4472 myfree (buf);
4473
4474 return NULL;
4475 }
4476
4477 static void *thread_calc (void *p)
4478 {
4479 hc_device_param_t *device_param = (hc_device_param_t *) p;
4480
4481 if (device_param->skipped) return NULL;
4482
4483 autotune (device_param);
4484
4485 const uint attack_mode = data.attack_mode;
4486 const uint attack_kern = data.attack_kern;
4487
4488 if (attack_mode == ATTACK_MODE_BF)
4489 {
4490 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4491 {
4492 const uint work = get_work (device_param, -1, true);
4493
4494 if (work == 0) break;
4495
4496 const u64 words_off = device_param->words_off;
4497 const u64 words_fin = words_off + work;
4498
4499 const uint pws_cnt = work;
4500
4501 device_param->pws_cnt = pws_cnt;
4502
4503 if (pws_cnt)
4504 {
4505 run_copy (device_param, pws_cnt);
4506
4507 run_cracker (device_param, pws_cnt);
4508
4509 device_param->pws_cnt = 0;
4510
4511 /*
4512 still required?
4513 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4514 */
4515 }
4516
4517 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4518
4519 if (data.devices_status == STATUS_CRACKED) break;
4520 if (data.devices_status == STATUS_ABORTED) break;
4521 if (data.devices_status == STATUS_QUIT) break;
4522 if (data.devices_status == STATUS_BYPASS) break;
4523
4524 if (data.benchmark == 1) break;
4525
4526 device_param->words_done = words_fin;
4527 }
4528 }
4529 else
4530 {
4531 const uint segment_size = data.segment_size;
4532
4533 char *dictfile = data.dictfile;
4534
4535 if (attack_mode == ATTACK_MODE_COMBI)
4536 {
4537 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4538 {
4539 dictfile = data.dictfile2;
4540 }
4541 }
4542
4543 FILE *fd = fopen (dictfile, "rb");
4544
4545 if (fd == NULL)
4546 {
4547 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4548
4549 return NULL;
4550 }
4551
4552 if (attack_mode == ATTACK_MODE_COMBI)
4553 {
4554 const uint combs_mode = data.combs_mode;
4555
4556 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4557 {
4558 const char *dictfilec = data.dictfile2;
4559
4560 FILE *combs_fp = fopen (dictfilec, "rb");
4561
4562 if (combs_fp == NULL)
4563 {
4564 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4565
4566 fclose (fd);
4567
4568 return NULL;
4569 }
4570
4571 device_param->combs_fp = combs_fp;
4572 }
4573 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4574 {
4575 const char *dictfilec = data.dictfile;
4576
4577 FILE *combs_fp = fopen (dictfilec, "rb");
4578
4579 if (combs_fp == NULL)
4580 {
4581 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4582
4583 fclose (fd);
4584
4585 return NULL;
4586 }
4587
4588 device_param->combs_fp = combs_fp;
4589 }
4590 }
4591
4592 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4593
4594 wl_data->buf = (char *) mymalloc (segment_size);
4595 wl_data->avail = segment_size;
4596 wl_data->incr = segment_size;
4597 wl_data->cnt = 0;
4598 wl_data->pos = 0;
4599
4600 u64 words_cur = 0;
4601
4602 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4603 {
4604 u64 words_off = 0;
4605 u64 words_fin = 0;
4606
4607 bool allow_div = true;
4608
4609 u64 max = -1;
4610
4611 while (max)
4612 {
4613 const uint work = get_work (device_param, max, allow_div);
4614
4615 allow_div = false;
4616
4617 if (work == 0) break;
4618
4619 words_off = device_param->words_off;
4620 words_fin = words_off + work;
4621
4622 char *line_buf;
4623 uint line_len;
4624
4625 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4626
4627 max = 0;
4628
4629 for ( ; words_cur < words_fin; words_cur++)
4630 {
4631 get_next_word (wl_data, fd, &line_buf, &line_len);
4632
4633 line_len = convert_from_hex (line_buf, line_len);
4634
4635 // post-process rule engine
4636
4637 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4638 {
4639 char rule_buf_out[BLOCK_SIZE] = { 0 };
4640
4641 int rule_len_out = -1;
4642
4643 if (line_len < BLOCK_SIZE)
4644 {
4645 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4646 }
4647
4648 if (rule_len_out < 0) continue;
4649
4650 line_buf = rule_buf_out;
4651 line_len = rule_len_out;
4652 }
4653
4654 if (attack_kern == ATTACK_KERN_STRAIGHT)
4655 {
4656 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4657 {
4658 max++;
4659
4660 hc_thread_mutex_lock (mux_counter);
4661
4662 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4663 {
4664 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4665 }
4666
4667 hc_thread_mutex_unlock (mux_counter);
4668
4669 continue;
4670 }
4671 }
4672 else if (attack_kern == ATTACK_KERN_COMBI)
4673 {
4674 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4675 // since we still need to combine the plains
4676
4677 if (line_len > data.pw_max)
4678 {
4679 max++;
4680
4681 hc_thread_mutex_lock (mux_counter);
4682
4683 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4684 {
4685 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4686 }
4687
4688 hc_thread_mutex_unlock (mux_counter);
4689
4690 continue;
4691 }
4692 }
4693
4694 pw_add (device_param, (u8 *) line_buf, line_len);
4695
4696 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4697
4698 if (data.devices_status == STATUS_CRACKED) break;
4699 if (data.devices_status == STATUS_ABORTED) break;
4700 if (data.devices_status == STATUS_QUIT) break;
4701 if (data.devices_status == STATUS_BYPASS) break;
4702 }
4703
4704 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4705
4706 if (data.devices_status == STATUS_CRACKED) break;
4707 if (data.devices_status == STATUS_ABORTED) break;
4708 if (data.devices_status == STATUS_QUIT) break;
4709 if (data.devices_status == STATUS_BYPASS) break;
4710 }
4711
4712 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4713
4714 if (data.devices_status == STATUS_CRACKED) break;
4715 if (data.devices_status == STATUS_ABORTED) break;
4716 if (data.devices_status == STATUS_QUIT) break;
4717 if (data.devices_status == STATUS_BYPASS) break;
4718
4719 //
4720 // flush
4721 //
4722
4723 const uint pws_cnt = device_param->pws_cnt;
4724
4725 if (pws_cnt)
4726 {
4727 run_copy (device_param, pws_cnt);
4728
4729 run_cracker (device_param, pws_cnt);
4730
4731 device_param->pws_cnt = 0;
4732
4733 /*
4734 still required?
4735 if (attack_kern == ATTACK_KERN_STRAIGHT)
4736 {
4737 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4738 }
4739 else if (attack_kern == ATTACK_KERN_COMBI)
4740 {
4741 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4742 }
4743 */
4744 }
4745
4746 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4747
4748 if (data.devices_status == STATUS_CRACKED) break;
4749 if (data.devices_status == STATUS_ABORTED) break;
4750 if (data.devices_status == STATUS_QUIT) break;
4751 if (data.devices_status == STATUS_BYPASS) break;
4752
4753 if (words_fin == 0) break;
4754
4755 device_param->words_done = words_fin;
4756 }
4757
4758 if (attack_mode == ATTACK_MODE_COMBI)
4759 {
4760 fclose (device_param->combs_fp);
4761 }
4762
4763 free (wl_data->buf);
4764 free (wl_data);
4765
4766 fclose (fd);
4767 }
4768
4769 device_param->kernel_accel = 0;
4770 device_param->kernel_loops = 0;
4771
4772 return NULL;
4773 }
4774
4775 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4776 {
4777 if (!device_param)
4778 {
4779 log_error ("ERROR: %s : Invalid argument", __func__);
4780
4781 exit (-1);
4782 }
4783
4784 salt_t *salt_buf = &data.salts_buf[salt_pos];
4785
4786 device_param->kernel_params_buf32[24] = salt_pos;
4787 device_param->kernel_params_buf32[27] = 1;
4788 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4789 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4790 device_param->kernel_params_buf32[30] = 0;
4791 device_param->kernel_params_buf32[31] = 1;
4792
4793 char *dictfile_old = data.dictfile;
4794
4795 const char *weak_hash_check = "weak-hash-check";
4796
4797 data.dictfile = (char *) weak_hash_check;
4798
4799 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4800
4801 data.kernel_rules_buf[0].cmds[0] = 0;
4802
4803 /**
4804 * run the kernel
4805 */
4806
4807 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4808 {
4809 run_kernel (KERN_RUN_1, device_param, 1, false);
4810 }
4811 else
4812 {
4813 run_kernel (KERN_RUN_1, device_param, 1, false);
4814
4815 uint loop_step = 16;
4816
4817 const uint iter = salt_buf->salt_iter;
4818
4819 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4820 {
4821 uint loop_left = iter - loop_pos;
4822
4823 loop_left = MIN (loop_left, loop_step);
4824
4825 device_param->kernel_params_buf32[25] = loop_pos;
4826 device_param->kernel_params_buf32[26] = loop_left;
4827
4828 run_kernel (KERN_RUN_2, device_param, 1, false);
4829 }
4830
4831 run_kernel (KERN_RUN_3, device_param, 1, false);
4832 }
4833
4834 /**
4835 * result
4836 */
4837
4838 check_cracked (device_param, salt_pos);
4839
4840 /**
4841 * cleanup
4842 */
4843
4844 device_param->kernel_params_buf32[24] = 0;
4845 device_param->kernel_params_buf32[25] = 0;
4846 device_param->kernel_params_buf32[26] = 0;
4847 device_param->kernel_params_buf32[27] = 0;
4848 device_param->kernel_params_buf32[28] = 0;
4849 device_param->kernel_params_buf32[29] = 0;
4850 device_param->kernel_params_buf32[30] = 0;
4851 device_param->kernel_params_buf32[31] = 0;
4852
4853 data.dictfile = dictfile_old;
4854
4855 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4856 }
4857
4858 // hlfmt hashcat
4859
4860 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4861 {
4862 if (data.username == 0)
4863 {
4864 *hashbuf_pos = line_buf;
4865 *hashbuf_len = line_len;
4866 }
4867 else
4868 {
4869 char *pos = line_buf;
4870 int len = line_len;
4871
4872 for (int i = 0; i < line_len; i++, pos++, len--)
4873 {
4874 if (line_buf[i] == data.separator)
4875 {
4876 pos++;
4877
4878 len--;
4879
4880 break;
4881 }
4882 }
4883
4884 *hashbuf_pos = pos;
4885 *hashbuf_len = len;
4886 }
4887 }
4888
4889 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4890 {
4891 char *pos = NULL;
4892 int len = 0;
4893
4894 int sep_cnt = 0;
4895
4896 for (int i = 0; i < line_len; i++)
4897 {
4898 if (line_buf[i] == data.separator)
4899 {
4900 sep_cnt++;
4901
4902 continue;
4903 }
4904
4905 if (sep_cnt == 0)
4906 {
4907 if (pos == NULL) pos = line_buf + i;
4908
4909 len++;
4910 }
4911 }
4912
4913 *userbuf_pos = pos;
4914 *userbuf_len = len;
4915 }
4916
4917 // hlfmt pwdump
4918
4919 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4920 {
4921 int sep_cnt = 0;
4922
4923 int sep2_len = 0;
4924 int sep3_len = 0;
4925
4926 for (int i = 0; i < line_len; i++)
4927 {
4928 if (line_buf[i] == ':')
4929 {
4930 sep_cnt++;
4931
4932 continue;
4933 }
4934
4935 if (sep_cnt == 2) sep2_len++;
4936 if (sep_cnt == 3) sep3_len++;
4937 }
4938
4939 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4940
4941 return 0;
4942 }
4943
4944 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4945 {
4946 char *pos = NULL;
4947 int len = 0;
4948
4949 int sep_cnt = 0;
4950
4951 for (int i = 0; i < line_len; i++)
4952 {
4953 if (line_buf[i] == ':')
4954 {
4955 sep_cnt++;
4956
4957 continue;
4958 }
4959
4960 if (data.hash_mode == 1000)
4961 {
4962 if (sep_cnt == 3)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969 else if (data.hash_mode == 3000)
4970 {
4971 if (sep_cnt == 2)
4972 {
4973 if (pos == NULL) pos = line_buf + i;
4974
4975 len++;
4976 }
4977 }
4978 }
4979
4980 *hashbuf_pos = pos;
4981 *hashbuf_len = len;
4982 }
4983
4984 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4985 {
4986 char *pos = NULL;
4987 int len = 0;
4988
4989 int sep_cnt = 0;
4990
4991 for (int i = 0; i < line_len; i++)
4992 {
4993 if (line_buf[i] == ':')
4994 {
4995 sep_cnt++;
4996
4997 continue;
4998 }
4999
5000 if (sep_cnt == 0)
5001 {
5002 if (pos == NULL) pos = line_buf + i;
5003
5004 len++;
5005 }
5006 }
5007
5008 *userbuf_pos = pos;
5009 *userbuf_len = len;
5010 }
5011
5012 // hlfmt passwd
5013
5014 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5015 {
5016 int sep_cnt = 0;
5017
5018 char sep5_first = 0;
5019 char sep6_first = 0;
5020
5021 for (int i = 0; i < line_len; i++)
5022 {
5023 if (line_buf[i] == ':')
5024 {
5025 sep_cnt++;
5026
5027 continue;
5028 }
5029
5030 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5031 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5032 }
5033
5034 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5035
5036 return 0;
5037 }
5038
5039 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5040 {
5041 char *pos = NULL;
5042 int len = 0;
5043
5044 int sep_cnt = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == ':')
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (sep_cnt == 1)
5056 {
5057 if (pos == NULL) pos = line_buf + i;
5058
5059 len++;
5060 }
5061 }
5062
5063 *hashbuf_pos = pos;
5064 *hashbuf_len = len;
5065 }
5066
5067 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5068 {
5069 char *pos = NULL;
5070 int len = 0;
5071
5072 int sep_cnt = 0;
5073
5074 for (int i = 0; i < line_len; i++)
5075 {
5076 if (line_buf[i] == ':')
5077 {
5078 sep_cnt++;
5079
5080 continue;
5081 }
5082
5083 if (sep_cnt == 0)
5084 {
5085 if (pos == NULL) pos = line_buf + i;
5086
5087 len++;
5088 }
5089 }
5090
5091 *userbuf_pos = pos;
5092 *userbuf_len = len;
5093 }
5094
5095 // hlfmt shadow
5096
5097 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5098 {
5099 int sep_cnt = 0;
5100
5101 for (int i = 0; i < line_len; i++)
5102 {
5103 if (line_buf[i] == ':') sep_cnt++;
5104 }
5105
5106 if (sep_cnt == 8) return 1;
5107
5108 return 0;
5109 }
5110
5111 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5112 {
5113 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5114 }
5115
5116 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5117 {
5118 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5119 }
5120
5121 // hlfmt main
5122
5123 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5124 {
5125 switch (hashfile_format)
5126 {
5127 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5128 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5129 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5130 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5131 }
5132 }
5133
5134 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5135 {
5136 switch (hashfile_format)
5137 {
5138 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5139 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5140 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5141 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5142 }
5143 }
5144
5145 char *strhlfmt (const uint hashfile_format)
5146 {
5147 switch (hashfile_format)
5148 {
5149 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5150 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5151 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5152 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5153 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5154 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5155 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5156 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5157 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5158 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5159 }
5160
5161 return ((char *) "Unknown");
5162 }
5163
5164 static uint hlfmt_detect (FILE *fp, uint max_check)
5165 {
5166 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5167
5168 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5169 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5170
5171 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5172
5173 uint num_check = 0;
5174
5175 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5176
5177 while (!feof (fp))
5178 {
5179 int line_len = fgetl (fp, line_buf);
5180
5181 if (line_len == 0) continue;
5182
5183 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5184 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5185 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5186
5187 if (num_check == max_check) break;
5188
5189 num_check++;
5190 }
5191
5192 myfree (line_buf);
5193
5194 uint hashlist_format = HLFMT_HASHCAT;
5195
5196 for (int i = 1; i < HLFMTS_CNT; i++)
5197 {
5198 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5199
5200 hashlist_format = i;
5201 }
5202
5203 free (formats_cnt);
5204
5205 return hashlist_format;
5206 }
5207
5208 /**
5209 * some further helper function
5210 */
5211
5212 // wrapper around mymalloc for ADL
5213
5214 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5215 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5216 {
5217 return mymalloc (iSize);
5218 }
5219 #endif
5220
5221 static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, const uint dgst_shifts, char *digests_buf_ptr, const uint bitmap_mask, const uint bitmap_size, uint *bitmap_a, uint *bitmap_b, uint *bitmap_c, uint *bitmap_d, const u64 collisions_max)
5222 {
5223 u64 collisions = 0;
5224
5225 const uint dgst_pos0 = data.dgst_pos0;
5226 const uint dgst_pos1 = data.dgst_pos1;
5227 const uint dgst_pos2 = data.dgst_pos2;
5228 const uint dgst_pos3 = data.dgst_pos3;
5229
5230 memset (bitmap_a, 0, bitmap_size);
5231 memset (bitmap_b, 0, bitmap_size);
5232 memset (bitmap_c, 0, bitmap_size);
5233 memset (bitmap_d, 0, bitmap_size);
5234
5235 for (uint i = 0; i < digests_cnt; i++)
5236 {
5237 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5238
5239 uint *digest_ptr = (uint *) digests_buf_ptr;
5240
5241 digests_buf_ptr += dgst_size;
5242
5243 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5244 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5245 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5246 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5247
5248 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5249 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5250 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5251 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5252
5253 if (bitmap_a[idx0] & val0) collisions++;
5254 if (bitmap_b[idx1] & val1) collisions++;
5255 if (bitmap_c[idx2] & val2) collisions++;
5256 if (bitmap_d[idx3] & val3) collisions++;
5257
5258 bitmap_a[idx0] |= val0;
5259 bitmap_b[idx1] |= val1;
5260 bitmap_c[idx2] |= val2;
5261 bitmap_d[idx3] |= val3;
5262
5263 if (collisions >= collisions_max) return 0x7fffffff;
5264 }
5265
5266 return collisions;
5267 }
5268
5269 /**
5270 * main
5271 */
5272
5273 int main (int argc, char **argv)
5274 {
5275 /**
5276 * To help users a bit
5277 */
5278
5279 char *compute = getenv ("COMPUTE");
5280
5281 if (compute)
5282 {
5283 static char display[100];
5284
5285 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5286
5287 putenv (display);
5288 }
5289 else
5290 {
5291 if (getenv ("DISPLAY") == NULL)
5292 putenv ((char *) "DISPLAY=:0");
5293 }
5294
5295 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5296 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5297
5298 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5299 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5300
5301 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5302 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5303
5304 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5305 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5306
5307 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5308 putenv ((char *) "POCL_KERNEL_CACHE=0");
5309
5310 umask (077);
5311
5312 /**
5313 * Real init
5314 */
5315
5316 memset (&data, 0, sizeof (hc_global_data_t));
5317
5318 time_t proc_start;
5319
5320 time (&proc_start);
5321
5322 data.proc_start = proc_start;
5323
5324 int myargc = argc;
5325 char **myargv = argv;
5326
5327 hc_thread_mutex_init (mux_dispatcher);
5328 hc_thread_mutex_init (mux_counter);
5329 hc_thread_mutex_init (mux_display);
5330 hc_thread_mutex_init (mux_adl);
5331
5332 /**
5333 * commandline parameters
5334 */
5335
5336 uint usage = USAGE;
5337 uint version = VERSION;
5338 uint quiet = QUIET;
5339 uint benchmark = BENCHMARK;
5340 uint show = SHOW;
5341 uint left = LEFT;
5342 uint username = USERNAME;
5343 uint remove = REMOVE;
5344 uint remove_timer = REMOVE_TIMER;
5345 u64 skip = SKIP;
5346 u64 limit = LIMIT;
5347 uint keyspace = KEYSPACE;
5348 uint potfile_disable = POTFILE_DISABLE;
5349 char *potfile_path = NULL;
5350 uint debug_mode = DEBUG_MODE;
5351 char *debug_file = NULL;
5352 char *induction_dir = NULL;
5353 char *outfile_check_dir = NULL;
5354 uint force = FORCE;
5355 uint runtime = RUNTIME;
5356 uint hash_mode = HASH_MODE;
5357 uint attack_mode = ATTACK_MODE;
5358 uint markov_disable = MARKOV_DISABLE;
5359 uint markov_classic = MARKOV_CLASSIC;
5360 uint markov_threshold = MARKOV_THRESHOLD;
5361 char *markov_hcstat = NULL;
5362 char *outfile = NULL;
5363 uint outfile_format = OUTFILE_FORMAT;
5364 uint outfile_autohex = OUTFILE_AUTOHEX;
5365 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5366 uint restore = RESTORE;
5367 uint restore_timer = RESTORE_TIMER;
5368 uint restore_disable = RESTORE_DISABLE;
5369 uint status = STATUS;
5370 uint status_timer = STATUS_TIMER;
5371 uint status_automat = STATUS_AUTOMAT;
5372 uint loopback = LOOPBACK;
5373 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5374 char *session = NULL;
5375 uint hex_charset = HEX_CHARSET;
5376 uint hex_salt = HEX_SALT;
5377 uint hex_wordlist = HEX_WORDLIST;
5378 uint rp_gen = RP_GEN;
5379 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5380 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5381 uint rp_gen_seed = RP_GEN_SEED;
5382 char *rule_buf_l = (char *) RULE_BUF_L;
5383 char *rule_buf_r = (char *) RULE_BUF_R;
5384 uint increment = INCREMENT;
5385 uint increment_min = INCREMENT_MIN;
5386 uint increment_max = INCREMENT_MAX;
5387 char *cpu_affinity = NULL;
5388 OCL_PTR *ocl = NULL;
5389 char *opencl_devices = NULL;
5390 char *opencl_platforms = NULL;
5391 char *opencl_device_types = NULL;
5392 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5393 char *truecrypt_keyfiles = NULL;
5394 char *veracrypt_keyfiles = NULL;
5395 uint veracrypt_pim = 0;
5396 uint workload_profile = WORKLOAD_PROFILE;
5397 uint kernel_accel = KERNEL_ACCEL;
5398 uint kernel_loops = KERNEL_LOOPS;
5399 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5400 #ifdef HAVE_HWMON
5401 uint gpu_temp_abort = GPU_TEMP_ABORT;
5402 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5403 #ifdef HAVE_ADL
5404 uint powertune_enable = POWERTUNE_ENABLE;
5405 #endif
5406 #endif
5407 uint logfile_disable = LOGFILE_DISABLE;
5408 uint segment_size = SEGMENT_SIZE;
5409 uint scrypt_tmto = SCRYPT_TMTO;
5410 char separator = SEPARATOR;
5411 uint bitmap_min = BITMAP_MIN;
5412 uint bitmap_max = BITMAP_MAX;
5413 char *custom_charset_1 = NULL;
5414 char *custom_charset_2 = NULL;
5415 char *custom_charset_3 = NULL;
5416 char *custom_charset_4 = NULL;
5417
5418 #define IDX_HELP 'h'
5419 #define IDX_VERSION 'V'
5420 #define IDX_VERSION_LOWER 'v'
5421 #define IDX_QUIET 0xff02
5422 #define IDX_SHOW 0xff03
5423 #define IDX_LEFT 0xff04
5424 #define IDX_REMOVE 0xff05
5425 #define IDX_REMOVE_TIMER 0xff37
5426 #define IDX_SKIP 's'
5427 #define IDX_LIMIT 'l'
5428 #define IDX_KEYSPACE 0xff35
5429 #define IDX_POTFILE_DISABLE 0xff06
5430 #define IDX_POTFILE_PATH 0xffe0
5431 #define IDX_DEBUG_MODE 0xff43
5432 #define IDX_DEBUG_FILE 0xff44
5433 #define IDX_INDUCTION_DIR 0xff46
5434 #define IDX_OUTFILE_CHECK_DIR 0xff47
5435 #define IDX_USERNAME 0xff07
5436 #define IDX_FORCE 0xff08
5437 #define IDX_RUNTIME 0xff09
5438 #define IDX_BENCHMARK 'b'
5439 #define IDX_HASH_MODE 'm'
5440 #define IDX_ATTACK_MODE 'a'
5441 #define IDX_RP_FILE 'r'
5442 #define IDX_RP_GEN 'g'
5443 #define IDX_RP_GEN_FUNC_MIN 0xff10
5444 #define IDX_RP_GEN_FUNC_MAX 0xff11
5445 #define IDX_RP_GEN_SEED 0xff34
5446 #define IDX_RULE_BUF_L 'j'
5447 #define IDX_RULE_BUF_R 'k'
5448 #define IDX_INCREMENT 'i'
5449 #define IDX_INCREMENT_MIN 0xff12
5450 #define IDX_INCREMENT_MAX 0xff13
5451 #define IDX_OUTFILE 'o'
5452 #define IDX_OUTFILE_FORMAT 0xff14
5453 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5454 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5455 #define IDX_RESTORE 0xff15
5456 #define IDX_RESTORE_DISABLE 0xff27
5457 #define IDX_STATUS 0xff17
5458 #define IDX_STATUS_TIMER 0xff18
5459 #define IDX_STATUS_AUTOMAT 0xff50
5460 #define IDX_LOOPBACK 0xff38
5461 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5462 #define IDX_SESSION 0xff19
5463 #define IDX_HEX_CHARSET 0xff20
5464 #define IDX_HEX_SALT 0xff21
5465 #define IDX_HEX_WORDLIST 0xff40
5466 #define IDX_MARKOV_DISABLE 0xff22
5467 #define IDX_MARKOV_CLASSIC 0xff23
5468 #define IDX_MARKOV_THRESHOLD 't'
5469 #define IDX_MARKOV_HCSTAT 0xff24
5470 #define IDX_CPU_AFFINITY 0xff25
5471 #define IDX_OPENCL_DEVICES 'd'
5472 #define IDX_OPENCL_PLATFORMS 0xff72
5473 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5474 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5475 #define IDX_WORKLOAD_PROFILE 'w'
5476 #define IDX_KERNEL_ACCEL 'n'
5477 #define IDX_KERNEL_LOOPS 'u'
5478 #define IDX_GPU_TEMP_DISABLE 0xff29
5479 #define IDX_GPU_TEMP_ABORT 0xff30
5480 #define IDX_GPU_TEMP_RETAIN 0xff31
5481 #define IDX_POWERTUNE_ENABLE 0xff41
5482 #define IDX_LOGFILE_DISABLE 0xff51
5483 #define IDX_TRUECRYPT_KEYFILES 0xff52
5484 #define IDX_VERACRYPT_KEYFILES 0xff53
5485 #define IDX_VERACRYPT_PIM 0xff54
5486 #define IDX_SCRYPT_TMTO 0xff61
5487 #define IDX_SEGMENT_SIZE 'c'
5488 #define IDX_SEPARATOR 'p'
5489 #define IDX_BITMAP_MIN 0xff70
5490 #define IDX_BITMAP_MAX 0xff71
5491 #define IDX_CUSTOM_CHARSET_1 '1'
5492 #define IDX_CUSTOM_CHARSET_2 '2'
5493 #define IDX_CUSTOM_CHARSET_3 '3'
5494 #define IDX_CUSTOM_CHARSET_4 '4'
5495
5496 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5497
5498 struct option long_options[] =
5499 {
5500 {"help", no_argument, 0, IDX_HELP},
5501 {"version", no_argument, 0, IDX_VERSION},
5502 {"quiet", no_argument, 0, IDX_QUIET},
5503 {"show", no_argument, 0, IDX_SHOW},
5504 {"left", no_argument, 0, IDX_LEFT},
5505 {"username", no_argument, 0, IDX_USERNAME},
5506 {"remove", no_argument, 0, IDX_REMOVE},
5507 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5508 {"skip", required_argument, 0, IDX_SKIP},
5509 {"limit", required_argument, 0, IDX_LIMIT},
5510 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5511 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5512 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5513 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5514 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5515 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5516 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5517 {"force", no_argument, 0, IDX_FORCE},
5518 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5519 {"restore", no_argument, 0, IDX_RESTORE},
5520 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5521 {"status", no_argument, 0, IDX_STATUS},
5522 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5523 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5524 {"loopback", no_argument, 0, IDX_LOOPBACK},
5525 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5526 {"session", required_argument, 0, IDX_SESSION},
5527 {"runtime", required_argument, 0, IDX_RUNTIME},
5528 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5529 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5530 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5531 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5532 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5533 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5534 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5535 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5536 {"rules-file", required_argument, 0, IDX_RP_FILE},
5537 {"outfile", required_argument, 0, IDX_OUTFILE},
5538 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5539 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5540 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5541 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5542 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5543 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5544 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5545 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5546 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5547 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5548 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5549 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5550 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5551 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5552 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5553 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5554 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5555 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5556 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5557 #ifdef HAVE_HWMON
5558 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5559 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5560 #ifdef HAVE_ADL
5561 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5562 #endif
5563 #endif // HAVE_HWMON
5564 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5565 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5566 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5567 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5568 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5569 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5570 {"seperator", required_argument, 0, IDX_SEPARATOR},
5571 {"separator", required_argument, 0, IDX_SEPARATOR},
5572 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5573 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5574 {"increment", no_argument, 0, IDX_INCREMENT},
5575 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5576 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5577 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5578 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5579 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5580 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5581 {0, 0, 0, 0}
5582 };
5583
5584 uint rp_files_cnt = 0;
5585
5586 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5587
5588 int option_index = 0;
5589 int c = -1;
5590
5591 optind = 1;
5592 optopt = 0;
5593
5594 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5595 {
5596 switch (c)
5597 {
5598 case IDX_HELP: usage = 1; break;
5599 case IDX_VERSION:
5600 case IDX_VERSION_LOWER: version = 1; break;
5601 case IDX_RESTORE: restore = 1; break;
5602 case IDX_SESSION: session = optarg; break;
5603 case IDX_SHOW: show = 1; break;
5604 case IDX_LEFT: left = 1; break;
5605 case '?': return (-1);
5606 }
5607 }
5608
5609 if (optopt != 0)
5610 {
5611 log_error ("ERROR: Invalid argument specified");
5612
5613 return (-1);
5614 }
5615
5616 /**
5617 * exit functions
5618 */
5619
5620 if (version)
5621 {
5622 log_info ("%s", VERSION_TAG);
5623
5624 return (0);
5625 }
5626
5627 if (usage)
5628 {
5629 usage_big_print (PROGNAME);
5630
5631 return (0);
5632 }
5633
5634 /**
5635 * session needs to be set, always!
5636 */
5637
5638 if (session == NULL) session = (char *) PROGNAME;
5639
5640 /**
5641 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5642 */
5643
5644 char *exec_path = get_exec_path ();
5645
5646 #ifdef LINUX
5647
5648 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5649 char *resolved_exec_path = realpath (exec_path, NULL);
5650
5651 char *install_dir = get_install_dir (resolved_exec_path);
5652 char *profile_dir = NULL;
5653 char *session_dir = NULL;
5654 char *shared_dir = NULL;
5655
5656 if (strcmp (install_dir, resolved_install_folder) == 0)
5657 {
5658 struct passwd *pw = getpwuid (getuid ());
5659
5660 const char *homedir = pw->pw_dir;
5661
5662 profile_dir = get_profile_dir (homedir);
5663 session_dir = get_session_dir (profile_dir);
5664 shared_dir = strdup (SHARED_FOLDER);
5665
5666 mkdir (profile_dir, 0700);
5667 mkdir (session_dir, 0700);
5668 }
5669 else
5670 {
5671 profile_dir = install_dir;
5672 session_dir = install_dir;
5673 shared_dir = install_dir;
5674 }
5675
5676 myfree (resolved_install_folder);
5677 myfree (resolved_exec_path);
5678
5679 #else
5680
5681 char *install_dir = get_install_dir (exec_path);
5682 char *profile_dir = install_dir;
5683 char *session_dir = install_dir;
5684 char *shared_dir = install_dir;
5685
5686 #endif
5687
5688 data.install_dir = install_dir;
5689 data.profile_dir = profile_dir;
5690 data.session_dir = session_dir;
5691 data.shared_dir = shared_dir;
5692
5693 myfree (exec_path);
5694
5695 /**
5696 * kernel cache, we need to make sure folder exist
5697 */
5698
5699 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5700
5701 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5702
5703 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5704
5705 mkdir (kernels_folder, 0700);
5706
5707 myfree (kernels_folder);
5708
5709 /**
5710 * session
5711 */
5712
5713 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5714
5715 data.session = session;
5716
5717 char *eff_restore_file = (char *) mymalloc (session_size);
5718 char *new_restore_file = (char *) mymalloc (session_size);
5719
5720 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5721 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5722
5723 data.eff_restore_file = eff_restore_file;
5724 data.new_restore_file = new_restore_file;
5725
5726 if (((show == 1) || (left == 1)) && (restore == 1))
5727 {
5728 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5729 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5730
5731 return (-1);
5732 }
5733
5734 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5735 if ((show == 1) || (left == 1))
5736 {
5737 restore_disable = 1;
5738
5739 restore = 0;
5740 }
5741
5742 data.restore_disable = restore_disable;
5743
5744 restore_data_t *rd = init_restore (argc, argv);
5745
5746 data.rd = rd;
5747
5748 /**
5749 * restore file
5750 */
5751
5752 if (restore == 1)
5753 {
5754 read_restore (eff_restore_file, rd);
5755
5756 if (rd->version_bin < RESTORE_MIN)
5757 {
5758 log_error ("ERROR: Incompatible restore-file version");
5759
5760 return (-1);
5761 }
5762
5763 myargc = rd->argc;
5764 myargv = rd->argv;
5765
5766 #ifdef _POSIX
5767 rd->pid = getpid ();
5768 #elif _WIN
5769 rd->pid = GetCurrentProcessId ();
5770 #endif
5771 }
5772
5773 uint hash_mode_chgd = 0;
5774 uint runtime_chgd = 0;
5775 uint kernel_loops_chgd = 0;
5776 uint kernel_accel_chgd = 0;
5777 uint attack_mode_chgd = 0;
5778 uint outfile_format_chgd = 0;
5779 uint rp_gen_seed_chgd = 0;
5780 uint remove_timer_chgd = 0;
5781 uint increment_min_chgd = 0;
5782 uint increment_max_chgd = 0;
5783 uint workload_profile_chgd = 0;
5784 uint opencl_vector_width_chgd = 0;
5785
5786 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5787 uint gpu_temp_retain_chgd = 0;
5788 uint gpu_temp_abort_chgd = 0;
5789 #endif
5790
5791 optind = 1;
5792 optopt = 0;
5793 option_index = 0;
5794
5795 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5796 {
5797 switch (c)
5798 {
5799 //case IDX_HELP: usage = 1; break;
5800 //case IDX_VERSION: version = 1; break;
5801 //case IDX_RESTORE: restore = 1; break;
5802 case IDX_QUIET: quiet = 1; break;
5803 //case IDX_SHOW: show = 1; break;
5804 case IDX_SHOW: break;
5805 //case IDX_LEFT: left = 1; break;
5806 case IDX_LEFT: break;
5807 case IDX_USERNAME: username = 1; break;
5808 case IDX_REMOVE: remove = 1; break;
5809 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5810 remove_timer_chgd = 1; break;
5811 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5812 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5813 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5814 case IDX_DEBUG_FILE: debug_file = optarg; break;
5815 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5816 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5817 case IDX_FORCE: force = 1; break;
5818 case IDX_SKIP: skip = atoll (optarg); break;
5819 case IDX_LIMIT: limit = atoll (optarg); break;
5820 case IDX_KEYSPACE: keyspace = 1; break;
5821 case IDX_BENCHMARK: benchmark = 1; break;
5822 case IDX_RESTORE: break;
5823 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5824 case IDX_STATUS: status = 1; break;
5825 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5826 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5827 case IDX_LOOPBACK: loopback = 1; break;
5828 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5829 //case IDX_SESSION: session = optarg; break;
5830 case IDX_SESSION: break;
5831 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5832 hash_mode_chgd = 1; break;
5833 case IDX_RUNTIME: runtime = atoi (optarg);
5834 runtime_chgd = 1; break;
5835 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5836 attack_mode_chgd = 1; break;
5837 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5838 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5839 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5840 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5841 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5842 rp_gen_seed_chgd = 1; break;
5843 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5844 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5845 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5846 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5847 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5848 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5849 case IDX_OUTFILE: outfile = optarg; break;
5850 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5851 outfile_format_chgd = 1; break;
5852 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5853 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5854 case IDX_HEX_CHARSET: hex_charset = 1; break;
5855 case IDX_HEX_SALT: hex_salt = 1; break;
5856 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5857 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5858 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5859 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5860 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5861 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5862 opencl_vector_width_chgd = 1; break;
5863 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5864 workload_profile_chgd = 1; break;
5865 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5866 kernel_accel_chgd = 1; break;
5867 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5868 kernel_loops_chgd = 1; break;
5869 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5870 #ifdef HAVE_HWMON
5871 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5872 #ifdef HAVE_ADL
5873 gpu_temp_abort_chgd = 1;
5874 #endif
5875 break;
5876 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5877 #ifdef HAVE_ADL
5878 gpu_temp_retain_chgd = 1;
5879 #endif
5880 break;
5881 #ifdef HAVE_ADL
5882 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5883 #endif
5884 #endif // HAVE_HWMON
5885 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5886 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5887 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5888 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5889 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5890 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5891 case IDX_SEPARATOR: separator = optarg[0]; break;
5892 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5893 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5894 case IDX_INCREMENT: increment = 1; break;
5895 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5896 increment_min_chgd = 1; break;
5897 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5898 increment_max_chgd = 1; break;
5899 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5900 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5901 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5902 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5903
5904 default:
5905 log_error ("ERROR: Invalid argument specified");
5906 return (-1);
5907 }
5908 }
5909
5910 if (optopt != 0)
5911 {
5912 log_error ("ERROR: Invalid argument specified");
5913
5914 return (-1);
5915 }
5916
5917 /**
5918 * Inform user things getting started,
5919 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5920 * - we do not need to check algorithm_pos
5921 */
5922
5923 if (quiet == 0)
5924 {
5925 if (benchmark == 1)
5926 {
5927 if (status_automat == 0)
5928 {
5929 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5930 log_info ("");
5931 }
5932 else
5933 {
5934 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5935 }
5936 }
5937 else if (restore == 1)
5938 {
5939 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5940 log_info ("");
5941 }
5942 else
5943 {
5944 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5945 log_info ("");
5946 }
5947 }
5948
5949 /**
5950 * sanity check
5951 */
5952
5953 if (attack_mode > 7)
5954 {
5955 log_error ("ERROR: Invalid attack-mode specified");
5956
5957 return (-1);
5958 }
5959
5960 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5961 {
5962 log_error ("ERROR: Invalid runtime specified");
5963
5964 return (-1);
5965 }
5966
5967 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5968 {
5969 log_error ("ERROR: Invalid hash-type specified");
5970
5971 return (-1);
5972 }
5973
5974 // renamed hash modes
5975
5976 if (hash_mode_chgd)
5977 {
5978 int n = -1;
5979
5980 switch (hash_mode)
5981 {
5982 case 123: n = 124;
5983 break;
5984 }
5985
5986 if (n >= 0)
5987 {
5988 log_error ("Old -m specified, use -m %d instead", n);
5989
5990 return (-1);
5991 }
5992 }
5993
5994 if (username == 1)
5995 {
5996 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5997 {
5998 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5999
6000 return (-1);
6001 }
6002 }
6003
6004 if (outfile_format > 16)
6005 {
6006 log_error ("ERROR: Invalid outfile-format specified");
6007
6008 return (-1);
6009 }
6010
6011 if (left == 1)
6012 {
6013 if (outfile_format_chgd == 1)
6014 {
6015 if (outfile_format > 1)
6016 {
6017 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6018
6019 return (-1);
6020 }
6021 }
6022 else
6023 {
6024 outfile_format = OUTFILE_FMT_HASH;
6025 }
6026 }
6027
6028 if (show == 1)
6029 {
6030 if (outfile_format_chgd == 1)
6031 {
6032 if ((outfile_format > 7) && (outfile_format < 16))
6033 {
6034 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6035
6036 return (-1);
6037 }
6038 }
6039 }
6040
6041 if (increment_min < INCREMENT_MIN)
6042 {
6043 log_error ("ERROR: Invalid increment-min specified");
6044
6045 return (-1);
6046 }
6047
6048 if (increment_max > INCREMENT_MAX)
6049 {
6050 log_error ("ERROR: Invalid increment-max specified");
6051
6052 return (-1);
6053 }
6054
6055 if (increment_min > increment_max)
6056 {
6057 log_error ("ERROR: Invalid increment-min specified");
6058
6059 return (-1);
6060 }
6061
6062 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6063 {
6064 log_error ("ERROR: increment is not allowed in attack-mode 0");
6065
6066 return (-1);
6067 }
6068
6069 if ((increment == 0) && (increment_min_chgd == 1))
6070 {
6071 log_error ("ERROR: increment-min is only supported together with increment switch");
6072
6073 return (-1);
6074 }
6075
6076 if ((increment == 0) && (increment_max_chgd == 1))
6077 {
6078 log_error ("ERROR: increment-max is only supported together with increment switch");
6079
6080 return (-1);
6081 }
6082
6083 if (rp_files_cnt && rp_gen)
6084 {
6085 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6086
6087 return (-1);
6088 }
6089
6090 if (rp_files_cnt || rp_gen)
6091 {
6092 if (attack_mode != ATTACK_MODE_STRAIGHT)
6093 {
6094 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6095
6096 return (-1);
6097 }
6098 }
6099
6100 if (rp_gen_func_min > rp_gen_func_max)
6101 {
6102 log_error ("ERROR: Invalid rp-gen-func-min specified");
6103
6104 return (-1);
6105 }
6106
6107 if (kernel_accel_chgd == 1)
6108 {
6109 if (force == 0)
6110 {
6111 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6112 log_info ("Please consider using the option -w instead");
6113 log_info ("You can use --force to override this but do not post error reports if you do so");
6114 log_info ("");
6115
6116 return (-1);
6117 }
6118
6119 if (kernel_accel < 1)
6120 {
6121 log_error ("ERROR: Invalid kernel-accel specified");
6122
6123 return (-1);
6124 }
6125
6126 if (kernel_accel > 1024)
6127 {
6128 log_error ("ERROR: Invalid kernel-accel specified");
6129
6130 return (-1);
6131 }
6132 }
6133
6134 if (kernel_loops_chgd == 1)
6135 {
6136 if (force == 0)
6137 {
6138 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6139 log_info ("Please consider using the option -w instead");
6140 log_info ("You can use --force to override this but do not post error reports if you do so");
6141 log_info ("");
6142
6143 return (-1);
6144 }
6145
6146 if (kernel_loops < 1)
6147 {
6148 log_error ("ERROR: Invalid kernel-loops specified");
6149
6150 return (-1);
6151 }
6152
6153 if (kernel_loops > 1024)
6154 {
6155 log_error ("ERROR: Invalid kernel-loops specified");
6156
6157 return (-1);
6158 }
6159 }
6160
6161 if ((workload_profile < 1) || (workload_profile > 4))
6162 {
6163 log_error ("ERROR: workload-profile %i not available", workload_profile);
6164
6165 return (-1);
6166 }
6167
6168 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6169 {
6170 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6171
6172 return (-1);
6173 }
6174
6175 if (show == 1 || left == 1)
6176 {
6177 attack_mode = ATTACK_MODE_NONE;
6178
6179 if (remove == 1)
6180 {
6181 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6182
6183 return (-1);
6184 }
6185
6186 if (potfile_disable == 1)
6187 {
6188 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6189
6190 return (-1);
6191 }
6192 }
6193
6194 uint attack_kern = ATTACK_KERN_NONE;
6195
6196 switch (attack_mode)
6197 {
6198 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6199 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6200 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6201 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6202 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6203 }
6204
6205 if (benchmark == 0)
6206 {
6207 if (keyspace == 1)
6208 {
6209 int num_additional_params = 1;
6210
6211 if (attack_kern == ATTACK_KERN_COMBI)
6212 {
6213 num_additional_params = 2;
6214 }
6215
6216 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6217
6218 if (keyspace_wordlist_specified == 0) optind--;
6219 }
6220
6221 if (attack_kern == ATTACK_KERN_NONE)
6222 {
6223 if ((optind + 1) != myargc)
6224 {
6225 usage_mini_print (myargv[0]);
6226
6227 return (-1);
6228 }
6229 }
6230 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6231 {
6232 if ((optind + 1) > myargc)
6233 {
6234 usage_mini_print (myargv[0]);
6235
6236 return (-1);
6237 }
6238 }
6239 else if (attack_kern == ATTACK_KERN_COMBI)
6240 {
6241 if ((optind + 3) != myargc)
6242 {
6243 usage_mini_print (myargv[0]);
6244
6245 return (-1);
6246 }
6247 }
6248 else if (attack_kern == ATTACK_KERN_BF)
6249 {
6250 if ((optind + 1) > myargc)
6251 {
6252 usage_mini_print (myargv[0]);
6253
6254 return (-1);
6255 }
6256 }
6257 else
6258 {
6259 usage_mini_print (myargv[0]);
6260
6261 return (-1);
6262 }
6263 }
6264 else
6265 {
6266 if (myargv[optind] != 0)
6267 {
6268 log_error ("ERROR: Invalid argument for benchmark mode specified");
6269
6270 return (-1);
6271 }
6272
6273 if (attack_mode_chgd == 1)
6274 {
6275 if (attack_mode != ATTACK_MODE_BF)
6276 {
6277 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6278
6279 return (-1);
6280 }
6281 }
6282 }
6283
6284 if (skip != 0 && limit != 0)
6285 {
6286 limit += skip;
6287 }
6288
6289 if (keyspace == 1)
6290 {
6291 if (show == 1)
6292 {
6293 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6294
6295 return (-1);
6296 }
6297 else if (left == 1)
6298 {
6299 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6300
6301 return (-1);
6302 }
6303
6304 potfile_disable = 1;
6305
6306 restore_disable = 1;
6307
6308 restore = 0;
6309
6310 weak_hash_threshold = 0;
6311
6312 quiet = 1;
6313 }
6314
6315 if (remove_timer_chgd == 1)
6316 {
6317 if (remove == 0)
6318 {
6319 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6320
6321 return (-1);
6322 }
6323
6324 if (remove_timer < 1)
6325 {
6326 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6327
6328 return (-1);
6329 }
6330 }
6331
6332 if (loopback == 1)
6333 {
6334 if (attack_mode == ATTACK_MODE_STRAIGHT)
6335 {
6336 if ((rp_files_cnt == 0) && (rp_gen == 0))
6337 {
6338 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6339
6340 return (-1);
6341 }
6342 }
6343 else
6344 {
6345 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6346
6347 return (-1);
6348 }
6349 }
6350
6351 if (debug_mode > 0)
6352 {
6353 if (attack_mode != ATTACK_MODE_STRAIGHT)
6354 {
6355 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6356
6357 return (-1);
6358 }
6359
6360 if ((rp_files_cnt == 0) && (rp_gen == 0))
6361 {
6362 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6363
6364 return (-1);
6365 }
6366 }
6367
6368 if (debug_mode > 4)
6369 {
6370 log_error ("ERROR: Invalid debug-mode specified");
6371
6372 return (-1);
6373 }
6374
6375 if (debug_file != NULL)
6376 {
6377 if (debug_mode < 1)
6378 {
6379 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6380
6381 return (-1);
6382 }
6383 }
6384
6385 if (induction_dir != NULL)
6386 {
6387 if (attack_mode == ATTACK_MODE_BF)
6388 {
6389 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6390
6391 return (-1);
6392 }
6393 }
6394
6395 if (attack_mode != ATTACK_MODE_STRAIGHT)
6396 {
6397 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6398 {
6399 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6400
6401 return (-1);
6402 }
6403
6404 weak_hash_threshold = 0;
6405 }
6406
6407 /**
6408 * induction directory
6409 */
6410
6411 char *induction_directory = NULL;
6412
6413 if (attack_mode != ATTACK_MODE_BF)
6414 {
6415 if (induction_dir == NULL)
6416 {
6417 induction_directory = (char *) mymalloc (session_size);
6418
6419 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6420
6421 // create induction folder if it does not already exist
6422
6423 if (keyspace == 0)
6424 {
6425 if (rmdir (induction_directory) == -1)
6426 {
6427 if (errno == ENOENT)
6428 {
6429 // good, we can ignore
6430 }
6431 else if (errno == ENOTEMPTY)
6432 {
6433 char *induction_directory_mv = (char *) mymalloc (session_size);
6434
6435 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6436
6437 if (rename (induction_directory, induction_directory_mv) != 0)
6438 {
6439 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6440
6441 return (-1);
6442 }
6443 }
6444 else
6445 {
6446 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6447
6448 return (-1);
6449 }
6450 }
6451
6452 if (mkdir (induction_directory, 0700) == -1)
6453 {
6454 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6455
6456 return (-1);
6457 }
6458 }
6459 }
6460 else
6461 {
6462 induction_directory = induction_dir;
6463 }
6464 }
6465
6466 data.induction_directory = induction_directory;
6467
6468 /**
6469 * loopback
6470 */
6471
6472 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6473
6474 char *loopback_file = (char *) mymalloc (loopback_size);
6475
6476 /**
6477 * tuning db
6478 */
6479
6480 char tuning_db_file[256] = { 0 };
6481
6482 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6483
6484 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6485
6486 /**
6487 * outfile-check directory
6488 */
6489
6490 char *outfile_check_directory = NULL;
6491
6492 if (outfile_check_dir == NULL)
6493 {
6494 outfile_check_directory = (char *) mymalloc (session_size);
6495
6496 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6497 }
6498 else
6499 {
6500 outfile_check_directory = outfile_check_dir;
6501 }
6502
6503 data.outfile_check_directory = outfile_check_directory;
6504
6505 if (keyspace == 0)
6506 {
6507 struct stat outfile_check_stat;
6508
6509 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6510 {
6511 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6512
6513 if (is_dir == 0)
6514 {
6515 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6516
6517 return (-1);
6518 }
6519 }
6520 else if (outfile_check_dir == NULL)
6521 {
6522 if (mkdir (outfile_check_directory, 0700) == -1)
6523 {
6524 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6525
6526 return (-1);
6527 }
6528 }
6529 }
6530
6531 /**
6532 * special other stuff
6533 */
6534
6535 if (hash_mode == 9710)
6536 {
6537 outfile_format = 5;
6538 outfile_format_chgd = 1;
6539 }
6540
6541 if (hash_mode == 9810)
6542 {
6543 outfile_format = 5;
6544 outfile_format_chgd = 1;
6545 }
6546
6547 if (hash_mode == 10410)
6548 {
6549 outfile_format = 5;
6550 outfile_format_chgd = 1;
6551 }
6552
6553 /**
6554 * store stuff
6555 */
6556
6557 data.hash_mode = hash_mode;
6558 data.restore = restore;
6559 data.restore_timer = restore_timer;
6560 data.restore_disable = restore_disable;
6561 data.status = status;
6562 data.status_timer = status_timer;
6563 data.status_automat = status_automat;
6564 data.loopback = loopback;
6565 data.runtime = runtime;
6566 data.remove = remove;
6567 data.remove_timer = remove_timer;
6568 data.debug_mode = debug_mode;
6569 data.debug_file = debug_file;
6570 data.username = username;
6571 data.quiet = quiet;
6572 data.outfile = outfile;
6573 data.outfile_format = outfile_format;
6574 data.outfile_autohex = outfile_autohex;
6575 data.hex_charset = hex_charset;
6576 data.hex_salt = hex_salt;
6577 data.hex_wordlist = hex_wordlist;
6578 data.separator = separator;
6579 data.rp_files = rp_files;
6580 data.rp_files_cnt = rp_files_cnt;
6581 data.rp_gen = rp_gen;
6582 data.rp_gen_seed = rp_gen_seed;
6583 data.force = force;
6584 data.benchmark = benchmark;
6585 data.skip = skip;
6586 data.limit = limit;
6587 #ifdef HAVE_HWMON
6588 #ifdef HAVE_ADL
6589 data.powertune_enable = powertune_enable;
6590 #endif
6591 #endif
6592 data.logfile_disable = logfile_disable;
6593 data.truecrypt_keyfiles = truecrypt_keyfiles;
6594 data.veracrypt_keyfiles = veracrypt_keyfiles;
6595 data.veracrypt_pim = veracrypt_pim;
6596 data.scrypt_tmto = scrypt_tmto;
6597 data.workload_profile = workload_profile;
6598
6599 /**
6600 * cpu affinity
6601 */
6602
6603 if (cpu_affinity)
6604 {
6605 set_cpu_affinity (cpu_affinity);
6606 }
6607
6608 if (rp_gen_seed_chgd == 0)
6609 {
6610 srand (proc_start);
6611 }
6612 else
6613 {
6614 srand (rp_gen_seed);
6615 }
6616
6617 /**
6618 * logfile init
6619 */
6620
6621 if (logfile_disable == 0)
6622 {
6623 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6624
6625 char *logfile = (char *) mymalloc (logfile_size);
6626
6627 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6628
6629 data.logfile = logfile;
6630
6631 char *topid = logfile_generate_topid ();
6632
6633 data.topid = topid;
6634 }
6635
6636 // logfile_append() checks for logfile_disable internally to make it easier from here
6637
6638 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6639 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6640 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6641 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6642 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6643 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6644 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6645 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6646 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6647 #define logfile_sub_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s\t%s", data.topid, data.subid, (var), (val));
6648
6649 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6650 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6651 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6652 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6653 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6654 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6655 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6656 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6657
6658 logfile_top_msg ("START");
6659
6660 logfile_top_uint (attack_mode);
6661 logfile_top_uint (attack_kern);
6662 logfile_top_uint (benchmark);
6663 logfile_top_uint (bitmap_min);
6664 logfile_top_uint (bitmap_max);
6665 logfile_top_uint (debug_mode);
6666 logfile_top_uint (force);
6667 logfile_top_uint (kernel_accel);
6668 logfile_top_uint (kernel_loops);
6669 logfile_top_uint (gpu_temp_disable);
6670 #ifdef HAVE_HWMON
6671 logfile_top_uint (gpu_temp_abort);
6672 logfile_top_uint (gpu_temp_retain);
6673 #endif
6674 logfile_top_uint (hash_mode);
6675 logfile_top_uint (hex_charset);
6676 logfile_top_uint (hex_salt);
6677 logfile_top_uint (hex_wordlist);
6678 logfile_top_uint (increment);
6679 logfile_top_uint (increment_max);
6680 logfile_top_uint (increment_min);
6681 logfile_top_uint (keyspace);
6682 logfile_top_uint (left);
6683 logfile_top_uint (logfile_disable);
6684 logfile_top_uint (loopback);
6685 logfile_top_uint (markov_classic);
6686 logfile_top_uint (markov_disable);
6687 logfile_top_uint (markov_threshold);
6688 logfile_top_uint (outfile_autohex);
6689 logfile_top_uint (outfile_check_timer);
6690 logfile_top_uint (outfile_format);
6691 logfile_top_uint (potfile_disable);
6692 logfile_top_string (potfile_path);
6693 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6694 logfile_top_uint (powertune_enable);
6695 #endif
6696 logfile_top_uint (scrypt_tmto);
6697 logfile_top_uint (quiet);
6698 logfile_top_uint (remove);
6699 logfile_top_uint (remove_timer);
6700 logfile_top_uint (restore);
6701 logfile_top_uint (restore_disable);
6702 logfile_top_uint (restore_timer);
6703 logfile_top_uint (rp_gen);
6704 logfile_top_uint (rp_gen_func_max);
6705 logfile_top_uint (rp_gen_func_min);
6706 logfile_top_uint (rp_gen_seed);
6707 logfile_top_uint (runtime);
6708 logfile_top_uint (segment_size);
6709 logfile_top_uint (show);
6710 logfile_top_uint (status);
6711 logfile_top_uint (status_automat);
6712 logfile_top_uint (status_timer);
6713 logfile_top_uint (usage);
6714 logfile_top_uint (username);
6715 logfile_top_uint (version);
6716 logfile_top_uint (weak_hash_threshold);
6717 logfile_top_uint (workload_profile);
6718 logfile_top_uint64 (limit);
6719 logfile_top_uint64 (skip);
6720 logfile_top_char (separator);
6721 logfile_top_string (cpu_affinity);
6722 logfile_top_string (custom_charset_1);
6723 logfile_top_string (custom_charset_2);
6724 logfile_top_string (custom_charset_3);
6725 logfile_top_string (custom_charset_4);
6726 logfile_top_string (debug_file);
6727 logfile_top_string (opencl_devices);
6728 logfile_top_string (opencl_platforms);
6729 logfile_top_string (opencl_device_types);
6730 logfile_top_uint (opencl_vector_width);
6731 logfile_top_string (induction_dir);
6732 logfile_top_string (markov_hcstat);
6733 logfile_top_string (outfile);
6734 logfile_top_string (outfile_check_dir);
6735 logfile_top_string (rule_buf_l);
6736 logfile_top_string (rule_buf_r);
6737 logfile_top_string (session);
6738 logfile_top_string (truecrypt_keyfiles);
6739 logfile_top_string (veracrypt_keyfiles);
6740 logfile_top_uint (veracrypt_pim);
6741
6742 /**
6743 * Init OpenCL library loader
6744 */
6745
6746 if (keyspace == 0)
6747 {
6748 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6749
6750 ocl_init (ocl);
6751
6752 data.ocl = ocl;
6753 }
6754
6755 /**
6756 * OpenCL platform selection
6757 */
6758
6759 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6760
6761 /**
6762 * OpenCL device selection
6763 */
6764
6765 u32 devices_filter = setup_devices_filter (opencl_devices);
6766
6767 /**
6768 * OpenCL device type selection
6769 */
6770
6771 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6772
6773 /**
6774 * benchmark
6775 */
6776
6777 if (benchmark == 1)
6778 {
6779 /**
6780 * disable useless stuff for benchmark
6781 */
6782
6783 status_timer = 0;
6784 restore_timer = 0;
6785 restore_disable = 1;
6786 potfile_disable = 1;
6787 weak_hash_threshold = 0;
6788 gpu_temp_disable = 1;
6789
6790 data.status_timer = status_timer;
6791 data.restore_timer = restore_timer;
6792 data.restore_disable = restore_disable;
6793
6794 /**
6795 * force attack mode to be bruteforce
6796 */
6797
6798 attack_mode = ATTACK_MODE_BF;
6799 attack_kern = ATTACK_KERN_BF;
6800
6801 if (workload_profile_chgd == 0)
6802 {
6803 workload_profile = 3;
6804
6805 data.workload_profile = workload_profile;
6806 }
6807 }
6808
6809 /**
6810 * config
6811 */
6812
6813 uint hash_type = 0;
6814 uint salt_type = 0;
6815 uint attack_exec = 0;
6816 uint opts_type = 0;
6817 uint kern_type = 0;
6818 uint dgst_size = 0;
6819 uint esalt_size = 0;
6820 uint opti_type = 0;
6821 uint dgst_pos0 = -1;
6822 uint dgst_pos1 = -1;
6823 uint dgst_pos2 = -1;
6824 uint dgst_pos3 = -1;
6825
6826 int (*parse_func) (char *, uint, hash_t *);
6827 int (*sort_by_digest) (const void *, const void *);
6828
6829 uint algorithm_pos = 0;
6830 uint algorithm_max = 1;
6831
6832 uint *algorithms = default_benchmark_algorithms;
6833
6834 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6835
6836 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6837 {
6838 /*
6839 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6840 * the following algos are skipped entirely
6841 */
6842
6843 if (algorithm_pos > 0)
6844 {
6845 local_free (rd);
6846
6847 rd = init_restore (argc, argv);
6848
6849 data.rd = rd;
6850 }
6851
6852 /**
6853 * update hash_mode in case of multihash benchmark
6854 */
6855
6856 if (benchmark == 1)
6857 {
6858 if (hash_mode_chgd == 0)
6859 {
6860 hash_mode = algorithms[algorithm_pos];
6861
6862 data.hash_mode = hash_mode;
6863 }
6864
6865 quiet = 1;
6866
6867 data.quiet = quiet;
6868 }
6869
6870 switch (hash_mode)
6871 {
6872 case 0: hash_type = HASH_TYPE_MD5;
6873 salt_type = SALT_TYPE_NONE;
6874 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6875 opts_type = OPTS_TYPE_PT_GENERATE_LE
6876 | OPTS_TYPE_PT_ADD80
6877 | OPTS_TYPE_PT_ADDBITS14;
6878 kern_type = KERN_TYPE_MD5;
6879 dgst_size = DGST_SIZE_4_4;
6880 parse_func = md5_parse_hash;
6881 sort_by_digest = sort_by_digest_4_4;
6882 opti_type = OPTI_TYPE_ZERO_BYTE
6883 | OPTI_TYPE_PRECOMPUTE_INIT
6884 | OPTI_TYPE_PRECOMPUTE_MERKLE
6885 | OPTI_TYPE_MEET_IN_MIDDLE
6886 | OPTI_TYPE_EARLY_SKIP
6887 | OPTI_TYPE_NOT_ITERATED
6888 | OPTI_TYPE_NOT_SALTED
6889 | OPTI_TYPE_RAW_HASH;
6890 dgst_pos0 = 0;
6891 dgst_pos1 = 3;
6892 dgst_pos2 = 2;
6893 dgst_pos3 = 1;
6894 break;
6895
6896 case 10: hash_type = HASH_TYPE_MD5;
6897 salt_type = SALT_TYPE_INTERN;
6898 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6899 opts_type = OPTS_TYPE_PT_GENERATE_LE
6900 | OPTS_TYPE_ST_ADD80
6901 | OPTS_TYPE_ST_ADDBITS14;
6902 kern_type = KERN_TYPE_MD5_PWSLT;
6903 dgst_size = DGST_SIZE_4_4;
6904 parse_func = md5s_parse_hash;
6905 sort_by_digest = sort_by_digest_4_4;
6906 opti_type = OPTI_TYPE_ZERO_BYTE
6907 | OPTI_TYPE_PRECOMPUTE_INIT
6908 | OPTI_TYPE_PRECOMPUTE_MERKLE
6909 | OPTI_TYPE_MEET_IN_MIDDLE
6910 | OPTI_TYPE_EARLY_SKIP
6911 | OPTI_TYPE_NOT_ITERATED
6912 | OPTI_TYPE_APPENDED_SALT
6913 | OPTI_TYPE_RAW_HASH;
6914 dgst_pos0 = 0;
6915 dgst_pos1 = 3;
6916 dgst_pos2 = 2;
6917 dgst_pos3 = 1;
6918 break;
6919
6920 case 11: hash_type = HASH_TYPE_MD5;
6921 salt_type = SALT_TYPE_INTERN;
6922 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6923 opts_type = OPTS_TYPE_PT_GENERATE_LE
6924 | OPTS_TYPE_ST_ADD80
6925 | OPTS_TYPE_ST_ADDBITS14;
6926 kern_type = KERN_TYPE_MD5_PWSLT;
6927 dgst_size = DGST_SIZE_4_4;
6928 parse_func = joomla_parse_hash;
6929 sort_by_digest = sort_by_digest_4_4;
6930 opti_type = OPTI_TYPE_ZERO_BYTE
6931 | OPTI_TYPE_PRECOMPUTE_INIT
6932 | OPTI_TYPE_PRECOMPUTE_MERKLE
6933 | OPTI_TYPE_MEET_IN_MIDDLE
6934 | OPTI_TYPE_EARLY_SKIP
6935 | OPTI_TYPE_NOT_ITERATED
6936 | OPTI_TYPE_APPENDED_SALT
6937 | OPTI_TYPE_RAW_HASH;
6938 dgst_pos0 = 0;
6939 dgst_pos1 = 3;
6940 dgst_pos2 = 2;
6941 dgst_pos3 = 1;
6942 break;
6943
6944 case 12: hash_type = HASH_TYPE_MD5;
6945 salt_type = SALT_TYPE_INTERN;
6946 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6947 opts_type = OPTS_TYPE_PT_GENERATE_LE
6948 | OPTS_TYPE_ST_ADD80
6949 | OPTS_TYPE_ST_ADDBITS14;
6950 kern_type = KERN_TYPE_MD5_PWSLT;
6951 dgst_size = DGST_SIZE_4_4;
6952 parse_func = postgresql_parse_hash;
6953 sort_by_digest = sort_by_digest_4_4;
6954 opti_type = OPTI_TYPE_ZERO_BYTE
6955 | OPTI_TYPE_PRECOMPUTE_INIT
6956 | OPTI_TYPE_PRECOMPUTE_MERKLE
6957 | OPTI_TYPE_MEET_IN_MIDDLE
6958 | OPTI_TYPE_EARLY_SKIP
6959 | OPTI_TYPE_NOT_ITERATED
6960 | OPTI_TYPE_APPENDED_SALT
6961 | OPTI_TYPE_RAW_HASH;
6962 dgst_pos0 = 0;
6963 dgst_pos1 = 3;
6964 dgst_pos2 = 2;
6965 dgst_pos3 = 1;
6966 break;
6967
6968 case 20: hash_type = HASH_TYPE_MD5;
6969 salt_type = SALT_TYPE_INTERN;
6970 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6971 opts_type = OPTS_TYPE_PT_GENERATE_LE
6972 | OPTS_TYPE_PT_ADD80
6973 | OPTS_TYPE_PT_ADDBITS14;
6974 kern_type = KERN_TYPE_MD5_SLTPW;
6975 dgst_size = DGST_SIZE_4_4;
6976 parse_func = md5s_parse_hash;
6977 sort_by_digest = sort_by_digest_4_4;
6978 opti_type = OPTI_TYPE_ZERO_BYTE
6979 | OPTI_TYPE_PRECOMPUTE_INIT
6980 | OPTI_TYPE_PRECOMPUTE_MERKLE
6981 | OPTI_TYPE_EARLY_SKIP
6982 | OPTI_TYPE_NOT_ITERATED
6983 | OPTI_TYPE_PREPENDED_SALT
6984 | OPTI_TYPE_RAW_HASH;
6985 dgst_pos0 = 0;
6986 dgst_pos1 = 3;
6987 dgst_pos2 = 2;
6988 dgst_pos3 = 1;
6989 break;
6990
6991 case 21: hash_type = HASH_TYPE_MD5;
6992 salt_type = SALT_TYPE_INTERN;
6993 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6994 opts_type = OPTS_TYPE_PT_GENERATE_LE
6995 | OPTS_TYPE_PT_ADD80
6996 | OPTS_TYPE_PT_ADDBITS14;
6997 kern_type = KERN_TYPE_MD5_SLTPW;
6998 dgst_size = DGST_SIZE_4_4;
6999 parse_func = osc_parse_hash;
7000 sort_by_digest = sort_by_digest_4_4;
7001 opti_type = OPTI_TYPE_ZERO_BYTE
7002 | OPTI_TYPE_PRECOMPUTE_INIT
7003 | OPTI_TYPE_PRECOMPUTE_MERKLE
7004 | OPTI_TYPE_EARLY_SKIP
7005 | OPTI_TYPE_NOT_ITERATED
7006 | OPTI_TYPE_PREPENDED_SALT
7007 | OPTI_TYPE_RAW_HASH;
7008 dgst_pos0 = 0;
7009 dgst_pos1 = 3;
7010 dgst_pos2 = 2;
7011 dgst_pos3 = 1;
7012 break;
7013
7014 case 22: hash_type = HASH_TYPE_MD5;
7015 salt_type = SALT_TYPE_EMBEDDED;
7016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7017 opts_type = OPTS_TYPE_PT_GENERATE_LE
7018 | OPTS_TYPE_PT_ADD80
7019 | OPTS_TYPE_PT_ADDBITS14;
7020 kern_type = KERN_TYPE_MD5_SLTPW;
7021 dgst_size = DGST_SIZE_4_4;
7022 parse_func = netscreen_parse_hash;
7023 sort_by_digest = sort_by_digest_4_4;
7024 opti_type = OPTI_TYPE_ZERO_BYTE
7025 | OPTI_TYPE_PRECOMPUTE_INIT
7026 | OPTI_TYPE_PRECOMPUTE_MERKLE
7027 | OPTI_TYPE_EARLY_SKIP
7028 | OPTI_TYPE_NOT_ITERATED
7029 | OPTI_TYPE_PREPENDED_SALT
7030 | OPTI_TYPE_RAW_HASH;
7031 dgst_pos0 = 0;
7032 dgst_pos1 = 3;
7033 dgst_pos2 = 2;
7034 dgst_pos3 = 1;
7035 break;
7036
7037 case 23: hash_type = HASH_TYPE_MD5;
7038 salt_type = SALT_TYPE_EMBEDDED;
7039 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7040 opts_type = OPTS_TYPE_PT_GENERATE_LE
7041 | OPTS_TYPE_PT_ADD80
7042 | OPTS_TYPE_PT_ADDBITS14;
7043 kern_type = KERN_TYPE_MD5_SLTPW;
7044 dgst_size = DGST_SIZE_4_4;
7045 parse_func = skype_parse_hash;
7046 sort_by_digest = sort_by_digest_4_4;
7047 opti_type = OPTI_TYPE_ZERO_BYTE
7048 | OPTI_TYPE_PRECOMPUTE_INIT
7049 | OPTI_TYPE_PRECOMPUTE_MERKLE
7050 | OPTI_TYPE_EARLY_SKIP
7051 | OPTI_TYPE_NOT_ITERATED
7052 | OPTI_TYPE_PREPENDED_SALT
7053 | OPTI_TYPE_RAW_HASH;
7054 dgst_pos0 = 0;
7055 dgst_pos1 = 3;
7056 dgst_pos2 = 2;
7057 dgst_pos3 = 1;
7058 break;
7059
7060 case 30: hash_type = HASH_TYPE_MD5;
7061 salt_type = SALT_TYPE_INTERN;
7062 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7063 opts_type = OPTS_TYPE_PT_GENERATE_LE
7064 | OPTS_TYPE_PT_UNICODE
7065 | OPTS_TYPE_ST_ADD80
7066 | OPTS_TYPE_ST_ADDBITS14;
7067 kern_type = KERN_TYPE_MD5_PWUSLT;
7068 dgst_size = DGST_SIZE_4_4;
7069 parse_func = md5s_parse_hash;
7070 sort_by_digest = sort_by_digest_4_4;
7071 opti_type = OPTI_TYPE_ZERO_BYTE
7072 | OPTI_TYPE_PRECOMPUTE_INIT
7073 | OPTI_TYPE_PRECOMPUTE_MERKLE
7074 | OPTI_TYPE_MEET_IN_MIDDLE
7075 | OPTI_TYPE_EARLY_SKIP
7076 | OPTI_TYPE_NOT_ITERATED
7077 | OPTI_TYPE_APPENDED_SALT
7078 | OPTI_TYPE_RAW_HASH;
7079 dgst_pos0 = 0;
7080 dgst_pos1 = 3;
7081 dgst_pos2 = 2;
7082 dgst_pos3 = 1;
7083 break;
7084
7085 case 40: hash_type = HASH_TYPE_MD5;
7086 salt_type = SALT_TYPE_INTERN;
7087 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7088 opts_type = OPTS_TYPE_PT_GENERATE_LE
7089 | OPTS_TYPE_PT_ADD80
7090 | OPTS_TYPE_PT_ADDBITS14
7091 | OPTS_TYPE_PT_UNICODE;
7092 kern_type = KERN_TYPE_MD5_SLTPWU;
7093 dgst_size = DGST_SIZE_4_4;
7094 parse_func = md5s_parse_hash;
7095 sort_by_digest = sort_by_digest_4_4;
7096 opti_type = OPTI_TYPE_ZERO_BYTE
7097 | OPTI_TYPE_PRECOMPUTE_INIT
7098 | OPTI_TYPE_PRECOMPUTE_MERKLE
7099 | OPTI_TYPE_EARLY_SKIP
7100 | OPTI_TYPE_NOT_ITERATED
7101 | OPTI_TYPE_PREPENDED_SALT
7102 | OPTI_TYPE_RAW_HASH;
7103 dgst_pos0 = 0;
7104 dgst_pos1 = 3;
7105 dgst_pos2 = 2;
7106 dgst_pos3 = 1;
7107 break;
7108
7109 case 50: hash_type = HASH_TYPE_MD5;
7110 salt_type = SALT_TYPE_INTERN;
7111 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7112 opts_type = OPTS_TYPE_PT_GENERATE_LE
7113 | OPTS_TYPE_ST_ADD80
7114 | OPTS_TYPE_ST_ADDBITS14;
7115 kern_type = KERN_TYPE_HMACMD5_PW;
7116 dgst_size = DGST_SIZE_4_4;
7117 parse_func = hmacmd5_parse_hash;
7118 sort_by_digest = sort_by_digest_4_4;
7119 opti_type = OPTI_TYPE_ZERO_BYTE
7120 | OPTI_TYPE_NOT_ITERATED;
7121 dgst_pos0 = 0;
7122 dgst_pos1 = 3;
7123 dgst_pos2 = 2;
7124 dgst_pos3 = 1;
7125 break;
7126
7127 case 60: hash_type = HASH_TYPE_MD5;
7128 salt_type = SALT_TYPE_INTERN;
7129 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7130 opts_type = OPTS_TYPE_PT_GENERATE_LE
7131 | OPTS_TYPE_PT_ADD80
7132 | OPTS_TYPE_PT_ADDBITS14;
7133 kern_type = KERN_TYPE_HMACMD5_SLT;
7134 dgst_size = DGST_SIZE_4_4;
7135 parse_func = hmacmd5_parse_hash;
7136 sort_by_digest = sort_by_digest_4_4;
7137 opti_type = OPTI_TYPE_ZERO_BYTE
7138 | OPTI_TYPE_NOT_ITERATED;
7139 dgst_pos0 = 0;
7140 dgst_pos1 = 3;
7141 dgst_pos2 = 2;
7142 dgst_pos3 = 1;
7143 break;
7144
7145 case 100: hash_type = HASH_TYPE_SHA1;
7146 salt_type = SALT_TYPE_NONE;
7147 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7148 opts_type = OPTS_TYPE_PT_GENERATE_BE
7149 | OPTS_TYPE_PT_ADD80
7150 | OPTS_TYPE_PT_ADDBITS15;
7151 kern_type = KERN_TYPE_SHA1;
7152 dgst_size = DGST_SIZE_4_5;
7153 parse_func = sha1_parse_hash;
7154 sort_by_digest = sort_by_digest_4_5;
7155 opti_type = OPTI_TYPE_ZERO_BYTE
7156 | OPTI_TYPE_PRECOMPUTE_INIT
7157 | OPTI_TYPE_PRECOMPUTE_MERKLE
7158 | OPTI_TYPE_EARLY_SKIP
7159 | OPTI_TYPE_NOT_ITERATED
7160 | OPTI_TYPE_NOT_SALTED
7161 | OPTI_TYPE_RAW_HASH;
7162 dgst_pos0 = 3;
7163 dgst_pos1 = 4;
7164 dgst_pos2 = 2;
7165 dgst_pos3 = 1;
7166 break;
7167
7168 case 101: hash_type = HASH_TYPE_SHA1;
7169 salt_type = SALT_TYPE_NONE;
7170 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7171 opts_type = OPTS_TYPE_PT_GENERATE_BE
7172 | OPTS_TYPE_PT_ADD80
7173 | OPTS_TYPE_PT_ADDBITS15;
7174 kern_type = KERN_TYPE_SHA1;
7175 dgst_size = DGST_SIZE_4_5;
7176 parse_func = sha1b64_parse_hash;
7177 sort_by_digest = sort_by_digest_4_5;
7178 opti_type = OPTI_TYPE_ZERO_BYTE
7179 | OPTI_TYPE_PRECOMPUTE_INIT
7180 | OPTI_TYPE_PRECOMPUTE_MERKLE
7181 | OPTI_TYPE_EARLY_SKIP
7182 | OPTI_TYPE_NOT_ITERATED
7183 | OPTI_TYPE_NOT_SALTED
7184 | OPTI_TYPE_RAW_HASH;
7185 dgst_pos0 = 3;
7186 dgst_pos1 = 4;
7187 dgst_pos2 = 2;
7188 dgst_pos3 = 1;
7189 break;
7190
7191 case 110: hash_type = HASH_TYPE_SHA1;
7192 salt_type = SALT_TYPE_INTERN;
7193 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7194 opts_type = OPTS_TYPE_PT_GENERATE_BE
7195 | OPTS_TYPE_ST_ADD80
7196 | OPTS_TYPE_ST_ADDBITS15;
7197 kern_type = KERN_TYPE_SHA1_PWSLT;
7198 dgst_size = DGST_SIZE_4_5;
7199 parse_func = sha1s_parse_hash;
7200 sort_by_digest = sort_by_digest_4_5;
7201 opti_type = OPTI_TYPE_ZERO_BYTE
7202 | OPTI_TYPE_PRECOMPUTE_INIT
7203 | OPTI_TYPE_PRECOMPUTE_MERKLE
7204 | OPTI_TYPE_EARLY_SKIP
7205 | OPTI_TYPE_NOT_ITERATED
7206 | OPTI_TYPE_APPENDED_SALT
7207 | OPTI_TYPE_RAW_HASH;
7208 dgst_pos0 = 3;
7209 dgst_pos1 = 4;
7210 dgst_pos2 = 2;
7211 dgst_pos3 = 1;
7212 break;
7213
7214 case 111: hash_type = HASH_TYPE_SHA1;
7215 salt_type = SALT_TYPE_EMBEDDED;
7216 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7217 opts_type = OPTS_TYPE_PT_GENERATE_BE
7218 | OPTS_TYPE_ST_ADD80
7219 | OPTS_TYPE_ST_ADDBITS15;
7220 kern_type = KERN_TYPE_SHA1_PWSLT;
7221 dgst_size = DGST_SIZE_4_5;
7222 parse_func = sha1b64s_parse_hash;
7223 sort_by_digest = sort_by_digest_4_5;
7224 opti_type = OPTI_TYPE_ZERO_BYTE
7225 | OPTI_TYPE_PRECOMPUTE_INIT
7226 | OPTI_TYPE_PRECOMPUTE_MERKLE
7227 | OPTI_TYPE_EARLY_SKIP
7228 | OPTI_TYPE_NOT_ITERATED
7229 | OPTI_TYPE_APPENDED_SALT
7230 | OPTI_TYPE_RAW_HASH;
7231 dgst_pos0 = 3;
7232 dgst_pos1 = 4;
7233 dgst_pos2 = 2;
7234 dgst_pos3 = 1;
7235 break;
7236
7237 case 112: hash_type = HASH_TYPE_SHA1;
7238 salt_type = SALT_TYPE_INTERN;
7239 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7240 opts_type = OPTS_TYPE_PT_GENERATE_BE
7241 | OPTS_TYPE_ST_ADD80
7242 | OPTS_TYPE_ST_ADDBITS15
7243 | OPTS_TYPE_ST_HEX;
7244 kern_type = KERN_TYPE_SHA1_PWSLT;
7245 dgst_size = DGST_SIZE_4_5;
7246 parse_func = oracles_parse_hash;
7247 sort_by_digest = sort_by_digest_4_5;
7248 opti_type = OPTI_TYPE_ZERO_BYTE
7249 | OPTI_TYPE_PRECOMPUTE_INIT
7250 | OPTI_TYPE_PRECOMPUTE_MERKLE
7251 | OPTI_TYPE_EARLY_SKIP
7252 | OPTI_TYPE_NOT_ITERATED
7253 | OPTI_TYPE_APPENDED_SALT
7254 | OPTI_TYPE_RAW_HASH;
7255 dgst_pos0 = 3;
7256 dgst_pos1 = 4;
7257 dgst_pos2 = 2;
7258 dgst_pos3 = 1;
7259 break;
7260
7261 case 120: hash_type = HASH_TYPE_SHA1;
7262 salt_type = SALT_TYPE_INTERN;
7263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7264 opts_type = OPTS_TYPE_PT_GENERATE_BE
7265 | OPTS_TYPE_PT_ADD80
7266 | OPTS_TYPE_PT_ADDBITS15;
7267 kern_type = KERN_TYPE_SHA1_SLTPW;
7268 dgst_size = DGST_SIZE_4_5;
7269 parse_func = sha1s_parse_hash;
7270 sort_by_digest = sort_by_digest_4_5;
7271 opti_type = OPTI_TYPE_ZERO_BYTE
7272 | OPTI_TYPE_PRECOMPUTE_INIT
7273 | OPTI_TYPE_PRECOMPUTE_MERKLE
7274 | OPTI_TYPE_EARLY_SKIP
7275 | OPTI_TYPE_NOT_ITERATED
7276 | OPTI_TYPE_PREPENDED_SALT
7277 | OPTI_TYPE_RAW_HASH;
7278 dgst_pos0 = 3;
7279 dgst_pos1 = 4;
7280 dgst_pos2 = 2;
7281 dgst_pos3 = 1;
7282 break;
7283
7284 case 121: hash_type = HASH_TYPE_SHA1;
7285 salt_type = SALT_TYPE_INTERN;
7286 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7287 opts_type = OPTS_TYPE_PT_GENERATE_BE
7288 | OPTS_TYPE_PT_ADD80
7289 | OPTS_TYPE_PT_ADDBITS15
7290 | OPTS_TYPE_ST_LOWER;
7291 kern_type = KERN_TYPE_SHA1_SLTPW;
7292 dgst_size = DGST_SIZE_4_5;
7293 parse_func = smf_parse_hash;
7294 sort_by_digest = sort_by_digest_4_5;
7295 opti_type = OPTI_TYPE_ZERO_BYTE
7296 | OPTI_TYPE_PRECOMPUTE_INIT
7297 | OPTI_TYPE_PRECOMPUTE_MERKLE
7298 | OPTI_TYPE_EARLY_SKIP
7299 | OPTI_TYPE_NOT_ITERATED
7300 | OPTI_TYPE_PREPENDED_SALT
7301 | OPTI_TYPE_RAW_HASH;
7302 dgst_pos0 = 3;
7303 dgst_pos1 = 4;
7304 dgst_pos2 = 2;
7305 dgst_pos3 = 1;
7306 break;
7307
7308 case 122: hash_type = HASH_TYPE_SHA1;
7309 salt_type = SALT_TYPE_EMBEDDED;
7310 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7311 opts_type = OPTS_TYPE_PT_GENERATE_BE
7312 | OPTS_TYPE_PT_ADD80
7313 | OPTS_TYPE_PT_ADDBITS15
7314 | OPTS_TYPE_ST_HEX;
7315 kern_type = KERN_TYPE_SHA1_SLTPW;
7316 dgst_size = DGST_SIZE_4_5;
7317 parse_func = osx1_parse_hash;
7318 sort_by_digest = sort_by_digest_4_5;
7319 opti_type = OPTI_TYPE_ZERO_BYTE
7320 | OPTI_TYPE_PRECOMPUTE_INIT
7321 | OPTI_TYPE_PRECOMPUTE_MERKLE
7322 | OPTI_TYPE_EARLY_SKIP
7323 | OPTI_TYPE_NOT_ITERATED
7324 | OPTI_TYPE_PREPENDED_SALT
7325 | OPTI_TYPE_RAW_HASH;
7326 dgst_pos0 = 3;
7327 dgst_pos1 = 4;
7328 dgst_pos2 = 2;
7329 dgst_pos3 = 1;
7330 break;
7331
7332 case 124: hash_type = HASH_TYPE_SHA1;
7333 salt_type = SALT_TYPE_EMBEDDED;
7334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7335 opts_type = OPTS_TYPE_PT_GENERATE_BE
7336 | OPTS_TYPE_PT_ADD80
7337 | OPTS_TYPE_PT_ADDBITS15;
7338 kern_type = KERN_TYPE_SHA1_SLTPW;
7339 dgst_size = DGST_SIZE_4_5;
7340 parse_func = djangosha1_parse_hash;
7341 sort_by_digest = sort_by_digest_4_5;
7342 opti_type = OPTI_TYPE_ZERO_BYTE
7343 | OPTI_TYPE_PRECOMPUTE_INIT
7344 | OPTI_TYPE_PRECOMPUTE_MERKLE
7345 | OPTI_TYPE_EARLY_SKIP
7346 | OPTI_TYPE_NOT_ITERATED
7347 | OPTI_TYPE_PREPENDED_SALT
7348 | OPTI_TYPE_RAW_HASH;
7349 dgst_pos0 = 3;
7350 dgst_pos1 = 4;
7351 dgst_pos2 = 2;
7352 dgst_pos3 = 1;
7353 break;
7354
7355 case 125: hash_type = HASH_TYPE_SHA1;
7356 salt_type = SALT_TYPE_EMBEDDED;
7357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7358 opts_type = OPTS_TYPE_PT_GENERATE_BE
7359 | OPTS_TYPE_PT_ADD80
7360 | OPTS_TYPE_PT_ADDBITS15
7361 | OPTS_TYPE_ST_HEX;
7362 kern_type = KERN_TYPE_SHA1_SLTPW;
7363 dgst_size = DGST_SIZE_4_5;
7364 parse_func = arubaos_parse_hash;
7365 sort_by_digest = sort_by_digest_4_5;
7366 opti_type = OPTI_TYPE_ZERO_BYTE
7367 | OPTI_TYPE_PRECOMPUTE_INIT
7368 | OPTI_TYPE_PRECOMPUTE_MERKLE
7369 | OPTI_TYPE_EARLY_SKIP
7370 | OPTI_TYPE_NOT_ITERATED
7371 | OPTI_TYPE_PREPENDED_SALT
7372 | OPTI_TYPE_RAW_HASH;
7373 dgst_pos0 = 3;
7374 dgst_pos1 = 4;
7375 dgst_pos2 = 2;
7376 dgst_pos3 = 1;
7377 break;
7378
7379 case 130: hash_type = HASH_TYPE_SHA1;
7380 salt_type = SALT_TYPE_INTERN;
7381 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7382 opts_type = OPTS_TYPE_PT_GENERATE_BE
7383 | OPTS_TYPE_PT_UNICODE
7384 | OPTS_TYPE_ST_ADD80
7385 | OPTS_TYPE_ST_ADDBITS15;
7386 kern_type = KERN_TYPE_SHA1_PWUSLT;
7387 dgst_size = DGST_SIZE_4_5;
7388 parse_func = sha1s_parse_hash;
7389 sort_by_digest = sort_by_digest_4_5;
7390 opti_type = OPTI_TYPE_ZERO_BYTE
7391 | OPTI_TYPE_PRECOMPUTE_INIT
7392 | OPTI_TYPE_PRECOMPUTE_MERKLE
7393 | OPTI_TYPE_EARLY_SKIP
7394 | OPTI_TYPE_NOT_ITERATED
7395 | OPTI_TYPE_APPENDED_SALT
7396 | OPTI_TYPE_RAW_HASH;
7397 dgst_pos0 = 3;
7398 dgst_pos1 = 4;
7399 dgst_pos2 = 2;
7400 dgst_pos3 = 1;
7401 break;
7402
7403 case 131: hash_type = HASH_TYPE_SHA1;
7404 salt_type = SALT_TYPE_EMBEDDED;
7405 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7406 opts_type = OPTS_TYPE_PT_GENERATE_BE
7407 | OPTS_TYPE_PT_UNICODE
7408 | OPTS_TYPE_PT_UPPER
7409 | OPTS_TYPE_ST_ADD80
7410 | OPTS_TYPE_ST_ADDBITS15
7411 | OPTS_TYPE_ST_HEX;
7412 kern_type = KERN_TYPE_SHA1_PWUSLT;
7413 dgst_size = DGST_SIZE_4_5;
7414 parse_func = mssql2000_parse_hash;
7415 sort_by_digest = sort_by_digest_4_5;
7416 opti_type = OPTI_TYPE_ZERO_BYTE
7417 | OPTI_TYPE_PRECOMPUTE_INIT
7418 | OPTI_TYPE_PRECOMPUTE_MERKLE
7419 | OPTI_TYPE_EARLY_SKIP
7420 | OPTI_TYPE_NOT_ITERATED
7421 | OPTI_TYPE_APPENDED_SALT
7422 | OPTI_TYPE_RAW_HASH;
7423 dgst_pos0 = 3;
7424 dgst_pos1 = 4;
7425 dgst_pos2 = 2;
7426 dgst_pos3 = 1;
7427 break;
7428
7429 case 132: hash_type = HASH_TYPE_SHA1;
7430 salt_type = SALT_TYPE_EMBEDDED;
7431 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7432 opts_type = OPTS_TYPE_PT_GENERATE_BE
7433 | OPTS_TYPE_PT_UNICODE
7434 | OPTS_TYPE_ST_ADD80
7435 | OPTS_TYPE_ST_ADDBITS15
7436 | OPTS_TYPE_ST_HEX;
7437 kern_type = KERN_TYPE_SHA1_PWUSLT;
7438 dgst_size = DGST_SIZE_4_5;
7439 parse_func = mssql2005_parse_hash;
7440 sort_by_digest = sort_by_digest_4_5;
7441 opti_type = OPTI_TYPE_ZERO_BYTE
7442 | OPTI_TYPE_PRECOMPUTE_INIT
7443 | OPTI_TYPE_PRECOMPUTE_MERKLE
7444 | OPTI_TYPE_EARLY_SKIP
7445 | OPTI_TYPE_NOT_ITERATED
7446 | OPTI_TYPE_APPENDED_SALT
7447 | OPTI_TYPE_RAW_HASH;
7448 dgst_pos0 = 3;
7449 dgst_pos1 = 4;
7450 dgst_pos2 = 2;
7451 dgst_pos3 = 1;
7452 break;
7453
7454 case 133: hash_type = HASH_TYPE_SHA1;
7455 salt_type = SALT_TYPE_EMBEDDED;
7456 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7457 opts_type = OPTS_TYPE_PT_GENERATE_BE
7458 | OPTS_TYPE_PT_UNICODE
7459 | OPTS_TYPE_ST_ADD80
7460 | OPTS_TYPE_ST_ADDBITS15;
7461 kern_type = KERN_TYPE_SHA1_PWUSLT;
7462 dgst_size = DGST_SIZE_4_5;
7463 parse_func = peoplesoft_parse_hash;
7464 sort_by_digest = sort_by_digest_4_5;
7465 opti_type = OPTI_TYPE_ZERO_BYTE
7466 | OPTI_TYPE_PRECOMPUTE_INIT
7467 | OPTI_TYPE_PRECOMPUTE_MERKLE
7468 | OPTI_TYPE_EARLY_SKIP
7469 | OPTI_TYPE_NOT_ITERATED
7470 | OPTI_TYPE_APPENDED_SALT
7471 | OPTI_TYPE_RAW_HASH;
7472 dgst_pos0 = 3;
7473 dgst_pos1 = 4;
7474 dgst_pos2 = 2;
7475 dgst_pos3 = 1;
7476 break;
7477
7478 case 140: hash_type = HASH_TYPE_SHA1;
7479 salt_type = SALT_TYPE_INTERN;
7480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7481 opts_type = OPTS_TYPE_PT_GENERATE_BE
7482 | OPTS_TYPE_PT_ADD80
7483 | OPTS_TYPE_PT_ADDBITS15
7484 | OPTS_TYPE_PT_UNICODE;
7485 kern_type = KERN_TYPE_SHA1_SLTPWU;
7486 dgst_size = DGST_SIZE_4_5;
7487 parse_func = sha1s_parse_hash;
7488 sort_by_digest = sort_by_digest_4_5;
7489 opti_type = OPTI_TYPE_ZERO_BYTE
7490 | OPTI_TYPE_PRECOMPUTE_INIT
7491 | OPTI_TYPE_PRECOMPUTE_MERKLE
7492 | OPTI_TYPE_EARLY_SKIP
7493 | OPTI_TYPE_NOT_ITERATED
7494 | OPTI_TYPE_PREPENDED_SALT
7495 | OPTI_TYPE_RAW_HASH;
7496 dgst_pos0 = 3;
7497 dgst_pos1 = 4;
7498 dgst_pos2 = 2;
7499 dgst_pos3 = 1;
7500 break;
7501
7502 case 141: hash_type = HASH_TYPE_SHA1;
7503 salt_type = SALT_TYPE_EMBEDDED;
7504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7505 opts_type = OPTS_TYPE_PT_GENERATE_BE
7506 | OPTS_TYPE_PT_ADD80
7507 | OPTS_TYPE_PT_ADDBITS15
7508 | OPTS_TYPE_PT_UNICODE
7509 | OPTS_TYPE_ST_BASE64;
7510 kern_type = KERN_TYPE_SHA1_SLTPWU;
7511 dgst_size = DGST_SIZE_4_5;
7512 parse_func = episerver_parse_hash;
7513 sort_by_digest = sort_by_digest_4_5;
7514 opti_type = OPTI_TYPE_ZERO_BYTE
7515 | OPTI_TYPE_PRECOMPUTE_INIT
7516 | OPTI_TYPE_PRECOMPUTE_MERKLE
7517 | OPTI_TYPE_EARLY_SKIP
7518 | OPTI_TYPE_NOT_ITERATED
7519 | OPTI_TYPE_PREPENDED_SALT
7520 | OPTI_TYPE_RAW_HASH;
7521 dgst_pos0 = 3;
7522 dgst_pos1 = 4;
7523 dgst_pos2 = 2;
7524 dgst_pos3 = 1;
7525 break;
7526
7527 case 150: hash_type = HASH_TYPE_SHA1;
7528 salt_type = SALT_TYPE_INTERN;
7529 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7530 opts_type = OPTS_TYPE_PT_GENERATE_BE
7531 | OPTS_TYPE_ST_ADD80
7532 | OPTS_TYPE_ST_ADDBITS15;
7533 kern_type = KERN_TYPE_HMACSHA1_PW;
7534 dgst_size = DGST_SIZE_4_5;
7535 parse_func = hmacsha1_parse_hash;
7536 sort_by_digest = sort_by_digest_4_5;
7537 opti_type = OPTI_TYPE_ZERO_BYTE
7538 | OPTI_TYPE_NOT_ITERATED;
7539 dgst_pos0 = 3;
7540 dgst_pos1 = 4;
7541 dgst_pos2 = 2;
7542 dgst_pos3 = 1;
7543 break;
7544
7545 case 160: hash_type = HASH_TYPE_SHA1;
7546 salt_type = SALT_TYPE_INTERN;
7547 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7548 opts_type = OPTS_TYPE_PT_GENERATE_BE
7549 | OPTS_TYPE_PT_ADD80
7550 | OPTS_TYPE_PT_ADDBITS15;
7551 kern_type = KERN_TYPE_HMACSHA1_SLT;
7552 dgst_size = DGST_SIZE_4_5;
7553 parse_func = hmacsha1_parse_hash;
7554 sort_by_digest = sort_by_digest_4_5;
7555 opti_type = OPTI_TYPE_ZERO_BYTE
7556 | OPTI_TYPE_NOT_ITERATED;
7557 dgst_pos0 = 3;
7558 dgst_pos1 = 4;
7559 dgst_pos2 = 2;
7560 dgst_pos3 = 1;
7561 break;
7562
7563 case 190: hash_type = HASH_TYPE_SHA1;
7564 salt_type = SALT_TYPE_NONE;
7565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7566 opts_type = OPTS_TYPE_PT_GENERATE_BE
7567 | OPTS_TYPE_PT_ADD80
7568 | OPTS_TYPE_PT_ADDBITS15;
7569 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7570 dgst_size = DGST_SIZE_4_5;
7571 parse_func = sha1linkedin_parse_hash;
7572 sort_by_digest = sort_by_digest_4_5;
7573 opti_type = OPTI_TYPE_ZERO_BYTE
7574 | OPTI_TYPE_PRECOMPUTE_INIT
7575 | OPTI_TYPE_EARLY_SKIP
7576 | OPTI_TYPE_NOT_ITERATED
7577 | OPTI_TYPE_NOT_SALTED;
7578 dgst_pos0 = 0;
7579 dgst_pos1 = 4;
7580 dgst_pos2 = 3;
7581 dgst_pos3 = 2;
7582 break;
7583
7584 case 200: hash_type = HASH_TYPE_MYSQL;
7585 salt_type = SALT_TYPE_NONE;
7586 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7587 opts_type = 0;
7588 kern_type = KERN_TYPE_MYSQL;
7589 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7590 parse_func = mysql323_parse_hash;
7591 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7592 opti_type = OPTI_TYPE_ZERO_BYTE;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 1;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 3;
7597 break;
7598
7599 case 300: hash_type = HASH_TYPE_SHA1;
7600 salt_type = SALT_TYPE_NONE;
7601 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_BE
7603 | OPTS_TYPE_PT_ADD80
7604 | OPTS_TYPE_PT_ADDBITS15;
7605 kern_type = KERN_TYPE_MYSQL41;
7606 dgst_size = DGST_SIZE_4_5;
7607 parse_func = sha1_parse_hash;
7608 sort_by_digest = sort_by_digest_4_5;
7609 opti_type = OPTI_TYPE_ZERO_BYTE
7610 | OPTI_TYPE_PRECOMPUTE_INIT
7611 | OPTI_TYPE_PRECOMPUTE_MERKLE
7612 | OPTI_TYPE_EARLY_SKIP
7613 | OPTI_TYPE_NOT_ITERATED
7614 | OPTI_TYPE_NOT_SALTED;
7615 dgst_pos0 = 3;
7616 dgst_pos1 = 4;
7617 dgst_pos2 = 2;
7618 dgst_pos3 = 1;
7619 break;
7620
7621 case 400: hash_type = HASH_TYPE_MD5;
7622 salt_type = SALT_TYPE_EMBEDDED;
7623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7624 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7625 kern_type = KERN_TYPE_PHPASS;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = phpass_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE
7630 | OPTI_TYPE_SLOW_HASH_SIMD;
7631 dgst_pos0 = 0;
7632 dgst_pos1 = 1;
7633 dgst_pos2 = 2;
7634 dgst_pos3 = 3;
7635 break;
7636
7637 case 500: hash_type = HASH_TYPE_MD5;
7638 salt_type = SALT_TYPE_EMBEDDED;
7639 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7640 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7641 kern_type = KERN_TYPE_MD5CRYPT;
7642 dgst_size = DGST_SIZE_4_4;
7643 parse_func = md5crypt_parse_hash;
7644 sort_by_digest = sort_by_digest_4_4;
7645 opti_type = OPTI_TYPE_ZERO_BYTE;
7646 dgst_pos0 = 0;
7647 dgst_pos1 = 1;
7648 dgst_pos2 = 2;
7649 dgst_pos3 = 3;
7650 break;
7651
7652 case 501: hash_type = HASH_TYPE_MD5;
7653 salt_type = SALT_TYPE_EMBEDDED;
7654 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7655 opts_type = OPTS_TYPE_PT_GENERATE_LE
7656 | OPTS_TYPE_HASH_COPY;
7657 kern_type = KERN_TYPE_MD5CRYPT;
7658 dgst_size = DGST_SIZE_4_4;
7659 parse_func = juniper_parse_hash;
7660 sort_by_digest = sort_by_digest_4_4;
7661 opti_type = OPTI_TYPE_ZERO_BYTE;
7662 dgst_pos0 = 0;
7663 dgst_pos1 = 1;
7664 dgst_pos2 = 2;
7665 dgst_pos3 = 3;
7666 break;
7667
7668 case 900: hash_type = HASH_TYPE_MD4;
7669 salt_type = SALT_TYPE_NONE;
7670 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7671 opts_type = OPTS_TYPE_PT_GENERATE_LE
7672 | OPTS_TYPE_PT_ADD80
7673 | OPTS_TYPE_PT_ADDBITS14;
7674 kern_type = KERN_TYPE_MD4;
7675 dgst_size = DGST_SIZE_4_4;
7676 parse_func = md4_parse_hash;
7677 sort_by_digest = sort_by_digest_4_4;
7678 opti_type = OPTI_TYPE_ZERO_BYTE
7679 | OPTI_TYPE_PRECOMPUTE_INIT
7680 | OPTI_TYPE_PRECOMPUTE_MERKLE
7681 | OPTI_TYPE_MEET_IN_MIDDLE
7682 | OPTI_TYPE_EARLY_SKIP
7683 | OPTI_TYPE_NOT_ITERATED
7684 | OPTI_TYPE_NOT_SALTED
7685 | OPTI_TYPE_RAW_HASH;
7686 dgst_pos0 = 0;
7687 dgst_pos1 = 3;
7688 dgst_pos2 = 2;
7689 dgst_pos3 = 1;
7690 break;
7691
7692 case 1000: hash_type = HASH_TYPE_MD4;
7693 salt_type = SALT_TYPE_NONE;
7694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7695 opts_type = OPTS_TYPE_PT_GENERATE_LE
7696 | OPTS_TYPE_PT_ADD80
7697 | OPTS_TYPE_PT_ADDBITS14
7698 | OPTS_TYPE_PT_UNICODE;
7699 kern_type = KERN_TYPE_MD4_PWU;
7700 dgst_size = DGST_SIZE_4_4;
7701 parse_func = md4_parse_hash;
7702 sort_by_digest = sort_by_digest_4_4;
7703 opti_type = OPTI_TYPE_ZERO_BYTE
7704 | OPTI_TYPE_PRECOMPUTE_INIT
7705 | OPTI_TYPE_PRECOMPUTE_MERKLE
7706 | OPTI_TYPE_MEET_IN_MIDDLE
7707 | OPTI_TYPE_EARLY_SKIP
7708 | OPTI_TYPE_NOT_ITERATED
7709 | OPTI_TYPE_NOT_SALTED
7710 | OPTI_TYPE_RAW_HASH;
7711 dgst_pos0 = 0;
7712 dgst_pos1 = 3;
7713 dgst_pos2 = 2;
7714 dgst_pos3 = 1;
7715 break;
7716
7717 case 1100: hash_type = HASH_TYPE_MD4;
7718 salt_type = SALT_TYPE_INTERN;
7719 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7720 opts_type = OPTS_TYPE_PT_GENERATE_LE
7721 | OPTS_TYPE_PT_ADD80
7722 | OPTS_TYPE_PT_ADDBITS14
7723 | OPTS_TYPE_PT_UNICODE
7724 | OPTS_TYPE_ST_ADD80
7725 | OPTS_TYPE_ST_UNICODE
7726 | OPTS_TYPE_ST_LOWER;
7727 kern_type = KERN_TYPE_MD44_PWUSLT;
7728 dgst_size = DGST_SIZE_4_4;
7729 parse_func = dcc_parse_hash;
7730 sort_by_digest = sort_by_digest_4_4;
7731 opti_type = OPTI_TYPE_ZERO_BYTE
7732 | OPTI_TYPE_PRECOMPUTE_INIT
7733 | OPTI_TYPE_PRECOMPUTE_MERKLE
7734 | OPTI_TYPE_EARLY_SKIP
7735 | OPTI_TYPE_NOT_ITERATED;
7736 dgst_pos0 = 0;
7737 dgst_pos1 = 3;
7738 dgst_pos2 = 2;
7739 dgst_pos3 = 1;
7740 break;
7741
7742 case 1400: hash_type = HASH_TYPE_SHA256;
7743 salt_type = SALT_TYPE_NONE;
7744 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7745 opts_type = OPTS_TYPE_PT_GENERATE_BE
7746 | OPTS_TYPE_PT_ADD80
7747 | OPTS_TYPE_PT_ADDBITS15;
7748 kern_type = KERN_TYPE_SHA256;
7749 dgst_size = DGST_SIZE_4_8;
7750 parse_func = sha256_parse_hash;
7751 sort_by_digest = sort_by_digest_4_8;
7752 opti_type = OPTI_TYPE_ZERO_BYTE
7753 | OPTI_TYPE_PRECOMPUTE_INIT
7754 | OPTI_TYPE_PRECOMPUTE_MERKLE
7755 | OPTI_TYPE_EARLY_SKIP
7756 | OPTI_TYPE_NOT_ITERATED
7757 | OPTI_TYPE_NOT_SALTED
7758 | OPTI_TYPE_RAW_HASH;
7759 dgst_pos0 = 3;
7760 dgst_pos1 = 7;
7761 dgst_pos2 = 2;
7762 dgst_pos3 = 6;
7763 break;
7764
7765 case 1410: hash_type = HASH_TYPE_SHA256;
7766 salt_type = SALT_TYPE_INTERN;
7767 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7768 opts_type = OPTS_TYPE_PT_GENERATE_BE
7769 | OPTS_TYPE_ST_ADD80
7770 | OPTS_TYPE_ST_ADDBITS15;
7771 kern_type = KERN_TYPE_SHA256_PWSLT;
7772 dgst_size = DGST_SIZE_4_8;
7773 parse_func = sha256s_parse_hash;
7774 sort_by_digest = sort_by_digest_4_8;
7775 opti_type = OPTI_TYPE_ZERO_BYTE
7776 | OPTI_TYPE_PRECOMPUTE_INIT
7777 | OPTI_TYPE_PRECOMPUTE_MERKLE
7778 | OPTI_TYPE_EARLY_SKIP
7779 | OPTI_TYPE_NOT_ITERATED
7780 | OPTI_TYPE_APPENDED_SALT
7781 | OPTI_TYPE_RAW_HASH;
7782 dgst_pos0 = 3;
7783 dgst_pos1 = 7;
7784 dgst_pos2 = 2;
7785 dgst_pos3 = 6;
7786 break;
7787
7788 case 1420: hash_type = HASH_TYPE_SHA256;
7789 salt_type = SALT_TYPE_INTERN;
7790 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7791 opts_type = OPTS_TYPE_PT_GENERATE_BE
7792 | OPTS_TYPE_PT_ADD80
7793 | OPTS_TYPE_PT_ADDBITS15;
7794 kern_type = KERN_TYPE_SHA256_SLTPW;
7795 dgst_size = DGST_SIZE_4_8;
7796 parse_func = sha256s_parse_hash;
7797 sort_by_digest = sort_by_digest_4_8;
7798 opti_type = OPTI_TYPE_ZERO_BYTE
7799 | OPTI_TYPE_PRECOMPUTE_INIT
7800 | OPTI_TYPE_PRECOMPUTE_MERKLE
7801 | OPTI_TYPE_EARLY_SKIP
7802 | OPTI_TYPE_NOT_ITERATED
7803 | OPTI_TYPE_PREPENDED_SALT
7804 | OPTI_TYPE_RAW_HASH;
7805 dgst_pos0 = 3;
7806 dgst_pos1 = 7;
7807 dgst_pos2 = 2;
7808 dgst_pos3 = 6;
7809 break;
7810
7811 case 1421: hash_type = HASH_TYPE_SHA256;
7812 salt_type = SALT_TYPE_EMBEDDED;
7813 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7814 opts_type = OPTS_TYPE_PT_GENERATE_BE
7815 | OPTS_TYPE_PT_ADD80
7816 | OPTS_TYPE_PT_ADDBITS15;
7817 kern_type = KERN_TYPE_SHA256_SLTPW;
7818 dgst_size = DGST_SIZE_4_8;
7819 parse_func = hmailserver_parse_hash;
7820 sort_by_digest = sort_by_digest_4_8;
7821 opti_type = OPTI_TYPE_ZERO_BYTE
7822 | OPTI_TYPE_PRECOMPUTE_INIT
7823 | OPTI_TYPE_PRECOMPUTE_MERKLE
7824 | OPTI_TYPE_EARLY_SKIP
7825 | OPTI_TYPE_NOT_ITERATED
7826 | OPTI_TYPE_PREPENDED_SALT
7827 | OPTI_TYPE_RAW_HASH;
7828 dgst_pos0 = 3;
7829 dgst_pos1 = 7;
7830 dgst_pos2 = 2;
7831 dgst_pos3 = 6;
7832 break;
7833
7834 case 1430: hash_type = HASH_TYPE_SHA256;
7835 salt_type = SALT_TYPE_INTERN;
7836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7837 opts_type = OPTS_TYPE_PT_GENERATE_BE
7838 | OPTS_TYPE_PT_UNICODE
7839 | OPTS_TYPE_ST_ADD80
7840 | OPTS_TYPE_ST_ADDBITS15;
7841 kern_type = KERN_TYPE_SHA256_PWUSLT;
7842 dgst_size = DGST_SIZE_4_8;
7843 parse_func = sha256s_parse_hash;
7844 sort_by_digest = sort_by_digest_4_8;
7845 opti_type = OPTI_TYPE_ZERO_BYTE
7846 | OPTI_TYPE_PRECOMPUTE_INIT
7847 | OPTI_TYPE_PRECOMPUTE_MERKLE
7848 | OPTI_TYPE_EARLY_SKIP
7849 | OPTI_TYPE_NOT_ITERATED
7850 | OPTI_TYPE_APPENDED_SALT
7851 | OPTI_TYPE_RAW_HASH;
7852 dgst_pos0 = 3;
7853 dgst_pos1 = 7;
7854 dgst_pos2 = 2;
7855 dgst_pos3 = 6;
7856 break;
7857
7858 case 1440: hash_type = HASH_TYPE_SHA256;
7859 salt_type = SALT_TYPE_INTERN;
7860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7861 opts_type = OPTS_TYPE_PT_GENERATE_BE
7862 | OPTS_TYPE_PT_ADD80
7863 | OPTS_TYPE_PT_ADDBITS15
7864 | OPTS_TYPE_PT_UNICODE;
7865 kern_type = KERN_TYPE_SHA256_SLTPWU;
7866 dgst_size = DGST_SIZE_4_8;
7867 parse_func = sha256s_parse_hash;
7868 sort_by_digest = sort_by_digest_4_8;
7869 opti_type = OPTI_TYPE_ZERO_BYTE
7870 | OPTI_TYPE_PRECOMPUTE_INIT
7871 | OPTI_TYPE_PRECOMPUTE_MERKLE
7872 | OPTI_TYPE_EARLY_SKIP
7873 | OPTI_TYPE_NOT_ITERATED
7874 | OPTI_TYPE_PREPENDED_SALT
7875 | OPTI_TYPE_RAW_HASH;
7876 dgst_pos0 = 3;
7877 dgst_pos1 = 7;
7878 dgst_pos2 = 2;
7879 dgst_pos3 = 6;
7880 break;
7881
7882 case 1441: hash_type = HASH_TYPE_SHA256;
7883 salt_type = SALT_TYPE_EMBEDDED;
7884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7885 opts_type = OPTS_TYPE_PT_GENERATE_BE
7886 | OPTS_TYPE_PT_ADD80
7887 | OPTS_TYPE_PT_ADDBITS15
7888 | OPTS_TYPE_PT_UNICODE
7889 | OPTS_TYPE_ST_BASE64;
7890 kern_type = KERN_TYPE_SHA256_SLTPWU;
7891 dgst_size = DGST_SIZE_4_8;
7892 parse_func = episerver4_parse_hash;
7893 sort_by_digest = sort_by_digest_4_8;
7894 opti_type = OPTI_TYPE_ZERO_BYTE
7895 | OPTI_TYPE_PRECOMPUTE_INIT
7896 | OPTI_TYPE_PRECOMPUTE_MERKLE
7897 | OPTI_TYPE_EARLY_SKIP
7898 | OPTI_TYPE_NOT_ITERATED
7899 | OPTI_TYPE_PREPENDED_SALT
7900 | OPTI_TYPE_RAW_HASH;
7901 dgst_pos0 = 3;
7902 dgst_pos1 = 7;
7903 dgst_pos2 = 2;
7904 dgst_pos3 = 6;
7905 break;
7906
7907 case 1450: hash_type = HASH_TYPE_SHA256;
7908 salt_type = SALT_TYPE_INTERN;
7909 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7910 opts_type = OPTS_TYPE_PT_GENERATE_BE
7911 | OPTS_TYPE_ST_ADD80;
7912 kern_type = KERN_TYPE_HMACSHA256_PW;
7913 dgst_size = DGST_SIZE_4_8;
7914 parse_func = hmacsha256_parse_hash;
7915 sort_by_digest = sort_by_digest_4_8;
7916 opti_type = OPTI_TYPE_ZERO_BYTE
7917 | OPTI_TYPE_NOT_ITERATED;
7918 dgst_pos0 = 3;
7919 dgst_pos1 = 7;
7920 dgst_pos2 = 2;
7921 dgst_pos3 = 6;
7922 break;
7923
7924 case 1460: hash_type = HASH_TYPE_SHA256;
7925 salt_type = SALT_TYPE_INTERN;
7926 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7927 opts_type = OPTS_TYPE_PT_GENERATE_BE
7928 | OPTS_TYPE_PT_ADD80
7929 | OPTS_TYPE_PT_ADDBITS15;
7930 kern_type = KERN_TYPE_HMACSHA256_SLT;
7931 dgst_size = DGST_SIZE_4_8;
7932 parse_func = hmacsha256_parse_hash;
7933 sort_by_digest = sort_by_digest_4_8;
7934 opti_type = OPTI_TYPE_ZERO_BYTE
7935 | OPTI_TYPE_NOT_ITERATED;
7936 dgst_pos0 = 3;
7937 dgst_pos1 = 7;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 6;
7940 break;
7941
7942 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7943 salt_type = SALT_TYPE_EMBEDDED;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_LE
7946 | OPTS_TYPE_PT_BITSLICE;
7947 kern_type = KERN_TYPE_DESCRYPT;
7948 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7949 parse_func = descrypt_parse_hash;
7950 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7951 opti_type = OPTI_TYPE_ZERO_BYTE
7952 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7953 dgst_pos0 = 0;
7954 dgst_pos1 = 1;
7955 dgst_pos2 = 2;
7956 dgst_pos3 = 3;
7957 break;
7958
7959 case 1600: hash_type = HASH_TYPE_MD5;
7960 salt_type = SALT_TYPE_EMBEDDED;
7961 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7962 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7963 kern_type = KERN_TYPE_APR1CRYPT;
7964 dgst_size = DGST_SIZE_4_4;
7965 parse_func = md5apr1_parse_hash;
7966 sort_by_digest = sort_by_digest_4_4;
7967 opti_type = OPTI_TYPE_ZERO_BYTE;
7968 dgst_pos0 = 0;
7969 dgst_pos1 = 1;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 3;
7972 break;
7973
7974 case 1700: hash_type = HASH_TYPE_SHA512;
7975 salt_type = SALT_TYPE_NONE;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA512;
7981 dgst_size = DGST_SIZE_8_8;
7982 parse_func = sha512_parse_hash;
7983 sort_by_digest = sort_by_digest_8_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_NOT_SALTED
7990 | OPTI_TYPE_USES_BITS_64
7991 | OPTI_TYPE_RAW_HASH;
7992 dgst_pos0 = 14;
7993 dgst_pos1 = 15;
7994 dgst_pos2 = 6;
7995 dgst_pos3 = 7;
7996 break;
7997
7998 case 1710: hash_type = HASH_TYPE_SHA512;
7999 salt_type = SALT_TYPE_INTERN;
8000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8001 opts_type = OPTS_TYPE_PT_GENERATE_BE
8002 | OPTS_TYPE_ST_ADD80
8003 | OPTS_TYPE_ST_ADDBITS15;
8004 kern_type = KERN_TYPE_SHA512_PWSLT;
8005 dgst_size = DGST_SIZE_8_8;
8006 parse_func = sha512s_parse_hash;
8007 sort_by_digest = sort_by_digest_8_8;
8008 opti_type = OPTI_TYPE_ZERO_BYTE
8009 | OPTI_TYPE_PRECOMPUTE_INIT
8010 | OPTI_TYPE_PRECOMPUTE_MERKLE
8011 | OPTI_TYPE_EARLY_SKIP
8012 | OPTI_TYPE_NOT_ITERATED
8013 | OPTI_TYPE_APPENDED_SALT
8014 | OPTI_TYPE_USES_BITS_64
8015 | OPTI_TYPE_RAW_HASH;
8016 dgst_pos0 = 14;
8017 dgst_pos1 = 15;
8018 dgst_pos2 = 6;
8019 dgst_pos3 = 7;
8020 break;
8021
8022 case 1711: hash_type = HASH_TYPE_SHA512;
8023 salt_type = SALT_TYPE_EMBEDDED;
8024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8025 opts_type = OPTS_TYPE_PT_GENERATE_BE
8026 | OPTS_TYPE_ST_ADD80
8027 | OPTS_TYPE_ST_ADDBITS15;
8028 kern_type = KERN_TYPE_SHA512_PWSLT;
8029 dgst_size = DGST_SIZE_8_8;
8030 parse_func = sha512b64s_parse_hash;
8031 sort_by_digest = sort_by_digest_8_8;
8032 opti_type = OPTI_TYPE_ZERO_BYTE
8033 | OPTI_TYPE_PRECOMPUTE_INIT
8034 | OPTI_TYPE_PRECOMPUTE_MERKLE
8035 | OPTI_TYPE_EARLY_SKIP
8036 | OPTI_TYPE_NOT_ITERATED
8037 | OPTI_TYPE_APPENDED_SALT
8038 | OPTI_TYPE_USES_BITS_64
8039 | OPTI_TYPE_RAW_HASH;
8040 dgst_pos0 = 14;
8041 dgst_pos1 = 15;
8042 dgst_pos2 = 6;
8043 dgst_pos3 = 7;
8044 break;
8045
8046 case 1720: hash_type = HASH_TYPE_SHA512;
8047 salt_type = SALT_TYPE_INTERN;
8048 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8049 opts_type = OPTS_TYPE_PT_GENERATE_BE
8050 | OPTS_TYPE_PT_ADD80
8051 | OPTS_TYPE_PT_ADDBITS15;
8052 kern_type = KERN_TYPE_SHA512_SLTPW;
8053 dgst_size = DGST_SIZE_8_8;
8054 parse_func = sha512s_parse_hash;
8055 sort_by_digest = sort_by_digest_8_8;
8056 opti_type = OPTI_TYPE_ZERO_BYTE
8057 | OPTI_TYPE_PRECOMPUTE_INIT
8058 | OPTI_TYPE_PRECOMPUTE_MERKLE
8059 | OPTI_TYPE_EARLY_SKIP
8060 | OPTI_TYPE_NOT_ITERATED
8061 | OPTI_TYPE_PREPENDED_SALT
8062 | OPTI_TYPE_USES_BITS_64
8063 | OPTI_TYPE_RAW_HASH;
8064 dgst_pos0 = 14;
8065 dgst_pos1 = 15;
8066 dgst_pos2 = 6;
8067 dgst_pos3 = 7;
8068 break;
8069
8070 case 1722: hash_type = HASH_TYPE_SHA512;
8071 salt_type = SALT_TYPE_EMBEDDED;
8072 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8073 opts_type = OPTS_TYPE_PT_GENERATE_BE
8074 | OPTS_TYPE_PT_ADD80
8075 | OPTS_TYPE_PT_ADDBITS15
8076 | OPTS_TYPE_ST_HEX;
8077 kern_type = KERN_TYPE_SHA512_SLTPW;
8078 dgst_size = DGST_SIZE_8_8;
8079 parse_func = osx512_parse_hash;
8080 sort_by_digest = sort_by_digest_8_8;
8081 opti_type = OPTI_TYPE_ZERO_BYTE
8082 | OPTI_TYPE_PRECOMPUTE_INIT
8083 | OPTI_TYPE_PRECOMPUTE_MERKLE
8084 | OPTI_TYPE_EARLY_SKIP
8085 | OPTI_TYPE_NOT_ITERATED
8086 | OPTI_TYPE_PREPENDED_SALT
8087 | OPTI_TYPE_USES_BITS_64
8088 | OPTI_TYPE_RAW_HASH;
8089 dgst_pos0 = 14;
8090 dgst_pos1 = 15;
8091 dgst_pos2 = 6;
8092 dgst_pos3 = 7;
8093 break;
8094
8095 case 1730: hash_type = HASH_TYPE_SHA512;
8096 salt_type = SALT_TYPE_INTERN;
8097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8098 opts_type = OPTS_TYPE_PT_GENERATE_BE
8099 | OPTS_TYPE_PT_UNICODE
8100 | OPTS_TYPE_ST_ADD80
8101 | OPTS_TYPE_ST_ADDBITS15;
8102 kern_type = KERN_TYPE_SHA512_PWSLTU;
8103 dgst_size = DGST_SIZE_8_8;
8104 parse_func = sha512s_parse_hash;
8105 sort_by_digest = sort_by_digest_8_8;
8106 opti_type = OPTI_TYPE_ZERO_BYTE
8107 | OPTI_TYPE_PRECOMPUTE_INIT
8108 | OPTI_TYPE_PRECOMPUTE_MERKLE
8109 | OPTI_TYPE_EARLY_SKIP
8110 | OPTI_TYPE_NOT_ITERATED
8111 | OPTI_TYPE_APPENDED_SALT
8112 | OPTI_TYPE_USES_BITS_64
8113 | OPTI_TYPE_RAW_HASH;
8114 dgst_pos0 = 14;
8115 dgst_pos1 = 15;
8116 dgst_pos2 = 6;
8117 dgst_pos3 = 7;
8118 break;
8119
8120 case 1731: hash_type = HASH_TYPE_SHA512;
8121 salt_type = SALT_TYPE_EMBEDDED;
8122 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8123 opts_type = OPTS_TYPE_PT_GENERATE_BE
8124 | OPTS_TYPE_PT_UNICODE
8125 | OPTS_TYPE_ST_ADD80
8126 | OPTS_TYPE_ST_ADDBITS15
8127 | OPTS_TYPE_ST_HEX;
8128 kern_type = KERN_TYPE_SHA512_PWSLTU;
8129 dgst_size = DGST_SIZE_8_8;
8130 parse_func = mssql2012_parse_hash;
8131 sort_by_digest = sort_by_digest_8_8;
8132 opti_type = OPTI_TYPE_ZERO_BYTE
8133 | OPTI_TYPE_PRECOMPUTE_INIT
8134 | OPTI_TYPE_PRECOMPUTE_MERKLE
8135 | OPTI_TYPE_EARLY_SKIP
8136 | OPTI_TYPE_NOT_ITERATED
8137 | OPTI_TYPE_APPENDED_SALT
8138 | OPTI_TYPE_USES_BITS_64
8139 | OPTI_TYPE_RAW_HASH;
8140 dgst_pos0 = 14;
8141 dgst_pos1 = 15;
8142 dgst_pos2 = 6;
8143 dgst_pos3 = 7;
8144 break;
8145
8146 case 1740: hash_type = HASH_TYPE_SHA512;
8147 salt_type = SALT_TYPE_INTERN;
8148 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8149 opts_type = OPTS_TYPE_PT_GENERATE_BE
8150 | OPTS_TYPE_PT_ADD80
8151 | OPTS_TYPE_PT_ADDBITS15
8152 | OPTS_TYPE_PT_UNICODE;
8153 kern_type = KERN_TYPE_SHA512_SLTPWU;
8154 dgst_size = DGST_SIZE_8_8;
8155 parse_func = sha512s_parse_hash;
8156 sort_by_digest = sort_by_digest_8_8;
8157 opti_type = OPTI_TYPE_ZERO_BYTE
8158 | OPTI_TYPE_PRECOMPUTE_INIT
8159 | OPTI_TYPE_PRECOMPUTE_MERKLE
8160 | OPTI_TYPE_EARLY_SKIP
8161 | OPTI_TYPE_NOT_ITERATED
8162 | OPTI_TYPE_PREPENDED_SALT
8163 | OPTI_TYPE_USES_BITS_64
8164 | OPTI_TYPE_RAW_HASH;
8165 dgst_pos0 = 14;
8166 dgst_pos1 = 15;
8167 dgst_pos2 = 6;
8168 dgst_pos3 = 7;
8169 break;
8170
8171 case 1750: hash_type = HASH_TYPE_SHA512;
8172 salt_type = SALT_TYPE_INTERN;
8173 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8174 opts_type = OPTS_TYPE_PT_GENERATE_BE
8175 | OPTS_TYPE_ST_ADD80;
8176 kern_type = KERN_TYPE_HMACSHA512_PW;
8177 dgst_size = DGST_SIZE_8_8;
8178 parse_func = hmacsha512_parse_hash;
8179 sort_by_digest = sort_by_digest_8_8;
8180 opti_type = OPTI_TYPE_ZERO_BYTE
8181 | OPTI_TYPE_USES_BITS_64
8182 | OPTI_TYPE_NOT_ITERATED;
8183 dgst_pos0 = 14;
8184 dgst_pos1 = 15;
8185 dgst_pos2 = 6;
8186 dgst_pos3 = 7;
8187 break;
8188
8189 case 1760: hash_type = HASH_TYPE_SHA512;
8190 salt_type = SALT_TYPE_INTERN;
8191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8192 opts_type = OPTS_TYPE_PT_GENERATE_BE
8193 | OPTS_TYPE_PT_ADD80
8194 | OPTS_TYPE_PT_ADDBITS15;
8195 kern_type = KERN_TYPE_HMACSHA512_SLT;
8196 dgst_size = DGST_SIZE_8_8;
8197 parse_func = hmacsha512_parse_hash;
8198 sort_by_digest = sort_by_digest_8_8;
8199 opti_type = OPTI_TYPE_ZERO_BYTE
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_NOT_ITERATED;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1800: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8212 kern_type = KERN_TYPE_SHA512CRYPT;
8213 dgst_size = DGST_SIZE_8_8;
8214 parse_func = sha512crypt_parse_hash;
8215 sort_by_digest = sort_by_digest_8_8;
8216 opti_type = OPTI_TYPE_ZERO_BYTE
8217 | OPTI_TYPE_USES_BITS_64;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 1;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 3;
8222 break;
8223
8224 case 2100: hash_type = HASH_TYPE_DCC2;
8225 salt_type = SALT_TYPE_EMBEDDED;
8226 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8228 | OPTS_TYPE_ST_LOWER
8229 | OPTS_TYPE_ST_UNICODE;
8230 kern_type = KERN_TYPE_DCC2;
8231 dgst_size = DGST_SIZE_4_4;
8232 parse_func = dcc2_parse_hash;
8233 sort_by_digest = sort_by_digest_4_4;
8234 opti_type = OPTI_TYPE_ZERO_BYTE
8235 | OPTI_TYPE_SLOW_HASH_SIMD;
8236 dgst_pos0 = 0;
8237 dgst_pos1 = 1;
8238 dgst_pos2 = 2;
8239 dgst_pos3 = 3;
8240 break;
8241
8242 case 2400: hash_type = HASH_TYPE_MD5;
8243 salt_type = SALT_TYPE_NONE;
8244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8245 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8246 kern_type = KERN_TYPE_MD5PIX;
8247 dgst_size = DGST_SIZE_4_4;
8248 parse_func = md5pix_parse_hash;
8249 sort_by_digest = sort_by_digest_4_4;
8250 opti_type = OPTI_TYPE_ZERO_BYTE
8251 | OPTI_TYPE_PRECOMPUTE_INIT
8252 | OPTI_TYPE_PRECOMPUTE_MERKLE
8253 | OPTI_TYPE_EARLY_SKIP
8254 | OPTI_TYPE_NOT_ITERATED
8255 | OPTI_TYPE_NOT_SALTED;
8256 dgst_pos0 = 0;
8257 dgst_pos1 = 3;
8258 dgst_pos2 = 2;
8259 dgst_pos3 = 1;
8260 break;
8261
8262 case 2410: hash_type = HASH_TYPE_MD5;
8263 salt_type = SALT_TYPE_INTERN;
8264 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8265 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8266 kern_type = KERN_TYPE_MD5ASA;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md5asa_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP
8274 | OPTI_TYPE_NOT_ITERATED;
8275 dgst_pos0 = 0;
8276 dgst_pos1 = 3;
8277 dgst_pos2 = 2;
8278 dgst_pos3 = 1;
8279 break;
8280
8281 case 2500: hash_type = HASH_TYPE_WPA;
8282 salt_type = SALT_TYPE_EMBEDDED;
8283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8285 kern_type = KERN_TYPE_WPA;
8286 dgst_size = DGST_SIZE_4_4;
8287 parse_func = wpa_parse_hash;
8288 sort_by_digest = sort_by_digest_4_4;
8289 opti_type = OPTI_TYPE_ZERO_BYTE
8290 | OPTI_TYPE_SLOW_HASH_SIMD;
8291 dgst_pos0 = 0;
8292 dgst_pos1 = 1;
8293 dgst_pos2 = 2;
8294 dgst_pos3 = 3;
8295 break;
8296
8297 case 2600: hash_type = HASH_TYPE_MD5;
8298 salt_type = SALT_TYPE_VIRTUAL;
8299 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8300 opts_type = OPTS_TYPE_PT_GENERATE_LE
8301 | OPTS_TYPE_PT_ADD80
8302 | OPTS_TYPE_PT_ADDBITS14
8303 | OPTS_TYPE_ST_ADD80;
8304 kern_type = KERN_TYPE_MD55_PWSLT1;
8305 dgst_size = DGST_SIZE_4_4;
8306 parse_func = md5md5_parse_hash;
8307 sort_by_digest = sort_by_digest_4_4;
8308 opti_type = OPTI_TYPE_ZERO_BYTE
8309 | OPTI_TYPE_PRECOMPUTE_INIT
8310 | OPTI_TYPE_PRECOMPUTE_MERKLE
8311 | OPTI_TYPE_EARLY_SKIP;
8312 dgst_pos0 = 0;
8313 dgst_pos1 = 3;
8314 dgst_pos2 = 2;
8315 dgst_pos3 = 1;
8316 break;
8317
8318 case 2611: hash_type = HASH_TYPE_MD5;
8319 salt_type = SALT_TYPE_INTERN;
8320 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8321 opts_type = OPTS_TYPE_PT_GENERATE_LE
8322 | OPTS_TYPE_PT_ADD80
8323 | OPTS_TYPE_PT_ADDBITS14
8324 | OPTS_TYPE_ST_ADD80;
8325 kern_type = KERN_TYPE_MD55_PWSLT1;
8326 dgst_size = DGST_SIZE_4_4;
8327 parse_func = vb3_parse_hash;
8328 sort_by_digest = sort_by_digest_4_4;
8329 opti_type = OPTI_TYPE_ZERO_BYTE
8330 | OPTI_TYPE_PRECOMPUTE_INIT
8331 | OPTI_TYPE_PRECOMPUTE_MERKLE
8332 | OPTI_TYPE_EARLY_SKIP;
8333 dgst_pos0 = 0;
8334 dgst_pos1 = 3;
8335 dgst_pos2 = 2;
8336 dgst_pos3 = 1;
8337 break;
8338
8339 case 2612: hash_type = HASH_TYPE_MD5;
8340 salt_type = SALT_TYPE_EMBEDDED;
8341 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8342 opts_type = OPTS_TYPE_PT_GENERATE_LE
8343 | OPTS_TYPE_PT_ADD80
8344 | OPTS_TYPE_PT_ADDBITS14
8345 | OPTS_TYPE_ST_ADD80
8346 | OPTS_TYPE_ST_HEX;
8347 kern_type = KERN_TYPE_MD55_PWSLT1;
8348 dgst_size = DGST_SIZE_4_4;
8349 parse_func = phps_parse_hash;
8350 sort_by_digest = sort_by_digest_4_4;
8351 opti_type = OPTI_TYPE_ZERO_BYTE
8352 | OPTI_TYPE_PRECOMPUTE_INIT
8353 | OPTI_TYPE_PRECOMPUTE_MERKLE
8354 | OPTI_TYPE_EARLY_SKIP;
8355 dgst_pos0 = 0;
8356 dgst_pos1 = 3;
8357 dgst_pos2 = 2;
8358 dgst_pos3 = 1;
8359 break;
8360
8361 case 2711: hash_type = HASH_TYPE_MD5;
8362 salt_type = SALT_TYPE_INTERN;
8363 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8364 opts_type = OPTS_TYPE_PT_GENERATE_LE
8365 | OPTS_TYPE_PT_ADD80
8366 | OPTS_TYPE_PT_ADDBITS14
8367 | OPTS_TYPE_ST_ADD80;
8368 kern_type = KERN_TYPE_MD55_PWSLT2;
8369 dgst_size = DGST_SIZE_4_4;
8370 parse_func = vb30_parse_hash;
8371 sort_by_digest = sort_by_digest_4_4;
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_PRECOMPUTE_INIT
8374 | OPTI_TYPE_EARLY_SKIP;
8375 dgst_pos0 = 0;
8376 dgst_pos1 = 3;
8377 dgst_pos2 = 2;
8378 dgst_pos3 = 1;
8379 break;
8380
8381 case 2811: hash_type = HASH_TYPE_MD5;
8382 salt_type = SALT_TYPE_INTERN;
8383 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8384 opts_type = OPTS_TYPE_PT_GENERATE_LE
8385 | OPTS_TYPE_PT_ADD80
8386 | OPTS_TYPE_PT_ADDBITS14;
8387 kern_type = KERN_TYPE_MD55_SLTPW;
8388 dgst_size = DGST_SIZE_4_4;
8389 parse_func = ipb2_parse_hash;
8390 sort_by_digest = sort_by_digest_4_4;
8391 opti_type = OPTI_TYPE_ZERO_BYTE
8392 | OPTI_TYPE_PRECOMPUTE_INIT
8393 | OPTI_TYPE_EARLY_SKIP;
8394 dgst_pos0 = 0;
8395 dgst_pos1 = 3;
8396 dgst_pos2 = 2;
8397 dgst_pos3 = 1;
8398 break;
8399
8400 case 3000: hash_type = HASH_TYPE_LM;
8401 salt_type = SALT_TYPE_NONE;
8402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8403 opts_type = OPTS_TYPE_PT_GENERATE_LE
8404 | OPTS_TYPE_PT_UPPER
8405 | OPTS_TYPE_PT_BITSLICE;
8406 kern_type = KERN_TYPE_LM;
8407 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8408 parse_func = lm_parse_hash;
8409 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8410 opti_type = OPTI_TYPE_ZERO_BYTE
8411 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8412 dgst_pos0 = 0;
8413 dgst_pos1 = 1;
8414 dgst_pos2 = 2;
8415 dgst_pos3 = 3;
8416 break;
8417
8418 case 3100: hash_type = HASH_TYPE_ORACLEH;
8419 salt_type = SALT_TYPE_INTERN;
8420 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8421 opts_type = OPTS_TYPE_PT_GENERATE_LE
8422 | OPTS_TYPE_PT_UPPER
8423 | OPTS_TYPE_ST_UPPER;
8424 kern_type = KERN_TYPE_ORACLEH;
8425 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8426 parse_func = oracleh_parse_hash;
8427 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8428 opti_type = OPTI_TYPE_ZERO_BYTE;
8429 dgst_pos0 = 0;
8430 dgst_pos1 = 1;
8431 dgst_pos2 = 2;
8432 dgst_pos3 = 3;
8433 break;
8434
8435 case 3200: hash_type = HASH_TYPE_BCRYPT;
8436 salt_type = SALT_TYPE_EMBEDDED;
8437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8438 opts_type = OPTS_TYPE_PT_GENERATE_LE
8439 | OPTS_TYPE_ST_GENERATE_LE;
8440 kern_type = KERN_TYPE_BCRYPT;
8441 dgst_size = DGST_SIZE_4_6;
8442 parse_func = bcrypt_parse_hash;
8443 sort_by_digest = sort_by_digest_4_6;
8444 opti_type = OPTI_TYPE_ZERO_BYTE;
8445 dgst_pos0 = 0;
8446 dgst_pos1 = 1;
8447 dgst_pos2 = 2;
8448 dgst_pos3 = 3;
8449 break;
8450
8451 case 3710: hash_type = HASH_TYPE_MD5;
8452 salt_type = SALT_TYPE_INTERN;
8453 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8454 opts_type = OPTS_TYPE_PT_GENERATE_LE
8455 | OPTS_TYPE_PT_ADD80
8456 | OPTS_TYPE_PT_ADDBITS14;
8457 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8458 dgst_size = DGST_SIZE_4_4;
8459 parse_func = md5s_parse_hash;
8460 sort_by_digest = sort_by_digest_4_4;
8461 opti_type = OPTI_TYPE_ZERO_BYTE
8462 | OPTI_TYPE_PRECOMPUTE_INIT
8463 | OPTI_TYPE_PRECOMPUTE_MERKLE
8464 | OPTI_TYPE_EARLY_SKIP;
8465 dgst_pos0 = 0;
8466 dgst_pos1 = 3;
8467 dgst_pos2 = 2;
8468 dgst_pos3 = 1;
8469 break;
8470
8471 case 3711: hash_type = HASH_TYPE_MD5;
8472 salt_type = SALT_TYPE_EMBEDDED;
8473 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8474 opts_type = OPTS_TYPE_PT_GENERATE_LE
8475 | OPTS_TYPE_PT_ADD80
8476 | OPTS_TYPE_PT_ADDBITS14;
8477 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8478 dgst_size = DGST_SIZE_4_4;
8479 parse_func = mediawiki_b_parse_hash;
8480 sort_by_digest = sort_by_digest_4_4;
8481 opti_type = OPTI_TYPE_ZERO_BYTE
8482 | OPTI_TYPE_PRECOMPUTE_INIT
8483 | OPTI_TYPE_PRECOMPUTE_MERKLE
8484 | OPTI_TYPE_EARLY_SKIP;
8485 dgst_pos0 = 0;
8486 dgst_pos1 = 3;
8487 dgst_pos2 = 2;
8488 dgst_pos3 = 1;
8489 break;
8490
8491 case 3800: hash_type = HASH_TYPE_MD5;
8492 salt_type = SALT_TYPE_INTERN;
8493 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8494 opts_type = OPTS_TYPE_PT_GENERATE_LE
8495 | OPTS_TYPE_ST_ADDBITS14;
8496 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8497 dgst_size = DGST_SIZE_4_4;
8498 parse_func = md5s_parse_hash;
8499 sort_by_digest = sort_by_digest_4_4;
8500 opti_type = OPTI_TYPE_ZERO_BYTE
8501 | OPTI_TYPE_PRECOMPUTE_INIT
8502 | OPTI_TYPE_PRECOMPUTE_MERKLE
8503 | OPTI_TYPE_EARLY_SKIP
8504 | OPTI_TYPE_NOT_ITERATED
8505 | OPTI_TYPE_RAW_HASH;
8506 dgst_pos0 = 0;
8507 dgst_pos1 = 3;
8508 dgst_pos2 = 2;
8509 dgst_pos3 = 1;
8510 break;
8511
8512 case 4300: hash_type = HASH_TYPE_MD5;
8513 salt_type = SALT_TYPE_VIRTUAL;
8514 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8515 opts_type = OPTS_TYPE_PT_GENERATE_LE
8516 | OPTS_TYPE_PT_ADD80
8517 | OPTS_TYPE_PT_ADDBITS14
8518 | OPTS_TYPE_ST_ADD80;
8519 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8520 dgst_size = DGST_SIZE_4_4;
8521 parse_func = md5md5_parse_hash;
8522 sort_by_digest = sort_by_digest_4_4;
8523 opti_type = OPTI_TYPE_ZERO_BYTE
8524 | OPTI_TYPE_PRECOMPUTE_INIT
8525 | OPTI_TYPE_PRECOMPUTE_MERKLE
8526 | OPTI_TYPE_EARLY_SKIP;
8527 dgst_pos0 = 0;
8528 dgst_pos1 = 3;
8529 dgst_pos2 = 2;
8530 dgst_pos3 = 1;
8531 break;
8532
8533
8534 case 4400: hash_type = HASH_TYPE_MD5;
8535 salt_type = SALT_TYPE_NONE;
8536 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8537 opts_type = OPTS_TYPE_PT_GENERATE_BE
8538 | OPTS_TYPE_PT_ADD80
8539 | OPTS_TYPE_PT_ADDBITS15;
8540 kern_type = KERN_TYPE_MD5_SHA1;
8541 dgst_size = DGST_SIZE_4_4;
8542 parse_func = md5_parse_hash;
8543 sort_by_digest = sort_by_digest_4_4;
8544 opti_type = OPTI_TYPE_ZERO_BYTE
8545 | OPTI_TYPE_PRECOMPUTE_INIT
8546 | OPTI_TYPE_PRECOMPUTE_MERKLE
8547 | OPTI_TYPE_EARLY_SKIP
8548 | OPTI_TYPE_NOT_ITERATED
8549 | OPTI_TYPE_NOT_SALTED
8550 | OPTI_TYPE_RAW_HASH;
8551 dgst_pos0 = 0;
8552 dgst_pos1 = 3;
8553 dgst_pos2 = 2;
8554 dgst_pos3 = 1;
8555 break;
8556
8557 case 4500: hash_type = HASH_TYPE_SHA1;
8558 salt_type = SALT_TYPE_NONE;
8559 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8560 opts_type = OPTS_TYPE_PT_GENERATE_BE
8561 | OPTS_TYPE_PT_ADD80
8562 | OPTS_TYPE_PT_ADDBITS15;
8563 kern_type = KERN_TYPE_SHA11;
8564 dgst_size = DGST_SIZE_4_5;
8565 parse_func = sha1_parse_hash;
8566 sort_by_digest = sort_by_digest_4_5;
8567 opti_type = OPTI_TYPE_ZERO_BYTE
8568 | OPTI_TYPE_PRECOMPUTE_INIT
8569 | OPTI_TYPE_PRECOMPUTE_MERKLE
8570 | OPTI_TYPE_EARLY_SKIP
8571 | OPTI_TYPE_NOT_SALTED;
8572 dgst_pos0 = 3;
8573 dgst_pos1 = 4;
8574 dgst_pos2 = 2;
8575 dgst_pos3 = 1;
8576 break;
8577
8578 case 4700: hash_type = HASH_TYPE_SHA1;
8579 salt_type = SALT_TYPE_NONE;
8580 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8581 opts_type = OPTS_TYPE_PT_GENERATE_LE
8582 | OPTS_TYPE_PT_ADD80
8583 | OPTS_TYPE_PT_ADDBITS14;
8584 kern_type = KERN_TYPE_SHA1_MD5;
8585 dgst_size = DGST_SIZE_4_5;
8586 parse_func = sha1_parse_hash;
8587 sort_by_digest = sort_by_digest_4_5;
8588 opti_type = OPTI_TYPE_ZERO_BYTE
8589 | OPTI_TYPE_PRECOMPUTE_INIT
8590 | OPTI_TYPE_PRECOMPUTE_MERKLE
8591 | OPTI_TYPE_EARLY_SKIP
8592 | OPTI_TYPE_NOT_ITERATED
8593 | OPTI_TYPE_NOT_SALTED
8594 | OPTI_TYPE_RAW_HASH;
8595 dgst_pos0 = 3;
8596 dgst_pos1 = 4;
8597 dgst_pos2 = 2;
8598 dgst_pos3 = 1;
8599 break;
8600
8601 case 4800: hash_type = HASH_TYPE_MD5;
8602 salt_type = SALT_TYPE_EMBEDDED;
8603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8604 opts_type = OPTS_TYPE_PT_GENERATE_LE
8605 | OPTS_TYPE_PT_ADDBITS14;
8606 kern_type = KERN_TYPE_MD5_CHAP;
8607 dgst_size = DGST_SIZE_4_4;
8608 parse_func = chap_parse_hash;
8609 sort_by_digest = sort_by_digest_4_4;
8610 opti_type = OPTI_TYPE_ZERO_BYTE
8611 | OPTI_TYPE_PRECOMPUTE_INIT
8612 | OPTI_TYPE_PRECOMPUTE_MERKLE
8613 | OPTI_TYPE_MEET_IN_MIDDLE
8614 | OPTI_TYPE_EARLY_SKIP
8615 | OPTI_TYPE_NOT_ITERATED
8616 | OPTI_TYPE_RAW_HASH;
8617 dgst_pos0 = 0;
8618 dgst_pos1 = 3;
8619 dgst_pos2 = 2;
8620 dgst_pos3 = 1;
8621 break;
8622
8623 case 4900: hash_type = HASH_TYPE_SHA1;
8624 salt_type = SALT_TYPE_INTERN;
8625 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8626 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8627 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8628 dgst_size = DGST_SIZE_4_5;
8629 parse_func = sha1s_parse_hash;
8630 sort_by_digest = sort_by_digest_4_5;
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_PRECOMPUTE_INIT
8633 | OPTI_TYPE_PRECOMPUTE_MERKLE
8634 | OPTI_TYPE_EARLY_SKIP;
8635 dgst_pos0 = 3;
8636 dgst_pos1 = 4;
8637 dgst_pos2 = 2;
8638 dgst_pos3 = 1;
8639 break;
8640
8641 case 5000: hash_type = HASH_TYPE_KECCAK;
8642 salt_type = SALT_TYPE_EMBEDDED;
8643 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8644 opts_type = OPTS_TYPE_PT_GENERATE_LE
8645 | OPTS_TYPE_PT_ADD01;
8646 kern_type = KERN_TYPE_KECCAK;
8647 dgst_size = DGST_SIZE_8_25;
8648 parse_func = keccak_parse_hash;
8649 sort_by_digest = sort_by_digest_8_25;
8650 opti_type = OPTI_TYPE_ZERO_BYTE
8651 | OPTI_TYPE_USES_BITS_64
8652 | OPTI_TYPE_RAW_HASH;
8653 dgst_pos0 = 2;
8654 dgst_pos1 = 3;
8655 dgst_pos2 = 4;
8656 dgst_pos3 = 5;
8657 break;
8658
8659 case 5100: hash_type = HASH_TYPE_MD5H;
8660 salt_type = SALT_TYPE_NONE;
8661 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8662 opts_type = OPTS_TYPE_PT_GENERATE_LE
8663 | OPTS_TYPE_PT_ADD80
8664 | OPTS_TYPE_PT_ADDBITS14;
8665 kern_type = KERN_TYPE_MD5H;
8666 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8667 parse_func = md5half_parse_hash;
8668 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8669 opti_type = OPTI_TYPE_ZERO_BYTE
8670 | OPTI_TYPE_RAW_HASH;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 1;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 3;
8675 break;
8676
8677 case 5200: hash_type = HASH_TYPE_SHA256;
8678 salt_type = SALT_TYPE_EMBEDDED;
8679 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8681 kern_type = KERN_TYPE_PSAFE3;
8682 dgst_size = DGST_SIZE_4_8;
8683 parse_func = psafe3_parse_hash;
8684 sort_by_digest = sort_by_digest_4_8;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 0;
8687 dgst_pos1 = 1;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 3;
8690 break;
8691
8692 case 5300: hash_type = HASH_TYPE_MD5;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE
8696 | OPTS_TYPE_ST_ADD80;
8697 kern_type = KERN_TYPE_IKEPSK_MD5;
8698 dgst_size = DGST_SIZE_4_4;
8699 parse_func = ikepsk_md5_parse_hash;
8700 sort_by_digest = sort_by_digest_4_4;
8701 opti_type = OPTI_TYPE_ZERO_BYTE;
8702 dgst_pos0 = 0;
8703 dgst_pos1 = 3;
8704 dgst_pos2 = 2;
8705 dgst_pos3 = 1;
8706 break;
8707
8708 case 5400: hash_type = HASH_TYPE_SHA1;
8709 salt_type = SALT_TYPE_EMBEDDED;
8710 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8711 opts_type = OPTS_TYPE_PT_GENERATE_BE
8712 | OPTS_TYPE_ST_ADD80;
8713 kern_type = KERN_TYPE_IKEPSK_SHA1;
8714 dgst_size = DGST_SIZE_4_5;
8715 parse_func = ikepsk_sha1_parse_hash;
8716 sort_by_digest = sort_by_digest_4_5;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 3;
8719 dgst_pos1 = 4;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 5500: hash_type = HASH_TYPE_NETNTLM;
8725 salt_type = SALT_TYPE_EMBEDDED;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_LE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS14
8730 | OPTS_TYPE_PT_UNICODE
8731 | OPTS_TYPE_ST_HEX;
8732 kern_type = KERN_TYPE_NETNTLMv1;
8733 dgst_size = DGST_SIZE_4_4;
8734 parse_func = netntlmv1_parse_hash;
8735 sort_by_digest = sort_by_digest_4_4;
8736 opti_type = OPTI_TYPE_ZERO_BYTE
8737 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8738 dgst_pos0 = 0;
8739 dgst_pos1 = 1;
8740 dgst_pos2 = 2;
8741 dgst_pos3 = 3;
8742 break;
8743
8744 case 5600: hash_type = HASH_TYPE_MD5;
8745 salt_type = SALT_TYPE_EMBEDDED;
8746 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8747 opts_type = OPTS_TYPE_PT_GENERATE_LE
8748 | OPTS_TYPE_PT_ADD80
8749 | OPTS_TYPE_PT_ADDBITS14
8750 | OPTS_TYPE_PT_UNICODE;
8751 kern_type = KERN_TYPE_NETNTLMv2;
8752 dgst_size = DGST_SIZE_4_4;
8753 parse_func = netntlmv2_parse_hash;
8754 sort_by_digest = sort_by_digest_4_4;
8755 opti_type = OPTI_TYPE_ZERO_BYTE;
8756 dgst_pos0 = 0;
8757 dgst_pos1 = 3;
8758 dgst_pos2 = 2;
8759 dgst_pos3 = 1;
8760 break;
8761
8762 case 5700: hash_type = HASH_TYPE_SHA256;
8763 salt_type = SALT_TYPE_NONE;
8764 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8765 opts_type = OPTS_TYPE_PT_GENERATE_BE
8766 | OPTS_TYPE_PT_ADD80
8767 | OPTS_TYPE_PT_ADDBITS15;
8768 kern_type = KERN_TYPE_SHA256;
8769 dgst_size = DGST_SIZE_4_8;
8770 parse_func = cisco4_parse_hash;
8771 sort_by_digest = sort_by_digest_4_8;
8772 opti_type = OPTI_TYPE_ZERO_BYTE
8773 | OPTI_TYPE_PRECOMPUTE_INIT
8774 | OPTI_TYPE_PRECOMPUTE_MERKLE
8775 | OPTI_TYPE_EARLY_SKIP
8776 | OPTI_TYPE_NOT_ITERATED
8777 | OPTI_TYPE_NOT_SALTED
8778 | OPTI_TYPE_RAW_HASH;
8779 dgst_pos0 = 3;
8780 dgst_pos1 = 7;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 6;
8783 break;
8784
8785 case 5800: hash_type = HASH_TYPE_SHA1;
8786 salt_type = SALT_TYPE_INTERN;
8787 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8789 | OPTS_TYPE_ST_ADD80;
8790 kern_type = KERN_TYPE_ANDROIDPIN;
8791 dgst_size = DGST_SIZE_4_5;
8792 parse_func = androidpin_parse_hash;
8793 sort_by_digest = sort_by_digest_4_5;
8794 opti_type = OPTI_TYPE_ZERO_BYTE;
8795 dgst_pos0 = 0;
8796 dgst_pos1 = 1;
8797 dgst_pos2 = 2;
8798 dgst_pos3 = 3;
8799 break;
8800
8801 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8802 salt_type = SALT_TYPE_NONE;
8803 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE
8805 | OPTS_TYPE_PT_ADD80;
8806 kern_type = KERN_TYPE_RIPEMD160;
8807 dgst_size = DGST_SIZE_4_5;
8808 parse_func = ripemd160_parse_hash;
8809 sort_by_digest = sort_by_digest_4_5;
8810 opti_type = OPTI_TYPE_ZERO_BYTE;
8811 dgst_pos0 = 0;
8812 dgst_pos1 = 1;
8813 dgst_pos2 = 2;
8814 dgst_pos3 = 3;
8815 break;
8816
8817 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8818 salt_type = SALT_TYPE_NONE;
8819 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8820 opts_type = OPTS_TYPE_PT_GENERATE_BE
8821 | OPTS_TYPE_PT_ADD80;
8822 kern_type = KERN_TYPE_WHIRLPOOL;
8823 dgst_size = DGST_SIZE_4_16;
8824 parse_func = whirlpool_parse_hash;
8825 sort_by_digest = sort_by_digest_4_16;
8826 opti_type = OPTI_TYPE_ZERO_BYTE;
8827 dgst_pos0 = 0;
8828 dgst_pos1 = 1;
8829 dgst_pos2 = 2;
8830 dgst_pos3 = 3;
8831 break;
8832
8833 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8834 salt_type = SALT_TYPE_EMBEDDED;
8835 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8836 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8837 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8838 dgst_size = DGST_SIZE_4_5;
8839 parse_func = truecrypt_parse_hash_2k;
8840 sort_by_digest = sort_by_digest_4_5;
8841 opti_type = OPTI_TYPE_ZERO_BYTE;
8842 dgst_pos0 = 0;
8843 dgst_pos1 = 1;
8844 dgst_pos2 = 2;
8845 dgst_pos3 = 3;
8846 break;
8847
8848 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8849 salt_type = SALT_TYPE_EMBEDDED;
8850 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8851 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8852 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8853 dgst_size = DGST_SIZE_4_5;
8854 parse_func = truecrypt_parse_hash_2k;
8855 sort_by_digest = sort_by_digest_4_5;
8856 opti_type = OPTI_TYPE_ZERO_BYTE;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8867 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8868 dgst_size = DGST_SIZE_4_5;
8869 parse_func = truecrypt_parse_hash_2k;
8870 sort_by_digest = sort_by_digest_4_5;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6221: hash_type = HASH_TYPE_SHA512;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8882 kern_type = KERN_TYPE_TCSHA512_XTS512;
8883 dgst_size = DGST_SIZE_8_8;
8884 parse_func = truecrypt_parse_hash_1k;
8885 sort_by_digest = sort_by_digest_8_8;
8886 opti_type = OPTI_TYPE_ZERO_BYTE
8887 | OPTI_TYPE_USES_BITS_64;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 1;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 3;
8892 break;
8893
8894 case 6222: hash_type = HASH_TYPE_SHA512;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8898 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8899 dgst_size = DGST_SIZE_8_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_8_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE
8903 | OPTI_TYPE_USES_BITS_64;
8904 dgst_pos0 = 0;
8905 dgst_pos1 = 1;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 3;
8908 break;
8909
8910 case 6223: hash_type = HASH_TYPE_SHA512;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8914 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8915 dgst_size = DGST_SIZE_8_8;
8916 parse_func = truecrypt_parse_hash_1k;
8917 sort_by_digest = sort_by_digest_8_8;
8918 opti_type = OPTI_TYPE_ZERO_BYTE
8919 | OPTI_TYPE_USES_BITS_64;
8920 dgst_pos0 = 0;
8921 dgst_pos1 = 1;
8922 dgst_pos2 = 2;
8923 dgst_pos3 = 3;
8924 break;
8925
8926 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8927 salt_type = SALT_TYPE_EMBEDDED;
8928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8929 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8930 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8931 dgst_size = DGST_SIZE_4_8;
8932 parse_func = truecrypt_parse_hash_1k;
8933 sort_by_digest = sort_by_digest_4_8;
8934 opti_type = OPTI_TYPE_ZERO_BYTE;
8935 dgst_pos0 = 0;
8936 dgst_pos1 = 1;
8937 dgst_pos2 = 2;
8938 dgst_pos3 = 3;
8939 break;
8940
8941 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8942 salt_type = SALT_TYPE_EMBEDDED;
8943 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8944 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8945 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8946 dgst_size = DGST_SIZE_4_8;
8947 parse_func = truecrypt_parse_hash_1k;
8948 sort_by_digest = sort_by_digest_4_8;
8949 opti_type = OPTI_TYPE_ZERO_BYTE;
8950 dgst_pos0 = 0;
8951 dgst_pos1 = 1;
8952 dgst_pos2 = 2;
8953 dgst_pos3 = 3;
8954 break;
8955
8956 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8957 salt_type = SALT_TYPE_EMBEDDED;
8958 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8959 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8960 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8961 dgst_size = DGST_SIZE_4_8;
8962 parse_func = truecrypt_parse_hash_1k;
8963 sort_by_digest = sort_by_digest_4_8;
8964 opti_type = OPTI_TYPE_ZERO_BYTE;
8965 dgst_pos0 = 0;
8966 dgst_pos1 = 1;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 3;
8969 break;
8970
8971 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8972 salt_type = SALT_TYPE_EMBEDDED;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8975 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8976 dgst_size = DGST_SIZE_4_5;
8977 parse_func = truecrypt_parse_hash_1k;
8978 sort_by_digest = sort_by_digest_4_5;
8979 opti_type = OPTI_TYPE_ZERO_BYTE;
8980 dgst_pos0 = 0;
8981 dgst_pos1 = 1;
8982 dgst_pos2 = 2;
8983 dgst_pos3 = 3;
8984 break;
8985
8986 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8987 salt_type = SALT_TYPE_EMBEDDED;
8988 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8989 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8990 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8991 dgst_size = DGST_SIZE_4_5;
8992 parse_func = truecrypt_parse_hash_1k;
8993 sort_by_digest = sort_by_digest_4_5;
8994 opti_type = OPTI_TYPE_ZERO_BYTE;
8995 dgst_pos0 = 0;
8996 dgst_pos1 = 1;
8997 dgst_pos2 = 2;
8998 dgst_pos3 = 3;
8999 break;
9000
9001 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9002 salt_type = SALT_TYPE_EMBEDDED;
9003 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9004 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9005 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9006 dgst_size = DGST_SIZE_4_5;
9007 parse_func = truecrypt_parse_hash_1k;
9008 sort_by_digest = sort_by_digest_4_5;
9009 opti_type = OPTI_TYPE_ZERO_BYTE;
9010 dgst_pos0 = 0;
9011 dgst_pos1 = 1;
9012 dgst_pos2 = 2;
9013 dgst_pos3 = 3;
9014 break;
9015
9016 case 6300: hash_type = HASH_TYPE_MD5;
9017 salt_type = SALT_TYPE_EMBEDDED;
9018 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9019 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9020 kern_type = KERN_TYPE_MD5AIX;
9021 dgst_size = DGST_SIZE_4_4;
9022 parse_func = md5aix_parse_hash;
9023 sort_by_digest = sort_by_digest_4_4;
9024 opti_type = OPTI_TYPE_ZERO_BYTE;
9025 dgst_pos0 = 0;
9026 dgst_pos1 = 1;
9027 dgst_pos2 = 2;
9028 dgst_pos3 = 3;
9029 break;
9030
9031 case 6400: hash_type = HASH_TYPE_SHA256;
9032 salt_type = SALT_TYPE_EMBEDDED;
9033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9034 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9035 kern_type = KERN_TYPE_SHA256AIX;
9036 dgst_size = DGST_SIZE_4_8;
9037 parse_func = sha256aix_parse_hash;
9038 sort_by_digest = sort_by_digest_4_8;
9039 opti_type = OPTI_TYPE_ZERO_BYTE;
9040 dgst_pos0 = 0;
9041 dgst_pos1 = 1;
9042 dgst_pos2 = 2;
9043 dgst_pos3 = 3;
9044 break;
9045
9046 case 6500: hash_type = HASH_TYPE_SHA512;
9047 salt_type = SALT_TYPE_EMBEDDED;
9048 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9049 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9050 kern_type = KERN_TYPE_SHA512AIX;
9051 dgst_size = DGST_SIZE_8_8;
9052 parse_func = sha512aix_parse_hash;
9053 sort_by_digest = sort_by_digest_8_8;
9054 opti_type = OPTI_TYPE_ZERO_BYTE
9055 | OPTI_TYPE_USES_BITS_64;
9056 dgst_pos0 = 0;
9057 dgst_pos1 = 1;
9058 dgst_pos2 = 2;
9059 dgst_pos3 = 3;
9060 break;
9061
9062 case 6600: hash_type = HASH_TYPE_AES;
9063 salt_type = SALT_TYPE_EMBEDDED;
9064 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9065 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9066 kern_type = KERN_TYPE_AGILEKEY;
9067 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9068 parse_func = agilekey_parse_hash;
9069 sort_by_digest = sort_by_digest_4_5;
9070 opti_type = OPTI_TYPE_ZERO_BYTE;
9071 dgst_pos0 = 0;
9072 dgst_pos1 = 1;
9073 dgst_pos2 = 2;
9074 dgst_pos3 = 3;
9075 break;
9076
9077 case 6700: hash_type = HASH_TYPE_SHA1;
9078 salt_type = SALT_TYPE_EMBEDDED;
9079 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9080 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9081 kern_type = KERN_TYPE_SHA1AIX;
9082 dgst_size = DGST_SIZE_4_5;
9083 parse_func = sha1aix_parse_hash;
9084 sort_by_digest = sort_by_digest_4_5;
9085 opti_type = OPTI_TYPE_ZERO_BYTE;
9086 dgst_pos0 = 0;
9087 dgst_pos1 = 1;
9088 dgst_pos2 = 2;
9089 dgst_pos3 = 3;
9090 break;
9091
9092 case 6800: hash_type = HASH_TYPE_AES;
9093 salt_type = SALT_TYPE_EMBEDDED;
9094 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9095 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9096 kern_type = KERN_TYPE_LASTPASS;
9097 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9098 parse_func = lastpass_parse_hash;
9099 sort_by_digest = sort_by_digest_4_8;
9100 opti_type = OPTI_TYPE_ZERO_BYTE;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 6900: hash_type = HASH_TYPE_GOST;
9108 salt_type = SALT_TYPE_NONE;
9109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9111 kern_type = KERN_TYPE_GOST;
9112 dgst_size = DGST_SIZE_4_8;
9113 parse_func = gost_parse_hash;
9114 sort_by_digest = sort_by_digest_4_8;
9115 opti_type = OPTI_TYPE_ZERO_BYTE;
9116 dgst_pos0 = 0;
9117 dgst_pos1 = 1;
9118 dgst_pos2 = 2;
9119 dgst_pos3 = 3;
9120 break;
9121
9122 case 7100: hash_type = HASH_TYPE_SHA512;
9123 salt_type = SALT_TYPE_EMBEDDED;
9124 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9125 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9126 kern_type = KERN_TYPE_PBKDF2_SHA512;
9127 dgst_size = DGST_SIZE_8_16;
9128 parse_func = sha512osx_parse_hash;
9129 sort_by_digest = sort_by_digest_8_16;
9130 opti_type = OPTI_TYPE_ZERO_BYTE
9131 | OPTI_TYPE_USES_BITS_64
9132 | OPTI_TYPE_SLOW_HASH_SIMD;
9133 dgst_pos0 = 0;
9134 dgst_pos1 = 1;
9135 dgst_pos2 = 2;
9136 dgst_pos3 = 3;
9137 break;
9138
9139 case 7200: hash_type = HASH_TYPE_SHA512;
9140 salt_type = SALT_TYPE_EMBEDDED;
9141 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9142 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9143 kern_type = KERN_TYPE_PBKDF2_SHA512;
9144 dgst_size = DGST_SIZE_8_16;
9145 parse_func = sha512grub_parse_hash;
9146 sort_by_digest = sort_by_digest_8_16;
9147 opti_type = OPTI_TYPE_ZERO_BYTE
9148 | OPTI_TYPE_USES_BITS_64
9149 | OPTI_TYPE_SLOW_HASH_SIMD;
9150 dgst_pos0 = 0;
9151 dgst_pos1 = 1;
9152 dgst_pos2 = 2;
9153 dgst_pos3 = 3;
9154 break;
9155
9156 case 7300: hash_type = HASH_TYPE_SHA1;
9157 salt_type = SALT_TYPE_EMBEDDED;
9158 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9159 opts_type = OPTS_TYPE_PT_GENERATE_BE
9160 | OPTS_TYPE_ST_ADD80
9161 | OPTS_TYPE_ST_ADDBITS15;
9162 kern_type = KERN_TYPE_RAKP;
9163 dgst_size = DGST_SIZE_4_5;
9164 parse_func = rakp_parse_hash;
9165 sort_by_digest = sort_by_digest_4_5;
9166 opti_type = OPTI_TYPE_ZERO_BYTE
9167 | OPTI_TYPE_NOT_ITERATED;
9168 dgst_pos0 = 3;
9169 dgst_pos1 = 4;
9170 dgst_pos2 = 2;
9171 dgst_pos3 = 1;
9172 break;
9173
9174 case 7400: hash_type = HASH_TYPE_SHA256;
9175 salt_type = SALT_TYPE_EMBEDDED;
9176 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9177 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9178 kern_type = KERN_TYPE_SHA256CRYPT;
9179 dgst_size = DGST_SIZE_4_8;
9180 parse_func = sha256crypt_parse_hash;
9181 sort_by_digest = sort_by_digest_4_8;
9182 opti_type = OPTI_TYPE_ZERO_BYTE;
9183 dgst_pos0 = 0;
9184 dgst_pos1 = 1;
9185 dgst_pos2 = 2;
9186 dgst_pos3 = 3;
9187 break;
9188
9189 case 7500: hash_type = HASH_TYPE_KRB5PA;
9190 salt_type = SALT_TYPE_EMBEDDED;
9191 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9192 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9193 kern_type = KERN_TYPE_KRB5PA;
9194 dgst_size = DGST_SIZE_4_4;
9195 parse_func = krb5pa_parse_hash;
9196 sort_by_digest = sort_by_digest_4_4;
9197 opti_type = OPTI_TYPE_ZERO_BYTE
9198 | OPTI_TYPE_NOT_ITERATED;
9199 dgst_pos0 = 0;
9200 dgst_pos1 = 1;
9201 dgst_pos2 = 2;
9202 dgst_pos3 = 3;
9203 break;
9204
9205 case 7600: hash_type = HASH_TYPE_SHA1;
9206 salt_type = SALT_TYPE_INTERN;
9207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9208 opts_type = OPTS_TYPE_PT_GENERATE_BE
9209 | OPTS_TYPE_PT_ADD80
9210 | OPTS_TYPE_PT_ADDBITS15;
9211 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9212 dgst_size = DGST_SIZE_4_5;
9213 parse_func = redmine_parse_hash;
9214 sort_by_digest = sort_by_digest_4_5;
9215 opti_type = OPTI_TYPE_ZERO_BYTE
9216 | OPTI_TYPE_PRECOMPUTE_INIT
9217 | OPTI_TYPE_EARLY_SKIP
9218 | OPTI_TYPE_NOT_ITERATED
9219 | OPTI_TYPE_PREPENDED_SALT;
9220 dgst_pos0 = 3;
9221 dgst_pos1 = 4;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 1;
9224 break;
9225
9226 case 7700: hash_type = HASH_TYPE_SAPB;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE
9230 | OPTS_TYPE_PT_UPPER
9231 | OPTS_TYPE_ST_UPPER;
9232 kern_type = KERN_TYPE_SAPB;
9233 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9234 parse_func = sapb_parse_hash;
9235 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9236 opti_type = OPTI_TYPE_ZERO_BYTE
9237 | OPTI_TYPE_PRECOMPUTE_INIT
9238 | OPTI_TYPE_NOT_ITERATED;
9239 dgst_pos0 = 0;
9240 dgst_pos1 = 1;
9241 dgst_pos2 = 2;
9242 dgst_pos3 = 3;
9243 break;
9244
9245 case 7800: hash_type = HASH_TYPE_SAPG;
9246 salt_type = SALT_TYPE_EMBEDDED;
9247 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9248 opts_type = OPTS_TYPE_PT_GENERATE_BE
9249 | OPTS_TYPE_ST_ADD80
9250 | OPTS_TYPE_ST_UPPER;
9251 kern_type = KERN_TYPE_SAPG;
9252 dgst_size = DGST_SIZE_4_5;
9253 parse_func = sapg_parse_hash;
9254 sort_by_digest = sort_by_digest_4_5;
9255 opti_type = OPTI_TYPE_ZERO_BYTE
9256 | OPTI_TYPE_PRECOMPUTE_INIT
9257 | OPTI_TYPE_NOT_ITERATED;
9258 dgst_pos0 = 3;
9259 dgst_pos1 = 4;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 1;
9262 break;
9263
9264 case 7900: hash_type = HASH_TYPE_SHA512;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9268 kern_type = KERN_TYPE_DRUPAL7;
9269 dgst_size = DGST_SIZE_8_8;
9270 parse_func = drupal7_parse_hash;
9271 sort_by_digest = sort_by_digest_8_8;
9272 opti_type = OPTI_TYPE_ZERO_BYTE
9273 | OPTI_TYPE_USES_BITS_64;
9274 dgst_pos0 = 0;
9275 dgst_pos1 = 1;
9276 dgst_pos2 = 2;
9277 dgst_pos3 = 3;
9278 break;
9279
9280 case 8000: hash_type = HASH_TYPE_SHA256;
9281 salt_type = SALT_TYPE_EMBEDDED;
9282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9283 opts_type = OPTS_TYPE_PT_GENERATE_BE
9284 | OPTS_TYPE_PT_UNICODE
9285 | OPTS_TYPE_ST_ADD80
9286 | OPTS_TYPE_ST_HEX;
9287 kern_type = KERN_TYPE_SYBASEASE;
9288 dgst_size = DGST_SIZE_4_8;
9289 parse_func = sybasease_parse_hash;
9290 sort_by_digest = sort_by_digest_4_8;
9291 opti_type = OPTI_TYPE_ZERO_BYTE
9292 | OPTI_TYPE_PRECOMPUTE_INIT
9293 | OPTI_TYPE_EARLY_SKIP
9294 | OPTI_TYPE_NOT_ITERATED
9295 | OPTI_TYPE_RAW_HASH;
9296 dgst_pos0 = 3;
9297 dgst_pos1 = 7;
9298 dgst_pos2 = 2;
9299 dgst_pos3 = 6;
9300 break;
9301
9302 case 8100: hash_type = HASH_TYPE_SHA1;
9303 salt_type = SALT_TYPE_EMBEDDED;
9304 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9305 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9306 kern_type = KERN_TYPE_NETSCALER;
9307 dgst_size = DGST_SIZE_4_5;
9308 parse_func = netscaler_parse_hash;
9309 sort_by_digest = sort_by_digest_4_5;
9310 opti_type = OPTI_TYPE_ZERO_BYTE
9311 | OPTI_TYPE_PRECOMPUTE_INIT
9312 | OPTI_TYPE_PRECOMPUTE_MERKLE
9313 | OPTI_TYPE_EARLY_SKIP
9314 | OPTI_TYPE_NOT_ITERATED
9315 | OPTI_TYPE_PREPENDED_SALT
9316 | OPTI_TYPE_RAW_HASH;
9317 dgst_pos0 = 3;
9318 dgst_pos1 = 4;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 1;
9321 break;
9322
9323 case 8200: hash_type = HASH_TYPE_SHA256;
9324 salt_type = SALT_TYPE_EMBEDDED;
9325 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9327 kern_type = KERN_TYPE_CLOUDKEY;
9328 dgst_size = DGST_SIZE_4_8;
9329 parse_func = cloudkey_parse_hash;
9330 sort_by_digest = sort_by_digest_4_8;
9331 opti_type = OPTI_TYPE_ZERO_BYTE;
9332 dgst_pos0 = 0;
9333 dgst_pos1 = 1;
9334 dgst_pos2 = 2;
9335 dgst_pos3 = 3;
9336 break;
9337
9338 case 8300: hash_type = HASH_TYPE_SHA1;
9339 salt_type = SALT_TYPE_EMBEDDED;
9340 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9341 opts_type = OPTS_TYPE_PT_GENERATE_BE
9342 | OPTS_TYPE_ST_HEX
9343 | OPTS_TYPE_ST_ADD80;
9344 kern_type = KERN_TYPE_NSEC3;
9345 dgst_size = DGST_SIZE_4_5;
9346 parse_func = nsec3_parse_hash;
9347 sort_by_digest = sort_by_digest_4_5;
9348 opti_type = OPTI_TYPE_ZERO_BYTE;
9349 dgst_pos0 = 3;
9350 dgst_pos1 = 4;
9351 dgst_pos2 = 2;
9352 dgst_pos3 = 1;
9353 break;
9354
9355 case 8400: hash_type = HASH_TYPE_SHA1;
9356 salt_type = SALT_TYPE_INTERN;
9357 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9358 opts_type = OPTS_TYPE_PT_GENERATE_BE
9359 | OPTS_TYPE_PT_ADD80
9360 | OPTS_TYPE_PT_ADDBITS15;
9361 kern_type = KERN_TYPE_WBB3;
9362 dgst_size = DGST_SIZE_4_5;
9363 parse_func = wbb3_parse_hash;
9364 sort_by_digest = sort_by_digest_4_5;
9365 opti_type = OPTI_TYPE_ZERO_BYTE
9366 | OPTI_TYPE_PRECOMPUTE_INIT
9367 | OPTI_TYPE_NOT_ITERATED;
9368 dgst_pos0 = 3;
9369 dgst_pos1 = 4;
9370 dgst_pos2 = 2;
9371 dgst_pos3 = 1;
9372 break;
9373
9374 case 8500: hash_type = HASH_TYPE_DESRACF;
9375 salt_type = SALT_TYPE_EMBEDDED;
9376 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9377 opts_type = OPTS_TYPE_PT_GENERATE_LE
9378 | OPTS_TYPE_ST_UPPER;
9379 kern_type = KERN_TYPE_RACF;
9380 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9381 parse_func = racf_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 8600: hash_type = HASH_TYPE_LOTUS5;
9392 salt_type = SALT_TYPE_NONE;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9395 kern_type = KERN_TYPE_LOTUS5;
9396 dgst_size = DGST_SIZE_4_4;
9397 parse_func = lotus5_parse_hash;
9398 sort_by_digest = sort_by_digest_4_4;
9399 opti_type = OPTI_TYPE_EARLY_SKIP
9400 | OPTI_TYPE_NOT_ITERATED
9401 | OPTI_TYPE_NOT_SALTED
9402 | OPTI_TYPE_RAW_HASH;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 8700: hash_type = HASH_TYPE_LOTUS6;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_LOTUS6;
9414 dgst_size = DGST_SIZE_4_4;
9415 parse_func = lotus6_parse_hash;
9416 sort_by_digest = sort_by_digest_4_4;
9417 opti_type = OPTI_TYPE_EARLY_SKIP
9418 | OPTI_TYPE_NOT_ITERATED
9419 | OPTI_TYPE_RAW_HASH;
9420 dgst_pos0 = 0;
9421 dgst_pos1 = 1;
9422 dgst_pos2 = 2;
9423 dgst_pos3 = 3;
9424 break;
9425
9426 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9427 salt_type = SALT_TYPE_EMBEDDED;
9428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9430 kern_type = KERN_TYPE_ANDROIDFDE;
9431 dgst_size = DGST_SIZE_4_4;
9432 parse_func = androidfde_parse_hash;
9433 sort_by_digest = sort_by_digest_4_4;
9434 opti_type = OPTI_TYPE_ZERO_BYTE;
9435 dgst_pos0 = 0;
9436 dgst_pos1 = 1;
9437 dgst_pos2 = 2;
9438 dgst_pos3 = 3;
9439 break;
9440
9441 case 8900: hash_type = HASH_TYPE_SCRYPT;
9442 salt_type = SALT_TYPE_EMBEDDED;
9443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9445 kern_type = KERN_TYPE_SCRYPT;
9446 dgst_size = DGST_SIZE_4_8;
9447 parse_func = scrypt_parse_hash;
9448 sort_by_digest = sort_by_digest_4_8;
9449 opti_type = OPTI_TYPE_ZERO_BYTE;
9450 dgst_pos0 = 0;
9451 dgst_pos1 = 1;
9452 dgst_pos2 = 2;
9453 dgst_pos3 = 3;
9454 break;
9455
9456 case 9000: hash_type = HASH_TYPE_SHA1;
9457 salt_type = SALT_TYPE_EMBEDDED;
9458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9459 opts_type = OPTS_TYPE_PT_GENERATE_LE
9460 | OPTS_TYPE_ST_GENERATE_LE;
9461 kern_type = KERN_TYPE_PSAFE2;
9462 dgst_size = DGST_SIZE_4_5;
9463 parse_func = psafe2_parse_hash;
9464 sort_by_digest = sort_by_digest_4_5;
9465 opti_type = OPTI_TYPE_ZERO_BYTE;
9466 dgst_pos0 = 0;
9467 dgst_pos1 = 1;
9468 dgst_pos2 = 2;
9469 dgst_pos3 = 3;
9470 break;
9471
9472 case 9100: hash_type = HASH_TYPE_LOTUS8;
9473 salt_type = SALT_TYPE_EMBEDDED;
9474 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9475 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9476 kern_type = KERN_TYPE_LOTUS8;
9477 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9478 parse_func = lotus8_parse_hash;
9479 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9480 opti_type = OPTI_TYPE_ZERO_BYTE;
9481 dgst_pos0 = 0;
9482 dgst_pos1 = 1;
9483 dgst_pos2 = 2;
9484 dgst_pos3 = 3;
9485 break;
9486
9487 case 9200: hash_type = HASH_TYPE_SHA256;
9488 salt_type = SALT_TYPE_EMBEDDED;
9489 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9490 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9491 kern_type = KERN_TYPE_PBKDF2_SHA256;
9492 dgst_size = DGST_SIZE_4_32;
9493 parse_func = cisco8_parse_hash;
9494 sort_by_digest = sort_by_digest_4_32;
9495 opti_type = OPTI_TYPE_ZERO_BYTE
9496 | OPTI_TYPE_SLOW_HASH_SIMD;
9497 dgst_pos0 = 0;
9498 dgst_pos1 = 1;
9499 dgst_pos2 = 2;
9500 dgst_pos3 = 3;
9501 break;
9502
9503 case 9300: hash_type = HASH_TYPE_SCRYPT;
9504 salt_type = SALT_TYPE_EMBEDDED;
9505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9507 kern_type = KERN_TYPE_SCRYPT;
9508 dgst_size = DGST_SIZE_4_8;
9509 parse_func = cisco9_parse_hash;
9510 sort_by_digest = sort_by_digest_4_8;
9511 opti_type = OPTI_TYPE_ZERO_BYTE;
9512 dgst_pos0 = 0;
9513 dgst_pos1 = 1;
9514 dgst_pos2 = 2;
9515 dgst_pos3 = 3;
9516 break;
9517
9518 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9519 salt_type = SALT_TYPE_EMBEDDED;
9520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9522 kern_type = KERN_TYPE_OFFICE2007;
9523 dgst_size = DGST_SIZE_4_4;
9524 parse_func = office2007_parse_hash;
9525 sort_by_digest = sort_by_digest_4_4;
9526 opti_type = OPTI_TYPE_ZERO_BYTE;
9527 dgst_pos0 = 0;
9528 dgst_pos1 = 1;
9529 dgst_pos2 = 2;
9530 dgst_pos3 = 3;
9531 break;
9532
9533 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9534 salt_type = SALT_TYPE_EMBEDDED;
9535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9537 kern_type = KERN_TYPE_OFFICE2010;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = office2010_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE;
9542 dgst_pos0 = 0;
9543 dgst_pos1 = 1;
9544 dgst_pos2 = 2;
9545 dgst_pos3 = 3;
9546 break;
9547
9548 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9549 salt_type = SALT_TYPE_EMBEDDED;
9550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9551 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9552 kern_type = KERN_TYPE_OFFICE2013;
9553 dgst_size = DGST_SIZE_4_4;
9554 parse_func = office2013_parse_hash;
9555 sort_by_digest = sort_by_digest_4_4;
9556 opti_type = OPTI_TYPE_ZERO_BYTE;
9557 dgst_pos0 = 0;
9558 dgst_pos1 = 1;
9559 dgst_pos2 = 2;
9560 dgst_pos3 = 3;
9561 break;
9562
9563 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9564 salt_type = SALT_TYPE_EMBEDDED;
9565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9566 opts_type = OPTS_TYPE_PT_GENERATE_LE
9567 | OPTS_TYPE_PT_ADD80
9568 | OPTS_TYPE_PT_UNICODE;
9569 kern_type = KERN_TYPE_OLDOFFICE01;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = oldoffice01_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_PRECOMPUTE_INIT
9575 | OPTI_TYPE_NOT_ITERATED;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_LE
9586 | OPTS_TYPE_PT_ADD80;
9587 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9588 dgst_size = DGST_SIZE_4_4;
9589 parse_func = oldoffice01cm1_parse_hash;
9590 sort_by_digest = sort_by_digest_4_4;
9591 opti_type = OPTI_TYPE_ZERO_BYTE
9592 | OPTI_TYPE_PRECOMPUTE_INIT
9593 | OPTI_TYPE_NOT_ITERATED;
9594 dgst_pos0 = 0;
9595 dgst_pos1 = 1;
9596 dgst_pos2 = 2;
9597 dgst_pos3 = 3;
9598 break;
9599
9600 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9601 salt_type = SALT_TYPE_EMBEDDED;
9602 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9603 opts_type = OPTS_TYPE_PT_GENERATE_LE
9604 | OPTS_TYPE_PT_ADD80
9605 | OPTS_TYPE_PT_UNICODE
9606 | OPTS_TYPE_PT_NEVERCRACK;
9607 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9608 dgst_size = DGST_SIZE_4_4;
9609 parse_func = oldoffice01cm2_parse_hash;
9610 sort_by_digest = sort_by_digest_4_4;
9611 opti_type = OPTI_TYPE_ZERO_BYTE
9612 | OPTI_TYPE_PRECOMPUTE_INIT
9613 | OPTI_TYPE_NOT_ITERATED;
9614 dgst_pos0 = 0;
9615 dgst_pos1 = 1;
9616 dgst_pos2 = 2;
9617 dgst_pos3 = 3;
9618 break;
9619
9620 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9621 salt_type = SALT_TYPE_EMBEDDED;
9622 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9623 opts_type = OPTS_TYPE_PT_GENERATE_BE
9624 | OPTS_TYPE_PT_ADD80
9625 | OPTS_TYPE_PT_UNICODE;
9626 kern_type = KERN_TYPE_OLDOFFICE34;
9627 dgst_size = DGST_SIZE_4_4;
9628 parse_func = oldoffice34_parse_hash;
9629 sort_by_digest = sort_by_digest_4_4;
9630 opti_type = OPTI_TYPE_ZERO_BYTE
9631 | OPTI_TYPE_PRECOMPUTE_INIT
9632 | OPTI_TYPE_NOT_ITERATED;
9633 dgst_pos0 = 0;
9634 dgst_pos1 = 1;
9635 dgst_pos2 = 2;
9636 dgst_pos3 = 3;
9637 break;
9638
9639 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9640 salt_type = SALT_TYPE_EMBEDDED;
9641 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9642 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9643 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9644 dgst_size = DGST_SIZE_4_4;
9645 parse_func = oldoffice34cm1_parse_hash;
9646 sort_by_digest = sort_by_digest_4_4;
9647 opti_type = OPTI_TYPE_ZERO_BYTE
9648 | OPTI_TYPE_PRECOMPUTE_INIT
9649 | OPTI_TYPE_NOT_ITERATED;
9650 dgst_pos0 = 0;
9651 dgst_pos1 = 1;
9652 dgst_pos2 = 2;
9653 dgst_pos3 = 3;
9654 break;
9655
9656 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9657 salt_type = SALT_TYPE_EMBEDDED;
9658 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9659 opts_type = OPTS_TYPE_PT_GENERATE_BE
9660 | OPTS_TYPE_PT_ADD80
9661 | OPTS_TYPE_PT_UNICODE
9662 | OPTS_TYPE_PT_NEVERCRACK;
9663 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9664 dgst_size = DGST_SIZE_4_4;
9665 parse_func = oldoffice34cm2_parse_hash;
9666 sort_by_digest = sort_by_digest_4_4;
9667 opti_type = OPTI_TYPE_ZERO_BYTE
9668 | OPTI_TYPE_PRECOMPUTE_INIT
9669 | OPTI_TYPE_NOT_ITERATED;
9670 dgst_pos0 = 0;
9671 dgst_pos1 = 1;
9672 dgst_pos2 = 2;
9673 dgst_pos3 = 3;
9674 break;
9675
9676 case 9900: hash_type = HASH_TYPE_MD5;
9677 salt_type = SALT_TYPE_NONE;
9678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9679 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9680 kern_type = KERN_TYPE_RADMIN2;
9681 dgst_size = DGST_SIZE_4_4;
9682 parse_func = radmin2_parse_hash;
9683 sort_by_digest = sort_by_digest_4_4;
9684 opti_type = OPTI_TYPE_ZERO_BYTE
9685 | OPTI_TYPE_PRECOMPUTE_INIT
9686 | OPTI_TYPE_EARLY_SKIP
9687 | OPTI_TYPE_NOT_ITERATED
9688 | OPTI_TYPE_NOT_SALTED;
9689 dgst_pos0 = 0;
9690 dgst_pos1 = 3;
9691 dgst_pos2 = 2;
9692 dgst_pos3 = 1;
9693 break;
9694
9695 case 10000: hash_type = HASH_TYPE_SHA256;
9696 salt_type = SALT_TYPE_EMBEDDED;
9697 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9698 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9699 kern_type = KERN_TYPE_PBKDF2_SHA256;
9700 dgst_size = DGST_SIZE_4_32;
9701 parse_func = djangopbkdf2_parse_hash;
9702 sort_by_digest = sort_by_digest_4_32;
9703 opti_type = OPTI_TYPE_ZERO_BYTE
9704 | OPTI_TYPE_SLOW_HASH_SIMD;
9705 dgst_pos0 = 0;
9706 dgst_pos1 = 1;
9707 dgst_pos2 = 2;
9708 dgst_pos3 = 3;
9709 break;
9710
9711 case 10100: hash_type = HASH_TYPE_SIPHASH;
9712 salt_type = SALT_TYPE_EMBEDDED;
9713 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9714 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9715 kern_type = KERN_TYPE_SIPHASH;
9716 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9717 parse_func = siphash_parse_hash;
9718 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9719 opti_type = OPTI_TYPE_ZERO_BYTE
9720 | OPTI_TYPE_NOT_ITERATED
9721 | OPTI_TYPE_RAW_HASH;
9722 dgst_pos0 = 0;
9723 dgst_pos1 = 1;
9724 dgst_pos2 = 2;
9725 dgst_pos3 = 3;
9726 break;
9727
9728 case 10200: hash_type = HASH_TYPE_MD5;
9729 salt_type = SALT_TYPE_EMBEDDED;
9730 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9731 opts_type = OPTS_TYPE_PT_GENERATE_LE
9732 | OPTS_TYPE_ST_ADD80
9733 | OPTS_TYPE_ST_ADDBITS14;
9734 kern_type = KERN_TYPE_HMACMD5_PW;
9735 dgst_size = DGST_SIZE_4_4;
9736 parse_func = crammd5_parse_hash;
9737 sort_by_digest = sort_by_digest_4_4;
9738 opti_type = OPTI_TYPE_ZERO_BYTE
9739 | OPTI_TYPE_NOT_ITERATED;
9740 dgst_pos0 = 0;
9741 dgst_pos1 = 3;
9742 dgst_pos2 = 2;
9743 dgst_pos3 = 1;
9744 break;
9745
9746 case 10300: hash_type = HASH_TYPE_SHA1;
9747 salt_type = SALT_TYPE_EMBEDDED;
9748 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9749 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9750 kern_type = KERN_TYPE_SAPH_SHA1;
9751 dgst_size = DGST_SIZE_4_5;
9752 parse_func = saph_sha1_parse_hash;
9753 sort_by_digest = sort_by_digest_4_5;
9754 opti_type = OPTI_TYPE_ZERO_BYTE;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 10400: hash_type = HASH_TYPE_PDFU16;
9762 salt_type = SALT_TYPE_EMBEDDED;
9763 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9764 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9765 kern_type = KERN_TYPE_PDF11;
9766 dgst_size = DGST_SIZE_4_4;
9767 parse_func = pdf11_parse_hash;
9768 sort_by_digest = sort_by_digest_4_4;
9769 opti_type = OPTI_TYPE_ZERO_BYTE
9770 | OPTI_TYPE_NOT_ITERATED;
9771 dgst_pos0 = 0;
9772 dgst_pos1 = 1;
9773 dgst_pos2 = 2;
9774 dgst_pos3 = 3;
9775 break;
9776
9777 case 10410: hash_type = HASH_TYPE_PDFU16;
9778 salt_type = SALT_TYPE_EMBEDDED;
9779 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9781 kern_type = KERN_TYPE_PDF11CM1;
9782 dgst_size = DGST_SIZE_4_4;
9783 parse_func = pdf11cm1_parse_hash;
9784 sort_by_digest = sort_by_digest_4_4;
9785 opti_type = OPTI_TYPE_ZERO_BYTE
9786 | OPTI_TYPE_NOT_ITERATED;
9787 dgst_pos0 = 0;
9788 dgst_pos1 = 1;
9789 dgst_pos2 = 2;
9790 dgst_pos3 = 3;
9791 break;
9792
9793 case 10420: hash_type = HASH_TYPE_PDFU16;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9797 kern_type = KERN_TYPE_PDF11CM2;
9798 dgst_size = DGST_SIZE_4_4;
9799 parse_func = pdf11cm2_parse_hash;
9800 sort_by_digest = sort_by_digest_4_4;
9801 opti_type = OPTI_TYPE_ZERO_BYTE
9802 | OPTI_TYPE_NOT_ITERATED;
9803 dgst_pos0 = 0;
9804 dgst_pos1 = 1;
9805 dgst_pos2 = 2;
9806 dgst_pos3 = 3;
9807 break;
9808
9809 case 10500: hash_type = HASH_TYPE_PDFU16;
9810 salt_type = SALT_TYPE_EMBEDDED;
9811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9813 kern_type = KERN_TYPE_PDF14;
9814 dgst_size = DGST_SIZE_4_4;
9815 parse_func = pdf14_parse_hash;
9816 sort_by_digest = sort_by_digest_4_4;
9817 opti_type = OPTI_TYPE_ZERO_BYTE
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 10600: hash_type = HASH_TYPE_SHA256;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_BE
9829 | OPTS_TYPE_ST_ADD80
9830 | OPTS_TYPE_ST_ADDBITS15
9831 | OPTS_TYPE_HASH_COPY;
9832 kern_type = KERN_TYPE_SHA256_PWSLT;
9833 dgst_size = DGST_SIZE_4_8;
9834 parse_func = pdf17l3_parse_hash;
9835 sort_by_digest = sort_by_digest_4_8;
9836 opti_type = OPTI_TYPE_ZERO_BYTE
9837 | OPTI_TYPE_PRECOMPUTE_INIT
9838 | OPTI_TYPE_PRECOMPUTE_MERKLE
9839 | OPTI_TYPE_EARLY_SKIP
9840 | OPTI_TYPE_NOT_ITERATED
9841 | OPTI_TYPE_APPENDED_SALT
9842 | OPTI_TYPE_RAW_HASH;
9843 dgst_pos0 = 3;
9844 dgst_pos1 = 7;
9845 dgst_pos2 = 2;
9846 dgst_pos3 = 6;
9847 break;
9848
9849 case 10700: hash_type = HASH_TYPE_PDFU32;
9850 salt_type = SALT_TYPE_EMBEDDED;
9851 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9852 opts_type = OPTS_TYPE_PT_GENERATE_LE
9853 | OPTS_TYPE_HASH_COPY;
9854 kern_type = KERN_TYPE_PDF17L8;
9855 dgst_size = DGST_SIZE_4_8;
9856 parse_func = pdf17l8_parse_hash;
9857 sort_by_digest = sort_by_digest_4_8;
9858 opti_type = OPTI_TYPE_ZERO_BYTE
9859 | OPTI_TYPE_NOT_ITERATED;
9860 dgst_pos0 = 0;
9861 dgst_pos1 = 1;
9862 dgst_pos2 = 2;
9863 dgst_pos3 = 3;
9864 break;
9865
9866 case 10800: hash_type = HASH_TYPE_SHA384;
9867 salt_type = SALT_TYPE_NONE;
9868 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9869 opts_type = OPTS_TYPE_PT_GENERATE_BE
9870 | OPTS_TYPE_PT_ADD80
9871 | OPTS_TYPE_PT_ADDBITS15;
9872 kern_type = KERN_TYPE_SHA384;
9873 dgst_size = DGST_SIZE_8_8;
9874 parse_func = sha384_parse_hash;
9875 sort_by_digest = sort_by_digest_8_8;
9876 opti_type = OPTI_TYPE_ZERO_BYTE
9877 | OPTI_TYPE_PRECOMPUTE_INIT
9878 | OPTI_TYPE_PRECOMPUTE_MERKLE
9879 | OPTI_TYPE_EARLY_SKIP
9880 | OPTI_TYPE_NOT_ITERATED
9881 | OPTI_TYPE_NOT_SALTED
9882 | OPTI_TYPE_USES_BITS_64
9883 | OPTI_TYPE_RAW_HASH;
9884 dgst_pos0 = 6;
9885 dgst_pos1 = 7;
9886 dgst_pos2 = 4;
9887 dgst_pos3 = 5;
9888 break;
9889
9890 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9891 salt_type = SALT_TYPE_EMBEDDED;
9892 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9893 opts_type = OPTS_TYPE_PT_GENERATE_LE
9894 | OPTS_TYPE_ST_BASE64
9895 | OPTS_TYPE_HASH_COPY;
9896 kern_type = KERN_TYPE_PBKDF2_SHA256;
9897 dgst_size = DGST_SIZE_4_32;
9898 parse_func = pbkdf2_sha256_parse_hash;
9899 sort_by_digest = sort_by_digest_4_32;
9900 opti_type = OPTI_TYPE_ZERO_BYTE
9901 | OPTI_TYPE_SLOW_HASH_SIMD;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 1;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 3;
9906 break;
9907
9908 case 11000: hash_type = HASH_TYPE_MD5;
9909 salt_type = SALT_TYPE_INTERN;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_LE
9912 | OPTS_TYPE_PT_ADD80;
9913 kern_type = KERN_TYPE_PRESTASHOP;
9914 dgst_size = DGST_SIZE_4_4;
9915 parse_func = prestashop_parse_hash;
9916 sort_by_digest = sort_by_digest_4_4;
9917 opti_type = OPTI_TYPE_ZERO_BYTE
9918 | OPTI_TYPE_PRECOMPUTE_INIT
9919 | OPTI_TYPE_NOT_ITERATED
9920 | OPTI_TYPE_PREPENDED_SALT;
9921 dgst_pos0 = 0;
9922 dgst_pos1 = 3;
9923 dgst_pos2 = 2;
9924 dgst_pos3 = 1;
9925 break;
9926
9927 case 11100: hash_type = HASH_TYPE_MD5;
9928 salt_type = SALT_TYPE_EMBEDDED;
9929 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9930 opts_type = OPTS_TYPE_PT_GENERATE_LE
9931 | OPTS_TYPE_ST_ADD80;
9932 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = postgresql_auth_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE
9937 | OPTI_TYPE_PRECOMPUTE_INIT
9938 | OPTI_TYPE_PRECOMPUTE_MERKLE
9939 | OPTI_TYPE_EARLY_SKIP;
9940 dgst_pos0 = 0;
9941 dgst_pos1 = 3;
9942 dgst_pos2 = 2;
9943 dgst_pos3 = 1;
9944 break;
9945
9946 case 11200: hash_type = HASH_TYPE_SHA1;
9947 salt_type = SALT_TYPE_EMBEDDED;
9948 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9949 opts_type = OPTS_TYPE_PT_GENERATE_BE
9950 | OPTS_TYPE_PT_ADD80
9951 | OPTS_TYPE_ST_HEX;
9952 kern_type = KERN_TYPE_MYSQL_AUTH;
9953 dgst_size = DGST_SIZE_4_5;
9954 parse_func = mysql_auth_parse_hash;
9955 sort_by_digest = sort_by_digest_4_5;
9956 opti_type = OPTI_TYPE_ZERO_BYTE
9957 | OPTI_TYPE_EARLY_SKIP;
9958 dgst_pos0 = 3;
9959 dgst_pos1 = 4;
9960 dgst_pos2 = 2;
9961 dgst_pos3 = 1;
9962 break;
9963
9964 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9965 salt_type = SALT_TYPE_EMBEDDED;
9966 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9967 opts_type = OPTS_TYPE_PT_GENERATE_LE
9968 | OPTS_TYPE_ST_HEX
9969 | OPTS_TYPE_ST_ADD80;
9970 kern_type = KERN_TYPE_BITCOIN_WALLET;
9971 dgst_size = DGST_SIZE_4_4;
9972 parse_func = bitcoin_wallet_parse_hash;
9973 sort_by_digest = sort_by_digest_4_4;
9974 opti_type = OPTI_TYPE_ZERO_BYTE;
9975 dgst_pos0 = 0;
9976 dgst_pos1 = 1;
9977 dgst_pos2 = 2;
9978 dgst_pos3 = 3;
9979 break;
9980
9981 case 11400: hash_type = HASH_TYPE_MD5;
9982 salt_type = SALT_TYPE_EMBEDDED;
9983 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9984 opts_type = OPTS_TYPE_PT_GENERATE_LE
9985 | OPTS_TYPE_PT_ADD80
9986 | OPTS_TYPE_HASH_COPY;
9987 kern_type = KERN_TYPE_SIP_AUTH;
9988 dgst_size = DGST_SIZE_4_4;
9989 parse_func = sip_auth_parse_hash;
9990 sort_by_digest = sort_by_digest_4_4;
9991 opti_type = OPTI_TYPE_ZERO_BYTE;
9992 dgst_pos0 = 0;
9993 dgst_pos1 = 3;
9994 dgst_pos2 = 2;
9995 dgst_pos3 = 1;
9996 break;
9997
9998 case 11500: hash_type = HASH_TYPE_CRC32;
9999 salt_type = SALT_TYPE_INTERN;
10000 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10001 opts_type = OPTS_TYPE_PT_GENERATE_LE
10002 | OPTS_TYPE_ST_GENERATE_LE
10003 | OPTS_TYPE_ST_HEX;
10004 kern_type = KERN_TYPE_CRC32;
10005 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10006 parse_func = crc32_parse_hash;
10007 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10008 opti_type = OPTI_TYPE_ZERO_BYTE;
10009 dgst_pos0 = 0;
10010 dgst_pos1 = 1;
10011 dgst_pos2 = 2;
10012 dgst_pos3 = 3;
10013 break;
10014
10015 case 11600: hash_type = HASH_TYPE_AES;
10016 salt_type = SALT_TYPE_EMBEDDED;
10017 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_NEVERCRACK;
10020 kern_type = KERN_TYPE_SEVEN_ZIP;
10021 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10022 parse_func = seven_zip_parse_hash;
10023 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10024 opti_type = OPTI_TYPE_ZERO_BYTE;
10025 dgst_pos0 = 0;
10026 dgst_pos1 = 1;
10027 dgst_pos2 = 2;
10028 dgst_pos3 = 3;
10029 break;
10030
10031 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10032 salt_type = SALT_TYPE_NONE;
10033 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_PT_ADD01;
10036 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10037 dgst_size = DGST_SIZE_4_8;
10038 parse_func = gost2012sbog_256_parse_hash;
10039 sort_by_digest = sort_by_digest_4_8;
10040 opti_type = OPTI_TYPE_ZERO_BYTE;
10041 dgst_pos0 = 0;
10042 dgst_pos1 = 1;
10043 dgst_pos2 = 2;
10044 dgst_pos3 = 3;
10045 break;
10046
10047 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10048 salt_type = SALT_TYPE_NONE;
10049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10050 opts_type = OPTS_TYPE_PT_GENERATE_LE
10051 | OPTS_TYPE_PT_ADD01;
10052 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10053 dgst_size = DGST_SIZE_4_16;
10054 parse_func = gost2012sbog_512_parse_hash;
10055 sort_by_digest = sort_by_digest_4_16;
10056 opti_type = OPTI_TYPE_ZERO_BYTE;
10057 dgst_pos0 = 0;
10058 dgst_pos1 = 1;
10059 dgst_pos2 = 2;
10060 dgst_pos3 = 3;
10061 break;
10062
10063 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10064 salt_type = SALT_TYPE_EMBEDDED;
10065 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10066 opts_type = OPTS_TYPE_PT_GENERATE_LE
10067 | OPTS_TYPE_ST_BASE64
10068 | OPTS_TYPE_HASH_COPY;
10069 kern_type = KERN_TYPE_PBKDF2_MD5;
10070 dgst_size = DGST_SIZE_4_32;
10071 parse_func = pbkdf2_md5_parse_hash;
10072 sort_by_digest = sort_by_digest_4_32;
10073 opti_type = OPTI_TYPE_ZERO_BYTE
10074 | OPTI_TYPE_SLOW_HASH_SIMD;
10075 dgst_pos0 = 0;
10076 dgst_pos1 = 1;
10077 dgst_pos2 = 2;
10078 dgst_pos3 = 3;
10079 break;
10080
10081 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10082 salt_type = SALT_TYPE_EMBEDDED;
10083 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10084 opts_type = OPTS_TYPE_PT_GENERATE_LE
10085 | OPTS_TYPE_ST_BASE64
10086 | OPTS_TYPE_HASH_COPY;
10087 kern_type = KERN_TYPE_PBKDF2_SHA1;
10088 dgst_size = DGST_SIZE_4_32;
10089 parse_func = pbkdf2_sha1_parse_hash;
10090 sort_by_digest = sort_by_digest_4_32;
10091 opti_type = OPTI_TYPE_ZERO_BYTE
10092 | OPTI_TYPE_SLOW_HASH_SIMD;
10093 dgst_pos0 = 0;
10094 dgst_pos1 = 1;
10095 dgst_pos2 = 2;
10096 dgst_pos3 = 3;
10097 break;
10098
10099 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10100 salt_type = SALT_TYPE_EMBEDDED;
10101 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10102 opts_type = OPTS_TYPE_PT_GENERATE_LE
10103 | OPTS_TYPE_ST_BASE64
10104 | OPTS_TYPE_HASH_COPY;
10105 kern_type = KERN_TYPE_PBKDF2_SHA512;
10106 dgst_size = DGST_SIZE_8_16;
10107 parse_func = pbkdf2_sha512_parse_hash;
10108 sort_by_digest = sort_by_digest_8_16;
10109 opti_type = OPTI_TYPE_ZERO_BYTE
10110 | OPTI_TYPE_USES_BITS_64
10111 | OPTI_TYPE_SLOW_HASH_SIMD;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10119 salt_type = SALT_TYPE_EMBEDDED;
10120 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10121 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10122 kern_type = KERN_TYPE_ECRYPTFS;
10123 dgst_size = DGST_SIZE_8_8;
10124 parse_func = ecryptfs_parse_hash;
10125 sort_by_digest = sort_by_digest_8_8;
10126 opti_type = OPTI_TYPE_ZERO_BYTE
10127 | OPTI_TYPE_USES_BITS_64;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12300: hash_type = HASH_TYPE_ORACLET;
10135 salt_type = SALT_TYPE_EMBEDDED;
10136 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10137 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10138 kern_type = KERN_TYPE_ORACLET;
10139 dgst_size = DGST_SIZE_8_16;
10140 parse_func = oraclet_parse_hash;
10141 sort_by_digest = sort_by_digest_8_16;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_USES_BITS_64;
10144 dgst_pos0 = 0;
10145 dgst_pos1 = 1;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 3;
10148 break;
10149
10150 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10154 kern_type = KERN_TYPE_BSDICRYPT;
10155 dgst_size = DGST_SIZE_4_4;
10156 parse_func = bsdicrypt_parse_hash;
10157 sort_by_digest = sort_by_digest_4_4;
10158 opti_type = OPTI_TYPE_ZERO_BYTE
10159 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10160 dgst_pos0 = 0;
10161 dgst_pos1 = 1;
10162 dgst_pos2 = 2;
10163 dgst_pos3 = 3;
10164 break;
10165
10166 case 12500: hash_type = HASH_TYPE_RAR3HP;
10167 salt_type = SALT_TYPE_EMBEDDED;
10168 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10169 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10170 kern_type = KERN_TYPE_RAR3;
10171 dgst_size = DGST_SIZE_4_4;
10172 parse_func = rar3hp_parse_hash;
10173 sort_by_digest = sort_by_digest_4_4;
10174 opti_type = OPTI_TYPE_ZERO_BYTE;
10175 dgst_pos0 = 0;
10176 dgst_pos1 = 1;
10177 dgst_pos2 = 2;
10178 dgst_pos3 = 3;
10179 break;
10180
10181 case 12600: hash_type = HASH_TYPE_SHA256;
10182 salt_type = SALT_TYPE_INTERN;
10183 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10184 opts_type = OPTS_TYPE_PT_GENERATE_BE
10185 | OPTS_TYPE_PT_ADD80;
10186 kern_type = KERN_TYPE_CF10;
10187 dgst_size = DGST_SIZE_4_8;
10188 parse_func = cf10_parse_hash;
10189 sort_by_digest = sort_by_digest_4_8;
10190 opti_type = OPTI_TYPE_ZERO_BYTE
10191 | OPTI_TYPE_PRECOMPUTE_INIT
10192 | OPTI_TYPE_EARLY_SKIP
10193 | OPTI_TYPE_NOT_ITERATED;
10194 dgst_pos0 = 3;
10195 dgst_pos1 = 7;
10196 dgst_pos2 = 2;
10197 dgst_pos3 = 6;
10198 break;
10199
10200 case 12700: hash_type = HASH_TYPE_AES;
10201 salt_type = SALT_TYPE_EMBEDDED;
10202 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10203 opts_type = OPTS_TYPE_PT_GENERATE_LE
10204 | OPTS_TYPE_HASH_COPY;
10205 kern_type = KERN_TYPE_MYWALLET;
10206 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10207 parse_func = mywallet_parse_hash;
10208 sort_by_digest = sort_by_digest_4_5;
10209 opti_type = OPTI_TYPE_ZERO_BYTE;
10210 dgst_pos0 = 0;
10211 dgst_pos1 = 1;
10212 dgst_pos2 = 2;
10213 dgst_pos3 = 3;
10214 break;
10215
10216 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10217 salt_type = SALT_TYPE_EMBEDDED;
10218 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10219 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10220 kern_type = KERN_TYPE_MS_DRSR;
10221 dgst_size = DGST_SIZE_4_8;
10222 parse_func = ms_drsr_parse_hash;
10223 sort_by_digest = sort_by_digest_4_8;
10224 opti_type = OPTI_TYPE_ZERO_BYTE;
10225 dgst_pos0 = 0;
10226 dgst_pos1 = 1;
10227 dgst_pos2 = 2;
10228 dgst_pos3 = 3;
10229 break;
10230
10231 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10232 salt_type = SALT_TYPE_EMBEDDED;
10233 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10234 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10235 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10236 dgst_size = DGST_SIZE_4_8;
10237 parse_func = androidfde_samsung_parse_hash;
10238 sort_by_digest = sort_by_digest_4_8;
10239 opti_type = OPTI_TYPE_ZERO_BYTE;
10240 dgst_pos0 = 0;
10241 dgst_pos1 = 1;
10242 dgst_pos2 = 2;
10243 dgst_pos3 = 3;
10244 break;
10245
10246 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10247 salt_type = SALT_TYPE_EMBEDDED;
10248 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10249 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10250 kern_type = KERN_TYPE_RAR5;
10251 dgst_size = DGST_SIZE_4_4;
10252 parse_func = rar5_parse_hash;
10253 sort_by_digest = sort_by_digest_4_4;
10254 opti_type = OPTI_TYPE_ZERO_BYTE;
10255 dgst_pos0 = 0;
10256 dgst_pos1 = 1;
10257 dgst_pos2 = 2;
10258 dgst_pos3 = 3;
10259 break;
10260
10261 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10262 salt_type = SALT_TYPE_EMBEDDED;
10263 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10264 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10265 kern_type = KERN_TYPE_KRB5TGS;
10266 dgst_size = DGST_SIZE_4_4;
10267 parse_func = krb5tgs_parse_hash;
10268 sort_by_digest = sort_by_digest_4_4;
10269 opti_type = OPTI_TYPE_ZERO_BYTE
10270 | OPTI_TYPE_NOT_ITERATED;
10271 dgst_pos0 = 0;
10272 dgst_pos1 = 1;
10273 dgst_pos2 = 2;
10274 dgst_pos3 = 3;
10275 break;
10276
10277 case 13200: hash_type = HASH_TYPE_AES;
10278 salt_type = SALT_TYPE_EMBEDDED;
10279 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10280 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10281 kern_type = KERN_TYPE_AXCRYPT;
10282 dgst_size = DGST_SIZE_4_4;
10283 parse_func = axcrypt_parse_hash;
10284 sort_by_digest = sort_by_digest_4_4;
10285 opti_type = OPTI_TYPE_ZERO_BYTE;
10286 dgst_pos0 = 0;
10287 dgst_pos1 = 1;
10288 dgst_pos2 = 2;
10289 dgst_pos3 = 3;
10290 break;
10291
10292 case 13300: hash_type = HASH_TYPE_SHA1;
10293 salt_type = SALT_TYPE_NONE;
10294 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10295 opts_type = OPTS_TYPE_PT_GENERATE_BE
10296 | OPTS_TYPE_PT_ADD80
10297 | OPTS_TYPE_PT_ADDBITS15;
10298 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10299 dgst_size = DGST_SIZE_4_5;
10300 parse_func = sha1axcrypt_parse_hash;
10301 sort_by_digest = sort_by_digest_4_5;
10302 opti_type = OPTI_TYPE_ZERO_BYTE
10303 | OPTI_TYPE_PRECOMPUTE_INIT
10304 | OPTI_TYPE_EARLY_SKIP
10305 | OPTI_TYPE_NOT_ITERATED
10306 | OPTI_TYPE_NOT_SALTED;
10307 dgst_pos0 = 0;
10308 dgst_pos1 = 4;
10309 dgst_pos2 = 3;
10310 dgst_pos3 = 2;
10311 break;
10312
10313 case 13400: hash_type = HASH_TYPE_AES;
10314 salt_type = SALT_TYPE_EMBEDDED;
10315 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10316 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10317 kern_type = KERN_TYPE_KEEPASS;
10318 dgst_size = DGST_SIZE_4_4;
10319 parse_func = keepass_parse_hash;
10320 sort_by_digest = sort_by_digest_4_4;
10321 opti_type = OPTI_TYPE_ZERO_BYTE;
10322 dgst_pos0 = 0;
10323 dgst_pos1 = 1;
10324 dgst_pos2 = 2;
10325 dgst_pos3 = 3;
10326 break;
10327
10328 case 13500: hash_type = HASH_TYPE_SHA1;
10329 salt_type = SALT_TYPE_EMBEDDED;
10330 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10331 opts_type = OPTS_TYPE_PT_GENERATE_BE
10332 | OPTS_TYPE_PT_UNICODE
10333 | OPTS_TYPE_PT_ADD80;
10334 kern_type = KERN_TYPE_PSTOKEN;
10335 dgst_size = DGST_SIZE_4_5;
10336 parse_func = pstoken_parse_hash;
10337 sort_by_digest = sort_by_digest_4_5;
10338 opti_type = OPTI_TYPE_ZERO_BYTE
10339 | OPTI_TYPE_PRECOMPUTE_INIT
10340 | OPTI_TYPE_EARLY_SKIP
10341 | OPTI_TYPE_NOT_ITERATED
10342 | OPTI_TYPE_PREPENDED_SALT
10343 | OPTI_TYPE_RAW_HASH;
10344 dgst_pos0 = 3;
10345 dgst_pos1 = 4;
10346 dgst_pos2 = 2;
10347 dgst_pos3 = 1;
10348 break;
10349
10350 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10351 salt_type = SALT_TYPE_EMBEDDED;
10352 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10353 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10354 kern_type = KERN_TYPE_ZIP2;
10355 dgst_size = DGST_SIZE_4_4;
10356 parse_func = zip2_parse_hash;
10357 sort_by_digest = sort_by_digest_4_4;
10358 opti_type = OPTI_TYPE_ZERO_BYTE;
10359 dgst_pos0 = 0;
10360 dgst_pos1 = 1;
10361 dgst_pos2 = 2;
10362 dgst_pos3 = 3;
10363 break;
10364
10365 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10366 salt_type = SALT_TYPE_EMBEDDED;
10367 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10368 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10369 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10370 dgst_size = DGST_SIZE_4_5;
10371 parse_func = veracrypt_parse_hash_655331;
10372 sort_by_digest = sort_by_digest_4_5;
10373 opti_type = OPTI_TYPE_ZERO_BYTE;
10374 dgst_pos0 = 0;
10375 dgst_pos1 = 1;
10376 dgst_pos2 = 2;
10377 dgst_pos3 = 3;
10378 break;
10379
10380 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10381 salt_type = SALT_TYPE_EMBEDDED;
10382 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10383 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10384 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10385 dgst_size = DGST_SIZE_4_5;
10386 parse_func = veracrypt_parse_hash_655331;
10387 sort_by_digest = sort_by_digest_4_5;
10388 opti_type = OPTI_TYPE_ZERO_BYTE;
10389 dgst_pos0 = 0;
10390 dgst_pos1 = 1;
10391 dgst_pos2 = 2;
10392 dgst_pos3 = 3;
10393 break;
10394
10395 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10396 salt_type = SALT_TYPE_EMBEDDED;
10397 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10398 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10399 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10400 dgst_size = DGST_SIZE_4_5;
10401 parse_func = veracrypt_parse_hash_655331;
10402 sort_by_digest = sort_by_digest_4_5;
10403 opti_type = OPTI_TYPE_ZERO_BYTE;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13721: hash_type = HASH_TYPE_SHA512;
10411 salt_type = SALT_TYPE_EMBEDDED;
10412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10413 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10414 kern_type = KERN_TYPE_TCSHA512_XTS512;
10415 dgst_size = DGST_SIZE_8_8;
10416 parse_func = veracrypt_parse_hash_500000;
10417 sort_by_digest = sort_by_digest_8_8;
10418 opti_type = OPTI_TYPE_ZERO_BYTE
10419 | OPTI_TYPE_USES_BITS_64;
10420 dgst_pos0 = 0;
10421 dgst_pos1 = 1;
10422 dgst_pos2 = 2;
10423 dgst_pos3 = 3;
10424 break;
10425
10426 case 13722: hash_type = HASH_TYPE_SHA512;
10427 salt_type = SALT_TYPE_EMBEDDED;
10428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10430 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10431 dgst_size = DGST_SIZE_8_8;
10432 parse_func = veracrypt_parse_hash_500000;
10433 sort_by_digest = sort_by_digest_8_8;
10434 opti_type = OPTI_TYPE_ZERO_BYTE
10435 | OPTI_TYPE_USES_BITS_64;
10436 dgst_pos0 = 0;
10437 dgst_pos1 = 1;
10438 dgst_pos2 = 2;
10439 dgst_pos3 = 3;
10440 break;
10441
10442 case 13723: hash_type = HASH_TYPE_SHA512;
10443 salt_type = SALT_TYPE_EMBEDDED;
10444 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10445 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10446 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10447 dgst_size = DGST_SIZE_8_8;
10448 parse_func = veracrypt_parse_hash_500000;
10449 sort_by_digest = sort_by_digest_8_8;
10450 opti_type = OPTI_TYPE_ZERO_BYTE
10451 | OPTI_TYPE_USES_BITS_64;
10452 dgst_pos0 = 0;
10453 dgst_pos1 = 1;
10454 dgst_pos2 = 2;
10455 dgst_pos3 = 3;
10456 break;
10457
10458 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10459 salt_type = SALT_TYPE_EMBEDDED;
10460 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10461 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10462 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10463 dgst_size = DGST_SIZE_4_8;
10464 parse_func = veracrypt_parse_hash_500000;
10465 sort_by_digest = sort_by_digest_4_8;
10466 opti_type = OPTI_TYPE_ZERO_BYTE;
10467 dgst_pos0 = 0;
10468 dgst_pos1 = 1;
10469 dgst_pos2 = 2;
10470 dgst_pos3 = 3;
10471 break;
10472
10473 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10474 salt_type = SALT_TYPE_EMBEDDED;
10475 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10476 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10477 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10478 dgst_size = DGST_SIZE_4_8;
10479 parse_func = veracrypt_parse_hash_500000;
10480 sort_by_digest = sort_by_digest_4_8;
10481 opti_type = OPTI_TYPE_ZERO_BYTE;
10482 dgst_pos0 = 0;
10483 dgst_pos1 = 1;
10484 dgst_pos2 = 2;
10485 dgst_pos3 = 3;
10486 break;
10487
10488 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10489 salt_type = SALT_TYPE_EMBEDDED;
10490 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10491 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10492 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10493 dgst_size = DGST_SIZE_4_8;
10494 parse_func = veracrypt_parse_hash_500000;
10495 sort_by_digest = sort_by_digest_4_8;
10496 opti_type = OPTI_TYPE_ZERO_BYTE;
10497 dgst_pos0 = 0;
10498 dgst_pos1 = 1;
10499 dgst_pos2 = 2;
10500 dgst_pos3 = 3;
10501 break;
10502
10503 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10504 salt_type = SALT_TYPE_EMBEDDED;
10505 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10506 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10507 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10508 dgst_size = DGST_SIZE_4_5;
10509 parse_func = veracrypt_parse_hash_327661;
10510 sort_by_digest = sort_by_digest_4_5;
10511 opti_type = OPTI_TYPE_ZERO_BYTE;
10512 dgst_pos0 = 0;
10513 dgst_pos1 = 1;
10514 dgst_pos2 = 2;
10515 dgst_pos3 = 3;
10516 break;
10517
10518 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10519 salt_type = SALT_TYPE_EMBEDDED;
10520 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10521 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10522 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10523 dgst_size = DGST_SIZE_4_5;
10524 parse_func = veracrypt_parse_hash_327661;
10525 sort_by_digest = sort_by_digest_4_5;
10526 opti_type = OPTI_TYPE_ZERO_BYTE;
10527 dgst_pos0 = 0;
10528 dgst_pos1 = 1;
10529 dgst_pos2 = 2;
10530 dgst_pos3 = 3;
10531 break;
10532
10533 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10534 salt_type = SALT_TYPE_EMBEDDED;
10535 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10536 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10537 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10538 dgst_size = DGST_SIZE_4_5;
10539 parse_func = veracrypt_parse_hash_327661;
10540 sort_by_digest = sort_by_digest_4_5;
10541 opti_type = OPTI_TYPE_ZERO_BYTE;
10542 dgst_pos0 = 0;
10543 dgst_pos1 = 1;
10544 dgst_pos2 = 2;
10545 dgst_pos3 = 3;
10546 break;
10547
10548 case 13751: hash_type = HASH_TYPE_SHA256;
10549 salt_type = SALT_TYPE_EMBEDDED;
10550 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10551 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10552 kern_type = KERN_TYPE_VCSHA256_XTS512;
10553 dgst_size = DGST_SIZE_4_8;
10554 parse_func = veracrypt_parse_hash_500000;
10555 sort_by_digest = sort_by_digest_4_8;
10556 opti_type = OPTI_TYPE_ZERO_BYTE;
10557 dgst_pos0 = 0;
10558 dgst_pos1 = 1;
10559 dgst_pos2 = 2;
10560 dgst_pos3 = 3;
10561 break;
10562
10563 case 13752: hash_type = HASH_TYPE_SHA256;
10564 salt_type = SALT_TYPE_EMBEDDED;
10565 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10566 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10567 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10568 dgst_size = DGST_SIZE_4_8;
10569 parse_func = veracrypt_parse_hash_500000;
10570 sort_by_digest = sort_by_digest_4_8;
10571 opti_type = OPTI_TYPE_ZERO_BYTE;
10572 dgst_pos0 = 0;
10573 dgst_pos1 = 1;
10574 dgst_pos2 = 2;
10575 dgst_pos3 = 3;
10576 break;
10577
10578 case 13753: hash_type = HASH_TYPE_SHA256;
10579 salt_type = SALT_TYPE_EMBEDDED;
10580 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10581 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10582 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10583 dgst_size = DGST_SIZE_4_8;
10584 parse_func = veracrypt_parse_hash_500000;
10585 sort_by_digest = sort_by_digest_4_8;
10586 opti_type = OPTI_TYPE_ZERO_BYTE;
10587 dgst_pos0 = 0;
10588 dgst_pos1 = 1;
10589 dgst_pos2 = 2;
10590 dgst_pos3 = 3;
10591 break;
10592
10593 case 13761: hash_type = HASH_TYPE_SHA256;
10594 salt_type = SALT_TYPE_EMBEDDED;
10595 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10596 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10597 kern_type = KERN_TYPE_VCSHA256_XTS512;
10598 dgst_size = DGST_SIZE_4_8;
10599 parse_func = veracrypt_parse_hash_200000;
10600 sort_by_digest = sort_by_digest_4_8;
10601 opti_type = OPTI_TYPE_ZERO_BYTE;
10602 dgst_pos0 = 0;
10603 dgst_pos1 = 1;
10604 dgst_pos2 = 2;
10605 dgst_pos3 = 3;
10606 break;
10607
10608 case 13762: hash_type = HASH_TYPE_SHA256;
10609 salt_type = SALT_TYPE_EMBEDDED;
10610 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10611 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10612 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10613 dgst_size = DGST_SIZE_4_8;
10614 parse_func = veracrypt_parse_hash_200000;
10615 sort_by_digest = sort_by_digest_4_8;
10616 opti_type = OPTI_TYPE_ZERO_BYTE;
10617 dgst_pos0 = 0;
10618 dgst_pos1 = 1;
10619 dgst_pos2 = 2;
10620 dgst_pos3 = 3;
10621 break;
10622
10623 case 13763: hash_type = HASH_TYPE_SHA256;
10624 salt_type = SALT_TYPE_EMBEDDED;
10625 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10626 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10627 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10628 dgst_size = DGST_SIZE_4_8;
10629 parse_func = veracrypt_parse_hash_200000;
10630 sort_by_digest = sort_by_digest_4_8;
10631 opti_type = OPTI_TYPE_ZERO_BYTE;
10632 dgst_pos0 = 0;
10633 dgst_pos1 = 1;
10634 dgst_pos2 = 2;
10635 dgst_pos3 = 3;
10636 break;
10637
10638
10639 default: usage_mini_print (PROGNAME); return (-1);
10640 }
10641
10642 /**
10643 * parser
10644 */
10645
10646 data.parse_func = parse_func;
10647
10648 /**
10649 * misc stuff
10650 */
10651
10652 if (hex_salt)
10653 {
10654 if (salt_type == SALT_TYPE_INTERN)
10655 {
10656 opts_type |= OPTS_TYPE_ST_HEX;
10657 }
10658 else
10659 {
10660 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10661
10662 return (-1);
10663 }
10664 }
10665
10666 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10667 | (salt_type == SALT_TYPE_EXTERN)
10668 | (salt_type == SALT_TYPE_EMBEDDED)
10669 | (salt_type == SALT_TYPE_VIRTUAL));
10670
10671 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10672
10673 data.hash_type = hash_type;
10674 data.attack_mode = attack_mode;
10675 data.attack_kern = attack_kern;
10676 data.attack_exec = attack_exec;
10677 data.kern_type = kern_type;
10678 data.opts_type = opts_type;
10679 data.dgst_size = dgst_size;
10680 data.salt_type = salt_type;
10681 data.isSalted = isSalted;
10682 data.sort_by_digest = sort_by_digest;
10683 data.dgst_pos0 = dgst_pos0;
10684 data.dgst_pos1 = dgst_pos1;
10685 data.dgst_pos2 = dgst_pos2;
10686 data.dgst_pos3 = dgst_pos3;
10687
10688 esalt_size = 0;
10689
10690 switch (hash_mode)
10691 {
10692 case 2500: esalt_size = sizeof (wpa_t); break;
10693 case 5300: esalt_size = sizeof (ikepsk_t); break;
10694 case 5400: esalt_size = sizeof (ikepsk_t); break;
10695 case 5500: esalt_size = sizeof (netntlm_t); break;
10696 case 5600: esalt_size = sizeof (netntlm_t); break;
10697 case 6211: esalt_size = sizeof (tc_t); break;
10698 case 6212: esalt_size = sizeof (tc_t); break;
10699 case 6213: esalt_size = sizeof (tc_t); break;
10700 case 6221: esalt_size = sizeof (tc_t); break;
10701 case 6222: esalt_size = sizeof (tc_t); break;
10702 case 6223: esalt_size = sizeof (tc_t); break;
10703 case 6231: esalt_size = sizeof (tc_t); break;
10704 case 6232: esalt_size = sizeof (tc_t); break;
10705 case 6233: esalt_size = sizeof (tc_t); break;
10706 case 6241: esalt_size = sizeof (tc_t); break;
10707 case 6242: esalt_size = sizeof (tc_t); break;
10708 case 6243: esalt_size = sizeof (tc_t); break;
10709 case 6600: esalt_size = sizeof (agilekey_t); break;
10710 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10711 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10712 case 7300: esalt_size = sizeof (rakp_t); break;
10713 case 7500: esalt_size = sizeof (krb5pa_t); break;
10714 case 8200: esalt_size = sizeof (cloudkey_t); break;
10715 case 8800: esalt_size = sizeof (androidfde_t); break;
10716 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10717 case 9400: esalt_size = sizeof (office2007_t); break;
10718 case 9500: esalt_size = sizeof (office2010_t); break;
10719 case 9600: esalt_size = sizeof (office2013_t); break;
10720 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10721 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10722 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10723 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10724 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10725 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10726 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10727 case 10200: esalt_size = sizeof (cram_md5_t); break;
10728 case 10400: esalt_size = sizeof (pdf_t); break;
10729 case 10410: esalt_size = sizeof (pdf_t); break;
10730 case 10420: esalt_size = sizeof (pdf_t); break;
10731 case 10500: esalt_size = sizeof (pdf_t); break;
10732 case 10600: esalt_size = sizeof (pdf_t); break;
10733 case 10700: esalt_size = sizeof (pdf_t); break;
10734 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10735 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10736 case 11400: esalt_size = sizeof (sip_t); break;
10737 case 11600: esalt_size = sizeof (seven_zip_t); break;
10738 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10739 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10740 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10741 case 13000: esalt_size = sizeof (rar5_t); break;
10742 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10743 case 13400: esalt_size = sizeof (keepass_t); break;
10744 case 13500: esalt_size = sizeof (pstoken_t); break;
10745 case 13600: esalt_size = sizeof (zip2_t); break;
10746 case 13711: esalt_size = sizeof (tc_t); break;
10747 case 13712: esalt_size = sizeof (tc_t); break;
10748 case 13713: esalt_size = sizeof (tc_t); break;
10749 case 13721: esalt_size = sizeof (tc_t); break;
10750 case 13722: esalt_size = sizeof (tc_t); break;
10751 case 13723: esalt_size = sizeof (tc_t); break;
10752 case 13731: esalt_size = sizeof (tc_t); break;
10753 case 13732: esalt_size = sizeof (tc_t); break;
10754 case 13733: esalt_size = sizeof (tc_t); break;
10755 case 13741: esalt_size = sizeof (tc_t); break;
10756 case 13742: esalt_size = sizeof (tc_t); break;
10757 case 13743: esalt_size = sizeof (tc_t); break;
10758 case 13751: esalt_size = sizeof (tc_t); break;
10759 case 13752: esalt_size = sizeof (tc_t); break;
10760 case 13753: esalt_size = sizeof (tc_t); break;
10761 case 13761: esalt_size = sizeof (tc_t); break;
10762 case 13762: esalt_size = sizeof (tc_t); break;
10763 case 13763: esalt_size = sizeof (tc_t); break;
10764 }
10765
10766 data.esalt_size = esalt_size;
10767
10768 /**
10769 * choose dictionary parser
10770 */
10771
10772 if (hash_type == HASH_TYPE_LM)
10773 {
10774 get_next_word_func = get_next_word_lm;
10775 }
10776 else if (opts_type & OPTS_TYPE_PT_UPPER)
10777 {
10778 get_next_word_func = get_next_word_uc;
10779 }
10780 else
10781 {
10782 get_next_word_func = get_next_word_std;
10783 }
10784
10785 /**
10786 * dictstat
10787 */
10788
10789 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10790
10791 #ifdef _POSIX
10792 size_t dictstat_nmemb = 0;
10793 #endif
10794
10795 #ifdef _WIN
10796 uint dictstat_nmemb = 0;
10797 #endif
10798
10799 char dictstat[256] = { 0 };
10800
10801 FILE *dictstat_fp = NULL;
10802
10803 if (keyspace == 0)
10804 {
10805 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10806
10807 dictstat_fp = fopen (dictstat, "rb");
10808
10809 if (dictstat_fp)
10810 {
10811 #ifdef _POSIX
10812 struct stat tmpstat;
10813
10814 fstat (fileno (dictstat_fp), &tmpstat);
10815 #endif
10816
10817 #ifdef _WIN
10818 struct stat64 tmpstat;
10819
10820 _fstat64 (fileno (dictstat_fp), &tmpstat);
10821 #endif
10822
10823 if (tmpstat.st_mtime < COMPTIME)
10824 {
10825 /* with v0.15 the format changed so we have to ensure user is using a good version
10826 since there is no version-header in the dictstat file */
10827
10828 fclose (dictstat_fp);
10829
10830 unlink (dictstat);
10831 }
10832 else
10833 {
10834 while (!feof (dictstat_fp))
10835 {
10836 dictstat_t d;
10837
10838 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10839
10840 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10841
10842 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10843 {
10844 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10845
10846 return -1;
10847 }
10848 }
10849
10850 fclose (dictstat_fp);
10851 }
10852 }
10853 }
10854
10855 /**
10856 * potfile
10857 */
10858
10859 char potfile[256] = { 0 };
10860
10861 if (potfile_path == NULL)
10862 {
10863 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10864 }
10865 else
10866 {
10867 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10868 }
10869
10870 data.pot_fp = NULL;
10871
10872 FILE *out_fp = NULL;
10873 FILE *pot_fp = NULL;
10874
10875 if (show == 1 || left == 1)
10876 {
10877 pot_fp = fopen (potfile, "rb");
10878
10879 if (pot_fp == NULL)
10880 {
10881 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10882
10883 return (-1);
10884 }
10885
10886 if (outfile != NULL)
10887 {
10888 if ((out_fp = fopen (outfile, "ab")) == NULL)
10889 {
10890 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10891
10892 fclose (pot_fp);
10893
10894 return (-1);
10895 }
10896 }
10897 else
10898 {
10899 out_fp = stdout;
10900 }
10901 }
10902 else
10903 {
10904 if (potfile_disable == 0)
10905 {
10906 pot_fp = fopen (potfile, "ab");
10907
10908 if (pot_fp == NULL)
10909 {
10910 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10911
10912 return (-1);
10913 }
10914
10915 data.pot_fp = pot_fp;
10916 }
10917 }
10918
10919 pot_t *pot = NULL;
10920
10921 uint pot_cnt = 0;
10922 uint pot_avail = 0;
10923
10924 if (show == 1 || left == 1)
10925 {
10926 SUPPRESS_OUTPUT = 1;
10927
10928 pot_avail = count_lines (pot_fp);
10929
10930 rewind (pot_fp);
10931
10932 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10933
10934 uint pot_hashes_avail = 0;
10935
10936 uint line_num = 0;
10937
10938 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10939
10940 while (!feof (pot_fp))
10941 {
10942 line_num++;
10943
10944 int line_len = fgetl (pot_fp, line_buf);
10945
10946 if (line_len == 0) continue;
10947
10948 char *plain_buf = line_buf + line_len;
10949
10950 pot_t *pot_ptr = &pot[pot_cnt];
10951
10952 hash_t *hashes_buf = &pot_ptr->hash;
10953
10954 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10955 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10956
10957 if (pot_cnt == pot_hashes_avail)
10958 {
10959 uint pos = 0;
10960
10961 for (pos = 0; pos < INCR_POT; pos++)
10962 {
10963 if ((pot_cnt + pos) >= pot_avail) break;
10964
10965 pot_t *tmp_pot = &pot[pot_cnt + pos];
10966
10967 hash_t *tmp_hash = &tmp_pot->hash;
10968
10969 tmp_hash->digest = mymalloc (dgst_size);
10970
10971 if (isSalted)
10972 {
10973 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10974 }
10975
10976 if (esalt_size)
10977 {
10978 tmp_hash->esalt = mymalloc (esalt_size);
10979 }
10980
10981 pot_hashes_avail++;
10982 }
10983 }
10984
10985 int plain_len = 0;
10986
10987 int parser_status;
10988
10989 int iter = MAX_CUT_TRIES;
10990
10991 do
10992 {
10993 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10994 {
10995 if (line_buf[i] == ':')
10996 {
10997 line_len--;
10998
10999 break;
11000 }
11001 }
11002
11003 if (data.hash_mode != 2500)
11004 {
11005 parser_status = parse_func (line_buf, line_len, hashes_buf);
11006 }
11007 else
11008 {
11009 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11010
11011 if (line_len > max_salt_size)
11012 {
11013 parser_status = PARSER_GLOBAL_LENGTH;
11014 }
11015 else
11016 {
11017 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11018
11019 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11020
11021 hashes_buf->salt->salt_len = line_len;
11022
11023 parser_status = PARSER_OK;
11024 }
11025 }
11026
11027 // if NOT parsed without error, we add the ":" to the plain
11028
11029 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11030 {
11031 plain_len++;
11032 plain_buf--;
11033 }
11034
11035 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11036
11037 if (parser_status < PARSER_GLOBAL_ZERO)
11038 {
11039 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11040
11041 continue;
11042 }
11043
11044 if (plain_len >= 255) continue;
11045
11046 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11047
11048 pot_ptr->plain_len = plain_len;
11049
11050 pot_cnt++;
11051 }
11052
11053 myfree (line_buf);
11054
11055 fclose (pot_fp);
11056
11057 SUPPRESS_OUTPUT = 0;
11058
11059 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11060 }
11061
11062 /**
11063 * word len
11064 */
11065
11066 uint pw_min = PW_MIN;
11067 uint pw_max = PW_MAX;
11068
11069 switch (hash_mode)
11070 {
11071 case 125: if (pw_max > 32) pw_max = 32;
11072 break;
11073 case 400: if (pw_max > 40) pw_max = 40;
11074 break;
11075 case 500: if (pw_max > 16) pw_max = 16;
11076 break;
11077 case 1500: if (pw_max > 8) pw_max = 8;
11078 break;
11079 case 1600: if (pw_max > 16) pw_max = 16;
11080 break;
11081 case 1800: if (pw_max > 16) pw_max = 16;
11082 break;
11083 case 2100: if (pw_max > 16) pw_max = 16;
11084 break;
11085 case 2500: if (pw_min < 8) pw_min = 8;
11086 break;
11087 case 3000: if (pw_max > 7) pw_max = 7;
11088 break;
11089 case 5200: if (pw_max > 24) pw_max = 24;
11090 break;
11091 case 5800: if (pw_max > 16) pw_max = 16;
11092 break;
11093 case 6300: if (pw_max > 16) pw_max = 16;
11094 break;
11095 case 7400: if (pw_max > 16) pw_max = 16;
11096 break;
11097 case 7900: if (pw_max > 48) pw_max = 48;
11098 break;
11099 case 8500: if (pw_max > 8) pw_max = 8;
11100 break;
11101 case 8600: if (pw_max > 16) pw_max = 16;
11102 break;
11103 case 9710: pw_min = 5;
11104 pw_max = 5;
11105 break;
11106 case 9810: pw_min = 5;
11107 pw_max = 5;
11108 break;
11109 case 10410: pw_min = 5;
11110 pw_max = 5;
11111 break;
11112 case 10300: if (pw_max < 3) pw_min = 3;
11113 if (pw_max > 40) pw_max = 40;
11114 break;
11115 case 10500: if (pw_max < 3) pw_min = 3;
11116 if (pw_max > 40) pw_max = 40;
11117 break;
11118 case 10700: if (pw_max > 16) pw_max = 16;
11119 break;
11120 case 11300: if (pw_max > 40) pw_max = 40;
11121 break;
11122 case 11600: if (pw_max > 32) pw_max = 32;
11123 break;
11124 case 12500: if (pw_max > 20) pw_max = 20;
11125 break;
11126 case 12800: if (pw_max > 24) pw_max = 24;
11127 break;
11128 }
11129
11130 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11131 {
11132 switch (attack_kern)
11133 {
11134 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11135 break;
11136 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11137 break;
11138 }
11139 }
11140
11141 /**
11142 * charsets : keep them together for more easy maintainnce
11143 */
11144
11145 cs_t mp_sys[6] = { { { 0 }, 0 } };
11146 cs_t mp_usr[4] = { { { 0 }, 0 } };
11147
11148 mp_setup_sys (mp_sys);
11149
11150 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11151 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11152 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11153 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11154
11155 /**
11156 * load hashes, part I: find input mode, count hashes
11157 */
11158
11159 uint hashlist_mode = 0;
11160 uint hashlist_format = HLFMT_HASHCAT;
11161
11162 uint hashes_avail = 0;
11163
11164 if (benchmark == 0)
11165 {
11166 struct stat f;
11167
11168 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11169
11170 if ((hash_mode == 2500) ||
11171 (hash_mode == 5200) ||
11172 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11173 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11174 (hash_mode == 9000))
11175 {
11176 hashlist_mode = HL_MODE_ARG;
11177
11178 char *hashfile = myargv[optind];
11179
11180 data.hashfile = hashfile;
11181
11182 logfile_top_var_string ("target", hashfile);
11183 }
11184
11185 if (hashlist_mode == HL_MODE_ARG)
11186 {
11187 if (hash_mode == 2500)
11188 {
11189 struct stat st;
11190
11191 if (stat (data.hashfile, &st) == -1)
11192 {
11193 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11194
11195 return (-1);
11196 }
11197
11198 hashes_avail = st.st_size / sizeof (hccap_t);
11199 }
11200 else
11201 {
11202 hashes_avail = 1;
11203 }
11204 }
11205 else if (hashlist_mode == HL_MODE_FILE)
11206 {
11207 char *hashfile = myargv[optind];
11208
11209 data.hashfile = hashfile;
11210
11211 logfile_top_var_string ("target", hashfile);
11212
11213 FILE *fp = NULL;
11214
11215 if ((fp = fopen (hashfile, "rb")) == NULL)
11216 {
11217 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11218
11219 return (-1);
11220 }
11221
11222 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11223
11224 hashes_avail = count_lines (fp);
11225
11226 rewind (fp);
11227
11228 if (hashes_avail == 0)
11229 {
11230 log_error ("ERROR: hashfile is empty or corrupt");
11231
11232 fclose (fp);
11233
11234 return (-1);
11235 }
11236
11237 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11238
11239 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11240 {
11241 log_error ("ERROR: remove not supported in native hashfile-format mode");
11242
11243 fclose (fp);
11244
11245 return (-1);
11246 }
11247
11248 fclose (fp);
11249 }
11250 }
11251 else
11252 {
11253 hashlist_mode = HL_MODE_ARG;
11254
11255 hashes_avail = 1;
11256 }
11257
11258 if (hash_mode == 3000) hashes_avail *= 2;
11259
11260 data.hashlist_mode = hashlist_mode;
11261 data.hashlist_format = hashlist_format;
11262
11263 logfile_top_uint (hashlist_mode);
11264 logfile_top_uint (hashlist_format);
11265
11266 /**
11267 * load hashes, part II: allocate required memory, set pointers
11268 */
11269
11270 hash_t *hashes_buf = NULL;
11271 void *digests_buf = NULL;
11272 salt_t *salts_buf = NULL;
11273 void *esalts_buf = NULL;
11274
11275 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11276
11277 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11278
11279 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11280 {
11281 u32 hash_pos;
11282
11283 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11284 {
11285 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11286
11287 hashes_buf[hash_pos].hash_info = hash_info;
11288
11289 if (username && (remove || show || left))
11290 {
11291 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11292 }
11293
11294 if (benchmark)
11295 {
11296 hash_info->orighash = (char *) mymalloc (256);
11297 }
11298 }
11299 }
11300
11301 if (isSalted)
11302 {
11303 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11304
11305 if (esalt_size)
11306 {
11307 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11308 }
11309 }
11310 else
11311 {
11312 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11313 }
11314
11315 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11316 {
11317 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11318
11319 if (isSalted)
11320 {
11321 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11322
11323 if (esalt_size)
11324 {
11325 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11326 }
11327 }
11328 else
11329 {
11330 hashes_buf[hash_pos].salt = &salts_buf[0];
11331 }
11332 }
11333
11334 /**
11335 * load hashes, part III: parse hashes or generate them if benchmark
11336 */
11337
11338 uint hashes_cnt = 0;
11339
11340 if (benchmark == 0)
11341 {
11342 if (keyspace == 1)
11343 {
11344 // useless to read hash file for keyspace, cheat a little bit w/ optind
11345 }
11346 else if (hashes_avail == 0)
11347 {
11348 }
11349 else if (hashlist_mode == HL_MODE_ARG)
11350 {
11351 char *input_buf = myargv[optind];
11352
11353 uint input_len = strlen (input_buf);
11354
11355 logfile_top_var_string ("target", input_buf);
11356
11357 char *hash_buf = NULL;
11358 int hash_len = 0;
11359
11360 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11361
11362 bool hash_fmt_error = 0;
11363
11364 if (hash_len < 1) hash_fmt_error = 1;
11365 if (hash_buf == NULL) hash_fmt_error = 1;
11366
11367 if (hash_fmt_error)
11368 {
11369 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11370 }
11371 else
11372 {
11373 if (opts_type & OPTS_TYPE_HASH_COPY)
11374 {
11375 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11376
11377 hash_info_tmp->orighash = mystrdup (hash_buf);
11378 }
11379
11380 if (isSalted)
11381 {
11382 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11383 }
11384
11385 int parser_status = PARSER_OK;
11386
11387 if (hash_mode == 2500)
11388 {
11389 if (hash_len == 0)
11390 {
11391 log_error ("ERROR: hccap file not specified");
11392
11393 return (-1);
11394 }
11395
11396 hashlist_mode = HL_MODE_FILE;
11397
11398 data.hashlist_mode = hashlist_mode;
11399
11400 FILE *fp = fopen (hash_buf, "rb");
11401
11402 if (fp == NULL)
11403 {
11404 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11405
11406 return (-1);
11407 }
11408
11409 if (hashes_avail < 1)
11410 {
11411 log_error ("ERROR: hccap file is empty or corrupt");
11412
11413 fclose (fp);
11414
11415 return (-1);
11416 }
11417
11418 uint hccap_size = sizeof (hccap_t);
11419
11420 char *in = (char *) mymalloc (hccap_size);
11421
11422 while (!feof (fp))
11423 {
11424 int n = fread (in, hccap_size, 1, fp);
11425
11426 if (n != 1)
11427 {
11428 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11429
11430 break;
11431 }
11432
11433 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11434
11435 if (parser_status != PARSER_OK)
11436 {
11437 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11438
11439 continue;
11440 }
11441
11442 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11443
11444 if ((show == 1) || (left == 1))
11445 {
11446 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11447
11448 char *salt_ptr = (char *) tmp_salt->salt_buf;
11449
11450 int cur_pos = tmp_salt->salt_len;
11451 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11452
11453 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11454
11455 // do the appending task
11456
11457 snprintf (salt_ptr + cur_pos,
11458 rem_len,
11459 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11460 wpa->orig_mac1[0],
11461 wpa->orig_mac1[1],
11462 wpa->orig_mac1[2],
11463 wpa->orig_mac1[3],
11464 wpa->orig_mac1[4],
11465 wpa->orig_mac1[5],
11466 wpa->orig_mac2[0],
11467 wpa->orig_mac2[1],
11468 wpa->orig_mac2[2],
11469 wpa->orig_mac2[3],
11470 wpa->orig_mac2[4],
11471 wpa->orig_mac2[5]);
11472
11473 // memset () the remaining part of the salt
11474
11475 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11476 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11477
11478 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11479
11480 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11481 }
11482
11483 if (show == 1) handle_show_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11484 if (left == 1) handle_left_request (pot, pot_cnt, (char *) hashes_buf[hashes_cnt].salt->salt_buf, hashes_buf[hashes_cnt].salt->salt_len, &hashes_buf[hashes_cnt], sort_by_salt_buf, out_fp);
11485
11486 hashes_cnt++;
11487 }
11488
11489 fclose (fp);
11490
11491 myfree (in);
11492 }
11493 else if (hash_mode == 3000)
11494 {
11495 if (hash_len == 32)
11496 {
11497 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11498
11499 hash_t *lm_hash_left = NULL;
11500
11501 if (parser_status == PARSER_OK)
11502 {
11503 lm_hash_left = &hashes_buf[hashes_cnt];
11504
11505 hashes_cnt++;
11506 }
11507 else
11508 {
11509 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11510 }
11511
11512 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11513
11514 hash_t *lm_hash_right = NULL;
11515
11516 if (parser_status == PARSER_OK)
11517 {
11518 lm_hash_right = &hashes_buf[hashes_cnt];
11519
11520 hashes_cnt++;
11521 }
11522 else
11523 {
11524 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11525 }
11526
11527 // show / left
11528
11529 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11530 {
11531 if (show == 1) handle_show_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11532 if (left == 1) handle_left_request_lm (pot, pot_cnt, input_buf, input_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11533 }
11534 }
11535 else
11536 {
11537 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11538
11539 if (parser_status == PARSER_OK)
11540 {
11541 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11542 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11543 }
11544
11545 if (parser_status == PARSER_OK)
11546 {
11547 hashes_cnt++;
11548 }
11549 else
11550 {
11551 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11552 }
11553 }
11554 }
11555 else
11556 {
11557 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11558
11559 if (parser_status == PARSER_OK)
11560 {
11561 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11562 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11563 }
11564
11565 if (parser_status == PARSER_OK)
11566 {
11567 hashes_cnt++;
11568 }
11569 else
11570 {
11571 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11572 }
11573 }
11574 }
11575 }
11576 else if (hashlist_mode == HL_MODE_FILE)
11577 {
11578 char *hashfile = data.hashfile;
11579
11580 FILE *fp;
11581
11582 if ((fp = fopen (hashfile, "rb")) == NULL)
11583 {
11584 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11585
11586 return (-1);
11587 }
11588
11589 uint line_num = 0;
11590
11591 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11592
11593 while (!feof (fp))
11594 {
11595 line_num++;
11596
11597 int line_len = fgetl (fp, line_buf);
11598
11599 if (line_len == 0) continue;
11600
11601 char *hash_buf = NULL;
11602 int hash_len = 0;
11603
11604 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11605
11606 bool hash_fmt_error = 0;
11607
11608 if (hash_len < 1) hash_fmt_error = 1;
11609 if (hash_buf == NULL) hash_fmt_error = 1;
11610
11611 if (hash_fmt_error)
11612 {
11613 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11614
11615 continue;
11616 }
11617
11618 if (username)
11619 {
11620 char *user_buf = NULL;
11621 int user_len = 0;
11622
11623 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11624
11625 if (remove || show)
11626 {
11627 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11628
11629 *user = (user_t *) mymalloc (sizeof (user_t));
11630
11631 user_t *user_ptr = *user;
11632
11633 if (user_buf != NULL)
11634 {
11635 user_ptr->user_name = mystrdup (user_buf);
11636 }
11637 else
11638 {
11639 user_ptr->user_name = mystrdup ("");
11640 }
11641
11642 user_ptr->user_len = user_len;
11643 }
11644 }
11645
11646 if (opts_type & OPTS_TYPE_HASH_COPY)
11647 {
11648 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11649
11650 hash_info_tmp->orighash = mystrdup (hash_buf);
11651 }
11652
11653 if (isSalted)
11654 {
11655 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11656 }
11657
11658 if (hash_mode == 3000)
11659 {
11660 if (hash_len == 32)
11661 {
11662 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11663
11664 if (parser_status < PARSER_GLOBAL_ZERO)
11665 {
11666 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11667
11668 continue;
11669 }
11670
11671 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11672
11673 hashes_cnt++;
11674
11675 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11676
11677 if (parser_status < PARSER_GLOBAL_ZERO)
11678 {
11679 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11680
11681 continue;
11682 }
11683
11684 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11685
11686 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11687
11688 hashes_cnt++;
11689
11690 // show / left
11691
11692 if (show == 1) handle_show_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11693 if (left == 1) handle_left_request_lm (pot, pot_cnt, line_buf, line_len, lm_hash_left, lm_hash_right, sort_by_pot, out_fp);
11694 }
11695 else
11696 {
11697 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11698
11699 if (parser_status < PARSER_GLOBAL_ZERO)
11700 {
11701 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11702
11703 continue;
11704 }
11705
11706 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11707
11708 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11709 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11710
11711 hashes_cnt++;
11712 }
11713 }
11714 else
11715 {
11716 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11717
11718 if (parser_status < PARSER_GLOBAL_ZERO)
11719 {
11720 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11721
11722 continue;
11723 }
11724
11725 if (data.quiet == 0) if ((hashes_cnt % 0x20000) == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, ((float) hashes_cnt / hashes_avail) * 100);
11726
11727 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11728 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11729
11730 hashes_cnt++;
11731 }
11732 }
11733
11734 myfree (line_buf);
11735
11736 fclose (fp);
11737
11738 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11739
11740 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11741 }
11742 }
11743 else
11744 {
11745 if (isSalted)
11746 {
11747 hashes_buf[0].salt->salt_len = 8;
11748
11749 // special salt handling
11750
11751 switch (hash_mode)
11752 {
11753 case 1500: hashes_buf[0].salt->salt_len = 2;
11754 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11755 break;
11756 case 1731: hashes_buf[0].salt->salt_len = 4;
11757 break;
11758 case 2410: hashes_buf[0].salt->salt_len = 4;
11759 break;
11760 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11761 break;
11762 case 3100: hashes_buf[0].salt->salt_len = 1;
11763 break;
11764 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11765 break;
11766 case 5800: hashes_buf[0].salt->salt_len = 16;
11767 break;
11768 case 6800: hashes_buf[0].salt->salt_len = 32;
11769 break;
11770 case 8400: hashes_buf[0].salt->salt_len = 40;
11771 break;
11772 case 8800: hashes_buf[0].salt->salt_len = 16;
11773 break;
11774 case 8900: hashes_buf[0].salt->salt_len = 16;
11775 hashes_buf[0].salt->scrypt_N = 1024;
11776 hashes_buf[0].salt->scrypt_r = 1;
11777 hashes_buf[0].salt->scrypt_p = 1;
11778 break;
11779 case 9100: hashes_buf[0].salt->salt_len = 16;
11780 break;
11781 case 9300: hashes_buf[0].salt->salt_len = 14;
11782 hashes_buf[0].salt->scrypt_N = 16384;
11783 hashes_buf[0].salt->scrypt_r = 1;
11784 hashes_buf[0].salt->scrypt_p = 1;
11785 break;
11786 case 9400: hashes_buf[0].salt->salt_len = 16;
11787 break;
11788 case 9500: hashes_buf[0].salt->salt_len = 16;
11789 break;
11790 case 9600: hashes_buf[0].salt->salt_len = 16;
11791 break;
11792 case 9700: hashes_buf[0].salt->salt_len = 16;
11793 break;
11794 case 9710: hashes_buf[0].salt->salt_len = 16;
11795 break;
11796 case 9720: hashes_buf[0].salt->salt_len = 16;
11797 break;
11798 case 9800: hashes_buf[0].salt->salt_len = 16;
11799 break;
11800 case 9810: hashes_buf[0].salt->salt_len = 16;
11801 break;
11802 case 9820: hashes_buf[0].salt->salt_len = 16;
11803 break;
11804 case 10300: hashes_buf[0].salt->salt_len = 12;
11805 break;
11806 case 11500: hashes_buf[0].salt->salt_len = 4;
11807 break;
11808 case 11600: hashes_buf[0].salt->salt_len = 4;
11809 break;
11810 case 12400: hashes_buf[0].salt->salt_len = 4;
11811 break;
11812 case 12500: hashes_buf[0].salt->salt_len = 8;
11813 break;
11814 case 12600: hashes_buf[0].salt->salt_len = 64;
11815 break;
11816 }
11817
11818 // special esalt handling
11819
11820 switch (hash_mode)
11821 {
11822 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11823 break;
11824 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11825 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11826 break;
11827 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11828 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11829 break;
11830 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11831 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11832 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11833 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11834 break;
11835 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11836 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11837 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11838 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11839 break;
11840 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11841 break;
11842 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11843 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11844 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11845 break;
11846 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11847 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11848 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11849 break;
11850 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11851 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11852 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11853 break;
11854 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11855 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11856 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11857 break;
11858 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11859 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11860 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11861 break;
11862 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11863 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11864 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11865 break;
11866 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11867 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11868 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11869 break;
11870 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11871 break;
11872 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11873 break;
11874 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11875 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11876 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11877 break;
11878 }
11879 }
11880
11881 // set hashfile
11882
11883 switch (hash_mode)
11884 {
11885 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11886 break;
11887 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11888 break;
11889 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11890 break;
11891 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11892 break;
11893 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11894 break;
11895 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11896 break;
11897 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11898 break;
11899 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11900 break;
11901 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11902 break;
11903 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11904 break;
11905 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11906 break;
11907 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11908 break;
11909 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11910 break;
11911 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11912 break;
11913 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11914 break;
11915 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11916 break;
11917 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11918 break;
11919 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11920 break;
11921 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11924 break;
11925 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11926 break;
11927 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11928 break;
11929 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11930 break;
11931 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11932 break;
11933 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11934 break;
11935 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11936 break;
11937 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11938 break;
11939 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11940 break;
11941 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11942 break;
11943 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11944 break;
11945 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11946 break;
11947 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11948 break;
11949 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11950 break;
11951 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11952 break;
11953 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11954 break;
11955 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11956 break;
11957 }
11958
11959 // set default iterations
11960
11961 switch (hash_mode)
11962 {
11963 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11964 break;
11965 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11966 break;
11967 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11968 break;
11969 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11970 break;
11971 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11972 break;
11973 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11974 break;
11975 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11976 break;
11977 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11978 break;
11979 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11980 break;
11981 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11982 break;
11983 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11984 break;
11985 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11986 break;
11987 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11988 break;
11989 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11990 break;
11991 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11992 break;
11993 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11994 break;
11995 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11996 break;
11997 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11998 break;
11999 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12000 break;
12001 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12002 break;
12003 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12004 break;
12005 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12006 break;
12007 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12008 break;
12009 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12010 break;
12011 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12012 break;
12013 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12014 break;
12015 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12016 break;
12017 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12018 break;
12019 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12020 break;
12021 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12022 break;
12023 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12024 break;
12025 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12026 break;
12027 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12028 break;
12029 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12030 break;
12031 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12032 break;
12033 case 8900: hashes_buf[0].salt->salt_iter = 1;
12034 break;
12035 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12036 break;
12037 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12038 break;
12039 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12040 break;
12041 case 9300: hashes_buf[0].salt->salt_iter = 1;
12042 break;
12043 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12044 break;
12045 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12046 break;
12047 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12048 break;
12049 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12050 break;
12051 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12052 break;
12053 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12054 break;
12055 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12056 break;
12057 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12058 break;
12059 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12060 break;
12061 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12062 break;
12063 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12064 break;
12065 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12066 break;
12067 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12068 break;
12069 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12070 break;
12071 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12072 break;
12073 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12074 break;
12075 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12076 break;
12077 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12078 break;
12079 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12080 break;
12081 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12082 break;
12083 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12084 break;
12085 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12086 break;
12087 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12088 break;
12089 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12090 break;
12091 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12092 break;
12093 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12094 break;
12095 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12096 break;
12097 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12098 break;
12099 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12100 break;
12101 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12102 break;
12103 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12104 break;
12105 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12106 break;
12107 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12108 break;
12109 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12110 break;
12111 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12112 break;
12113 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12114 break;
12115 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12116 break;
12117 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12118 break;
12119 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12120 break;
12121 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12122 break;
12123 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12124 break;
12125 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12126 break;
12127 }
12128
12129 hashes_cnt = 1;
12130 }
12131
12132 if (show == 1 || left == 1)
12133 {
12134 for (uint i = 0; i < pot_cnt; i++)
12135 {
12136 pot_t *pot_ptr = &pot[i];
12137
12138 hash_t *hashes_buf = &pot_ptr->hash;
12139
12140 local_free (hashes_buf->digest);
12141
12142 if (isSalted)
12143 {
12144 local_free (hashes_buf->salt);
12145 }
12146 }
12147
12148 local_free (pot);
12149
12150 if (data.quiet == 0) log_info_nn ("");
12151
12152 return (0);
12153 }
12154
12155 if (keyspace == 0)
12156 {
12157 if (hashes_cnt == 0)
12158 {
12159 log_error ("ERROR: No hashes loaded");
12160
12161 return (-1);
12162 }
12163 }
12164
12165 /**
12166 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12167 */
12168
12169 if (data.outfile != NULL)
12170 {
12171 if (data.hashfile != NULL)
12172 {
12173 #ifdef _POSIX
12174 struct stat tmpstat_outfile;
12175 struct stat tmpstat_hashfile;
12176 #endif
12177
12178 #ifdef _WIN
12179 struct stat64 tmpstat_outfile;
12180 struct stat64 tmpstat_hashfile;
12181 #endif
12182
12183 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12184
12185 if (tmp_outfile_fp)
12186 {
12187 #ifdef _POSIX
12188 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12189 #endif
12190
12191 #ifdef _WIN
12192 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12193 #endif
12194
12195 fclose (tmp_outfile_fp);
12196 }
12197
12198 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12199
12200 if (tmp_hashfile_fp)
12201 {
12202 #ifdef _POSIX
12203 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12204 #endif
12205
12206 #ifdef _WIN
12207 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12208 #endif
12209
12210 fclose (tmp_hashfile_fp);
12211 }
12212
12213 if (tmp_outfile_fp && tmp_outfile_fp)
12214 {
12215 tmpstat_outfile.st_mode = 0;
12216 tmpstat_outfile.st_nlink = 0;
12217 tmpstat_outfile.st_uid = 0;
12218 tmpstat_outfile.st_gid = 0;
12219 tmpstat_outfile.st_rdev = 0;
12220 tmpstat_outfile.st_atime = 0;
12221
12222 tmpstat_hashfile.st_mode = 0;
12223 tmpstat_hashfile.st_nlink = 0;
12224 tmpstat_hashfile.st_uid = 0;
12225 tmpstat_hashfile.st_gid = 0;
12226 tmpstat_hashfile.st_rdev = 0;
12227 tmpstat_hashfile.st_atime = 0;
12228
12229 #ifdef _POSIX
12230 tmpstat_outfile.st_blksize = 0;
12231 tmpstat_outfile.st_blocks = 0;
12232
12233 tmpstat_hashfile.st_blksize = 0;
12234 tmpstat_hashfile.st_blocks = 0;
12235 #endif
12236
12237 #ifdef _POSIX
12238 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12239 {
12240 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12241
12242 return (-1);
12243 }
12244 #endif
12245
12246 #ifdef _WIN
12247 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12248 {
12249 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12250
12251 return (-1);
12252 }
12253 #endif
12254 }
12255 }
12256 }
12257
12258 /**
12259 * Remove duplicates
12260 */
12261
12262 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12263
12264 if (isSalted)
12265 {
12266 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12267 }
12268 else
12269 {
12270 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12271 }
12272
12273 uint hashes_cnt_orig = hashes_cnt;
12274
12275 hashes_cnt = 1;
12276
12277 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12278 {
12279 if (isSalted)
12280 {
12281 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12282 {
12283 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12284 }
12285 }
12286 else
12287 {
12288 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12289 }
12290
12291 if (hashes_pos > hashes_cnt)
12292 {
12293 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12294 }
12295
12296 hashes_cnt++;
12297 }
12298
12299 /**
12300 * Potfile removes
12301 */
12302
12303 uint potfile_remove_cracks = 0;
12304
12305 if (potfile_disable == 0)
12306 {
12307 hash_t hash_buf;
12308
12309 hash_buf.digest = mymalloc (dgst_size);
12310 hash_buf.salt = NULL;
12311 hash_buf.esalt = NULL;
12312 hash_buf.hash_info = NULL;
12313 hash_buf.cracked = 0;
12314
12315 if (isSalted)
12316 {
12317 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12318 }
12319
12320 if (esalt_size)
12321 {
12322 hash_buf.esalt = mymalloc (esalt_size);
12323 }
12324
12325 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12326
12327 // no solution for these special hash types (for instane because they use hashfile in output etc)
12328 if ((hash_mode != 5200) &&
12329 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12330 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12331 (hash_mode != 9000))
12332 {
12333 FILE *fp = fopen (potfile, "rb");
12334
12335 if (fp != NULL)
12336 {
12337 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12338
12339 // to be safe work with a copy (because of line_len loop, i etc)
12340 // moved up here because it's easier to handle continue case
12341 // it's just 64kb
12342
12343 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12344
12345 while (!feof (fp))
12346 {
12347 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12348
12349 if (ptr == NULL) break;
12350
12351 int line_len = strlen (line_buf);
12352
12353 if (line_len == 0) continue;
12354
12355 int iter = MAX_CUT_TRIES;
12356
12357 for (int i = line_len - 1; i && iter; i--, line_len--)
12358 {
12359 if (line_buf[i] != ':') continue;
12360
12361 if (isSalted)
12362 {
12363 memset (hash_buf.salt, 0, sizeof (salt_t));
12364 }
12365
12366 hash_t *found = NULL;
12367
12368 if (hash_mode == 6800)
12369 {
12370 if (i < 64) // 64 = 16 * uint in salt_buf[]
12371 {
12372 // manipulate salt_buf
12373 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12374
12375 hash_buf.salt->salt_len = i;
12376
12377 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12378 }
12379 }
12380 else if (hash_mode == 2500)
12381 {
12382 if (i < 64) // 64 = 16 * uint in salt_buf[]
12383 {
12384 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12385 // manipulate salt_buf
12386
12387 memcpy (line_buf_cpy, line_buf, i);
12388
12389 char *mac2_pos = strrchr (line_buf_cpy, ':');
12390
12391 if (mac2_pos == NULL) continue;
12392
12393 mac2_pos[0] = 0;
12394 mac2_pos++;
12395
12396 if (strlen (mac2_pos) != 12) continue;
12397
12398 char *mac1_pos = strrchr (line_buf_cpy, ':');
12399
12400 if (mac1_pos == NULL) continue;
12401
12402 mac1_pos[0] = 0;
12403 mac1_pos++;
12404
12405 if (strlen (mac1_pos) != 12) continue;
12406
12407 uint essid_length = mac1_pos - line_buf_cpy - 1;
12408
12409 // here we need the ESSID
12410 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12411
12412 hash_buf.salt->salt_len = essid_length;
12413
12414 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12415
12416 if (found)
12417 {
12418 wpa_t *wpa = (wpa_t *) found->esalt;
12419
12420 // compare hex string(s) vs binary MAC address(es)
12421
12422 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12423 {
12424 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12425 {
12426 found = NULL;
12427
12428 break;
12429 }
12430 }
12431
12432 // early skip ;)
12433 if (!found) continue;
12434
12435 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12436 {
12437 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12438 {
12439 found = NULL;
12440
12441 break;
12442 }
12443 }
12444 }
12445 }
12446 }
12447 else
12448 {
12449 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12450
12451 if (parser_status == PARSER_OK)
12452 {
12453 if (isSalted)
12454 {
12455 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12456 }
12457 else
12458 {
12459 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12460 }
12461 }
12462 }
12463
12464 if (found == NULL) continue;
12465
12466 if (!found->cracked) potfile_remove_cracks++;
12467
12468 found->cracked = 1;
12469
12470 if (found) break;
12471
12472 iter--;
12473 }
12474 }
12475
12476 myfree (line_buf_cpy);
12477
12478 myfree (line_buf);
12479
12480 fclose (fp);
12481 }
12482 }
12483
12484 if (esalt_size)
12485 {
12486 local_free (hash_buf.esalt);
12487 }
12488
12489 if (isSalted)
12490 {
12491 local_free (hash_buf.salt);
12492 }
12493
12494 local_free (hash_buf.digest);
12495 }
12496
12497 /**
12498 * Now generate all the buffers required for later
12499 */
12500
12501 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12502
12503 salt_t *salts_buf_new = NULL;
12504 void *esalts_buf_new = NULL;
12505
12506 if (isSalted)
12507 {
12508 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12509
12510 if (esalt_size)
12511 {
12512 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12513 }
12514 }
12515 else
12516 {
12517 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12518 }
12519
12520 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12521
12522 uint digests_cnt = hashes_cnt;
12523 uint digests_done = 0;
12524
12525 size_t size_digests = digests_cnt * dgst_size;
12526 size_t size_shown = digests_cnt * sizeof (uint);
12527
12528 uint *digests_shown = (uint *) mymalloc (size_shown);
12529 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12530
12531 uint salts_cnt = 0;
12532 uint salts_done = 0;
12533
12534 hashinfo_t **hash_info = NULL;
12535
12536 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12537 {
12538 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12539
12540 if (username && (remove || show))
12541 {
12542 uint user_pos;
12543
12544 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12545 {
12546 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12547
12548 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12549 }
12550 }
12551 }
12552
12553 uint *salts_shown = (uint *) mymalloc (size_shown);
12554
12555 salt_t *salt_buf;
12556
12557 {
12558 // copied from inner loop
12559
12560 salt_buf = &salts_buf_new[salts_cnt];
12561
12562 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12563
12564 if (esalt_size)
12565 {
12566 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12567 }
12568
12569 salt_buf->digests_cnt = 0;
12570 salt_buf->digests_done = 0;
12571 salt_buf->digests_offset = 0;
12572
12573 salts_cnt++;
12574 }
12575
12576 if (hashes_buf[0].cracked == 1)
12577 {
12578 digests_shown[0] = 1;
12579
12580 digests_done++;
12581
12582 salt_buf->digests_done++;
12583 }
12584
12585 salt_buf->digests_cnt++;
12586
12587 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12588
12589 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12590 {
12591 hash_info[0] = hashes_buf[0].hash_info;
12592 }
12593
12594 // copy from inner loop
12595
12596 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12597 {
12598 if (isSalted)
12599 {
12600 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12601 {
12602 salt_buf = &salts_buf_new[salts_cnt];
12603
12604 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12605
12606 if (esalt_size)
12607 {
12608 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12609 }
12610
12611 salt_buf->digests_cnt = 0;
12612 salt_buf->digests_done = 0;
12613 salt_buf->digests_offset = hashes_pos;
12614
12615 salts_cnt++;
12616 }
12617 }
12618
12619 if (hashes_buf[hashes_pos].cracked == 1)
12620 {
12621 digests_shown[hashes_pos] = 1;
12622
12623 digests_done++;
12624
12625 salt_buf->digests_done++;
12626 }
12627
12628 salt_buf->digests_cnt++;
12629
12630 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12631
12632 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12633 {
12634 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12635 }
12636 }
12637
12638 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12639 {
12640 salt_t *salt_buf = &salts_buf_new[salt_pos];
12641
12642 if (salt_buf->digests_done == salt_buf->digests_cnt)
12643 {
12644 salts_shown[salt_pos] = 1;
12645
12646 salts_done++;
12647 }
12648
12649 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12650 }
12651
12652 local_free (digests_buf);
12653 local_free (salts_buf);
12654 local_free (esalts_buf);
12655
12656 digests_buf = digests_buf_new;
12657 salts_buf = salts_buf_new;
12658 esalts_buf = esalts_buf_new;
12659
12660 local_free (hashes_buf);
12661
12662 /**
12663 * special modification not set from parser
12664 */
12665
12666 switch (hash_mode)
12667 {
12668 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12669 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12670 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12671 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12672 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12673 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12674 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12675 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12676 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12677 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12678 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12679 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12680 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12681 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12682 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12683 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12684 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12685 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12686 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12687 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12688 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12689 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12690 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12691 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12692 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12693 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12694 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12695 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12696 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12697 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12698 }
12699
12700 if (truecrypt_keyfiles)
12701 {
12702 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12703
12704 char *keyfiles = strdup (truecrypt_keyfiles);
12705
12706 char *keyfile = strtok (keyfiles, ",");
12707
12708 do
12709 {
12710 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12711
12712 } while ((keyfile = strtok (NULL, ",")) != NULL);
12713
12714 free (keyfiles);
12715 }
12716
12717 if (veracrypt_keyfiles)
12718 {
12719 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12720
12721 char *keyfiles = strdup (veracrypt_keyfiles);
12722
12723 char *keyfile = strtok (keyfiles, ",");
12724
12725 do
12726 {
12727 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12728
12729 } while ((keyfile = strtok (NULL, ",")) != NULL);
12730
12731 free (keyfiles);
12732 }
12733
12734 data.digests_cnt = digests_cnt;
12735 data.digests_done = digests_done;
12736 data.digests_buf = digests_buf;
12737 data.digests_shown = digests_shown;
12738 data.digests_shown_tmp = digests_shown_tmp;
12739
12740 data.salts_cnt = salts_cnt;
12741 data.salts_done = salts_done;
12742 data.salts_buf = salts_buf;
12743 data.salts_shown = salts_shown;
12744
12745 data.esalts_buf = esalts_buf;
12746 data.hash_info = hash_info;
12747
12748 /**
12749 * Automatic Optimizers
12750 */
12751
12752 if (salts_cnt == 1)
12753 opti_type |= OPTI_TYPE_SINGLE_SALT;
12754
12755 if (digests_cnt == 1)
12756 opti_type |= OPTI_TYPE_SINGLE_HASH;
12757
12758 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12759 opti_type |= OPTI_TYPE_NOT_ITERATED;
12760
12761 if (attack_mode == ATTACK_MODE_BF)
12762 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12763
12764 data.opti_type = opti_type;
12765
12766 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12767 {
12768 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12769 {
12770 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12771 {
12772 if (opts_type & OPTS_TYPE_ST_ADD80)
12773 {
12774 opts_type &= ~OPTS_TYPE_ST_ADD80;
12775 opts_type |= OPTS_TYPE_PT_ADD80;
12776 }
12777
12778 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12779 {
12780 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12781 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12782 }
12783
12784 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12785 {
12786 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12787 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12788 }
12789 }
12790 }
12791 }
12792
12793 /**
12794 * Some algorithm, like descrypt, can benefit from JIT compilation
12795 */
12796
12797 int force_jit_compilation = -1;
12798
12799 if (hash_mode == 8900)
12800 {
12801 force_jit_compilation = 8900;
12802 }
12803 else if (hash_mode == 9300)
12804 {
12805 force_jit_compilation = 8900;
12806 }
12807 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12808 {
12809 force_jit_compilation = 1500;
12810 }
12811
12812 /**
12813 * generate bitmap tables
12814 */
12815
12816 const uint bitmap_shift1 = 5;
12817 const uint bitmap_shift2 = 13;
12818
12819 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12820
12821 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12822 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12823 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12824 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12825 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12826 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12827 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12828 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12829
12830 uint bitmap_bits;
12831 uint bitmap_nums;
12832 uint bitmap_mask;
12833 uint bitmap_size;
12834
12835 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12836 {
12837 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12838
12839 bitmap_nums = 1 << bitmap_bits;
12840
12841 bitmap_mask = bitmap_nums - 1;
12842
12843 bitmap_size = bitmap_nums * sizeof (uint);
12844
12845 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12846
12847 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12848 if (generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, digests_cnt / 2) == 0x7fffffff) continue;
12849
12850 break;
12851 }
12852
12853 bitmap_nums = 1 << bitmap_bits;
12854
12855 bitmap_mask = bitmap_nums - 1;
12856
12857 bitmap_size = bitmap_nums * sizeof (uint);
12858
12859 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift1, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
12860 generate_bitmaps (digests_cnt, dgst_size, bitmap_shift2, (char *) data.digests_buf, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
12861
12862 /**
12863 * prepare quick rule
12864 */
12865
12866 data.rule_buf_l = rule_buf_l;
12867 data.rule_buf_r = rule_buf_r;
12868
12869 int rule_len_l = (int) strlen (rule_buf_l);
12870 int rule_len_r = (int) strlen (rule_buf_r);
12871
12872 data.rule_len_l = rule_len_l;
12873 data.rule_len_r = rule_len_r;
12874
12875 /**
12876 * load rules
12877 */
12878
12879 uint *all_kernel_rules_cnt = NULL;
12880
12881 kernel_rule_t **all_kernel_rules_buf = NULL;
12882
12883 if (rp_files_cnt)
12884 {
12885 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12886
12887 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12888 }
12889
12890 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12891
12892 int rule_len = 0;
12893
12894 for (uint i = 0; i < rp_files_cnt; i++)
12895 {
12896 uint kernel_rules_avail = 0;
12897
12898 uint kernel_rules_cnt = 0;
12899
12900 kernel_rule_t *kernel_rules_buf = NULL;
12901
12902 char *rp_file = rp_files[i];
12903
12904 char in[BLOCK_SIZE] = { 0 };
12905 char out[BLOCK_SIZE] = { 0 };
12906
12907 FILE *fp = NULL;
12908
12909 uint rule_line = 0;
12910
12911 if ((fp = fopen (rp_file, "rb")) == NULL)
12912 {
12913 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12914
12915 return (-1);
12916 }
12917
12918 while (!feof (fp))
12919 {
12920 memset (rule_buf, 0, HCBUFSIZ);
12921
12922 rule_len = fgetl (fp, rule_buf);
12923
12924 rule_line++;
12925
12926 if (rule_len == 0) continue;
12927
12928 if (rule_buf[0] == '#') continue;
12929
12930 if (kernel_rules_avail == kernel_rules_cnt)
12931 {
12932 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12933
12934 kernel_rules_avail += INCR_RULES;
12935 }
12936
12937 memset (in, 0, BLOCK_SIZE);
12938 memset (out, 0, BLOCK_SIZE);
12939
12940 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12941
12942 if (result == -1)
12943 {
12944 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12945
12946 continue;
12947 }
12948
12949 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12950 {
12951 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12952
12953 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12954
12955 continue;
12956 }
12957
12958 /* its so slow
12959 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12960 {
12961 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12962
12963 continue;
12964 }
12965 */
12966
12967 kernel_rules_cnt++;
12968 }
12969
12970 fclose (fp);
12971
12972 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12973
12974 all_kernel_rules_buf[i] = kernel_rules_buf;
12975 }
12976
12977 /**
12978 * merge rules or automatic rule generator
12979 */
12980
12981 uint kernel_rules_cnt = 0;
12982
12983 kernel_rule_t *kernel_rules_buf = NULL;
12984
12985 if (attack_mode == ATTACK_MODE_STRAIGHT)
12986 {
12987 if (rp_files_cnt)
12988 {
12989 kernel_rules_cnt = 1;
12990
12991 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12992
12993 repeats[0] = kernel_rules_cnt;
12994
12995 for (uint i = 0; i < rp_files_cnt; i++)
12996 {
12997 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12998
12999 repeats[i + 1] = kernel_rules_cnt;
13000 }
13001
13002 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13003
13004 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13005
13006 for (uint i = 0; i < kernel_rules_cnt; i++)
13007 {
13008 uint out_pos = 0;
13009
13010 kernel_rule_t *out = &kernel_rules_buf[i];
13011
13012 for (uint j = 0; j < rp_files_cnt; j++)
13013 {
13014 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13015 uint in_pos;
13016
13017 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13018
13019 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13020 {
13021 if (out_pos == RULES_MAX - 1)
13022 {
13023 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13024
13025 break;
13026 }
13027
13028 out->cmds[out_pos] = in->cmds[in_pos];
13029 }
13030 }
13031 }
13032
13033 local_free (repeats);
13034 }
13035 else if (rp_gen)
13036 {
13037 uint kernel_rules_avail = 0;
13038
13039 while (kernel_rules_cnt < rp_gen)
13040 {
13041 if (kernel_rules_avail == kernel_rules_cnt)
13042 {
13043 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13044
13045 kernel_rules_avail += INCR_RULES;
13046 }
13047
13048 memset (rule_buf, 0, HCBUFSIZ);
13049
13050 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13051
13052 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13053
13054 kernel_rules_cnt++;
13055 }
13056 }
13057 }
13058
13059 myfree (rule_buf);
13060
13061 /**
13062 * generate NOP rules
13063 */
13064
13065 if (kernel_rules_cnt == 0)
13066 {
13067 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13068
13069 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13070
13071 kernel_rules_cnt++;
13072 }
13073
13074 data.kernel_rules_cnt = kernel_rules_cnt;
13075 data.kernel_rules_buf = kernel_rules_buf;
13076
13077 /**
13078 * OpenCL platforms: detect
13079 */
13080
13081 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13082 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13083
13084 cl_uint platforms_cnt = 0;
13085 cl_uint platform_devices_cnt = 0;
13086
13087 if (keyspace == 0)
13088 {
13089 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13090
13091 if (platforms_cnt == 0)
13092 {
13093 log_info ("");
13094 log_info ("ATTENTION! No OpenCL compatible platform found");
13095 log_info ("");
13096 log_info ("You're probably missing the OpenCL runtime installation");
13097 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13098 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13099 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13100 log_info ("");
13101
13102 return (-1);
13103 }
13104
13105 if (opencl_platforms_filter != (uint) -1)
13106 {
13107 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13108
13109 if (opencl_platforms_filter > platform_cnt_mask)
13110 {
13111 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13112
13113 return (-1);
13114 }
13115 }
13116 }
13117
13118 /**
13119 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13120 */
13121
13122 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13123 {
13124 cl_platform_id platform = platforms[platform_id];
13125
13126 char platform_vendor[INFOSZ] = { 0 };
13127
13128 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13129
13130 #ifdef HAVE_HWMON
13131 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13132 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13133 {
13134 // make sure that we do not directly control the fan for NVidia
13135
13136 gpu_temp_retain = 0;
13137
13138 data.gpu_temp_retain = gpu_temp_retain;
13139 }
13140 #endif // HAVE_NVML || HAVE_NVAPI
13141 #endif
13142 }
13143
13144 /**
13145 * OpenCL device types:
13146 * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
13147 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13148 */
13149
13150 if (opencl_device_types == NULL)
13151 {
13152 cl_device_type device_types_all = 0;
13153
13154 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13155 {
13156 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13157
13158 cl_platform_id platform = platforms[platform_id];
13159
13160 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13161
13162 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13163 {
13164 cl_device_id device = platform_devices[platform_devices_id];
13165
13166 cl_device_type device_type;
13167
13168 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13169
13170 device_types_all |= device_type;
13171 }
13172 }
13173
13174 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13175 {
13176 device_types_filter |= CL_DEVICE_TYPE_CPU;
13177 }
13178 }
13179
13180 /**
13181 * OpenCL devices: simply push all devices from all platforms into the same device array
13182 */
13183
13184 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13185
13186 data.devices_param = devices_param;
13187
13188 uint devices_cnt = 0;
13189
13190 uint devices_active = 0;
13191
13192 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13193 {
13194 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13195
13196 cl_platform_id platform = platforms[platform_id];
13197
13198 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13199
13200 char platform_vendor[INFOSZ] = { 0 };
13201
13202 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13203
13204 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13205 // this causes trouble with vendor id based macros
13206 // we'll assign generic to those without special optimization available
13207
13208 cl_uint vendor_id = 0;
13209
13210 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13211 {
13212 vendor_id = VENDOR_ID_AMD;
13213 }
13214 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13215 {
13216 vendor_id = VENDOR_ID_APPLE;
13217 }
13218 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13219 {
13220 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13221 }
13222 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13223 {
13224 vendor_id = VENDOR_ID_INTEL_SDK;
13225 }
13226 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13227 {
13228 vendor_id = VENDOR_ID_MESA;
13229 }
13230 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13231 {
13232 vendor_id = VENDOR_ID_NV;
13233 }
13234 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13235 {
13236 vendor_id = VENDOR_ID_POCL;
13237 }
13238 else
13239 {
13240 vendor_id = VENDOR_ID_GENERIC;
13241 }
13242
13243 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13244 {
13245 size_t param_value_size = 0;
13246
13247 const uint device_id = devices_cnt;
13248
13249 hc_device_param_t *device_param = &data.devices_param[device_id];
13250
13251 device_param->vendor_id = vendor_id;
13252
13253 device_param->device = platform_devices[platform_devices_id];
13254
13255 device_param->device_id = device_id;
13256
13257 device_param->platform_devices_id = platform_devices_id;
13258
13259 // device_type
13260
13261 cl_device_type device_type;
13262
13263 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13264
13265 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13266
13267 device_param->device_type = device_type;
13268
13269 // device_name
13270
13271 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13272
13273 char *device_name = (char *) mymalloc (param_value_size);
13274
13275 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13276
13277 device_param->device_name = device_name;
13278
13279 // tuning db
13280
13281 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13282
13283 // device_version
13284
13285 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13286
13287 char *device_version = (char *) mymalloc (param_value_size);
13288
13289 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13290
13291 device_param->device_version = device_version;
13292
13293 // device_opencl_version
13294
13295 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13296
13297 char *device_opencl_version = (char *) mymalloc (param_value_size);
13298
13299 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13300
13301 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13302
13303 myfree (device_opencl_version);
13304
13305 // vector_width
13306
13307 cl_uint vector_width;
13308
13309 if (opencl_vector_width_chgd == 0)
13310 {
13311 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13312 {
13313 if (opti_type & OPTI_TYPE_USES_BITS_64)
13314 {
13315 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13316 }
13317 else
13318 {
13319 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13320 }
13321 }
13322 else
13323 {
13324 vector_width = (cl_uint) tuningdb_entry->vector_width;
13325 }
13326 }
13327 else
13328 {
13329 vector_width = opencl_vector_width;
13330 }
13331
13332 if (vector_width > 16) vector_width = 16;
13333
13334 device_param->vector_width = vector_width;
13335
13336 // max_compute_units
13337
13338 cl_uint device_processors;
13339
13340 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13341
13342 device_param->device_processors = device_processors;
13343
13344 // device_maxmem_alloc
13345 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13346
13347 cl_ulong device_maxmem_alloc;
13348
13349 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13350
13351 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13352
13353 // device_global_mem
13354
13355 cl_ulong device_global_mem;
13356
13357 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13358
13359 device_param->device_global_mem = device_global_mem;
13360
13361 // max_work_group_size
13362
13363 size_t device_maxworkgroup_size;
13364
13365 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13366
13367 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13368
13369 // max_clock_frequency
13370
13371 cl_uint device_maxclock_frequency;
13372
13373 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13374
13375 device_param->device_maxclock_frequency = device_maxclock_frequency;
13376
13377 // device_endian_little
13378
13379 cl_bool device_endian_little;
13380
13381 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13382
13383 if (device_endian_little == CL_FALSE)
13384 {
13385 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13386
13387 device_param->skipped = 1;
13388 }
13389
13390 // device_available
13391
13392 cl_bool device_available;
13393
13394 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13395
13396 if (device_available == CL_FALSE)
13397 {
13398 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13399
13400 device_param->skipped = 1;
13401 }
13402
13403 // device_compiler_available
13404
13405 cl_bool device_compiler_available;
13406
13407 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13408
13409 if (device_compiler_available == CL_FALSE)
13410 {
13411 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13412
13413 device_param->skipped = 1;
13414 }
13415
13416 // device_execution_capabilities
13417
13418 cl_device_exec_capabilities device_execution_capabilities;
13419
13420 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13421
13422 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13423 {
13424 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13425
13426 device_param->skipped = 1;
13427 }
13428
13429 // device_extensions
13430
13431 size_t device_extensions_size;
13432
13433 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13434
13435 char *device_extensions = mymalloc (device_extensions_size + 1);
13436
13437 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13438
13439 if (strstr (device_extensions, "base_atomics") == 0)
13440 {
13441 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13442
13443 device_param->skipped = 1;
13444 }
13445
13446 if (strstr (device_extensions, "byte_addressable_store") == 0)
13447 {
13448 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13449
13450 device_param->skipped = 1;
13451 }
13452
13453 myfree (device_extensions);
13454
13455 // device_local_mem_size
13456
13457 cl_ulong device_local_mem_size;
13458
13459 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13460
13461 if (device_local_mem_size < 32768)
13462 {
13463 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13464
13465 device_param->skipped = 1;
13466 }
13467
13468
13469 // skipped
13470
13471 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13472 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13473
13474 // driver_version
13475
13476 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13477
13478 char *driver_version = (char *) mymalloc (param_value_size);
13479
13480 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13481
13482 device_param->driver_version = driver_version;
13483
13484 // device_name_chksum
13485
13486 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13487
13488 #if __x86_64__
13489 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13490 #else
13491 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13492 #endif
13493
13494 uint device_name_digest[4] = { 0 };
13495
13496 md5_64 ((uint *) device_name_chksum, device_name_digest);
13497
13498 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13499
13500 device_param->device_name_chksum = device_name_chksum;
13501
13502 // device_processor_cores
13503
13504 if (device_type & CL_DEVICE_TYPE_CPU)
13505 {
13506 cl_uint device_processor_cores = 1;
13507
13508 device_param->device_processor_cores = device_processor_cores;
13509 }
13510
13511 if (device_type & CL_DEVICE_TYPE_GPU)
13512 {
13513 if (vendor_id == VENDOR_ID_AMD)
13514 {
13515 cl_uint device_processor_cores = 0;
13516
13517 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13518
13519 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13520
13521 device_param->device_processor_cores = device_processor_cores;
13522 }
13523 else if (vendor_id == VENDOR_ID_NV)
13524 {
13525 cl_uint kernel_exec_timeout = 0;
13526
13527 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13528
13529 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13530
13531 device_param->kernel_exec_timeout = kernel_exec_timeout;
13532
13533 cl_uint device_processor_cores = 0;
13534
13535 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13536
13537 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13538
13539 device_param->device_processor_cores = device_processor_cores;
13540
13541 cl_uint sm_minor = 0;
13542 cl_uint sm_major = 0;
13543
13544 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13545 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13546
13547 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13548 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13549
13550 device_param->sm_minor = sm_minor;
13551 device_param->sm_major = sm_major;
13552 }
13553 else
13554 {
13555 cl_uint device_processor_cores = 1;
13556
13557 device_param->device_processor_cores = device_processor_cores;
13558 }
13559 }
13560
13561 // display results
13562
13563 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13564 {
13565 if (status_automat == 0)
13566 {
13567 if (device_param->skipped == 0)
13568 {
13569 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13570 device_id + 1,
13571 device_name,
13572 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13573 (unsigned int) (device_global_mem / 1024 / 1024),
13574 (unsigned int) (device_maxclock_frequency),
13575 (unsigned int) device_processors);
13576 }
13577 else
13578 {
13579 log_info ("Device #%u: %s, skipped",
13580 device_id + 1,
13581 device_name);
13582 }
13583 }
13584 }
13585
13586 // common driver check
13587
13588 if (device_param->skipped == 0)
13589 {
13590 if (device_type & CL_DEVICE_TYPE_GPU)
13591 {
13592 if (vendor_id == VENDOR_ID_AMD)
13593 {
13594 int catalyst_check = (force == 1) ? 0 : 1;
13595
13596 int catalyst_warn = 0;
13597
13598 int catalyst_broken = 0;
13599
13600 if (catalyst_check == 1)
13601 {
13602 catalyst_warn = 1;
13603
13604 // v14.9 and higher
13605 if (atoi (device_param->driver_version) >= 1573)
13606 {
13607 catalyst_warn = 0;
13608 }
13609
13610 catalyst_check = 0;
13611 }
13612
13613 if (catalyst_broken == 1)
13614 {
13615 log_info ("");
13616 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13617 log_info ("It will pass over cracked hashes and does not report them as cracked");
13618 log_info ("You are STRONGLY encouraged not to use it");
13619 log_info ("You can use --force to override this but do not post error reports if you do so");
13620 log_info ("");
13621
13622 return (-1);
13623 }
13624
13625 if (catalyst_warn == 1)
13626 {
13627 log_info ("");
13628 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13629 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13630 log_info ("See hashcat's homepage for official supported catalyst drivers");
13631 #ifdef _WIN
13632 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13633 #endif
13634 log_info ("You can use --force to override this but do not post error reports if you do so");
13635 log_info ("");
13636
13637 return (-1);
13638 }
13639 }
13640 else if (vendor_id == VENDOR_ID_NV)
13641 {
13642 if (device_param->kernel_exec_timeout != 0)
13643 {
13644 if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
13645 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13646 }
13647 }
13648 }
13649
13650 /* turns out pocl still creates segfaults (because of llvm)
13651 if (device_type & CL_DEVICE_TYPE_CPU)
13652 {
13653 if (vendor_id == VENDOR_ID_AMD)
13654 {
13655 if (force == 0)
13656 {
13657 log_info ("");
13658 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13659 log_info ("You are STRONGLY encouraged not to use it");
13660 log_info ("You can use --force to override this but do not post error reports if you do so");
13661 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13662 log_info ("");
13663
13664 return (-1);
13665 }
13666 }
13667 }
13668 */
13669
13670 /**
13671 * kernel accel and loops tuning db adjustment
13672 */
13673
13674 device_param->kernel_accel_min = 1;
13675 device_param->kernel_accel_max = 1024;
13676
13677 device_param->kernel_loops_min = 1;
13678 device_param->kernel_loops_max = 1024;
13679
13680 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13681
13682 if (tuningdb_entry)
13683 {
13684 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13685 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13686
13687 if (_kernel_accel)
13688 {
13689 device_param->kernel_accel_min = _kernel_accel;
13690 device_param->kernel_accel_max = _kernel_accel;
13691 }
13692
13693 if (_kernel_loops)
13694 {
13695 if (workload_profile == 1)
13696 {
13697 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13698 }
13699 else if (workload_profile == 2)
13700 {
13701 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13702 }
13703
13704 device_param->kernel_loops_min = _kernel_loops;
13705 device_param->kernel_loops_max = _kernel_loops;
13706 }
13707 }
13708
13709 // commandline parameters overwrite tuningdb entries
13710
13711 if (kernel_accel)
13712 {
13713 device_param->kernel_accel_min = kernel_accel;
13714 device_param->kernel_accel_max = kernel_accel;
13715 }
13716
13717 if (kernel_loops)
13718 {
13719 device_param->kernel_loops_min = kernel_loops;
13720 device_param->kernel_loops_max = kernel_loops;
13721 }
13722
13723 /**
13724 * activate device
13725 */
13726
13727 devices_active++;
13728 }
13729
13730 // next please
13731
13732 devices_cnt++;
13733 }
13734 }
13735
13736 if (keyspace == 0 && devices_active == 0)
13737 {
13738 log_error ("ERROR: No devices found/left");
13739
13740 return (-1);
13741 }
13742
13743 // 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)
13744
13745 if (devices_filter != (uint) -1)
13746 {
13747 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13748
13749 if (devices_filter > devices_cnt_mask)
13750 {
13751 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13752
13753 return (-1);
13754 }
13755 }
13756
13757 data.devices_cnt = devices_cnt;
13758
13759 data.devices_active = devices_active;
13760
13761 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13762 {
13763 if (status_automat == 0)
13764 {
13765 log_info ("");
13766 }
13767 }
13768
13769 /**
13770 * HM devices: init
13771 */
13772
13773 #ifdef HAVE_HWMON
13774 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13775 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13776 #endif
13777
13778 #ifdef HAVE_ADL
13779 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13780 #endif
13781
13782 if (gpu_temp_disable == 0)
13783 {
13784 #if defined(WIN) && defined(HAVE_NVAPI)
13785 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13786
13787 if (nvapi_init (nvapi) == 0)
13788 data.hm_nv = nvapi;
13789
13790 if (data.hm_nv)
13791 {
13792 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13793 {
13794 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13795
13796 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13797
13798 int tmp_out = 0;
13799
13800 for (int i = 0; i < tmp_in; i++)
13801 {
13802 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13803 }
13804
13805 for (int i = 0; i < tmp_out; i++)
13806 {
13807 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13808
13809 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13810
13811 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;
13812 }
13813 }
13814 }
13815 #endif // WIN && HAVE_NVAPI
13816
13817 #if defined(LINUX) && defined(HAVE_NVML)
13818 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13819
13820 if (nvml_init (nvml) == 0)
13821 data.hm_nv = nvml;
13822
13823 if (data.hm_nv)
13824 {
13825 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13826 {
13827 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13828
13829 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13830
13831 int tmp_out = 0;
13832
13833 for (int i = 0; i < tmp_in; i++)
13834 {
13835 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13836 }
13837
13838 for (int i = 0; i < tmp_out; i++)
13839 {
13840 unsigned int speed;
13841
13842 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;
13843 }
13844 }
13845 }
13846 #endif // LINUX && HAVE_NVML
13847
13848 data.hm_amd = NULL;
13849
13850 #ifdef HAVE_ADL
13851 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13852
13853 if (adl_init (adl) == 0)
13854 data.hm_amd = adl;
13855
13856 if (data.hm_amd)
13857 {
13858 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13859 {
13860 // total number of adapters
13861
13862 int hm_adapters_num;
13863
13864 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13865
13866 // adapter info
13867
13868 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13869
13870 if (lpAdapterInfo == NULL) return (-1);
13871
13872 // get a list (of ids of) valid/usable adapters
13873
13874 int num_adl_adapters = 0;
13875
13876 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13877
13878 if (num_adl_adapters > 0)
13879 {
13880 hc_thread_mutex_lock (mux_adl);
13881
13882 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13883
13884 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13885
13886 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13887 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13888
13889 hc_thread_mutex_unlock (mux_adl);
13890 }
13891
13892 myfree (valid_adl_device_list);
13893 myfree (lpAdapterInfo);
13894 }
13895 }
13896 #endif // HAVE_ADL
13897
13898 if (data.hm_amd == NULL && data.hm_nv == NULL)
13899 {
13900 gpu_temp_disable = 1;
13901 }
13902 }
13903
13904 /**
13905 * OpenCL devices: allocate buffer for device specific information
13906 */
13907
13908 #ifdef HAVE_HWMON
13909 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13910
13911 #ifdef HAVE_ADL
13912 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13913
13914 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13915 #endif // ADL
13916 #endif
13917
13918 /**
13919 * enable custom signal handler(s)
13920 */
13921
13922 if (benchmark == 0)
13923 {
13924 hc_signal (sigHandler_default);
13925 }
13926 else
13927 {
13928 hc_signal (sigHandler_benchmark);
13929 }
13930
13931 /**
13932 * User-defined GPU temp handling
13933 */
13934
13935 #ifdef HAVE_HWMON
13936 if (gpu_temp_disable == 1)
13937 {
13938 gpu_temp_abort = 0;
13939 gpu_temp_retain = 0;
13940 }
13941
13942 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13943 {
13944 if (gpu_temp_abort < gpu_temp_retain)
13945 {
13946 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13947
13948 return (-1);
13949 }
13950 }
13951
13952 data.gpu_temp_disable = gpu_temp_disable;
13953 data.gpu_temp_abort = gpu_temp_abort;
13954 data.gpu_temp_retain = gpu_temp_retain;
13955 #endif
13956
13957 /**
13958 * inform the user
13959 */
13960
13961 if (data.quiet == 0)
13962 {
13963 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13964
13965 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);
13966
13967 if (attack_mode == ATTACK_MODE_STRAIGHT)
13968 {
13969 log_info ("Rules: %u", kernel_rules_cnt);
13970 }
13971
13972 if (opti_type)
13973 {
13974 log_info ("Applicable Optimizers:");
13975
13976 for (uint i = 0; i < 32; i++)
13977 {
13978 const uint opti_bit = 1u << i;
13979
13980 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13981 }
13982 }
13983
13984 /**
13985 * Watchdog and Temperature balance
13986 */
13987
13988 #ifdef HAVE_HWMON
13989 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13990 {
13991 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13992 }
13993
13994 if (gpu_temp_abort == 0)
13995 {
13996 log_info ("Watchdog: Temperature abort trigger disabled");
13997 }
13998 else
13999 {
14000 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14001 }
14002
14003 if (gpu_temp_retain == 0)
14004 {
14005 log_info ("Watchdog: Temperature retain trigger disabled");
14006 }
14007 else
14008 {
14009 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14010 }
14011
14012 if (data.quiet == 0) log_info ("");
14013 #endif
14014 }
14015
14016 /**
14017 * HM devices: copy
14018 */
14019
14020 if (gpu_temp_disable == 0)
14021 {
14022 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14023 {
14024 hc_device_param_t *device_param = &data.devices_param[device_id];
14025
14026 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14027
14028 if (device_param->skipped) continue;
14029
14030 const uint platform_devices_id = device_param->platform_devices_id;
14031
14032 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14033 if (device_param->vendor_id == VENDOR_ID_NV)
14034 {
14035 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14036 }
14037 #endif
14038
14039 #ifdef HAVE_ADL
14040 if (device_param->vendor_id == VENDOR_ID_AMD)
14041 {
14042 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14043 }
14044 #endif
14045 }
14046 }
14047
14048 /*
14049 * Temporary fix:
14050 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14051 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14052 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14053 * Driver / ADL bug?
14054 */
14055
14056 #ifdef HAVE_ADL
14057 if (powertune_enable == 1)
14058 {
14059 hc_thread_mutex_lock (mux_adl);
14060
14061 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14062 {
14063 hc_device_param_t *device_param = &data.devices_param[device_id];
14064
14065 if (device_param->skipped) continue;
14066
14067 if (data.hm_device[device_id].od_version == 6)
14068 {
14069 // set powertune value only
14070
14071 int powertune_supported = 0;
14072
14073 int ADL_rc = 0;
14074
14075 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14076 {
14077 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14078
14079 return (-1);
14080 }
14081
14082 if (powertune_supported != 0)
14083 {
14084 // powertune set
14085 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14086
14087 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14088 {
14089 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14090
14091 return (-1);
14092 }
14093
14094 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14095 {
14096 log_error ("ERROR: Failed to set new ADL PowerControl values");
14097
14098 return (-1);
14099 }
14100 }
14101 }
14102 }
14103
14104 hc_thread_mutex_unlock (mux_adl);
14105 }
14106 #endif // HAVE_ADK
14107 #endif // HAVE_HWMON
14108
14109 #ifdef DEBUG
14110 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14111 #endif
14112
14113 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14114
14115 uint kernel_power_all = 0;
14116
14117 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14118 {
14119 /**
14120 * host buffer
14121 */
14122
14123 hc_device_param_t *device_param = &data.devices_param[device_id];
14124
14125 if (device_param->skipped) continue;
14126
14127 /**
14128 * device properties
14129 */
14130
14131 const char *device_name_chksum = device_param->device_name_chksum;
14132 const u32 device_processors = device_param->device_processors;
14133 const u32 device_processor_cores = device_param->device_processor_cores;
14134
14135 /**
14136 * create context for each device
14137 */
14138
14139 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14140
14141 /**
14142 * create command-queue
14143 */
14144
14145 // not supported with NV
14146 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14147
14148 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14149
14150 /**
14151 * kernel threads: some algorithms need a fixed kernel-threads count
14152 * because of shared memory usage or bitslice
14153 * there needs to be some upper limit, otherwise there's too much overhead
14154 */
14155
14156 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14157
14158 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14159 {
14160 kernel_threads = KERNEL_THREADS_MAX_CPU;
14161 }
14162
14163 if (hash_mode == 1500) kernel_threads = 64; // DES
14164 if (hash_mode == 3000) kernel_threads = 64; // DES
14165 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14166 if (hash_mode == 7500) kernel_threads = 64; // RC4
14167 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14168 if (hash_mode == 9700) kernel_threads = 64; // RC4
14169 if (hash_mode == 9710) kernel_threads = 64; // RC4
14170 if (hash_mode == 9800) kernel_threads = 64; // RC4
14171 if (hash_mode == 9810) kernel_threads = 64; // RC4
14172 if (hash_mode == 10400) kernel_threads = 64; // RC4
14173 if (hash_mode == 10410) kernel_threads = 64; // RC4
14174 if (hash_mode == 10500) kernel_threads = 64; // RC4
14175 if (hash_mode == 13100) kernel_threads = 64; // RC4
14176
14177 /**
14178 * create input buffers on device : calculate size of fixed memory buffers
14179 */
14180
14181 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14182 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14183
14184 device_param->size_root_css = size_root_css;
14185 device_param->size_markov_css = size_markov_css;
14186
14187 size_t size_results = sizeof (uint);
14188
14189 device_param->size_results = size_results;
14190
14191 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14192 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14193
14194 size_t size_plains = digests_cnt * sizeof (plain_t);
14195 size_t size_salts = salts_cnt * sizeof (salt_t);
14196 size_t size_esalts = salts_cnt * esalt_size;
14197
14198 device_param->size_plains = size_plains;
14199 device_param->size_digests = size_digests;
14200 device_param->size_shown = size_shown;
14201 device_param->size_salts = size_salts;
14202
14203 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14204 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14205 size_t size_tm = 32 * sizeof (bs_word_t);
14206
14207 // scryptV stuff
14208
14209 size_t size_scryptV = 1;
14210
14211 if ((hash_mode == 8900) || (hash_mode == 9300))
14212 {
14213 uint tmto_start = 0;
14214 uint tmto_stop = 10;
14215
14216 if (scrypt_tmto)
14217 {
14218 tmto_start = scrypt_tmto;
14219 }
14220 else
14221 {
14222 // in case the user did not specify the tmto manually
14223 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14224 // but set the lower end only in case the user has a device with too less memory
14225
14226 if (hash_mode == 8900)
14227 {
14228 if (device_param->vendor_id == VENDOR_ID_AMD)
14229 {
14230 tmto_start = 1;
14231 }
14232 else if (device_param->vendor_id == VENDOR_ID_NV)
14233 {
14234 tmto_start = 2;
14235 }
14236 }
14237 else if (hash_mode == 9300)
14238 {
14239 if (device_param->vendor_id == VENDOR_ID_AMD)
14240 {
14241 tmto_start = 2;
14242 }
14243 else if (device_param->vendor_id == VENDOR_ID_NV)
14244 {
14245 tmto_start = 2;
14246 }
14247 }
14248 }
14249
14250 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14251 {
14252 // TODO: in theory the following calculation needs to be done per salt, not global
14253 // we assume all hashes have the same scrypt settings
14254
14255 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14256
14257 size_scryptV /= 1 << tmto;
14258
14259 size_scryptV *= device_processors * device_processor_cores;
14260
14261 if (size_scryptV > device_param->device_maxmem_alloc)
14262 {
14263 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14264
14265 continue;
14266 }
14267
14268 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14269 {
14270 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14271 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14272 }
14273
14274 break;
14275 }
14276
14277 if (data.salts_buf[0].scrypt_phy == 0)
14278 {
14279 log_error ("ERROR: can't allocate enough device memory");
14280
14281 return -1;
14282 }
14283
14284 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14285 }
14286
14287 /**
14288 * some algorithms need a fixed kernel-loops count
14289 */
14290
14291 if (hash_mode == 1500)
14292 {
14293 const u32 kernel_loops_fixed = 1024;
14294
14295 device_param->kernel_loops_min = kernel_loops_fixed;
14296 device_param->kernel_loops_max = kernel_loops_fixed;
14297 }
14298
14299 if (hash_mode == 3000)
14300 {
14301 const u32 kernel_loops_fixed = 1024;
14302
14303 device_param->kernel_loops_min = kernel_loops_fixed;
14304 device_param->kernel_loops_max = kernel_loops_fixed;
14305 }
14306
14307 if (hash_mode == 8900)
14308 {
14309 const u32 kernel_loops_fixed = 1;
14310
14311 device_param->kernel_loops_min = kernel_loops_fixed;
14312 device_param->kernel_loops_max = kernel_loops_fixed;
14313 }
14314
14315 if (hash_mode == 9300)
14316 {
14317 const u32 kernel_loops_fixed = 1;
14318
14319 device_param->kernel_loops_min = kernel_loops_fixed;
14320 device_param->kernel_loops_max = kernel_loops_fixed;
14321 }
14322
14323 if (hash_mode == 12500)
14324 {
14325 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14326
14327 device_param->kernel_loops_min = kernel_loops_fixed;
14328 device_param->kernel_loops_max = kernel_loops_fixed;
14329 }
14330
14331 /**
14332 * some algorithms have a maximum kernel-loops count
14333 */
14334
14335 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14336 {
14337 u32 innerloop_cnt = 0;
14338
14339 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14340 {
14341 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14342 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14343 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14344 }
14345 else
14346 {
14347 innerloop_cnt = data.salts_buf[0].salt_iter;
14348 }
14349
14350 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14351 (innerloop_cnt <= device_param->kernel_loops_max))
14352 {
14353 device_param->kernel_loops_max = innerloop_cnt;
14354 }
14355 }
14356
14357 u32 kernel_accel_min = device_param->kernel_accel_min;
14358 u32 kernel_accel_max = device_param->kernel_accel_max;
14359
14360 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14361
14362 size_t size_pws = 4;
14363 size_t size_tmps = 4;
14364 size_t size_hooks = 4;
14365
14366 while (kernel_accel_max >= kernel_accel_min)
14367 {
14368 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14369
14370 // size_pws
14371
14372 size_pws = kernel_power_max * sizeof (pw_t);
14373
14374 // size_tmps
14375
14376 switch (hash_mode)
14377 {
14378 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14379 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14380 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14381 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14382 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14383 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14384 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14385 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14386 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14387 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14388 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14389 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14390 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14391 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14392 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14393 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14394 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14395 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14396 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14397 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14398 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14399 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14400 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14401 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14402 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14403 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14404 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14405 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14406 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14407 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14408 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14409 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14410 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14411 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14412 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14413 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14414 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14415 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14416 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14417 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14418 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14419 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14420 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14421 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14422 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14423 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14424 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14425 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14426 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14427 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14428 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14429 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14430 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14431 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14432 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14433 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14434 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14435 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14436 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14437 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14438 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14439 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14440 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14441 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14442 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14443 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14444 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14445 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14446 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14447 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14448 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14449 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14450 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14451 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14452 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14453 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14454 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14455 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14456 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14457 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14458 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14459 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14460 };
14461
14462 // size_hooks
14463
14464 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14465 {
14466 // none yet
14467 }
14468
14469 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14470 // if not, decrease amplifier and try again
14471
14472 int skip = 0;
14473
14474 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14475 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14476 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14477
14478 if (( bitmap_size
14479 + bitmap_size
14480 + bitmap_size
14481 + bitmap_size
14482 + bitmap_size
14483 + bitmap_size
14484 + bitmap_size
14485 + bitmap_size
14486 + size_bfs
14487 + size_combs
14488 + size_digests
14489 + size_esalts
14490 + size_hooks
14491 + size_markov_css
14492 + size_plains
14493 + size_pws
14494 + size_pws // not a bug
14495 + size_results
14496 + size_root_css
14497 + size_rules
14498 + size_rules_c
14499 + size_salts
14500 + size_scryptV
14501 + size_shown
14502 + size_tm
14503 + size_tmps) > device_param->device_global_mem) skip = 1;
14504
14505 if (skip == 1)
14506 {
14507 kernel_accel_max--;
14508
14509 continue;
14510 }
14511
14512 break;
14513 }
14514
14515 /*
14516 if (kernel_accel_max == 0)
14517 {
14518 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14519
14520 return -1;
14521 }
14522 */
14523
14524 device_param->kernel_accel_min = kernel_accel_min;
14525 device_param->kernel_accel_max = kernel_accel_max;
14526
14527 /*
14528 if (kernel_accel_max < kernel_accel)
14529 {
14530 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14531
14532 device_param->kernel_accel = kernel_accel_max;
14533 }
14534 */
14535
14536 device_param->size_bfs = size_bfs;
14537 device_param->size_combs = size_combs;
14538 device_param->size_rules = size_rules;
14539 device_param->size_rules_c = size_rules_c;
14540 device_param->size_pws = size_pws;
14541 device_param->size_tmps = size_tmps;
14542 device_param->size_hooks = size_hooks;
14543
14544 // do not confuse kernel_accel_max with kernel_accel here
14545
14546 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14547
14548 device_param->kernel_threads = kernel_threads;
14549 device_param->kernel_power_user = kernel_power;
14550
14551 kernel_power_all += kernel_power;
14552
14553 /**
14554 * default building options
14555 */
14556
14557 char build_opts[1024] = { 0 };
14558
14559 // we don't have sm_* on vendors not NV but it doesn't matter
14560
14561 #if _WIN
14562 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14563 #else
14564 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14565 #endif
14566
14567 char build_opts_new[1024] = { 0 };
14568
14569 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14570
14571 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14572
14573
14574 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14575 {
14576 // we do vectorizing much better than the auto-vectorizer
14577
14578 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14579
14580 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14581 }
14582
14583 #ifdef DEBUG
14584 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14585 #endif
14586
14587 /**
14588 * main kernel
14589 */
14590
14591 {
14592 /**
14593 * kernel source filename
14594 */
14595
14596 char source_file[256] = { 0 };
14597
14598 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14599
14600 struct stat sst;
14601
14602 if (stat (source_file, &sst) == -1)
14603 {
14604 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14605
14606 return -1;
14607 }
14608
14609 /**
14610 * kernel cached filename
14611 */
14612
14613 char cached_file[256] = { 0 };
14614
14615 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14616
14617 int cached = 1;
14618
14619 struct stat cst;
14620
14621 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14622 {
14623 cached = 0;
14624 }
14625
14626 /**
14627 * kernel compile or load
14628 */
14629
14630 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14631
14632 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14633
14634 if (force_jit_compilation == -1)
14635 {
14636 if (cached == 0)
14637 {
14638 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14639
14640 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14641
14642 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14643
14644 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14645
14646 #ifdef DEBUG
14647 size_t build_log_size = 0;
14648
14649 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14650
14651 if (build_log_size > 1)
14652 {
14653 char *build_log = (char *) malloc (build_log_size + 1);
14654
14655 memset (build_log, 0, build_log_size + 1);
14656
14657 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14658
14659 puts (build_log);
14660
14661 free (build_log);
14662 }
14663 #endif
14664
14665 if (rc != 0)
14666 {
14667 device_param->skipped = true;
14668
14669 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14670
14671 continue;
14672 }
14673
14674 size_t binary_size;
14675
14676 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14677
14678 u8 *binary = (u8 *) mymalloc (binary_size);
14679
14680 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14681
14682 writeProgramBin (cached_file, binary, binary_size);
14683
14684 local_free (binary);
14685 }
14686 else
14687 {
14688 #ifdef DEBUG
14689 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14690 #endif
14691
14692 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14693
14694 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14695
14696 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14697 }
14698 }
14699 else
14700 {
14701 #ifdef DEBUG
14702 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14703 #endif
14704
14705 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14706
14707 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14708
14709 char build_opts_update[1024] = { 0 };
14710
14711 if (force_jit_compilation == 1500)
14712 {
14713 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14714 }
14715 else if (force_jit_compilation == 8900)
14716 {
14717 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);
14718 }
14719 else
14720 {
14721 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14722 }
14723
14724 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14725
14726 #ifdef DEBUG
14727 size_t build_log_size = 0;
14728
14729 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14730
14731 if (build_log_size > 1)
14732 {
14733 char *build_log = (char *) malloc (build_log_size + 1);
14734
14735 memset (build_log, 0, build_log_size + 1);
14736
14737 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14738
14739 puts (build_log);
14740
14741 free (build_log);
14742 }
14743 #endif
14744
14745 if (rc != 0)
14746 {
14747 device_param->skipped = true;
14748
14749 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14750 }
14751 }
14752
14753 local_free (kernel_lengths);
14754 local_free (kernel_sources[0]);
14755 local_free (kernel_sources);
14756 }
14757
14758 /**
14759 * word generator kernel
14760 */
14761
14762 if (attack_mode != ATTACK_MODE_STRAIGHT)
14763 {
14764 /**
14765 * kernel mp source filename
14766 */
14767
14768 char source_file[256] = { 0 };
14769
14770 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14771
14772 struct stat sst;
14773
14774 if (stat (source_file, &sst) == -1)
14775 {
14776 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14777
14778 return -1;
14779 }
14780
14781 /**
14782 * kernel mp cached filename
14783 */
14784
14785 char cached_file[256] = { 0 };
14786
14787 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14788
14789 int cached = 1;
14790
14791 struct stat cst;
14792
14793 if (stat (cached_file, &cst) == -1)
14794 {
14795 cached = 0;
14796 }
14797
14798 /**
14799 * kernel compile or load
14800 */
14801
14802 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14803
14804 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14805
14806 if (cached == 0)
14807 {
14808 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14809 if (quiet == 0) log_info ("");
14810
14811 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14812
14813 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14814
14815 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14816
14817 if (rc != 0)
14818 {
14819 device_param->skipped = true;
14820
14821 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14822
14823 continue;
14824 }
14825
14826 size_t binary_size;
14827
14828 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14829
14830 u8 *binary = (u8 *) mymalloc (binary_size);
14831
14832 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14833
14834 writeProgramBin (cached_file, binary, binary_size);
14835
14836 local_free (binary);
14837 }
14838 else
14839 {
14840 #ifdef DEBUG
14841 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14842 #endif
14843
14844 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14845
14846 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14847
14848 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14849 }
14850
14851 local_free (kernel_lengths);
14852 local_free (kernel_sources[0]);
14853 local_free (kernel_sources);
14854 }
14855
14856 /**
14857 * amplifier kernel
14858 */
14859
14860 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14861 {
14862
14863 }
14864 else
14865 {
14866 /**
14867 * kernel amp source filename
14868 */
14869
14870 char source_file[256] = { 0 };
14871
14872 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14873
14874 struct stat sst;
14875
14876 if (stat (source_file, &sst) == -1)
14877 {
14878 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14879
14880 return -1;
14881 }
14882
14883 /**
14884 * kernel amp cached filename
14885 */
14886
14887 char cached_file[256] = { 0 };
14888
14889 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14890
14891 int cached = 1;
14892
14893 struct stat cst;
14894
14895 if (stat (cached_file, &cst) == -1)
14896 {
14897 cached = 0;
14898 }
14899
14900 /**
14901 * kernel compile or load
14902 */
14903
14904 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14905
14906 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14907
14908 if (cached == 0)
14909 {
14910 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14911 if (quiet == 0) log_info ("");
14912
14913 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14914
14915 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14916
14917 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14918
14919 if (rc != 0)
14920 {
14921 device_param->skipped = true;
14922
14923 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14924
14925 continue;
14926 }
14927
14928 size_t binary_size;
14929
14930 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14931
14932 u8 *binary = (u8 *) mymalloc (binary_size);
14933
14934 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14935
14936 writeProgramBin (cached_file, binary, binary_size);
14937
14938 local_free (binary);
14939 }
14940 else
14941 {
14942 #ifdef DEBUG
14943 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14944 #endif
14945
14946 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14947
14948 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14949
14950 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14951 }
14952
14953 local_free (kernel_lengths);
14954 local_free (kernel_sources[0]);
14955 local_free (kernel_sources);
14956 }
14957
14958 // some algorithm collide too fast, make that impossible
14959
14960 if (benchmark == 1)
14961 {
14962 ((uint *) digests_buf)[0] = -1;
14963 ((uint *) digests_buf)[1] = -1;
14964 ((uint *) digests_buf)[2] = -1;
14965 ((uint *) digests_buf)[3] = -1;
14966 }
14967
14968 /**
14969 * global buffers
14970 */
14971
14972 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14973 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14974 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14975 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14976 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14977 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14978 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14979 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14980 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14981 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14982 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14983 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14984 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14985 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14986 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14987 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14988 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14989 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14990
14991 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);
14992 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);
14993 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);
14994 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);
14995 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);
14996 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);
14997 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);
14998 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);
14999 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15000 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15001 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15002
15003 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15004 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15005 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15006 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15007 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15008 run_kernel_bzero (device_param, device_param->d_result, size_results);
15009
15010 /**
15011 * special buffers
15012 */
15013
15014 if (attack_kern == ATTACK_KERN_STRAIGHT)
15015 {
15016 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15017 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15018
15019 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15020
15021 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15022 }
15023 else if (attack_kern == ATTACK_KERN_COMBI)
15024 {
15025 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15026 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15027 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15028 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15029
15030 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15031 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15032 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15033 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15034 }
15035 else if (attack_kern == ATTACK_KERN_BF)
15036 {
15037 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15038 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15039 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15040 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15041 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15042
15043 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15044 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15045 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15046 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15047 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15048 }
15049
15050 if (size_esalts)
15051 {
15052 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15053
15054 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15055 }
15056
15057 /**
15058 * main host data
15059 */
15060
15061 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15062
15063 device_param->pws_buf = pws_buf;
15064
15065 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15066
15067 device_param->combs_buf = combs_buf;
15068
15069 void *hooks_buf = mymalloc (size_hooks);
15070
15071 device_param->hooks_buf = hooks_buf;
15072
15073 /**
15074 * kernel args
15075 */
15076
15077 device_param->kernel_params_buf32[21] = bitmap_mask;
15078 device_param->kernel_params_buf32[22] = bitmap_shift1;
15079 device_param->kernel_params_buf32[23] = bitmap_shift2;
15080 device_param->kernel_params_buf32[24] = 0; // salt_pos
15081 device_param->kernel_params_buf32[25] = 0; // loop_pos
15082 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15083 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15084 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15085 device_param->kernel_params_buf32[29] = 0; // digests_offset
15086 device_param->kernel_params_buf32[30] = 0; // combs_mode
15087 device_param->kernel_params_buf32[31] = 0; // gid_max
15088
15089 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15090 ? &device_param->d_pws_buf
15091 : &device_param->d_pws_amp_buf;
15092 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15093 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15094 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15095 device_param->kernel_params[ 4] = &device_param->d_tmps;
15096 device_param->kernel_params[ 5] = &device_param->d_hooks;
15097 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15098 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15099 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15100 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15101 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15102 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15103 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15104 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15105 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15106 device_param->kernel_params[15] = &device_param->d_digests_buf;
15107 device_param->kernel_params[16] = &device_param->d_digests_shown;
15108 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15109 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15110 device_param->kernel_params[19] = &device_param->d_result;
15111 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15112 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15113 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15114 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15115 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15116 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15117 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15118 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15119 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15120 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15121 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15122 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15123
15124 device_param->kernel_params_mp_buf64[3] = 0;
15125 device_param->kernel_params_mp_buf32[4] = 0;
15126 device_param->kernel_params_mp_buf32[5] = 0;
15127 device_param->kernel_params_mp_buf32[6] = 0;
15128 device_param->kernel_params_mp_buf32[7] = 0;
15129 device_param->kernel_params_mp_buf32[8] = 0;
15130
15131 device_param->kernel_params_mp[0] = NULL;
15132 device_param->kernel_params_mp[1] = NULL;
15133 device_param->kernel_params_mp[2] = NULL;
15134 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15135 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15136 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15137 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15138 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15139 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15140
15141 device_param->kernel_params_mp_l_buf64[3] = 0;
15142 device_param->kernel_params_mp_l_buf32[4] = 0;
15143 device_param->kernel_params_mp_l_buf32[5] = 0;
15144 device_param->kernel_params_mp_l_buf32[6] = 0;
15145 device_param->kernel_params_mp_l_buf32[7] = 0;
15146 device_param->kernel_params_mp_l_buf32[8] = 0;
15147 device_param->kernel_params_mp_l_buf32[9] = 0;
15148
15149 device_param->kernel_params_mp_l[0] = NULL;
15150 device_param->kernel_params_mp_l[1] = NULL;
15151 device_param->kernel_params_mp_l[2] = NULL;
15152 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15153 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15154 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15155 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15156 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15157 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15158 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15159
15160 device_param->kernel_params_mp_r_buf64[3] = 0;
15161 device_param->kernel_params_mp_r_buf32[4] = 0;
15162 device_param->kernel_params_mp_r_buf32[5] = 0;
15163 device_param->kernel_params_mp_r_buf32[6] = 0;
15164 device_param->kernel_params_mp_r_buf32[7] = 0;
15165 device_param->kernel_params_mp_r_buf32[8] = 0;
15166
15167 device_param->kernel_params_mp_r[0] = NULL;
15168 device_param->kernel_params_mp_r[1] = NULL;
15169 device_param->kernel_params_mp_r[2] = NULL;
15170 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15171 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15172 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15173 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15174 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15175 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15176
15177 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15178 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15179
15180 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15181 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15182 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15183 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15184 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15185 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15186 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15187
15188 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15189 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15190
15191 /**
15192 * kernel name
15193 */
15194
15195 size_t kernel_wgs_tmp;
15196
15197 char kernel_name[64] = { 0 };
15198
15199 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15200 {
15201 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15202 {
15203 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15204
15205 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15206
15207 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15208
15209 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15210
15211 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15212
15213 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15214 }
15215 else
15216 {
15217 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15218
15219 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15220
15221 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15222
15223 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15224
15225 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15226
15227 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15228 }
15229
15230 if (data.attack_mode == ATTACK_MODE_BF)
15231 {
15232 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15233 {
15234 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15235
15236 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15237
15238 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);
15239 }
15240 }
15241 }
15242 else
15243 {
15244 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15245
15246 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15247
15248 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15249
15250 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15251
15252 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15253
15254 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15255
15256 if (opts_type & OPTS_TYPE_HOOK12)
15257 {
15258 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15259
15260 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15261
15262 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);
15263 }
15264
15265 if (opts_type & OPTS_TYPE_HOOK23)
15266 {
15267 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15268
15269 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15270
15271 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);
15272 }
15273 }
15274
15275 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);
15276 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);
15277 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);
15278
15279 for (uint i = 0; i <= 20; i++)
15280 {
15281 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15282 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15283 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15284
15285 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15286 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15287 }
15288
15289 for (uint i = 21; i <= 31; i++)
15290 {
15291 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15292 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15293 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15294
15295 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15296 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15297 }
15298
15299 if (attack_mode == ATTACK_MODE_BF)
15300 {
15301 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15302 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15303
15304 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);
15305 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);
15306
15307 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15308 {
15309 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15310 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15311 }
15312 }
15313 else if (attack_mode == ATTACK_MODE_HYBRID1)
15314 {
15315 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15316
15317 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);
15318 }
15319 else if (attack_mode == ATTACK_MODE_HYBRID2)
15320 {
15321 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15322
15323 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);
15324 }
15325
15326 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15327 {
15328 // nothing to do
15329 }
15330 else
15331 {
15332 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15333
15334 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);
15335 }
15336
15337 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15338 {
15339 // nothing to do
15340 }
15341 else
15342 {
15343 for (uint i = 0; i < 5; i++)
15344 {
15345 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15346 }
15347
15348 for (uint i = 5; i < 7; i++)
15349 {
15350 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15351 }
15352 }
15353
15354 // maybe this has been updated by clGetKernelWorkGroupInfo()
15355 // value can only be decreased, so we don't need to reallocate buffers
15356
15357 device_param->kernel_threads = kernel_threads;
15358
15359 /**
15360 * Store initial fanspeed if gpu_temp_retain is enabled
15361 */
15362
15363 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15364 int gpu_temp_retain_set = 0;
15365
15366 if (gpu_temp_disable == 0)
15367 {
15368 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15369 {
15370 hc_thread_mutex_lock (mux_adl);
15371
15372 if (data.hm_device[device_id].fan_supported == 1)
15373 {
15374 if (gpu_temp_retain_chgd == 0)
15375 {
15376 uint cur_temp = 0;
15377 uint default_temp = 0;
15378
15379 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);
15380
15381 if (ADL_rc == ADL_OK)
15382 {
15383 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15384
15385 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15386
15387 // special case with multi gpu setups: always use minimum retain
15388
15389 if (gpu_temp_retain_set == 0)
15390 {
15391 gpu_temp_retain = gpu_temp_retain_target;
15392 gpu_temp_retain_set = 1;
15393 }
15394 else
15395 {
15396 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15397 }
15398
15399 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15400 }
15401 }
15402
15403 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15404
15405 temp_retain_fanspeed_value[device_id] = fan_speed;
15406
15407 if (fan_speed == -1)
15408 {
15409 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15410
15411 temp_retain_fanspeed_value[device_id] = 0;
15412 }
15413 }
15414
15415 hc_thread_mutex_unlock (mux_adl);
15416 }
15417 }
15418
15419 /**
15420 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15421 */
15422
15423 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15424 {
15425 hc_thread_mutex_lock (mux_adl);
15426
15427 if (data.hm_device[device_id].od_version == 6)
15428 {
15429 int ADL_rc;
15430
15431 // check powertune capabilities first, if not available then skip device
15432
15433 int powertune_supported = 0;
15434
15435 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15436 {
15437 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15438
15439 return (-1);
15440 }
15441
15442 if (powertune_supported != 0)
15443 {
15444 // powercontrol settings
15445
15446 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15447
15448 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15449 {
15450 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15451 }
15452
15453 if (ADL_rc != ADL_OK)
15454 {
15455 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15456
15457 return (-1);
15458 }
15459
15460 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15461 {
15462 log_error ("ERROR: Failed to set new ADL PowerControl values");
15463
15464 return (-1);
15465 }
15466
15467 // clocks
15468
15469 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15470
15471 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15472
15473 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)
15474 {
15475 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15476
15477 return (-1);
15478 }
15479
15480 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15481
15482 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15483
15484 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15485 {
15486 log_error ("ERROR: Failed to get ADL device capabilities");
15487
15488 return (-1);
15489 }
15490
15491 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15492 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15493
15494 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15495 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15496
15497 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15498 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15499
15500 // warning if profile has too low max values
15501
15502 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15503 {
15504 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15505 }
15506
15507 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15508 {
15509 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15510 }
15511
15512 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15513
15514 performance_state->iNumberOfPerformanceLevels = 2;
15515
15516 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15517 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15518 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15519 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15520
15521 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)
15522 {
15523 log_info ("ERROR: Failed to set ADL performance state");
15524
15525 return (-1);
15526 }
15527
15528 local_free (performance_state);
15529 }
15530 }
15531
15532 hc_thread_mutex_unlock (mux_adl);
15533 }
15534 #endif // HAVE_HWMON && HAVE_ADL
15535 }
15536
15537 data.kernel_power_all = kernel_power_all;
15538
15539 if (data.quiet == 0) log_info_nn ("");
15540
15541 /**
15542 * In benchmark-mode, inform user which algorithm is checked
15543 */
15544
15545 if (benchmark == 1)
15546 {
15547 if (status_automat == 0)
15548 {
15549 quiet = 0;
15550
15551 data.quiet = quiet;
15552
15553 char *hash_type = strhashtype (data.hash_mode); // not a bug
15554
15555 log_info ("Hashtype: %s", hash_type);
15556 log_info ("");
15557 }
15558 }
15559
15560 /**
15561 * keep track of the progress
15562 */
15563
15564 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15565 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15566 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15567
15568 /**
15569 * open filehandles
15570 */
15571
15572 #if _WIN
15573 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15574 {
15575 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15576
15577 return (-1);
15578 }
15579
15580 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15581 {
15582 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15583
15584 return (-1);
15585 }
15586
15587 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15588 {
15589 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15590
15591 return (-1);
15592 }
15593 #endif
15594
15595 /**
15596 * dictionary pad
15597 */
15598
15599 segment_size *= (1024 * 1024);
15600
15601 data.segment_size = segment_size;
15602
15603 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15604
15605 wl_data->buf = (char *) mymalloc (segment_size);
15606 wl_data->avail = segment_size;
15607 wl_data->incr = segment_size;
15608 wl_data->cnt = 0;
15609 wl_data->pos = 0;
15610
15611 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15612
15613 data.wordlist_mode = wordlist_mode;
15614
15615 cs_t *css_buf = NULL;
15616 uint css_cnt = 0;
15617 uint dictcnt = 0;
15618 uint maskcnt = 1;
15619 char **masks = NULL;
15620 char **dictfiles = NULL;
15621
15622 uint mask_from_file = 0;
15623
15624 if (attack_mode == ATTACK_MODE_STRAIGHT)
15625 {
15626 if (wordlist_mode == WL_MODE_FILE)
15627 {
15628 int wls_left = myargc - (optind + 1);
15629
15630 for (int i = 0; i < wls_left; i++)
15631 {
15632 char *l0_filename = myargv[optind + 1 + i];
15633
15634 struct stat l0_stat;
15635
15636 if (stat (l0_filename, &l0_stat) == -1)
15637 {
15638 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15639
15640 return (-1);
15641 }
15642
15643 uint is_dir = S_ISDIR (l0_stat.st_mode);
15644
15645 if (is_dir == 0)
15646 {
15647 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15648
15649 dictcnt++;
15650
15651 dictfiles[dictcnt - 1] = l0_filename;
15652 }
15653 else
15654 {
15655 // do not allow --keyspace w/ a directory
15656
15657 if (keyspace == 1)
15658 {
15659 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15660
15661 return (-1);
15662 }
15663
15664 char **dictionary_files = NULL;
15665
15666 dictionary_files = scan_directory (l0_filename);
15667
15668 if (dictionary_files != NULL)
15669 {
15670 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15671
15672 for (int d = 0; dictionary_files[d] != NULL; d++)
15673 {
15674 char *l1_filename = dictionary_files[d];
15675
15676 struct stat l1_stat;
15677
15678 if (stat (l1_filename, &l1_stat) == -1)
15679 {
15680 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15681
15682 return (-1);
15683 }
15684
15685 if (S_ISREG (l1_stat.st_mode))
15686 {
15687 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15688
15689 dictcnt++;
15690
15691 dictfiles[dictcnt - 1] = strdup (l1_filename);
15692 }
15693 }
15694 }
15695
15696 local_free (dictionary_files);
15697 }
15698 }
15699
15700 if (dictcnt < 1)
15701 {
15702 log_error ("ERROR: No usable dictionary file found.");
15703
15704 return (-1);
15705 }
15706 }
15707 else if (wordlist_mode == WL_MODE_STDIN)
15708 {
15709 dictcnt = 1;
15710 }
15711 }
15712 else if (attack_mode == ATTACK_MODE_COMBI)
15713 {
15714 // display
15715
15716 char *dictfile1 = myargv[optind + 1 + 0];
15717 char *dictfile2 = myargv[optind + 1 + 1];
15718
15719 // find the bigger dictionary and use as base
15720
15721 FILE *fp1 = NULL;
15722 FILE *fp2 = NULL;
15723
15724 struct stat tmp_stat;
15725
15726 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15727 {
15728 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15729
15730 return (-1);
15731 }
15732
15733 if (stat (dictfile1, &tmp_stat) == -1)
15734 {
15735 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15736
15737 fclose (fp1);
15738
15739 return (-1);
15740 }
15741
15742 if (S_ISDIR (tmp_stat.st_mode))
15743 {
15744 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15745
15746 fclose (fp1);
15747
15748 return (-1);
15749 }
15750
15751 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15752 {
15753 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15754
15755 fclose (fp1);
15756
15757 return (-1);
15758 }
15759
15760 if (stat (dictfile2, &tmp_stat) == -1)
15761 {
15762 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15763
15764 fclose (fp1);
15765 fclose (fp2);
15766
15767 return (-1);
15768 }
15769
15770 if (S_ISDIR (tmp_stat.st_mode))
15771 {
15772 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15773
15774 fclose (fp1);
15775 fclose (fp2);
15776
15777 return (-1);
15778 }
15779
15780 data.combs_cnt = 1;
15781
15782 data.quiet = 1;
15783
15784 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15785
15786 data.quiet = quiet;
15787
15788 if (words1_cnt == 0)
15789 {
15790 log_error ("ERROR: %s: empty file", dictfile1);
15791
15792 fclose (fp1);
15793 fclose (fp2);
15794
15795 return (-1);
15796 }
15797
15798 data.combs_cnt = 1;
15799
15800 data.quiet = 1;
15801
15802 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15803
15804 data.quiet = quiet;
15805
15806 if (words2_cnt == 0)
15807 {
15808 log_error ("ERROR: %s: empty file", dictfile2);
15809
15810 fclose (fp1);
15811 fclose (fp2);
15812
15813 return (-1);
15814 }
15815
15816 fclose (fp1);
15817 fclose (fp2);
15818
15819 data.dictfile = dictfile1;
15820 data.dictfile2 = dictfile2;
15821
15822 if (words1_cnt >= words2_cnt)
15823 {
15824 data.combs_cnt = words2_cnt;
15825 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15826
15827 dictfiles = &data.dictfile;
15828
15829 dictcnt = 1;
15830 }
15831 else
15832 {
15833 data.combs_cnt = words1_cnt;
15834 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15835
15836 dictfiles = &data.dictfile2;
15837
15838 dictcnt = 1;
15839
15840 // we also have to switch wordlist related rules!
15841
15842 char *tmpc = data.rule_buf_l;
15843
15844 data.rule_buf_l = data.rule_buf_r;
15845 data.rule_buf_r = tmpc;
15846
15847 int tmpi = data.rule_len_l;
15848
15849 data.rule_len_l = data.rule_len_r;
15850 data.rule_len_r = tmpi;
15851 }
15852 }
15853 else if (attack_mode == ATTACK_MODE_BF)
15854 {
15855 char *mask = NULL;
15856
15857 maskcnt = 0;
15858
15859 if (benchmark == 0)
15860 {
15861 mask = myargv[optind + 1];
15862
15863 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15864
15865 if ((optind + 2) <= myargc)
15866 {
15867 struct stat file_stat;
15868
15869 if (stat (mask, &file_stat) == -1)
15870 {
15871 maskcnt = 1;
15872
15873 masks[maskcnt - 1] = mystrdup (mask);
15874 }
15875 else
15876 {
15877 int wls_left = myargc - (optind + 1);
15878
15879 uint masks_avail = INCR_MASKS;
15880
15881 for (int i = 0; i < wls_left; i++)
15882 {
15883 if (i != 0)
15884 {
15885 mask = myargv[optind + 1 + i];
15886
15887 if (stat (mask, &file_stat) == -1)
15888 {
15889 log_error ("ERROR: %s: %s", mask, strerror (errno));
15890
15891 return (-1);
15892 }
15893 }
15894
15895 uint is_file = S_ISREG (file_stat.st_mode);
15896
15897 if (is_file == 1)
15898 {
15899 FILE *mask_fp;
15900
15901 if ((mask_fp = fopen (mask, "r")) == NULL)
15902 {
15903 log_error ("ERROR: %s: %s", mask, strerror (errno));
15904
15905 return (-1);
15906 }
15907
15908 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15909
15910 while (!feof (mask_fp))
15911 {
15912 memset (line_buf, 0, HCBUFSIZ);
15913
15914 int line_len = fgetl (mask_fp, line_buf);
15915
15916 if (line_len == 0) continue;
15917
15918 if (line_buf[0] == '#') continue;
15919
15920 if (masks_avail == maskcnt)
15921 {
15922 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15923
15924 masks_avail += INCR_MASKS;
15925 }
15926
15927 masks[maskcnt] = mystrdup (line_buf);
15928
15929 maskcnt++;
15930 }
15931
15932 myfree (line_buf);
15933
15934 fclose (mask_fp);
15935 }
15936 else
15937 {
15938 log_error ("ERROR: %s: unsupported file-type", mask);
15939
15940 return (-1);
15941 }
15942 }
15943
15944 mask_from_file = 1;
15945 }
15946 }
15947 else
15948 {
15949 custom_charset_1 = (char *) "?l?d?u";
15950 custom_charset_2 = (char *) "?l?d";
15951 custom_charset_3 = (char *) "?l?d*!$@_";
15952
15953 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15954 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15955 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15956
15957 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15958
15959 wordlist_mode = WL_MODE_MASK;
15960
15961 data.wordlist_mode = wordlist_mode;
15962
15963 increment = 1;
15964
15965 maskcnt = 1;
15966 }
15967 }
15968 else
15969 {
15970 /**
15971 * generate full masks and charsets
15972 */
15973
15974 masks = (char **) mymalloc (sizeof (char *));
15975
15976 switch (hash_mode)
15977 {
15978 case 1731: pw_min = 5;
15979 pw_max = 5;
15980 mask = mystrdup ("?b?b?b?b?b");
15981 break;
15982 case 12500: pw_min = 5;
15983 pw_max = 5;
15984 mask = mystrdup ("?b?b?b?b?b");
15985 break;
15986 default: pw_min = 7;
15987 pw_max = 7;
15988 mask = mystrdup ("?b?b?b?b?b?b?b");
15989 break;
15990 }
15991
15992 maskcnt = 1;
15993
15994 masks[maskcnt - 1] = mystrdup (mask);
15995
15996 wordlist_mode = WL_MODE_MASK;
15997
15998 data.wordlist_mode = wordlist_mode;
15999
16000 increment = 1;
16001 }
16002
16003 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16004
16005 if (increment)
16006 {
16007 if (increment_min > pw_min) pw_min = increment_min;
16008
16009 if (increment_max < pw_max) pw_max = increment_max;
16010 }
16011 }
16012 else if (attack_mode == ATTACK_MODE_HYBRID1)
16013 {
16014 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16015
16016 // display
16017
16018 char *mask = myargv[myargc - 1];
16019
16020 maskcnt = 0;
16021
16022 masks = (char **) mymalloc (1 * sizeof (char *));
16023
16024 // mod
16025
16026 struct stat file_stat;
16027
16028 if (stat (mask, &file_stat) == -1)
16029 {
16030 maskcnt = 1;
16031
16032 masks[maskcnt - 1] = mystrdup (mask);
16033 }
16034 else
16035 {
16036 uint is_file = S_ISREG (file_stat.st_mode);
16037
16038 if (is_file == 1)
16039 {
16040 FILE *mask_fp;
16041
16042 if ((mask_fp = fopen (mask, "r")) == NULL)
16043 {
16044 log_error ("ERROR: %s: %s", mask, strerror (errno));
16045
16046 return (-1);
16047 }
16048
16049 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16050
16051 uint masks_avail = 1;
16052
16053 while (!feof (mask_fp))
16054 {
16055 memset (line_buf, 0, HCBUFSIZ);
16056
16057 int line_len = fgetl (mask_fp, line_buf);
16058
16059 if (line_len == 0) continue;
16060
16061 if (line_buf[0] == '#') continue;
16062
16063 if (masks_avail == maskcnt)
16064 {
16065 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16066
16067 masks_avail += INCR_MASKS;
16068 }
16069
16070 masks[maskcnt] = mystrdup (line_buf);
16071
16072 maskcnt++;
16073 }
16074
16075 myfree (line_buf);
16076
16077 fclose (mask_fp);
16078
16079 mask_from_file = 1;
16080 }
16081 else
16082 {
16083 maskcnt = 1;
16084
16085 masks[maskcnt - 1] = mystrdup (mask);
16086 }
16087 }
16088
16089 // base
16090
16091 int wls_left = myargc - (optind + 2);
16092
16093 for (int i = 0; i < wls_left; i++)
16094 {
16095 char *filename = myargv[optind + 1 + i];
16096
16097 struct stat file_stat;
16098
16099 if (stat (filename, &file_stat) == -1)
16100 {
16101 log_error ("ERROR: %s: %s", filename, strerror (errno));
16102
16103 return (-1);
16104 }
16105
16106 uint is_dir = S_ISDIR (file_stat.st_mode);
16107
16108 if (is_dir == 0)
16109 {
16110 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16111
16112 dictcnt++;
16113
16114 dictfiles[dictcnt - 1] = filename;
16115 }
16116 else
16117 {
16118 // do not allow --keyspace w/ a directory
16119
16120 if (keyspace == 1)
16121 {
16122 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16123
16124 return (-1);
16125 }
16126
16127 char **dictionary_files = NULL;
16128
16129 dictionary_files = scan_directory (filename);
16130
16131 if (dictionary_files != NULL)
16132 {
16133 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16134
16135 for (int d = 0; dictionary_files[d] != NULL; d++)
16136 {
16137 char *l1_filename = dictionary_files[d];
16138
16139 struct stat l1_stat;
16140
16141 if (stat (l1_filename, &l1_stat) == -1)
16142 {
16143 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16144
16145 return (-1);
16146 }
16147
16148 if (S_ISREG (l1_stat.st_mode))
16149 {
16150 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16151
16152 dictcnt++;
16153
16154 dictfiles[dictcnt - 1] = strdup (l1_filename);
16155 }
16156 }
16157 }
16158
16159 local_free (dictionary_files);
16160 }
16161 }
16162
16163 if (dictcnt < 1)
16164 {
16165 log_error ("ERROR: No usable dictionary file found.");
16166
16167 return (-1);
16168 }
16169
16170 if (increment)
16171 {
16172 maskcnt = 0;
16173
16174 uint mask_min = increment_min; // we can't reject smaller masks here
16175 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16176
16177 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16178 {
16179 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16180
16181 if (cur_mask == NULL) break;
16182
16183 masks[maskcnt] = cur_mask;
16184
16185 maskcnt++;
16186
16187 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16188 }
16189 }
16190 }
16191 else if (attack_mode == ATTACK_MODE_HYBRID2)
16192 {
16193 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16194
16195 // display
16196
16197 char *mask = myargv[optind + 1 + 0];
16198
16199 maskcnt = 0;
16200
16201 masks = (char **) mymalloc (1 * sizeof (char *));
16202
16203 // mod
16204
16205 struct stat file_stat;
16206
16207 if (stat (mask, &file_stat) == -1)
16208 {
16209 maskcnt = 1;
16210
16211 masks[maskcnt - 1] = mystrdup (mask);
16212 }
16213 else
16214 {
16215 uint is_file = S_ISREG (file_stat.st_mode);
16216
16217 if (is_file == 1)
16218 {
16219 FILE *mask_fp;
16220
16221 if ((mask_fp = fopen (mask, "r")) == NULL)
16222 {
16223 log_error ("ERROR: %s: %s", mask, strerror (errno));
16224
16225 return (-1);
16226 }
16227
16228 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16229
16230 uint masks_avail = 1;
16231
16232 while (!feof (mask_fp))
16233 {
16234 memset (line_buf, 0, HCBUFSIZ);
16235
16236 int line_len = fgetl (mask_fp, line_buf);
16237
16238 if (line_len == 0) continue;
16239
16240 if (line_buf[0] == '#') continue;
16241
16242 if (masks_avail == maskcnt)
16243 {
16244 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16245
16246 masks_avail += INCR_MASKS;
16247 }
16248
16249 masks[maskcnt] = mystrdup (line_buf);
16250
16251 maskcnt++;
16252 }
16253
16254 myfree (line_buf);
16255
16256 fclose (mask_fp);
16257
16258 mask_from_file = 1;
16259 }
16260 else
16261 {
16262 maskcnt = 1;
16263
16264 masks[maskcnt - 1] = mystrdup (mask);
16265 }
16266 }
16267
16268 // base
16269
16270 int wls_left = myargc - (optind + 2);
16271
16272 for (int i = 0; i < wls_left; i++)
16273 {
16274 char *filename = myargv[optind + 2 + i];
16275
16276 struct stat file_stat;
16277
16278 if (stat (filename, &file_stat) == -1)
16279 {
16280 log_error ("ERROR: %s: %s", filename, strerror (errno));
16281
16282 return (-1);
16283 }
16284
16285 uint is_dir = S_ISDIR (file_stat.st_mode);
16286
16287 if (is_dir == 0)
16288 {
16289 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16290
16291 dictcnt++;
16292
16293 dictfiles[dictcnt - 1] = filename;
16294 }
16295 else
16296 {
16297 // do not allow --keyspace w/ a directory
16298
16299 if (keyspace == 1)
16300 {
16301 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16302
16303 return (-1);
16304 }
16305
16306 char **dictionary_files = NULL;
16307
16308 dictionary_files = scan_directory (filename);
16309
16310 if (dictionary_files != NULL)
16311 {
16312 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16313
16314 for (int d = 0; dictionary_files[d] != NULL; d++)
16315 {
16316 char *l1_filename = dictionary_files[d];
16317
16318 struct stat l1_stat;
16319
16320 if (stat (l1_filename, &l1_stat) == -1)
16321 {
16322 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16323
16324 return (-1);
16325 }
16326
16327 if (S_ISREG (l1_stat.st_mode))
16328 {
16329 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16330
16331 dictcnt++;
16332
16333 dictfiles[dictcnt - 1] = strdup (l1_filename);
16334 }
16335 }
16336 }
16337
16338 local_free (dictionary_files);
16339 }
16340 }
16341
16342 if (dictcnt < 1)
16343 {
16344 log_error ("ERROR: No usable dictionary file found.");
16345
16346 return (-1);
16347 }
16348
16349 if (increment)
16350 {
16351 maskcnt = 0;
16352
16353 uint mask_min = increment_min; // we can't reject smaller masks here
16354 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16355
16356 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16357 {
16358 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16359
16360 if (cur_mask == NULL) break;
16361
16362 masks[maskcnt] = cur_mask;
16363
16364 maskcnt++;
16365
16366 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16367 }
16368 }
16369 }
16370
16371 data.pw_min = pw_min;
16372 data.pw_max = pw_max;
16373
16374 /**
16375 * weak hash check
16376 */
16377
16378 if (weak_hash_threshold >= salts_cnt)
16379 {
16380 hc_device_param_t *device_param = NULL;
16381
16382 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16383 {
16384 device_param = &data.devices_param[device_id];
16385
16386 if (device_param->skipped) continue;
16387
16388 break;
16389 }
16390
16391 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16392
16393 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16394 {
16395 weak_hash_check (device_param, salt_pos);
16396 }
16397
16398 // Display hack, guarantee that there is at least one \r before real start
16399
16400 //if (data.quiet == 0) log_info ("");
16401 }
16402
16403 /**
16404 * status and monitor threads
16405 */
16406
16407 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16408
16409 hc_thread_t i_thread = 0;
16410
16411 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16412 {
16413 hc_thread_create (i_thread, thread_keypress, &benchmark);
16414 }
16415
16416 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16417
16418 uint ni_threads_cnt = 0;
16419
16420 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16421
16422 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16423
16424 ni_threads_cnt++;
16425
16426 /**
16427 * Outfile remove
16428 */
16429
16430 if (keyspace == 0)
16431 {
16432 if (outfile_check_timer != 0)
16433 {
16434 if (data.outfile_check_directory != NULL)
16435 {
16436 if ((hash_mode != 5200) &&
16437 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16438 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16439 (hash_mode != 9000))
16440 {
16441 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16442
16443 ni_threads_cnt++;
16444 }
16445 else
16446 {
16447 outfile_check_timer = 0;
16448 }
16449 }
16450 else
16451 {
16452 outfile_check_timer = 0;
16453 }
16454 }
16455 }
16456
16457 /**
16458 * Inform the user if we got some hashes remove because of the pot file remove feature
16459 */
16460
16461 if (data.quiet == 0)
16462 {
16463 if (potfile_remove_cracks > 0)
16464 {
16465 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16466 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16467 }
16468 }
16469
16470 data.outfile_check_timer = outfile_check_timer;
16471
16472 /**
16473 * main loop
16474 */
16475
16476 char **induction_dictionaries = NULL;
16477
16478 int induction_dictionaries_cnt = 0;
16479
16480 hcstat_table_t *root_table_buf = NULL;
16481 hcstat_table_t *markov_table_buf = NULL;
16482
16483 uint initial_restore_done = 0;
16484
16485 data.maskcnt = maskcnt;
16486
16487 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16488 {
16489 if (data.devices_status == STATUS_CRACKED) break;
16490
16491 data.devices_status = STATUS_INIT;
16492
16493 if (maskpos > rd->maskpos)
16494 {
16495 rd->dictpos = 0;
16496 }
16497
16498 rd->maskpos = maskpos;
16499 data.maskpos = maskpos;
16500
16501 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16502 {
16503 char *mask = masks[maskpos];
16504
16505 if (mask_from_file == 1)
16506 {
16507 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16508
16509 char *str_ptr;
16510 uint str_pos;
16511
16512 uint mask_offset = 0;
16513
16514 uint separator_cnt;
16515
16516 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16517 {
16518 str_ptr = strstr (mask + mask_offset, ",");
16519
16520 if (str_ptr == NULL) break;
16521
16522 str_pos = str_ptr - mask;
16523
16524 // escaped separator, i.e. "\,"
16525
16526 if (str_pos > 0)
16527 {
16528 if (mask[str_pos - 1] == '\\')
16529 {
16530 separator_cnt --;
16531
16532 mask_offset = str_pos + 1;
16533
16534 continue;
16535 }
16536 }
16537
16538 // reset the offset
16539
16540 mask_offset = 0;
16541
16542 mask[str_pos] = '\0';
16543
16544 switch (separator_cnt)
16545 {
16546 case 0:
16547 mp_reset_usr (mp_usr, 0);
16548
16549 custom_charset_1 = mask;
16550 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16551 break;
16552
16553 case 1:
16554 mp_reset_usr (mp_usr, 1);
16555
16556 custom_charset_2 = mask;
16557 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16558 break;
16559
16560 case 2:
16561 mp_reset_usr (mp_usr, 2);
16562
16563 custom_charset_3 = mask;
16564 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16565 break;
16566
16567 case 3:
16568 mp_reset_usr (mp_usr, 3);
16569
16570 custom_charset_4 = mask;
16571 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16572 break;
16573 }
16574
16575 mask = mask + str_pos + 1;
16576 }
16577 }
16578
16579 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16580 {
16581 if (maskpos > 0)
16582 {
16583 local_free (css_buf);
16584 local_free (data.root_css_buf);
16585 local_free (data.markov_css_buf);
16586
16587 local_free (masks[maskpos - 1]);
16588 }
16589
16590 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16591
16592 data.mask = mask;
16593 data.css_cnt = css_cnt;
16594 data.css_buf = css_buf;
16595
16596 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16597
16598 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16599
16600 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16601 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16602
16603 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16604
16605 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16606
16607 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16608 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16609
16610 data.root_css_buf = root_css_buf;
16611 data.markov_css_buf = markov_css_buf;
16612
16613 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16614
16615 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16616
16617 local_free (root_table_buf);
16618 local_free (markov_table_buf);
16619
16620 // args
16621
16622 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16623 {
16624 hc_device_param_t *device_param = &data.devices_param[device_id];
16625
16626 if (device_param->skipped) continue;
16627
16628 device_param->kernel_params_mp[0] = &device_param->d_combs;
16629 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16630 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16631
16632 device_param->kernel_params_mp_buf64[3] = 0;
16633 device_param->kernel_params_mp_buf32[4] = css_cnt;
16634 device_param->kernel_params_mp_buf32[5] = 0;
16635 device_param->kernel_params_mp_buf32[6] = 0;
16636 device_param->kernel_params_mp_buf32[7] = 0;
16637
16638 if (attack_mode == ATTACK_MODE_HYBRID1)
16639 {
16640 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16641 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16642 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16643 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16644 }
16645 else if (attack_mode == ATTACK_MODE_HYBRID2)
16646 {
16647 device_param->kernel_params_mp_buf32[5] = 0;
16648 device_param->kernel_params_mp_buf32[6] = 0;
16649 device_param->kernel_params_mp_buf32[7] = 0;
16650 }
16651
16652 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]);
16653 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]);
16654 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]);
16655
16656 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);
16657 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);
16658 }
16659 }
16660 else if (attack_mode == ATTACK_MODE_BF)
16661 {
16662 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16663
16664 if (increment)
16665 {
16666 for (uint i = 0; i < dictcnt; i++)
16667 {
16668 local_free (dictfiles[i]);
16669 }
16670
16671 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16672 {
16673 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16674
16675 if (l1_filename == NULL) break;
16676
16677 dictcnt++;
16678
16679 dictfiles[dictcnt - 1] = l1_filename;
16680 }
16681 }
16682 else
16683 {
16684 dictcnt++;
16685
16686 dictfiles[dictcnt - 1] = mask;
16687 }
16688
16689 if (dictcnt == 0)
16690 {
16691 log_error ("ERROR: Mask is too small");
16692
16693 return (-1);
16694 }
16695 }
16696 }
16697
16698 free (induction_dictionaries);
16699
16700 // induction_dictionaries_cnt = 0; // implied
16701
16702 if (attack_mode != ATTACK_MODE_BF)
16703 {
16704 if (keyspace == 0)
16705 {
16706 induction_dictionaries = scan_directory (induction_directory);
16707
16708 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16709 }
16710 }
16711
16712 if (induction_dictionaries_cnt)
16713 {
16714 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16715 }
16716
16717 /**
16718 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16719 */
16720 if (keyspace == 1)
16721 {
16722 if ((maskcnt > 1) || (dictcnt > 1))
16723 {
16724 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16725
16726 return (-1);
16727 }
16728 }
16729
16730 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16731 {
16732 char *subid = logfile_generate_subid ();
16733
16734 data.subid = subid;
16735
16736 logfile_sub_msg ("START");
16737
16738 data.devices_status = STATUS_INIT;
16739
16740 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16741 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16742 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16743
16744 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16745
16746 data.cpt_pos = 0;
16747
16748 data.cpt_start = time (NULL);
16749
16750 data.cpt_total = 0;
16751
16752 if (data.restore == 0)
16753 {
16754 rd->words_cur = skip;
16755
16756 skip = 0;
16757
16758 data.skip = 0;
16759 }
16760
16761 data.ms_paused = 0;
16762
16763 data.words_cur = rd->words_cur;
16764
16765 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16766 {
16767 hc_device_param_t *device_param = &data.devices_param[device_id];
16768
16769 if (device_param->skipped) continue;
16770
16771 device_param->speed_pos = 0;
16772
16773 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16774 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16775
16776 device_param->exec_pos = 0;
16777
16778 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16779
16780 device_param->kernel_power = device_param->kernel_power_user;
16781
16782 device_param->outerloop_pos = 0;
16783 device_param->outerloop_left = 0;
16784 device_param->innerloop_pos = 0;
16785 device_param->innerloop_left = 0;
16786
16787 // some more resets:
16788
16789 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16790
16791 device_param->pws_cnt = 0;
16792
16793 device_param->words_off = 0;
16794 device_param->words_done = 0;
16795 }
16796
16797 data.kernel_power_div = 0;
16798
16799 // figure out some workload
16800
16801 if (attack_mode == ATTACK_MODE_STRAIGHT)
16802 {
16803 if (data.wordlist_mode == WL_MODE_FILE)
16804 {
16805 char *dictfile = NULL;
16806
16807 if (induction_dictionaries_cnt)
16808 {
16809 dictfile = induction_dictionaries[0];
16810 }
16811 else
16812 {
16813 dictfile = dictfiles[dictpos];
16814 }
16815
16816 data.dictfile = dictfile;
16817
16818 logfile_sub_string (dictfile);
16819
16820 for (uint i = 0; i < rp_files_cnt; i++)
16821 {
16822 logfile_sub_var_string ("rulefile", rp_files[i]);
16823 }
16824
16825 FILE *fd2 = fopen (dictfile, "rb");
16826
16827 if (fd2 == NULL)
16828 {
16829 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16830
16831 return (-1);
16832 }
16833
16834 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16835
16836 fclose (fd2);
16837
16838 if (data.words_cnt == 0)
16839 {
16840 if (data.devices_status == STATUS_CRACKED) break;
16841 if (data.devices_status == STATUS_ABORTED) break;
16842
16843 dictpos++;
16844
16845 continue;
16846 }
16847 }
16848 }
16849 else if (attack_mode == ATTACK_MODE_COMBI)
16850 {
16851 char *dictfile = data.dictfile;
16852 char *dictfile2 = data.dictfile2;
16853
16854 logfile_sub_string (dictfile);
16855 logfile_sub_string (dictfile2);
16856
16857 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16858 {
16859 FILE *fd2 = fopen (dictfile, "rb");
16860
16861 if (fd2 == NULL)
16862 {
16863 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16864
16865 return (-1);
16866 }
16867
16868 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16869
16870 fclose (fd2);
16871 }
16872 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16873 {
16874 FILE *fd2 = fopen (dictfile2, "rb");
16875
16876 if (fd2 == NULL)
16877 {
16878 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16879
16880 return (-1);
16881 }
16882
16883 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16884
16885 fclose (fd2);
16886 }
16887
16888 if (data.words_cnt == 0)
16889 {
16890 if (data.devices_status == STATUS_CRACKED) break;
16891 if (data.devices_status == STATUS_ABORTED) break;
16892
16893 dictpos++;
16894
16895 continue;
16896 }
16897 }
16898 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16899 {
16900 char *dictfile = NULL;
16901
16902 if (induction_dictionaries_cnt)
16903 {
16904 dictfile = induction_dictionaries[0];
16905 }
16906 else
16907 {
16908 dictfile = dictfiles[dictpos];
16909 }
16910
16911 data.dictfile = dictfile;
16912
16913 char *mask = data.mask;
16914
16915 logfile_sub_string (dictfile);
16916 logfile_sub_string (mask);
16917
16918 FILE *fd2 = fopen (dictfile, "rb");
16919
16920 if (fd2 == NULL)
16921 {
16922 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16923
16924 return (-1);
16925 }
16926
16927 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16928
16929 fclose (fd2);
16930
16931 if (data.words_cnt == 0)
16932 {
16933 if (data.devices_status == STATUS_CRACKED) break;
16934 if (data.devices_status == STATUS_ABORTED) break;
16935
16936 dictpos++;
16937
16938 continue;
16939 }
16940 }
16941 else if (attack_mode == ATTACK_MODE_BF)
16942 {
16943 local_free (css_buf);
16944 local_free (data.root_css_buf);
16945 local_free (data.markov_css_buf);
16946
16947 char *mask = dictfiles[dictpos];
16948
16949 logfile_sub_string (mask);
16950
16951 // base
16952
16953 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16954
16955 if (opts_type & OPTS_TYPE_PT_UNICODE)
16956 {
16957 uint css_cnt_unicode = css_cnt * 2;
16958
16959 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16960
16961 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16962 {
16963 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16964
16965 css_buf_unicode[j + 1].cs_buf[0] = 0;
16966 css_buf_unicode[j + 1].cs_len = 1;
16967 }
16968
16969 free (css_buf);
16970
16971 css_buf = css_buf_unicode;
16972 css_cnt = css_cnt_unicode;
16973 }
16974
16975 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16976
16977 uint mask_min = pw_min;
16978 uint mask_max = pw_max;
16979
16980 if (opts_type & OPTS_TYPE_PT_UNICODE)
16981 {
16982 mask_min *= 2;
16983 mask_max *= 2;
16984 }
16985
16986 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16987 {
16988 if (css_cnt < mask_min)
16989 {
16990 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16991 }
16992
16993 if (css_cnt > mask_max)
16994 {
16995 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16996 }
16997
16998 // skip to next mask
16999
17000 dictpos++;
17001
17002 rd->dictpos = dictpos;
17003
17004 logfile_sub_msg ("STOP");
17005
17006 continue;
17007 }
17008
17009 uint save_css_cnt = css_cnt;
17010
17011 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17012 {
17013 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17014 {
17015 uint salt_len = (uint) data.salts_buf[0].salt_len;
17016 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17017
17018 uint css_cnt_salt = css_cnt + salt_len;
17019
17020 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17021
17022 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17023
17024 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17025 {
17026 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17027 css_buf_salt[j].cs_len = 1;
17028 }
17029
17030 free (css_buf);
17031
17032 css_buf = css_buf_salt;
17033 css_cnt = css_cnt_salt;
17034 }
17035 }
17036
17037 data.mask = mask;
17038 data.css_cnt = css_cnt;
17039 data.css_buf = css_buf;
17040
17041 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17042
17043 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17044
17045 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17046
17047 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17048 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17049
17050 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17051
17052 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17053
17054 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17055 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17056
17057 data.root_css_buf = root_css_buf;
17058 data.markov_css_buf = markov_css_buf;
17059
17060 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17061
17062 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17063
17064 local_free (root_table_buf);
17065 local_free (markov_table_buf);
17066
17067 // copy + args
17068
17069 uint css_cnt_l = css_cnt;
17070 uint css_cnt_r;
17071
17072 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17073 {
17074 if (save_css_cnt < 6)
17075 {
17076 css_cnt_r = 1;
17077 }
17078 else if (save_css_cnt == 6)
17079 {
17080 css_cnt_r = 2;
17081 }
17082 else
17083 {
17084 if (opts_type & OPTS_TYPE_PT_UNICODE)
17085 {
17086 if (save_css_cnt == 8 || save_css_cnt == 10)
17087 {
17088 css_cnt_r = 2;
17089 }
17090 else
17091 {
17092 css_cnt_r = 4;
17093 }
17094 }
17095 else
17096 {
17097 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17098 {
17099 css_cnt_r = 3;
17100 }
17101 else
17102 {
17103 css_cnt_r = 4;
17104 }
17105 }
17106 }
17107 }
17108 else
17109 {
17110 css_cnt_r = 1;
17111
17112 /* unfinished code?
17113 int sum = css_buf[css_cnt_r - 1].cs_len;
17114
17115 for (uint i = 1; i < 4 && i < css_cnt; i++)
17116 {
17117 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17118
17119 css_cnt_r++;
17120
17121 sum *= css_buf[css_cnt_r - 1].cs_len;
17122 }
17123 */
17124 }
17125
17126 css_cnt_l -= css_cnt_r;
17127
17128 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17129
17130 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17131 {
17132 hc_device_param_t *device_param = &data.devices_param[device_id];
17133
17134 if (device_param->skipped) continue;
17135
17136 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17137 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17138 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17139
17140 device_param->kernel_params_mp_l_buf64[3] = 0;
17141 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17142 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17143 device_param->kernel_params_mp_l_buf32[6] = 0;
17144 device_param->kernel_params_mp_l_buf32[7] = 0;
17145 device_param->kernel_params_mp_l_buf32[8] = 0;
17146
17147 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17148 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17149 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17150 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17151
17152 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17153 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17154 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17155
17156 device_param->kernel_params_mp_r_buf64[3] = 0;
17157 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17158 device_param->kernel_params_mp_r_buf32[5] = 0;
17159 device_param->kernel_params_mp_r_buf32[6] = 0;
17160 device_param->kernel_params_mp_r_buf32[7] = 0;
17161
17162 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]);
17163 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]);
17164 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]);
17165
17166 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]);
17167 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]);
17168 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]);
17169
17170 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);
17171 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);
17172 }
17173 }
17174
17175 u64 words_base = data.words_cnt;
17176
17177 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17178 {
17179 if (data.kernel_rules_cnt)
17180 {
17181 words_base /= data.kernel_rules_cnt;
17182 }
17183 }
17184 else if (data.attack_kern == ATTACK_KERN_COMBI)
17185 {
17186 if (data.combs_cnt)
17187 {
17188 words_base /= data.combs_cnt;
17189 }
17190 }
17191 else if (data.attack_kern == ATTACK_KERN_BF)
17192 {
17193 if (data.bfs_cnt)
17194 {
17195 words_base /= data.bfs_cnt;
17196 }
17197 }
17198
17199 data.words_base = words_base;
17200
17201 if (keyspace == 1)
17202 {
17203 log_info ("%llu", (unsigned long long int) words_base);
17204
17205 return (0);
17206 }
17207
17208 if (data.words_cur > data.words_base)
17209 {
17210 log_error ("ERROR: restore value greater keyspace");
17211
17212 return (-1);
17213 }
17214
17215 if (data.words_cur)
17216 {
17217 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17218 {
17219 for (uint i = 0; i < data.salts_cnt; i++)
17220 {
17221 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17222 }
17223 }
17224 else if (data.attack_kern == ATTACK_KERN_COMBI)
17225 {
17226 for (uint i = 0; i < data.salts_cnt; i++)
17227 {
17228 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17229 }
17230 }
17231 else if (data.attack_kern == ATTACK_KERN_BF)
17232 {
17233 for (uint i = 0; i < data.salts_cnt; i++)
17234 {
17235 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17236 }
17237 }
17238 }
17239
17240 /*
17241 * Inform user about possible slow speeds
17242 */
17243
17244 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17245 {
17246 if (data.words_base < kernel_power_all)
17247 {
17248 if (quiet == 0)
17249 {
17250 log_info ("ATTENTION!");
17251 log_info (" The wordlist or mask you are using is too small.");
17252 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17253 log_info (" The cracking speed will drop.");
17254 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17255 log_info ("");
17256 }
17257 }
17258 }
17259
17260 /*
17261 * Update loopback file
17262 */
17263
17264 if (loopback == 1)
17265 {
17266 time_t now;
17267
17268 time (&now);
17269
17270 uint random_num = get_random_num (0, 9999);
17271
17272 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17273
17274 data.loopback_file = loopback_file;
17275 }
17276
17277 /*
17278 * Update dictionary statistic
17279 */
17280
17281 if (keyspace == 0)
17282 {
17283 dictstat_fp = fopen (dictstat, "wb");
17284
17285 if (dictstat_fp)
17286 {
17287 lock_file (dictstat_fp);
17288
17289 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17290
17291 fclose (dictstat_fp);
17292 }
17293 }
17294
17295 data.devices_status = STATUS_RUNNING;
17296
17297 if (initial_restore_done == 0)
17298 {
17299 if (data.restore_disable == 0) cycle_restore ();
17300
17301 initial_restore_done = 1;
17302 }
17303
17304 hc_timer_set (&data.timer_running);
17305
17306 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17307 {
17308 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17309 {
17310 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17311 if (quiet == 0) fflush (stdout);
17312 }
17313 }
17314 else if (wordlist_mode == WL_MODE_STDIN)
17315 {
17316 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17317 if (data.quiet == 0) log_info ("");
17318 }
17319
17320 time_t runtime_start;
17321
17322 time (&runtime_start);
17323
17324 data.runtime_start = runtime_start;
17325
17326 /**
17327 * create cracker threads
17328 */
17329
17330 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17331
17332 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17333 {
17334 hc_device_param_t *device_param = &devices_param[device_id];
17335
17336 if (wordlist_mode == WL_MODE_STDIN)
17337 {
17338 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17339 }
17340 else
17341 {
17342 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17343 }
17344 }
17345
17346 // wait for crack threads to exit
17347
17348 hc_thread_wait (data.devices_cnt, c_threads);
17349
17350 local_free (c_threads);
17351
17352 data.restore = 0;
17353
17354 // finalize task
17355
17356 logfile_sub_var_uint ("status-after-work", data.devices_status);
17357
17358 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17359
17360 if (data.devices_status == STATUS_CRACKED) break;
17361 if (data.devices_status == STATUS_ABORTED) break;
17362
17363 if (data.devices_status == STATUS_BYPASS)
17364 {
17365 data.devices_status = STATUS_RUNNING;
17366 }
17367
17368 if (induction_dictionaries_cnt)
17369 {
17370 unlink (induction_dictionaries[0]);
17371 }
17372
17373 free (induction_dictionaries);
17374
17375 if (attack_mode != ATTACK_MODE_BF)
17376 {
17377 induction_dictionaries = scan_directory (induction_directory);
17378
17379 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17380 }
17381
17382 if (benchmark == 0)
17383 {
17384 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17385 {
17386 if (quiet == 0) clear_prompt ();
17387
17388 if (quiet == 0) log_info ("");
17389
17390 if (status == 1)
17391 {
17392 status_display ();
17393 }
17394 else
17395 {
17396 if (quiet == 0) status_display ();
17397 }
17398
17399 if (quiet == 0) log_info ("");
17400 }
17401 }
17402
17403 if (attack_mode == ATTACK_MODE_BF)
17404 {
17405 dictpos++;
17406
17407 rd->dictpos = dictpos;
17408 }
17409 else
17410 {
17411 if (induction_dictionaries_cnt)
17412 {
17413 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17414 }
17415 else
17416 {
17417 dictpos++;
17418
17419 rd->dictpos = dictpos;
17420 }
17421 }
17422
17423 time_t runtime_stop;
17424
17425 time (&runtime_stop);
17426
17427 data.runtime_stop = runtime_stop;
17428
17429 logfile_sub_uint (runtime_start);
17430 logfile_sub_uint (runtime_stop);
17431
17432 logfile_sub_msg ("STOP");
17433
17434 global_free (subid);
17435 }
17436
17437 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17438
17439 if (data.devices_status == STATUS_CRACKED) break;
17440 if (data.devices_status == STATUS_ABORTED) break;
17441 if (data.devices_status == STATUS_QUIT) break;
17442
17443 if (data.devices_status == STATUS_BYPASS)
17444 {
17445 data.devices_status = STATUS_RUNNING;
17446 }
17447 }
17448
17449 // 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
17450
17451 if (attack_mode == ATTACK_MODE_STRAIGHT)
17452 {
17453 if (data.wordlist_mode == WL_MODE_FILE)
17454 {
17455 if (data.dictfile == NULL)
17456 {
17457 if (dictfiles != NULL)
17458 {
17459 data.dictfile = dictfiles[0];
17460
17461 hc_timer_set (&data.timer_running);
17462 }
17463 }
17464 }
17465 }
17466 // NOTE: combi is okay because it is already set beforehand
17467 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17468 {
17469 if (data.dictfile == NULL)
17470 {
17471 if (dictfiles != NULL)
17472 {
17473 hc_timer_set (&data.timer_running);
17474
17475 data.dictfile = dictfiles[0];
17476 }
17477 }
17478 }
17479 else if (attack_mode == ATTACK_MODE_BF)
17480 {
17481 if (data.mask == NULL)
17482 {
17483 hc_timer_set (&data.timer_running);
17484
17485 data.mask = masks[0];
17486 }
17487 }
17488
17489 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17490 {
17491 data.devices_status = STATUS_EXHAUSTED;
17492 }
17493
17494 // if cracked / aborted remove last induction dictionary
17495
17496 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17497 {
17498 struct stat induct_stat;
17499
17500 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17501 {
17502 unlink (induction_dictionaries[file_pos]);
17503 }
17504 }
17505
17506 // wait for non-interactive threads
17507
17508 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17509 {
17510 hc_thread_wait (1, &ni_threads[thread_idx]);
17511 }
17512
17513 local_free (ni_threads);
17514
17515 // wait for interactive threads
17516
17517 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17518 {
17519 hc_thread_wait (1, &i_thread);
17520 }
17521
17522 // we dont need restore file anymore
17523 if (data.restore_disable == 0)
17524 {
17525 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17526 {
17527 unlink (eff_restore_file);
17528 unlink (new_restore_file);
17529 }
17530 else
17531 {
17532 cycle_restore ();
17533 }
17534 }
17535
17536 // finally save left hashes
17537
17538 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17539 {
17540 save_hash ();
17541 }
17542
17543 /**
17544 * Clean up
17545 */
17546
17547 if (benchmark == 1)
17548 {
17549 status_benchmark ();
17550
17551 if (status_automat == 0)
17552 {
17553 log_info ("");
17554 }
17555 }
17556 else
17557 {
17558 if (quiet == 0) clear_prompt ();
17559
17560 if (quiet == 0) log_info ("");
17561
17562 if (status == 1)
17563 {
17564 status_display ();
17565 }
17566 else
17567 {
17568 if (quiet == 0) status_display ();
17569 }
17570
17571 if (quiet == 0) log_info ("");
17572 }
17573
17574 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17575 {
17576 hc_device_param_t *device_param = &data.devices_param[device_id];
17577
17578 if (device_param->skipped) continue;
17579
17580 local_free (device_param->combs_buf);
17581
17582 local_free (device_param->hooks_buf);
17583
17584 local_free (device_param->device_name);
17585
17586 local_free (device_param->device_name_chksum);
17587
17588 local_free (device_param->device_version);
17589
17590 local_free (device_param->driver_version);
17591
17592 if (device_param->pws_buf) myfree (device_param->pws_buf);
17593 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17594 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17595 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17596 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17597 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17598 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17599 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17600 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17601 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17602 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17603 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17604 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17605 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17606 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17607 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17608 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17609 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17610 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17611 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17612 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17613 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17614 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17615 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17616 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17617 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17618 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17619 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17620 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17621
17622 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17623 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17624 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17625 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17626 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17627 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17628 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17629 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17630 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17631 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17632
17633 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17634 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17635 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17636
17637 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17638 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17639 }
17640
17641 // reset default fan speed
17642
17643 #ifdef HAVE_HWMON
17644 if (gpu_temp_disable == 0)
17645 {
17646 #ifdef HAVE_ADL
17647 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17648 {
17649 hc_thread_mutex_lock (mux_adl);
17650
17651 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17652 {
17653 hc_device_param_t *device_param = &data.devices_param[device_id];
17654
17655 if (device_param->skipped) continue;
17656
17657 if (data.hm_device[device_id].fan_supported == 1)
17658 {
17659 int fanspeed = temp_retain_fanspeed_value[device_id];
17660
17661 if (fanspeed == -1) continue;
17662
17663 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17664
17665 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17666 }
17667 }
17668
17669 hc_thread_mutex_unlock (mux_adl);
17670 }
17671 #endif // HAVE_ADL
17672 }
17673
17674 #ifdef HAVE_ADL
17675 // reset power tuning
17676
17677 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17678 {
17679 hc_thread_mutex_lock (mux_adl);
17680
17681 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17682 {
17683 hc_device_param_t *device_param = &data.devices_param[device_id];
17684
17685 if (device_param->skipped) continue;
17686
17687 if (data.hm_device[device_id].od_version == 6)
17688 {
17689 // check powertune capabilities first, if not available then skip device
17690
17691 int powertune_supported = 0;
17692
17693 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17694 {
17695 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17696
17697 return (-1);
17698 }
17699
17700 if (powertune_supported != 0)
17701 {
17702 // powercontrol settings
17703
17704 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)
17705 {
17706 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17707
17708 return (-1);
17709 }
17710
17711 // clocks
17712
17713 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17714
17715 performance_state->iNumberOfPerformanceLevels = 2;
17716
17717 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17718 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17719 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17720 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17721
17722 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)
17723 {
17724 log_info ("ERROR: Failed to restore ADL performance state");
17725
17726 return (-1);
17727 }
17728
17729 local_free (performance_state);
17730 }
17731 }
17732 }
17733
17734 hc_thread_mutex_unlock (mux_adl);
17735 }
17736 #endif // HAVE_ADL
17737
17738 if (gpu_temp_disable == 0)
17739 {
17740 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17741 if (data.hm_nv)
17742 {
17743 #if defined(LINUX) && defined(HAVE_NVML)
17744
17745 hm_NVML_nvmlShutdown (data.hm_nv);
17746
17747 nvml_close (data.hm_nv);
17748
17749 #elif defined(WIN) && (HAVE_NVAPI)
17750
17751 hm_NvAPI_Unload (data.hm_nv);
17752
17753 nvapi_close (data.hm_nv);
17754
17755 #endif
17756
17757 data.hm_nv = NULL;
17758 }
17759 #endif
17760
17761 #ifdef HAVE_ADL
17762 if (data.hm_amd)
17763 {
17764 hm_ADL_Main_Control_Destroy (data.hm_amd);
17765
17766 adl_close (data.hm_amd);
17767 data.hm_amd = NULL;
17768 }
17769 #endif
17770 }
17771 #endif // HAVE_HWMON
17772
17773 // free memory
17774
17775 local_free (masks);
17776
17777 local_free (dictstat_base);
17778
17779 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17780 {
17781 pot_t *pot_ptr = &pot[pot_pos];
17782
17783 hash_t *hash = &pot_ptr->hash;
17784
17785 local_free (hash->digest);
17786
17787 if (isSalted)
17788 {
17789 local_free (hash->salt);
17790 }
17791 }
17792
17793 local_free (pot);
17794
17795 local_free (all_kernel_rules_cnt);
17796 local_free (all_kernel_rules_buf);
17797
17798 local_free (wl_data->buf);
17799 local_free (wl_data);
17800
17801 local_free (bitmap_s1_a);
17802 local_free (bitmap_s1_b);
17803 local_free (bitmap_s1_c);
17804 local_free (bitmap_s1_d);
17805 local_free (bitmap_s2_a);
17806 local_free (bitmap_s2_b);
17807 local_free (bitmap_s2_c);
17808 local_free (bitmap_s2_d);
17809
17810 #ifdef HAVE_HWMON
17811 local_free (temp_retain_fanspeed_value);
17812 #ifdef HAVE_ADL
17813 local_free (od_clock_mem_status);
17814 local_free (od_power_control_status);
17815 #endif // ADL
17816 #endif
17817
17818 global_free (devices_param);
17819
17820 global_free (kernel_rules_buf);
17821
17822 global_free (root_css_buf);
17823 global_free (markov_css_buf);
17824
17825 global_free (digests_buf);
17826 global_free (digests_shown);
17827 global_free (digests_shown_tmp);
17828
17829 global_free (salts_buf);
17830 global_free (salts_shown);
17831
17832 global_free (esalts_buf);
17833
17834 global_free (words_progress_done);
17835 global_free (words_progress_rejected);
17836 global_free (words_progress_restored);
17837
17838 if (pot_fp) fclose (pot_fp);
17839
17840 if (data.devices_status == STATUS_QUIT) break;
17841 }
17842
17843 // destroy others mutex
17844
17845 hc_thread_mutex_delete (mux_dispatcher);
17846 hc_thread_mutex_delete (mux_counter);
17847 hc_thread_mutex_delete (mux_display);
17848 hc_thread_mutex_delete (mux_adl);
17849
17850 // free memory
17851
17852 local_free (eff_restore_file);
17853 local_free (new_restore_file);
17854
17855 local_free (rd);
17856
17857 // tuning db
17858
17859 tuning_db_destroy (tuning_db);
17860
17861 // loopback
17862
17863 local_free (loopback_file);
17864
17865 if (loopback == 1) unlink (loopback_file);
17866
17867 // induction directory
17868
17869 if (induction_dir == NULL)
17870 {
17871 if (attack_mode != ATTACK_MODE_BF)
17872 {
17873 if (rmdir (induction_directory) == -1)
17874 {
17875 if (errno == ENOENT)
17876 {
17877 // good, we can ignore
17878 }
17879 else if (errno == ENOTEMPTY)
17880 {
17881 // good, we can ignore
17882 }
17883 else
17884 {
17885 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17886
17887 return (-1);
17888 }
17889 }
17890
17891 local_free (induction_directory);
17892 }
17893 }
17894
17895 // outfile-check directory
17896
17897 if (outfile_check_dir == NULL)
17898 {
17899 if (rmdir (outfile_check_directory) == -1)
17900 {
17901 if (errno == ENOENT)
17902 {
17903 // good, we can ignore
17904 }
17905 else if (errno == ENOTEMPTY)
17906 {
17907 // good, we can ignore
17908 }
17909 else
17910 {
17911 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17912
17913 return (-1);
17914 }
17915 }
17916
17917 local_free (outfile_check_directory);
17918 }
17919
17920 time_t proc_stop;
17921
17922 time (&proc_stop);
17923
17924 logfile_top_uint (proc_start);
17925 logfile_top_uint (proc_stop);
17926
17927 logfile_top_msg ("STOP");
17928
17929 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17930 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17931
17932 if (data.ocl) ocl_close (data.ocl);
17933
17934 if (data.devices_status == STATUS_ABORTED) return 2;
17935 if (data.devices_status == STATUS_QUIT) return 2;
17936 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17937 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17938 if (data.devices_status == STATUS_CRACKED) return 0;
17939
17940 return -1;
17941 }
Hashcat additions to support pwdhash