projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Reduce helptext width from 134 to 118; Reduce -w 1 target to 2ms
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define STATUS_AUTOMAT 0
42 #define LOOPBACK 0
43 #define WEAK_HASH_THRESHOLD 100
44 #define SHOW 0
45 #define LEFT 0
46 #define USERNAME 0
47 #define REMOVE 0
48 #define REMOVE_TIMER 60
49 #define SKIP 0
50 #define LIMIT 0
51 #define KEYSPACE 0
52 #define POTFILE_DISABLE 0
53 #define DEBUG_MODE 0
54 #define RP_GEN 0
55 #define RP_GEN_FUNC_MIN 1
56 #define RP_GEN_FUNC_MAX 4
57 #define RP_GEN_SEED 0
58 #define RULE_BUF_L ":"
59 #define RULE_BUF_R ":"
60 #define FORCE 0
61 #define RUNTIME 0
62 #define HEX_CHARSET 0
63 #define HEX_SALT 0
64 #define HEX_WORDLIST 0
65 #define OUTFILE_FORMAT 3
66 #define OUTFILE_AUTOHEX 1
67 #define OUTFILE_CHECK_TIMER 5
68 #define ATTACK_MODE 0
69 #define HASH_MODE 0
70 #define SEGMENT_SIZE 32
71 #define INCREMENT 0
72 #define INCREMENT_MIN 1
73 #define INCREMENT_MAX PW_MAX
74 #define SEPARATOR ':'
75 #define BITMAP_MIN 16
76 #define BITMAP_MAX 24
77 #define GPU_TEMP_DISABLE 0
78 #define GPU_TEMP_ABORT 90
79 #define GPU_TEMP_RETAIN 80
80 #define WORKLOAD_PROFILE 2
81 #define KERNEL_ACCEL 0
82 #define KERNEL_LOOPS 0
83 #define KERNEL_RULES 1024
84 #define KERNEL_COMBS 1024
85 #define KERNEL_BFS 1024
86 #define KERNEL_THREADS_MAX 256
87 #define KERNEL_THREADS_MAX_CPU 16
88 #define POWERTUNE_ENABLE 0
89 #define LOGFILE_DISABLE 0
90 #define SCRYPT_TMTO 0
91 #define OPENCL_VECTOR_WIDTH 0
92
93 #define WL_MODE_STDIN 1
94 #define WL_MODE_FILE 2
95 #define WL_MODE_MASK 3
96
97 #define HL_MODE_FILE 4
98 #define HL_MODE_ARG 5
99
100 #define HLFMTS_CNT 11
101 #define HLFMT_HASHCAT 0
102 #define HLFMT_PWDUMP 1
103 #define HLFMT_PASSWD 2
104 #define HLFMT_SHADOW 3
105 #define HLFMT_DCC 4
106 #define HLFMT_DCC2 5
107 #define HLFMT_NETNTLM1 7
108 #define HLFMT_NETNTLM2 8
109 #define HLFMT_NSLDAP 9
110 #define HLFMT_NSLDAPS 10
111
112 #define HLFMT_TEXT_HASHCAT "native hashcat"
113 #define HLFMT_TEXT_PWDUMP "pwdump"
114 #define HLFMT_TEXT_PASSWD "passwd"
115 #define HLFMT_TEXT_SHADOW "shadow"
116 #define HLFMT_TEXT_DCC "DCC"
117 #define HLFMT_TEXT_DCC2 "DCC 2"
118 #define HLFMT_TEXT_NETNTLM1 "NetNTLMv1"
119 #define HLFMT_TEXT_NETNTLM2 "NetNTLMv2"
120 #define HLFMT_TEXT_NSLDAP "nsldap"
121 #define HLFMT_TEXT_NSLDAPS "nsldaps"
122
123 #define ATTACK_MODE_STRAIGHT 0
124 #define ATTACK_MODE_COMBI 1
125 #define ATTACK_MODE_TOGGLE 2
126 #define ATTACK_MODE_BF 3
127 #define ATTACK_MODE_PERM 4
128 #define ATTACK_MODE_TABLE 5
129 #define ATTACK_MODE_HYBRID1 6
130 #define ATTACK_MODE_HYBRID2 7
131 #define ATTACK_MODE_NONE 100
132
133 #define ATTACK_KERN_STRAIGHT 0
134 #define ATTACK_KERN_COMBI 1
135 #define ATTACK_KERN_BF 3
136 #define ATTACK_KERN_NONE 100
137
138 #define ATTACK_EXEC_OUTSIDE_KERNEL 10
139 #define ATTACK_EXEC_INSIDE_KERNEL 11
140
141 #define COMBINATOR_MODE_BASE_LEFT 10001
142 #define COMBINATOR_MODE_BASE_RIGHT 10002
143
144 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
145 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
146
147 #define MAX_CUT_TRIES 4
148
149 #define MAX_DICTSTAT 10000
150
151 #define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143
152
153 #define global_free(attr) \
154 { \
155 myfree ((void *) data.attr); \
156 \
157 data.attr = NULL; \
158 }
159
160 #define local_free(attr) \
161 { \
162 myfree ((void *) attr); \
163 \
164 attr = NULL; \
165 }
166
167 static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] =
168 {
169 900,
170 0,
171 5100,
172 100,
173 1400,
174 10800,
175 1700,
176 5000,
177 10100,
178 6000,
179 6100,
180 6900,
181 11700,
182 11800,
183 400,
184 8900,
185 11900,
186 12000,
187 10900,
188 12100,
189 23,
190 2500,
191 5300,
192 5400,
193 5500,
194 5600,
195 7300,
196 7500,
197 13100,
198 8300,
199 11100,
200 11200,
201 11400,
202 121,
203 2611,
204 2711,
205 2811,
206 8400,
207 11,
208 2612,
209 7900,
210 21,
211 11000,
212 124,
213 10000,
214 3711,
215 7600,
216 12,
217 131,
218 132,
219 1731,
220 200,
221 300,
222 3100,
223 112,
224 12300,
225 8000,
226 141,
227 1441,
228 1600,
229 12600,
230 1421,
231 101,
232 111,
233 1711,
234 3000,
235 1000,
236 1100,
237 2100,
238 12800,
239 1500,
240 12400,
241 500,
242 3200,
243 7400,
244 1800,
245 122,
246 1722,
247 7100,
248 6300,
249 6700,
250 6400,
251 6500,
252 2400,
253 2410,
254 5700,
255 9200,
256 9300,
257 22,
258 501,
259 5800,
260 8100,
261 8500,
262 7200,
263 9900,
264 7700,
265 7800,
266 10300,
267 8600,
268 8700,
269 9100,
270 133,
271 13500,
272 11600,
273 13600,
274 12500,
275 13000,
276 13200,
277 13300,
278 6211,
279 6221,
280 6231,
281 6241,
282 13711,
283 13721,
284 13731,
285 13741,
286 13751,
287 13761,
288 8800,
289 12900,
290 12200,
291 9700,
292 9710,
293 9800,
294 9810,
295 9400,
296 9500,
297 9600,
298 10400,
299 10410,
300 10500,
301 10600,
302 10700,
303 9000,
304 5200,
305 6800,
306 6600,
307 8200,
308 11300,
309 12700,
310 13400,
311 125
312 };
313
314 /**
315 * types
316 */
317
318 static void (*get_next_word_func) (char *, u32, u32 *, u32 *);
319
320 /**
321 * globals
322 */
323
324 static unsigned int full01 = 0x01010101;
325 static unsigned int full80 = 0x80808080;
326
327 int SUPPRESS_OUTPUT = 0;
328
329 hc_thread_mutex_t mux_adl;
330 hc_thread_mutex_t mux_counter;
331 hc_thread_mutex_t mux_dispatcher;
332 hc_thread_mutex_t mux_display;
333
334 hc_global_data_t data;
335
336 const char *PROMPT = "[s]tatus [p]ause [r]esume [b]ypass [c]heckpoint [q]uit => ";
337
338 const char *USAGE_MINI[] =
339 {
340 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
341 "",
342 "Try --help for more help.",
343 NULL
344 };
345
346 const char *USAGE_BIG[] =
347 {
348 "%s, advanced password recovery",
349 "",
350 "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...",
351 "",
352 "###########",
353 "# Options #",
354 "###########",
355 "",
356 " Options Short / Long | Type | Description | Example",
357 "===============================|======|======================================================|=======================",
358 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
359 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
360 " -V, --version | | Print version |",
361 " -h, --help | | Print help |",
362 " --quiet | | Suppress output |",
363 " --hex-charset | | Assume charset is given in hex |",
364 " --hex-salt | | Assume salt is given in hex |",
365 " --hex-wordlist | | Assume words in wordlist is given in hex |",
366 " --force | | Ignore warnings |",
367 " --status | | Enable automatic update of the status-screen |",
368 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
369 " --status-automat | | Display the status view in a machine readable format |",
370 " --loopback | | Add new plains to induct directory |",
371 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
372 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
373 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
374 " --markov-classic | | Enables classic markov-chains, no per-position |",
375 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
376 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
377 " --session | Str | Define specific session name | --session=mysession",
378 " --restore | | Restore session from --session |",
379 " --restore-disable | | Do not write restore file |",
380 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
381 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
382 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
383 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
384 " -p, --separator | Char | Separator CHR for hashlists and outfile | -p :",
385 " --show | | Show cracked passwords only |",
386 " --left | | Show un-cracked passwords only |",
387 " --username | | Enable ignoring of usernames in hashfile |",
388 " --remove | | Enable remove of hash once it is cracked |",
389 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
390 " --potfile-disable | | Do not write potfile |",
391 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
392 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
393 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
394 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
395 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
396 " --logfile-disable | | Disable the logfile |",
397 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
398 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
399 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
400 " -b, --benchmark | | Run benchmark |",
401 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
402 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
403 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
404 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
405 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
406 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
407 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
408 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
409 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
410 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
411 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
412 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
413 #ifdef HAVE_HWMON
414 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
415 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
416 #ifdef HAVE_ADL
417 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
418 #endif
419 #endif
420 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
421 " -s, --skip | Num | Skip X words from the start | -s 1000000",
422 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
423 " --keyspace | | Show keyspace base:mod values and quit |",
424 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
425 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
426 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
427 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
428 " --generate-rules-func-min | Num | Force min X funcs per rule |",
429 " --generate-rules-func-max | Num | Force max X funcs per rule |",
430 " --generate-rules-seed | Num | Force RNG seed set to X |",
431 " -1, --custom-CHR set1 | CS | User-defined CHR set ?1 | -1 ?l?d?u",
432 " -2, --custom-CHR set2 | CS | User-defined CHR set ?2 | -2 ?l?d?s",
433 " -3, --custom-CHR set3 | CS | User-defined CHR set ?3 |",
434 " -4, --custom-CHR set4 | CS | User-defined CHR set ?4 |",
435 " -i, --increment | | Enable mask increment mode |",
436 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
437 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
438 "",
439 "################",
440 "## Hash modes ##",
441 "################",
442 "",
443 " # | Name | Category",
444 " ------+--------------------------------------------------+--------------------------------------",
445 " 900 | MD4 | Raw Hash",
446 " 0 | MD5 | Raw Hash",
447 " 5100 | Half MD5 | Raw Hash",
448 " 100 | SHA1 | Raw Hash",
449 " 10800 | SHA-384 | Raw Hash",
450 " 1400 | SHA-256 | Raw Hash",
451 " 1700 | SHA-512 | Raw Hash",
452 " 5000 | SHA-3(Keccak) | Raw Hash",
453 " 10100 | SipHash | Raw Hash",
454 " 6000 | RipeMD160 | Raw Hash",
455 " 6100 | Whirlpool | Raw Hash",
456 " 6900 | GOST R 34.11-94 | Raw Hash",
457 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
458 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
459 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
461 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
462 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
463 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
464 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
465 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
466 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
467 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
468 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
469 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
470 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
471 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
472 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
473 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
474 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
475 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
480 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
481 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
482 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
483 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
484 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
485 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
486 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
487 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
488 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
489 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
490 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
491 " 400 | phpass | Generic KDF",
492 " 8900 | scrypt | Generic KDF",
493 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
494 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
495 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
496 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
497 " 23 | Skype | Network protocols",
498 " 2500 | WPA/WPA2 | Network protocols",
499 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
500 " 5300 | IKE-PSK MD5 | Network protocols",
501 " 5400 | IKE-PSK SHA1 | Network protocols",
502 " 5500 | NetNTLMv1 | Network protocols",
503 " 5500 | NetNTLMv1 + ESS | Network protocols",
504 " 5600 | NetNTLMv2 | Network protocols",
505 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
506 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
507 " 8300 | DNSSEC (NSEC3) | Network protocols",
508 " 10200 | Cram MD5 | Network protocols",
509 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
510 " 11200 | MySQL CRAM (SHA1) | Network protocols",
511 " 11400 | SIP digest authentication (MD5) | Network protocols",
512 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
513 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
514 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
515 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
516 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
519 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
521 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
523 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
524 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
525 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
527 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
528 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
529 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
530 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
531 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
532 " 12 | PostgreSQL | Database Server",
533 " 131 | MSSQL(2000) | Database Server",
534 " 132 | MSSQL(2005) | Database Server",
535 " 1731 | MSSQL(2012) | Database Server",
536 " 1731 | MSSQL(2014) | Database Server",
537 " 200 | MySQL323 | Database Server",
538 " 300 | MySQL4.1/MySQL5 | Database Server",
539 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
540 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
541 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
542 " 8000 | Sybase ASE | Database Server",
543 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
544 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
545 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
546 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
547 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
548 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
549 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
550 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
551 " 11500 | CRC32 | Checksums",
552 " 3000 | LM | Operating-Systems",
553 " 1000 | NTLM | Operating-Systems",
554 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
555 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
556 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
557 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
558 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
559 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
560 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
561 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
562 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
563 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
564 " 1722 | OSX v10.7 | Operating-Systems",
565 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
566 " 6300 | AIX {smd5} | Operating-Systems",
567 " 6700 | AIX {ssha1} | Operating-Systems",
568 " 6400 | AIX {ssha256} | Operating-Systems",
569 " 6500 | AIX {ssha512} | Operating-Systems",
570 " 2400 | Cisco-PIX | Operating-Systems",
571 " 2410 | Cisco-ASA | Operating-Systems",
572 " 500 | Cisco-IOS $1$ | Operating-Systems",
573 " 5700 | Cisco-IOS $4$ | Operating-Systems",
574 " 9200 | Cisco-IOS $8$ | Operating-Systems",
575 " 9300 | Cisco-IOS $9$ | Operating-Systems",
576 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
577 " 501 | Juniper IVE | Operating-Systems",
578 " 5800 | Android PIN | Operating-Systems",
579 " 8100 | Citrix Netscaler | Operating-Systems",
580 " 8500 | RACF | Operating-Systems",
581 " 7200 | GRUB 2 | Operating-Systems",
582 " 9900 | Radmin2 | Operating-Systems",
583 " 125 | ArubaOS | Operating-Systems",
584 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
585 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
586 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
587 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
588 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
589 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
590 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
591 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
592 " 11600 | 7-Zip | Archives",
593 " 12500 | RAR3-hp | Archives",
594 " 13000 | RAR5 | Archives",
595 " 13200 | AxCrypt | Archives",
596 " 13300 | AxCrypt in memory SHA1 | Archives",
597 " 13600 | WinZip | Archives",
598 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
599 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
600 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
601 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
602 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
603 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
612 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
613 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
614 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
615 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
616 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
617 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
618 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
619 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
620 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
621 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
622 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
623 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
632 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
633 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
634 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
635 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
636 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
637 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
638 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
639 " 9400 | MS Office 2007 | Documents",
640 " 9500 | MS Office 2010 | Documents",
641 " 9600 | MS Office 2013 | Documents",
642 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
643 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
644 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
645 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
646 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
647 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
648 " 9000 | Password Safe v2 | Password Managers",
649 " 5200 | Password Safe v3 | Password Managers",
650 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
651 " 6600 | 1Password, agilekeychain | Password Managers",
652 " 8200 | 1Password, cloudkeychain | Password Managers",
653 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
654 " 12700 | Blockchain, My Wallet | Password Managers",
655 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
656 "",
657 "#####################",
658 "## Outfile Formats ##",
659 "#####################",
660 "",
661 " # | Format",
662 " ---+--------",
663 " 1 | hash[:salt]",
664 " 2 | plain",
665 " 3 | hash[:salt]:plain",
666 " 4 | hex_plain",
667 " 5 | hash[:salt]:hex_plain",
668 " 6 | plain:hex_plain",
669 " 7 | hash[:salt]:plain:hex_plain",
670 " 8 | crackpos",
671 " 9 | hash[:salt]:crack_pos",
672 " 10 | plain:crack_pos",
673 " 11 | hash[:salt]:plain:crack_pos",
674 " 12 | hex_plain:crack_pos",
675 " 13 | hash[:salt]:hex_plain:crack_pos",
676 " 14 | plain:hex_plain:crack_pos",
677 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
678 "",
679 "##########################",
680 "## Rule Debugging Modes ##",
681 "##########################",
682 "",
683 " # | Format",
684 " ---+--------",
685 " 1 | Finding-Rule",
686 " 2 | Original-Word",
687 " 3 | Original-Word:Finding-Rule",
688 " 4 | Original-Word:Finding-Rule:Processed-Word",
689 "",
690 "##################",
691 "## Attack Modes ##",
692 "##################",
693 "",
694 " # | Mode",
695 " ---+------",
696 " 0 | Straight",
697 " 1 | Combination",
698 " 3 | Brute-force",
699 " 6 | Hybrid Wordlist + Mask",
700 " 7 | Hybrid Mask + Wordlist",
701 "",
702 "#######################",
703 "## Built-in Charsets ##",
704 "#######################",
705 "",
706 " ? | Charset",
707 " ---+---------",
708 " l | abcdefghijklmnopqrstuvwxyz",
709 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
710 " d | 0123456789",
711 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
712 " a | ?l?u?d?s",
713 " b | 0x00 - 0xff",
714 "",
715 "#########################",
716 "## OpenCL Device Types ##",
717 "#########################",
718 "",
719 " # | Device Type",
720 " ---+-------------",
721 " 1 | CPU",
722 " 2 | GPU",
723 " 3 | FPGA, DSP, Co-Processor",
724 "",
725 "#######################",
726 "## Workload Profiles ##",
727 "#######################",
728 "",
729 " # | Performance | Runtime | Power Consumption | Desktop Impact",
730 " ---+-------------+---------+-------------------+----------------",
731 " 1 | Low | 2 ms | Low | Minimal",
732 " 2 | Default | 12 ms | Economic | Noticeable",
733 " 3 | High | 96 ms | High | Unresponsive",
734 " 4 | Nightmare | 480 ms | Insane | Headless",
735 "",
736 "If you have no idea what just happend then visit the following pages:",
737 "",
738 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
739 "* https://hashcat.net/wiki/#frequently_asked_questions",
740 "",
741 NULL
742 };
743
744 /**
745 * hashcat specific functions
746 */
747
748 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
749 {
750 int exec_pos = (int) device_param->exec_pos - last_num_entries;
751
752 if (exec_pos < 0) exec_pos += EXEC_CACHE;
753
754 double exec_ms_sum = 0;
755
756 int exec_ms_cnt = 0;
757
758 for (int i = 0; i < last_num_entries; i++)
759 {
760 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
761
762 if (exec_ms)
763 {
764 exec_ms_sum += exec_ms;
765
766 exec_ms_cnt++;
767 }
768 }
769
770 if (exec_ms_cnt == 0) return 0;
771
772 return exec_ms_sum / exec_ms_cnt;
773 }
774
775 void status_display_automat ()
776 {
777 FILE *out = stdout;
778
779 fprintf (out, "STATUS\t%u\t", data.devices_status);
780
781 /**
782 * speed new
783 */
784
785 fprintf (out, "SPEED\t");
786
787 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
788 {
789 hc_device_param_t *device_param = &data.devices_param[device_id];
790
791 if (device_param->skipped) continue;
792
793 u64 speed_cnt = 0;
794 double speed_ms = 0;
795
796 for (int i = 0; i < SPEED_CACHE; i++)
797 {
798 speed_cnt += device_param->speed_cnt[i];
799 speed_ms += device_param->speed_ms[i];
800 }
801
802 speed_cnt /= SPEED_CACHE;
803 speed_ms /= SPEED_CACHE;
804
805 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
806 }
807
808 /**
809 * exec time
810 */
811
812 fprintf (out, "EXEC_RUNTIME\t");
813
814 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
815 {
816 hc_device_param_t *device_param = &data.devices_param[device_id];
817
818 if (device_param->skipped) continue;
819
820 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
821
822 fprintf (out, "%f\t", exec_ms_avg);
823 }
824
825 /**
826 * words_cur
827 */
828
829 u64 words_cur = get_lowest_words_done ();
830
831 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
832
833 /**
834 * counter
835 */
836
837 u64 progress_total = data.words_cnt * data.salts_cnt;
838
839 u64 all_done = 0;
840 u64 all_rejected = 0;
841 u64 all_restored = 0;
842
843 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
844 {
845 all_done += data.words_progress_done[salt_pos];
846 all_rejected += data.words_progress_rejected[salt_pos];
847 all_restored += data.words_progress_restored[salt_pos];
848 }
849
850 u64 progress_cur = all_restored + all_done + all_rejected;
851 u64 progress_end = progress_total;
852
853 u64 progress_skip = 0;
854
855 if (data.skip)
856 {
857 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
858
859 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
860 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
861 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
862 }
863
864 if (data.limit)
865 {
866 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
867
868 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
869 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
870 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
871 }
872
873 u64 progress_cur_relative_skip = progress_cur - progress_skip;
874 u64 progress_end_relative_skip = progress_end - progress_skip;
875
876 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
877
878 /**
879 * cracks
880 */
881
882 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
883 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
884
885 /**
886 * temperature
887 */
888
889 #ifdef HAVE_HWMON
890 if (data.gpu_temp_disable == 0)
891 {
892 fprintf (out, "TEMP\t");
893
894 hc_thread_mutex_lock (mux_adl);
895
896 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
897 {
898 hc_device_param_t *device_param = &data.devices_param[device_id];
899
900 if (device_param->skipped) continue;
901
902 int temp = hm_get_temperature_with_device_id (device_id);
903
904 fprintf (out, "%d\t", temp);
905 }
906
907 hc_thread_mutex_unlock (mux_adl);
908 }
909 #endif // HAVE_HWMON
910
911 /**
912 * flush
913 */
914
915 #ifdef _WIN
916 fputc ('\r', out);
917 fputc ('\n', out);
918 #endif
919
920 #ifdef _POSIX
921 fputc ('\n', out);
922 #endif
923
924 fflush (out);
925 }
926
927 void status_display ()
928 {
929 if (data.devices_status == STATUS_INIT) return;
930 if (data.devices_status == STATUS_STARTING) return;
931 if (data.devices_status == STATUS_BYPASS) return;
932
933 if (data.status_automat == 1)
934 {
935 status_display_automat ();
936
937 return;
938 }
939
940 char tmp_buf[1000] = { 0 };
941
942 uint tmp_len = 0;
943
944 log_info ("Session.Name...: %s", data.session);
945
946 char *status_type = strstatus (data.devices_status);
947
948 uint hash_mode = data.hash_mode;
949
950 char *hash_type = strhashtype (hash_mode); // not a bug
951
952 log_info ("Status.........: %s", status_type);
953
954 /**
955 * show rules
956 */
957
958 if (data.rp_files_cnt)
959 {
960 uint i;
961
962 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
963 {
964 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
965 }
966
967 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
968
969 log_info ("Rules.Type.....: %s", tmp_buf);
970
971 tmp_len = 0;
972 }
973
974 if (data.rp_gen)
975 {
976 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
977
978 if (data.rp_gen_seed)
979 {
980 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
981 }
982 }
983
984 /**
985 * show input
986 */
987
988 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
989 {
990 if (data.wordlist_mode == WL_MODE_FILE)
991 {
992 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
993 }
994 else if (data.wordlist_mode == WL_MODE_STDIN)
995 {
996 log_info ("Input.Mode.....: Pipe");
997 }
998 }
999 else if (data.attack_mode == ATTACK_MODE_COMBI)
1000 {
1001 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1002 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1003 }
1004 else if (data.attack_mode == ATTACK_MODE_BF)
1005 {
1006 char *mask = data.mask;
1007
1008 if (mask != NULL)
1009 {
1010 uint mask_len = data.css_cnt;
1011
1012 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1013
1014 if (mask_len > 0)
1015 {
1016 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1017 {
1018 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1019 {
1020 mask_len -= data.salts_buf[0].salt_len;
1021 }
1022 }
1023
1024 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1025
1026 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1027 }
1028
1029 if (data.maskcnt > 1)
1030 {
1031 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1032
1033 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1034 }
1035
1036 log_info ("Input.Mode.....: %s", tmp_buf);
1037 }
1038
1039 tmp_len = 0;
1040 }
1041 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1042 {
1043 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1044 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1045 }
1046 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1047 {
1048 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1049 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1050 }
1051
1052 if (data.digests_cnt == 1)
1053 {
1054 if (data.hash_mode == 2500)
1055 {
1056 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1057
1058 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1059 (char *) data.salts_buf[0].salt_buf,
1060 wpa->orig_mac1[0],
1061 wpa->orig_mac1[1],
1062 wpa->orig_mac1[2],
1063 wpa->orig_mac1[3],
1064 wpa->orig_mac1[4],
1065 wpa->orig_mac1[5],
1066 wpa->orig_mac2[0],
1067 wpa->orig_mac2[1],
1068 wpa->orig_mac2[2],
1069 wpa->orig_mac2[3],
1070 wpa->orig_mac2[4],
1071 wpa->orig_mac2[5]);
1072 }
1073 else if (data.hash_mode == 5200)
1074 {
1075 log_info ("Hash.Target....: File (%s)", data.hashfile);
1076 }
1077 else if (data.hash_mode == 9000)
1078 {
1079 log_info ("Hash.Target....: File (%s)", data.hashfile);
1080 }
1081 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1082 {
1083 log_info ("Hash.Target....: File (%s)", data.hashfile);
1084 }
1085 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1086 {
1087 log_info ("Hash.Target....: File (%s)", data.hashfile);
1088 }
1089 else
1090 {
1091 char out_buf[HCBUFSIZ] = { 0 };
1092
1093 ascii_digest (out_buf, 0, 0);
1094
1095 // limit length
1096 if (strlen (out_buf) > 40)
1097 {
1098 out_buf[41] = '.';
1099 out_buf[42] = '.';
1100 out_buf[43] = '.';
1101 out_buf[44] = 0;
1102 }
1103
1104 log_info ("Hash.Target....: %s", out_buf);
1105 }
1106 }
1107 else
1108 {
1109 if (data.hash_mode == 3000)
1110 {
1111 char out_buf1[32] = { 0 };
1112 char out_buf2[32] = { 0 };
1113
1114 ascii_digest (out_buf1, 0, 0);
1115 ascii_digest (out_buf2, 0, 1);
1116
1117 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1118 }
1119 else
1120 {
1121 log_info ("Hash.Target....: File (%s)", data.hashfile);
1122 }
1123 }
1124
1125 log_info ("Hash.Type......: %s", hash_type);
1126
1127 /**
1128 * speed new
1129 */
1130
1131 u64 speed_cnt[DEVICES_MAX] = { 0 };
1132 double speed_ms[DEVICES_MAX] = { 0 };
1133
1134 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1135 {
1136 hc_device_param_t *device_param = &data.devices_param[device_id];
1137
1138 if (device_param->skipped) continue;
1139
1140 speed_cnt[device_id] = 0;
1141 speed_ms[device_id] = 0;
1142
1143 for (int i = 0; i < SPEED_CACHE; i++)
1144 {
1145 speed_cnt[device_id] += device_param->speed_cnt[i];
1146 speed_ms[device_id] += device_param->speed_ms[i];
1147 }
1148
1149 speed_cnt[device_id] /= SPEED_CACHE;
1150 speed_ms[device_id] /= SPEED_CACHE;
1151 }
1152
1153 double hashes_all_ms = 0;
1154
1155 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1156
1157 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1158 {
1159 hc_device_param_t *device_param = &data.devices_param[device_id];
1160
1161 if (device_param->skipped) continue;
1162
1163 hashes_dev_ms[device_id] = 0;
1164
1165 if (speed_ms[device_id])
1166 {
1167 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1168
1169 hashes_all_ms += hashes_dev_ms[device_id];
1170 }
1171 }
1172
1173 /**
1174 * exec time
1175 */
1176
1177 double exec_all_ms[DEVICES_MAX] = { 0 };
1178
1179 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1180 {
1181 hc_device_param_t *device_param = &data.devices_param[device_id];
1182
1183 if (device_param->skipped) continue;
1184
1185 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1186
1187 exec_all_ms[device_id] = exec_ms_avg;
1188 }
1189
1190 /**
1191 * timers
1192 */
1193
1194 double ms_running = 0;
1195
1196 hc_timer_get (data.timer_running, ms_running);
1197
1198 double ms_paused = data.ms_paused;
1199
1200 if (data.devices_status == STATUS_PAUSED)
1201 {
1202 double ms_paused_tmp = 0;
1203
1204 hc_timer_get (data.timer_paused, ms_paused_tmp);
1205
1206 ms_paused += ms_paused_tmp;
1207 }
1208
1209 #ifdef WIN
1210
1211 __time64_t sec_run = ms_running / 1000;
1212
1213 #else
1214
1215 time_t sec_run = ms_running / 1000;
1216
1217 #endif
1218
1219 if (sec_run)
1220 {
1221 char display_run[32] = { 0 };
1222
1223 struct tm tm_run;
1224
1225 struct tm *tmp = NULL;
1226
1227 #ifdef WIN
1228
1229 tmp = _gmtime64 (&sec_run);
1230
1231 #else
1232
1233 tmp = gmtime (&sec_run);
1234
1235 #endif
1236
1237 if (tmp != NULL)
1238 {
1239 memset (&tm_run, 0, sizeof (tm_run));
1240
1241 memcpy (&tm_run, tmp, sizeof (tm_run));
1242
1243 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1244
1245 char *start = ctime (&data.proc_start);
1246
1247 size_t start_len = strlen (start);
1248
1249 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1250 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1251
1252 log_info ("Time.Started...: %s (%s)", start, display_run);
1253 }
1254 }
1255 else
1256 {
1257 log_info ("Time.Started...: 0 secs");
1258 }
1259
1260 /**
1261 * counters
1262 */
1263
1264 u64 progress_total = data.words_cnt * data.salts_cnt;
1265
1266 u64 all_done = 0;
1267 u64 all_rejected = 0;
1268 u64 all_restored = 0;
1269
1270 u64 progress_noneed = 0;
1271
1272 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1273 {
1274 all_done += data.words_progress_done[salt_pos];
1275 all_rejected += data.words_progress_rejected[salt_pos];
1276 all_restored += data.words_progress_restored[salt_pos];
1277
1278 // Important for ETA only
1279
1280 if (data.salts_shown[salt_pos] == 1)
1281 {
1282 const u64 all = data.words_progress_done[salt_pos]
1283 + data.words_progress_rejected[salt_pos]
1284 + data.words_progress_restored[salt_pos];
1285
1286 const u64 left = data.words_cnt - all;
1287
1288 progress_noneed += left;
1289 }
1290 }
1291
1292 u64 progress_cur = all_restored + all_done + all_rejected;
1293 u64 progress_end = progress_total;
1294
1295 u64 progress_skip = 0;
1296
1297 if (data.skip)
1298 {
1299 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1300
1301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1302 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1304 }
1305
1306 if (data.limit)
1307 {
1308 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1309
1310 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1311 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1313 }
1314
1315 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1316 u64 progress_end_relative_skip = progress_end - progress_skip;
1317
1318 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1319 {
1320 if (data.devices_status != STATUS_CRACKED)
1321 {
1322 #ifdef WIN
1323 __time64_t sec_etc = 0;
1324 #else
1325 time_t sec_etc = 0;
1326 #endif
1327
1328 if (hashes_all_ms)
1329 {
1330 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1331
1332 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1333
1334 sec_etc = ms_left / 1000;
1335 }
1336
1337 if (sec_etc == 0)
1338 {
1339 //log_info ("Time.Estimated.: 0 secs");
1340 }
1341 else if ((u64) sec_etc > ETC_MAX)
1342 {
1343 log_info ("Time.Estimated.: > 10 Years");
1344 }
1345 else
1346 {
1347 char display_etc[32] = { 0 };
1348
1349 struct tm tm_etc;
1350
1351 struct tm *tmp = NULL;
1352
1353 #ifdef WIN
1354
1355 tmp = _gmtime64 (&sec_etc);
1356
1357 #else
1358
1359 tmp = gmtime (&sec_etc);
1360
1361 #endif
1362
1363 if (tmp != NULL)
1364 {
1365 memset (&tm_etc, 0, sizeof (tm_etc));
1366
1367 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1368
1369 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1370
1371 time_t now;
1372
1373 time (&now);
1374
1375 now += sec_etc;
1376
1377 char *etc = ctime (&now);
1378
1379 size_t etc_len = strlen (etc);
1380
1381 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1382 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1383
1384 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1385 }
1386 }
1387 }
1388 }
1389
1390 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1391 {
1392 hc_device_param_t *device_param = &data.devices_param[device_id];
1393
1394 if (device_param->skipped) continue;
1395
1396 char display_dev_cur[16] = { 0 };
1397
1398 strncpy (display_dev_cur, "0.00", 4);
1399
1400 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1401
1402 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1403 }
1404
1405 char display_all_cur[16] = { 0 };
1406
1407 strncpy (display_all_cur, "0.00", 4);
1408
1409 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1410
1411 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1412
1413 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1414 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1415
1416 log_info ("Recovered......: %u/%u (%.2f%%) Digests, %u/%u (%.2f%%) Salts", data.digests_done, data.digests_cnt, digests_percent * 100, data.salts_done, data.salts_cnt, salts_percent * 100);
1417
1418 // crack-per-time
1419
1420 if (data.digests_cnt > 100)
1421 {
1422 time_t now = time (NULL);
1423
1424 int cpt_cur_min = 0;
1425 int cpt_cur_hour = 0;
1426 int cpt_cur_day = 0;
1427
1428 for (int i = 0; i < CPT_BUF; i++)
1429 {
1430 const uint cracked = data.cpt_buf[i].cracked;
1431 const time_t timestamp = data.cpt_buf[i].timestamp;
1432
1433 if ((timestamp + 60) > now)
1434 {
1435 cpt_cur_min += cracked;
1436 }
1437
1438 if ((timestamp + 3600) > now)
1439 {
1440 cpt_cur_hour += cracked;
1441 }
1442
1443 if ((timestamp + 86400) > now)
1444 {
1445 cpt_cur_day += cracked;
1446 }
1447 }
1448
1449 double ms_real = ms_running - ms_paused;
1450
1451 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1452 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1453 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1454
1455 if ((data.cpt_start + 86400) < now)
1456 {
1457 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1458 cpt_cur_min,
1459 cpt_cur_hour,
1460 cpt_cur_day,
1461 cpt_avg_min,
1462 cpt_avg_hour,
1463 cpt_avg_day);
1464 }
1465 else if ((data.cpt_start + 3600) < now)
1466 {
1467 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1468 cpt_cur_min,
1469 cpt_cur_hour,
1470 cpt_avg_min,
1471 cpt_avg_hour,
1472 cpt_avg_day);
1473 }
1474 else if ((data.cpt_start + 60) < now)
1475 {
1476 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1477 cpt_cur_min,
1478 cpt_avg_min,
1479 cpt_avg_hour,
1480 cpt_avg_day);
1481 }
1482 else
1483 {
1484 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1485 cpt_avg_min,
1486 cpt_avg_hour,
1487 cpt_avg_day);
1488 }
1489 }
1490
1491 // Restore point
1492
1493 u64 restore_point = get_lowest_words_done ();
1494
1495 u64 restore_total = data.words_base;
1496
1497 float percent_restore = 0;
1498
1499 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1500
1501 if (progress_end_relative_skip)
1502 {
1503 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1504 {
1505 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1506 float percent_rejected = 0.0;
1507
1508 if (progress_cur)
1509 {
1510 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1511 }
1512
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip, percent_finished * 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 if (percent_finished != 1)
1519 {
1520 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1521 }
1522 }
1523 }
1524 }
1525 else
1526 {
1527 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1528 {
1529 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1530 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531
1532 if (data.restore_disable == 0)
1533 {
1534 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1535 }
1536 }
1537 else
1538 {
1539 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1540 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1541
1542 // --restore not allowed if stdin is used -- really? why?
1543
1544 //if (data.restore_disable == 0)
1545 //{
1546 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1547 //}
1548 }
1549 }
1550
1551 #ifdef HAVE_HWMON
1552 if (data.gpu_temp_disable == 0)
1553 {
1554 hc_thread_mutex_lock (mux_adl);
1555
1556 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1557 {
1558 hc_device_param_t *device_param = &data.devices_param[device_id];
1559
1560 if (device_param->skipped) continue;
1561
1562 #define HM_STR_BUF_SIZE 255
1563
1564 if (data.hm_device[device_id].fan_supported == 1)
1565 {
1566 char utilization[HM_STR_BUF_SIZE] = { 0 };
1567 char temperature[HM_STR_BUF_SIZE] = { 0 };
1568 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1569
1570 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1571 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1572
1573 if (device_param->vendor_id == VENDOR_ID_AMD)
1574 {
1575 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1576 }
1577 else if (device_param->vendor_id == VENDOR_ID_NV)
1578 {
1579 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1580 }
1581
1582 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1583 }
1584 else
1585 {
1586 char utilization[HM_STR_BUF_SIZE] = { 0 };
1587 char temperature[HM_STR_BUF_SIZE] = { 0 };
1588
1589 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1590 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1591
1592 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1593 }
1594 }
1595
1596 hc_thread_mutex_unlock (mux_adl);
1597 }
1598 #endif // HAVE_HWMON
1599 }
1600
1601 static void status_benchmark_automat ()
1602 {
1603 u64 speed_cnt[DEVICES_MAX] = { 0 };
1604 double speed_ms[DEVICES_MAX] = { 0 };
1605
1606 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1607 {
1608 hc_device_param_t *device_param = &data.devices_param[device_id];
1609
1610 if (device_param->skipped) continue;
1611
1612 speed_cnt[device_id] = device_param->speed_cnt[0];
1613 speed_ms[device_id] = device_param->speed_ms[0];
1614 }
1615
1616 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1617
1618 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1619 {
1620 hc_device_param_t *device_param = &data.devices_param[device_id];
1621
1622 if (device_param->skipped) continue;
1623
1624 hashes_dev_ms[device_id] = 0;
1625
1626 if (speed_ms[device_id])
1627 {
1628 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1629 }
1630 }
1631
1632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1633 {
1634 hc_device_param_t *device_param = &data.devices_param[device_id];
1635
1636 if (device_param->skipped) continue;
1637
1638 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1639 }
1640 }
1641
1642 static void status_benchmark ()
1643 {
1644 if (data.devices_status == STATUS_INIT) return;
1645 if (data.devices_status == STATUS_STARTING) return;
1646 if (data.devices_status == STATUS_BYPASS) return;
1647
1648 if (data.status_automat == 1)
1649 {
1650 status_benchmark_automat ();
1651
1652 return;
1653 }
1654
1655 u64 speed_cnt[DEVICES_MAX] = { 0 };
1656 double speed_ms[DEVICES_MAX] = { 0 };
1657
1658 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1659 {
1660 hc_device_param_t *device_param = &data.devices_param[device_id];
1661
1662 if (device_param->skipped) continue;
1663
1664 speed_cnt[device_id] = device_param->speed_cnt[0];
1665 speed_ms[device_id] = device_param->speed_ms[0];
1666 }
1667
1668 double hashes_all_ms = 0;
1669
1670 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1671
1672 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1673 {
1674 hc_device_param_t *device_param = &data.devices_param[device_id];
1675
1676 if (device_param->skipped) continue;
1677
1678 hashes_dev_ms[device_id] = 0;
1679
1680 if (speed_ms[device_id])
1681 {
1682 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1683
1684 hashes_all_ms += hashes_dev_ms[device_id];
1685 }
1686 }
1687
1688 /**
1689 * exec time
1690 */
1691
1692 double exec_all_ms[DEVICES_MAX] = { 0 };
1693
1694 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1695 {
1696 hc_device_param_t *device_param = &data.devices_param[device_id];
1697
1698 if (device_param->skipped) continue;
1699
1700 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1701
1702 exec_all_ms[device_id] = exec_ms_avg;
1703 }
1704
1705 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1706 {
1707 hc_device_param_t *device_param = &data.devices_param[device_id];
1708
1709 if (device_param->skipped) continue;
1710
1711 char display_dev_cur[16] = { 0 };
1712
1713 strncpy (display_dev_cur, "0.00", 4);
1714
1715 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1716
1717 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1718 }
1719
1720 char display_all_cur[16] = { 0 };
1721
1722 strncpy (display_all_cur, "0.00", 4);
1723
1724 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1725
1726 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1727 }
1728
1729 /**
1730 * hashcat -only- functions
1731 */
1732
1733 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1734 {
1735 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1736 {
1737 if (attack_kern == ATTACK_KERN_STRAIGHT)
1738 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1739 else if (attack_kern == ATTACK_KERN_COMBI)
1740 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1741 else if (attack_kern == ATTACK_KERN_BF)
1742 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1743 }
1744 else
1745 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1746 }
1747
1748 static void generate_cached_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1749 {
1750 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1751 {
1752 if (attack_kern == ATTACK_KERN_STRAIGHT)
1753 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1754 else if (attack_kern == ATTACK_KERN_COMBI)
1755 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1756 else if (attack_kern == ATTACK_KERN_BF)
1757 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1758 }
1759 else
1760 {
1761 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1762 }
1763 }
1764
1765 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1766 {
1767 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1768 {
1769 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1770 }
1771 else
1772 {
1773 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1774 }
1775 }
1776
1777 static void generate_cached_kernel_mp_filename (const uint opti_type, const uint opts_type, char *profile_dir, const char *device_name_chksum, char *cached_file)
1778 {
1779 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1780 {
1781 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1790 {
1791 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1792 }
1793
1794 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1795 {
1796 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1797 }
1798
1799 static uint convert_from_hex (char *line_buf, const uint line_len)
1800 {
1801 if (line_len & 1) return (line_len); // not in hex
1802
1803 if (data.hex_wordlist == 1)
1804 {
1805 uint i;
1806 uint j;
1807
1808 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1809 {
1810 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1811 }
1812
1813 memset (line_buf + i, 0, line_len - i);
1814
1815 return (i);
1816 }
1817 else if (line_len >= 6) // $HEX[] = 6
1818 {
1819 if (line_buf[0] != '$') return (line_len);
1820 if (line_buf[1] != 'H') return (line_len);
1821 if (line_buf[2] != 'E') return (line_len);
1822 if (line_buf[3] != 'X') return (line_len);
1823 if (line_buf[4] != '[') return (line_len);
1824 if (line_buf[line_len - 1] != ']') return (line_len);
1825
1826 uint i;
1827 uint j;
1828
1829 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1830 {
1831 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1832 }
1833
1834 memset (line_buf + i, 0, line_len - i);
1835
1836 return (i);
1837 }
1838
1839 return (line_len);
1840 }
1841
1842 static void clear_prompt ()
1843 {
1844 fputc ('\r', stdout);
1845
1846 for (size_t i = 0; i < strlen (PROMPT); i++)
1847 {
1848 fputc (' ', stdout);
1849 }
1850
1851 fputc ('\r', stdout);
1852
1853 fflush (stdout);
1854 }
1855
1856 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1857 {
1858 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL);
1859 }
1860
1861 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1862 {
1863 char *outfile = data.outfile;
1864 uint quiet = data.quiet;
1865 FILE *pot_fp = data.pot_fp;
1866 uint loopback = data.loopback;
1867 uint debug_mode = data.debug_mode;
1868 char *debug_file = data.debug_file;
1869
1870 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1871 int debug_rule_len = 0; // -1 error
1872 uint debug_plain_len = 0;
1873
1874 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1875
1876 // hash
1877
1878 char out_buf[HCBUFSIZ] = { 0 };
1879
1880 const u32 salt_pos = plain->salt_pos;
1881 const u32 digest_pos = plain->digest_pos; // relative
1882 const u32 gidvid = plain->gidvid;
1883 const u32 il_pos = plain->il_pos;
1884
1885 ascii_digest (out_buf, salt_pos, digest_pos);
1886
1887 // plain
1888
1889 u64 crackpos = device_param->words_off;
1890
1891 uint plain_buf[16] = { 0 };
1892
1893 u8 *plain_ptr = (u8 *) plain_buf;
1894
1895 unsigned int plain_len = 0;
1896
1897 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1898 {
1899 pw_t pw;
1900
1901 gidd_to_pw_t (device_param, gidvid, &pw);
1902
1903 for (int i = 0; i < 16; i++)
1904 {
1905 plain_buf[i] = pw.i[i];
1906 }
1907
1908 plain_len = pw.pw_len;
1909
1910 const uint off = device_param->innerloop_pos + il_pos;
1911
1912 if (debug_mode > 0)
1913 {
1914 debug_rule_len = 0;
1915
1916 // save rule
1917 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1918 {
1919 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1920
1921 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1922 }
1923
1924 // save plain
1925 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1926 {
1927 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1928
1929 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1930
1931 debug_plain_len = plain_len;
1932 }
1933 }
1934
1935 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1936
1937 crackpos += gidvid;
1938 crackpos *= data.kernel_rules_cnt;
1939 crackpos += device_param->innerloop_pos + il_pos;
1940
1941 if (plain_len > data.pw_max) plain_len = data.pw_max;
1942 }
1943 else if (data.attack_mode == ATTACK_MODE_COMBI)
1944 {
1945 pw_t pw;
1946
1947 gidd_to_pw_t (device_param, gidvid, &pw);
1948
1949 for (int i = 0; i < 16; i++)
1950 {
1951 plain_buf[i] = pw.i[i];
1952 }
1953
1954 plain_len = pw.pw_len;
1955
1956 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1957 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1958
1959 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1960 {
1961 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1962 }
1963 else
1964 {
1965 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1966
1967 memcpy (plain_ptr, comb_buf, comb_len);
1968 }
1969
1970 plain_len += comb_len;
1971
1972 crackpos += gidvid;
1973 crackpos *= data.combs_cnt;
1974 crackpos += device_param->innerloop_pos + il_pos;
1975
1976 if (data.pw_max != PW_DICTMAX1)
1977 {
1978 if (plain_len > data.pw_max) plain_len = data.pw_max;
1979 }
1980 }
1981 else if (data.attack_mode == ATTACK_MODE_BF)
1982 {
1983 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1984 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1985
1986 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1987 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1988
1989 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1990 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1991
1992 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1993 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1994
1995 plain_len = data.css_cnt;
1996
1997 crackpos += gidvid;
1998 crackpos *= data.bfs_cnt;
1999 crackpos += device_param->innerloop_pos + il_pos;
2000 }
2001 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2002 {
2003 pw_t pw;
2004
2005 gidd_to_pw_t (device_param, gidvid, &pw);
2006
2007 for (int i = 0; i < 16; i++)
2008 {
2009 plain_buf[i] = pw.i[i];
2010 }
2011
2012 plain_len = pw.pw_len;
2013
2014 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2015
2016 uint start = 0;
2017 uint stop = device_param->kernel_params_mp_buf32[4];
2018
2019 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2020
2021 plain_len += start + stop;
2022
2023 crackpos += gidvid;
2024 crackpos *= data.combs_cnt;
2025 crackpos += device_param->innerloop_pos + il_pos;
2026
2027 if (data.pw_max != PW_DICTMAX1)
2028 {
2029 if (plain_len > data.pw_max) plain_len = data.pw_max;
2030 }
2031 }
2032 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2033 {
2034 pw_t pw;
2035
2036 gidd_to_pw_t (device_param, gidvid, &pw);
2037
2038 for (int i = 0; i < 16; i++)
2039 {
2040 plain_buf[i] = pw.i[i];
2041 }
2042
2043 plain_len = pw.pw_len;
2044
2045 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2046
2047 uint start = 0;
2048 uint stop = device_param->kernel_params_mp_buf32[4];
2049
2050 memmove (plain_ptr + stop, plain_ptr, plain_len);
2051
2052 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2053
2054 plain_len += start + stop;
2055
2056 crackpos += gidvid;
2057 crackpos *= data.combs_cnt;
2058 crackpos += device_param->innerloop_pos + il_pos;
2059
2060 if (data.pw_max != PW_DICTMAX1)
2061 {
2062 if (plain_len > data.pw_max) plain_len = data.pw_max;
2063 }
2064 }
2065
2066 if (data.attack_mode == ATTACK_MODE_BF)
2067 {
2068 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2069 {
2070 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2071 {
2072 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2073 {
2074 plain_len = plain_len - data.salts_buf[0].salt_len;
2075 }
2076 }
2077
2078 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2079 {
2080 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2081 {
2082 plain_ptr[j] = plain_ptr[i];
2083 }
2084
2085 plain_len = plain_len / 2;
2086 }
2087 }
2088 }
2089
2090 // if enabled, update also the potfile
2091
2092 if (pot_fp)
2093 {
2094 lock_file (pot_fp);
2095
2096 fprintf (pot_fp, "%s:", out_buf);
2097
2098 format_plain (pot_fp, plain_ptr, plain_len, 1);
2099
2100 fputc ('\n', pot_fp);
2101
2102 fflush (pot_fp);
2103
2104 unlock_file (pot_fp);
2105 }
2106
2107 // outfile
2108
2109 FILE *out_fp = NULL;
2110
2111 if (outfile != NULL)
2112 {
2113 if ((out_fp = fopen (outfile, "ab")) == NULL)
2114 {
2115 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2116
2117 out_fp = stdout;
2118 }
2119 lock_file (out_fp);
2120 }
2121 else
2122 {
2123 out_fp = stdout;
2124
2125 if (quiet == 0) clear_prompt ();
2126 }
2127
2128 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2129
2130 if (outfile != NULL)
2131 {
2132 if (out_fp != stdout)
2133 {
2134 fclose (out_fp);
2135 }
2136 }
2137 else
2138 {
2139 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2140 {
2141 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2142 {
2143 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2144 if (quiet == 0) fflush (stdout);
2145 }
2146 }
2147 }
2148
2149 // loopback
2150
2151 if (loopback)
2152 {
2153 char *loopback_file = data.loopback_file;
2154
2155 FILE *fb_fp = NULL;
2156
2157 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2158 {
2159 lock_file (fb_fp);
2160
2161 format_plain (fb_fp, plain_ptr, plain_len, 1);
2162
2163 fputc ('\n', fb_fp);
2164
2165 fclose (fb_fp);
2166 }
2167 }
2168
2169 // (rule) debug mode
2170
2171 // the next check implies that:
2172 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2173 // - debug_mode > 0
2174
2175 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2176 {
2177 if (debug_rule_len < 0) debug_rule_len = 0;
2178
2179 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2180
2181 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2182
2183 if ((quiet == 0) && (debug_file == NULL))
2184 {
2185 fprintf (stdout, "%s", PROMPT);
2186
2187 fflush (stdout);
2188 }
2189 }
2190 }
2191
2192 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2193 {
2194 salt_t *salt_buf = &data.salts_buf[salt_pos];
2195
2196 u32 num_cracked;
2197
2198 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2199
2200 if (num_cracked)
2201 {
2202 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2203
2204 log_info_nn ("");
2205
2206 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2207
2208 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL);
2209
2210 uint cpt_cracked = 0;
2211
2212 for (uint i = 0; i < num_cracked; i++)
2213 {
2214 const uint hash_pos = cracked[i].hash_pos;
2215
2216 if (data.digests_shown[hash_pos] == 1) continue;
2217
2218 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2219 {
2220 data.digests_shown[hash_pos] = 1;
2221
2222 data.digests_done++;
2223
2224 cpt_cracked++;
2225
2226 salt_buf->digests_done++;
2227
2228 if (salt_buf->digests_done == salt_buf->digests_cnt)
2229 {
2230 data.salts_shown[salt_pos] = 1;
2231
2232 data.salts_done++;
2233 }
2234 }
2235
2236 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2237
2238 check_hash (device_param, &cracked[i]);
2239 }
2240
2241 myfree (cracked);
2242
2243 if (cpt_cracked > 0)
2244 {
2245 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2246 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2247
2248 data.cpt_pos++;
2249
2250 data.cpt_total += cpt_cracked;
2251
2252 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2253 }
2254
2255 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2256 {
2257 // we need to reset cracked state on the device
2258 // otherwise host thinks again and again the hash was cracked
2259 // and returns invalid password each time
2260
2261 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2262
2263 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL);
2264 }
2265
2266 num_cracked = 0;
2267
2268 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2269 }
2270 }
2271
2272 static void save_hash ()
2273 {
2274 char *hashfile = data.hashfile;
2275
2276 char new_hashfile[256] = { 0 };
2277 char old_hashfile[256] = { 0 };
2278
2279 snprintf (new_hashfile, 255, "%s.new", hashfile);
2280 snprintf (old_hashfile, 255, "%s.old", hashfile);
2281
2282 unlink (new_hashfile);
2283
2284 char separator = data.separator;
2285
2286 FILE *fp = fopen (new_hashfile, "wb");
2287
2288 if (fp == NULL)
2289 {
2290 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2291
2292 exit (-1);
2293 }
2294
2295 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2296 {
2297 if (data.salts_shown[salt_pos] == 1) continue;
2298
2299 salt_t *salt_buf = &data.salts_buf[salt_pos];
2300
2301 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2302 {
2303 uint idx = salt_buf->digests_offset + digest_pos;
2304
2305 if (data.digests_shown[idx] == 1) continue;
2306
2307 if (data.hash_mode != 2500)
2308 {
2309 char out_buf[HCBUFSIZ] = { 0 };
2310
2311 if (data.username == 1)
2312 {
2313 user_t *user = data.hash_info[idx]->user;
2314
2315 uint i;
2316
2317 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2318
2319 fputc (separator, fp);
2320 }
2321
2322 ascii_digest (out_buf, salt_pos, digest_pos);
2323
2324 fputs (out_buf, fp);
2325
2326 log_out (fp, "");
2327 }
2328 else
2329 {
2330 hccap_t hccap;
2331
2332 to_hccap_t (&hccap, salt_pos, digest_pos);
2333
2334 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2335 }
2336 }
2337 }
2338
2339 fflush (fp);
2340
2341 fclose (fp);
2342
2343 unlink (old_hashfile);
2344
2345 if (rename (hashfile, old_hashfile) != 0)
2346 {
2347 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2348
2349 exit (-1);
2350 }
2351
2352 unlink (hashfile);
2353
2354 if (rename (new_hashfile, hashfile) != 0)
2355 {
2356 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2357
2358 exit (-1);
2359 }
2360
2361 unlink (old_hashfile);
2362 }
2363
2364 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2365 {
2366 // function called only in case kernel_power_all > words_left
2367
2368 float kernel_power_div = (float) (total_left) / kernel_power_all;
2369
2370 kernel_power_div += kernel_power_div / 100;
2371
2372 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2373
2374 while (kernel_power_new < total_left)
2375 {
2376 kernel_power_div += kernel_power_div / 100;
2377
2378 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2379 }
2380
2381 if (data.quiet == 0)
2382 {
2383 clear_prompt ();
2384
2385 //log_info ("");
2386
2387 log_info ("INFO: approaching final keyspace, workload adjusted");
2388 log_info ("");
2389
2390 fprintf (stdout, "%s", PROMPT);
2391
2392 fflush (stdout);
2393 }
2394
2395 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2396
2397 return kernel_power_div;
2398 }
2399
2400 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2401 {
2402 uint num_elements = num;
2403
2404 device_param->kernel_params_buf32[30] = data.combs_mode;
2405 device_param->kernel_params_buf32[31] = num;
2406
2407 uint kernel_threads = device_param->kernel_threads;
2408
2409 while (num_elements % kernel_threads) num_elements++;
2410
2411 cl_kernel kernel = NULL;
2412
2413 switch (kern_run)
2414 {
2415 case KERN_RUN_1: kernel = device_param->kernel1; break;
2416 case KERN_RUN_12: kernel = device_param->kernel12; break;
2417 case KERN_RUN_2: kernel = device_param->kernel2; break;
2418 case KERN_RUN_23: kernel = device_param->kernel23; break;
2419 case KERN_RUN_3: kernel = device_param->kernel3; break;
2420 }
2421
2422 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2423 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2424 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2425 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2426 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2427 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2428 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2429 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2430 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2431 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2432 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2433
2434 cl_event event;
2435
2436 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2437 {
2438 const size_t global_work_size[3] = { num_elements, 32, 1 };
2439 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2440
2441 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2442 }
2443 else
2444 {
2445 if (kern_run == KERN_RUN_2)
2446 {
2447 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2448 {
2449 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2450 }
2451 }
2452
2453 while (num_elements % kernel_threads) num_elements++;
2454
2455 const size_t global_work_size[3] = { num_elements, 1, 1 };
2456 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2457
2458 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2459 }
2460
2461 hc_clFlush (data.ocl, device_param->command_queue);
2462
2463 hc_clWaitForEvents (data.ocl, 1, &event);
2464
2465 if (event_update)
2466 {
2467 cl_ulong time_start;
2468 cl_ulong time_end;
2469
2470 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2471 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2472
2473 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2474
2475 uint exec_pos = device_param->exec_pos;
2476
2477 device_param->exec_ms[exec_pos] = exec_time;
2478
2479 exec_pos++;
2480
2481 if (exec_pos == EXEC_CACHE)
2482 {
2483 exec_pos = 0;
2484 }
2485
2486 device_param->exec_pos = exec_pos;
2487 }
2488
2489 hc_clReleaseEvent (data.ocl, event);
2490
2491 hc_clFinish (data.ocl, device_param->command_queue);
2492 }
2493
2494 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2495 {
2496 uint num_elements = num;
2497
2498 switch (kern_run)
2499 {
2500 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2501 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2502 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2503 }
2504
2505 // causes problems with special threads like in bcrypt
2506 // const uint kernel_threads = device_param->kernel_threads;
2507
2508 uint kernel_threads = device_param->kernel_threads;
2509
2510 while (num_elements % kernel_threads) num_elements++;
2511
2512 cl_kernel kernel = NULL;
2513
2514 switch (kern_run)
2515 {
2516 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2517 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2518 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2519 }
2520
2521 switch (kern_run)
2522 {
2523 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2524 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2525 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2526 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2527 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2528 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2529 break;
2530 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2531 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2532 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2533 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2534 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2535 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2536 break;
2537 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2538 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2539 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2540 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2541 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2542 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2543 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2544 break;
2545 }
2546
2547 const size_t global_work_size[3] = { num_elements, 1, 1 };
2548 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2549
2550 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2551
2552 hc_clFlush (data.ocl, device_param->command_queue);
2553
2554 hc_clFinish (data.ocl, device_param->command_queue);
2555 }
2556
2557 static void run_kernel_tm (hc_device_param_t *device_param)
2558 {
2559 const uint num_elements = 1024; // fixed
2560
2561 uint kernel_threads = 32;
2562
2563 cl_kernel kernel = device_param->kernel_tm;
2564
2565 const size_t global_work_size[3] = { num_elements, 1, 1 };
2566 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2567
2568 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2569
2570 hc_clFlush (data.ocl, device_param->command_queue);
2571
2572 hc_clFinish (data.ocl, device_param->command_queue);
2573 }
2574
2575 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2576 {
2577 uint num_elements = num;
2578
2579 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2580 device_param->kernel_params_amp_buf32[6] = num_elements;
2581
2582 // causes problems with special threads like in bcrypt
2583 // const uint kernel_threads = device_param->kernel_threads;
2584
2585 uint kernel_threads = device_param->kernel_threads;
2586
2587 while (num_elements % kernel_threads) num_elements++;
2588
2589 cl_kernel kernel = device_param->kernel_amp;
2590
2591 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2592 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2593
2594 const size_t global_work_size[3] = { num_elements, 1, 1 };
2595 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2596
2597 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2598
2599 hc_clFlush (data.ocl, device_param->command_queue);
2600
2601 hc_clFinish (data.ocl, device_param->command_queue);
2602 }
2603
2604 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2605 {
2606 int rc = -1;
2607
2608 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2609 {
2610 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2611
2612 const cl_uchar zero = 0;
2613
2614 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2615 }
2616
2617 if (rc != 0)
2618 {
2619 // NOTE: clEnqueueFillBuffer () always fails with -59
2620 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2621 // How's that possible, OpenCL 1.2 support is advertised??
2622 // We need to workaround...
2623
2624 #define FILLSZ 0x100000
2625
2626 char *tmp = (char *) mymalloc (FILLSZ);
2627
2628 for (size_t i = 0; i < size; i += FILLSZ)
2629 {
2630 const size_t left = size - i;
2631
2632 const size_t fillsz = MIN (FILLSZ, left);
2633
2634 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2635 }
2636
2637 myfree (tmp);
2638 }
2639 }
2640
2641 static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt)
2642 {
2643 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2644 {
2645 if (attack_mode == ATTACK_MODE_BF)
2646 {
2647 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2648 {
2649 const uint size_tm = 32 * sizeof (bs_word_t);
2650
2651 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2652
2653 run_kernel_tm (device_param);
2654
2655 hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_tm_c, device_param->d_bfs_c, 0, 0, size_tm, 0, NULL, NULL);
2656 }
2657 }
2658
2659 if (highest_pw_len < 16)
2660 {
2661 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2662 }
2663 else if (highest_pw_len < 32)
2664 {
2665 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2666 }
2667 else
2668 {
2669 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2670 }
2671 }
2672 else
2673 {
2674 run_kernel_amp (device_param, pws_cnt);
2675
2676 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2677
2678 if (opts_type & OPTS_TYPE_HOOK12)
2679 {
2680 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2681 }
2682
2683 uint iter = salt_buf->salt_iter;
2684
2685 uint loop_step = device_param->kernel_loops;
2686
2687 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2688 {
2689 uint loop_left = iter - loop_pos;
2690
2691 loop_left = MIN (loop_left, loop_step);
2692
2693 device_param->kernel_params_buf32[25] = loop_pos;
2694 device_param->kernel_params_buf32[26] = loop_left;
2695
2696 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2697
2698 if (data.devices_status == STATUS_CRACKED) break;
2699 if (data.devices_status == STATUS_ABORTED) break;
2700 if (data.devices_status == STATUS_QUIT) break;
2701
2702 /**
2703 * speed
2704 */
2705
2706 const float iter_part = (float) (loop_pos + loop_left) / iter;
2707
2708 const u64 perf_sum_all = pws_cnt * iter_part;
2709
2710 double speed_ms;
2711
2712 hc_timer_get (device_param->timer_speed, speed_ms);
2713
2714 const u32 speed_pos = device_param->speed_pos;
2715
2716 device_param->speed_cnt[speed_pos] = perf_sum_all;
2717
2718 device_param->speed_ms[speed_pos] = speed_ms;
2719
2720 if (data.benchmark == 1)
2721 {
2722 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2723 }
2724 }
2725
2726 if (opts_type & OPTS_TYPE_HOOK23)
2727 {
2728 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2729
2730 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2731
2732 // do something with data
2733
2734 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL);
2735 }
2736
2737 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2738 }
2739 }
2740
2741 static int run_rule_engine (const int rule_len, const char *rule_buf)
2742 {
2743 if (rule_len == 0)
2744 {
2745 return 0;
2746 }
2747 else if (rule_len == 1)
2748 {
2749 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2750 }
2751
2752 return 1;
2753 }
2754
2755 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2756 {
2757 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2758 {
2759 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, pws_cnt * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL);
2760 }
2761 else if (data.attack_kern == ATTACK_KERN_COMBI)
2762 {
2763 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2764 {
2765 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2766 {
2767 for (u32 i = 0; i < pws_cnt; i++)
2768 {
2769 const u32 pw_len = device_param->pws_buf[i].pw_len;
2770
2771 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2772
2773 ptr[pw_len] = 0x01;
2774 }
2775 }
2776 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2777 {
2778 for (u32 i = 0; i < pws_cnt; i++)
2779 {
2780 const u32 pw_len = device_param->pws_buf[i].pw_len;
2781
2782 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2783
2784 ptr[pw_len] = 0x80;
2785 }
2786 }
2787 }
2788
2789 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);
2790 }
2791 else if (data.attack_kern == ATTACK_KERN_BF)
2792 {
2793 const u64 off = device_param->words_off;
2794
2795 device_param->kernel_params_mp_l_buf64[3] = off;
2796
2797 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2798 }
2799 }
2800
2801 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2802 {
2803 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2804
2805 device_param->kernel_params_buf32[25] = 0;
2806 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2807 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2808
2809 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2810 {
2811 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2812 }
2813 else
2814 {
2815 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2816 }
2817
2818 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2819
2820 return exec_ms_prev;
2821 }
2822
2823 static void autotune (hc_device_param_t *device_param)
2824 {
2825 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2826
2827 const u32 kernel_accel_min = device_param->kernel_accel_min;
2828 const u32 kernel_accel_max = device_param->kernel_accel_max;
2829
2830 const u32 kernel_loops_min = device_param->kernel_loops_min;
2831 const u32 kernel_loops_max = device_param->kernel_loops_max;
2832
2833 u32 kernel_accel = kernel_accel_min;
2834 u32 kernel_loops = kernel_loops_min;
2835
2836 // in this case the user specified a fixed -u and -n on the commandline
2837 // no way to tune anything
2838 // but we need to run a few caching rounds
2839
2840 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2841 {
2842 try_run (device_param, kernel_accel, kernel_loops);
2843 try_run (device_param, kernel_accel, kernel_loops);
2844 try_run (device_param, kernel_accel, kernel_loops);
2845 try_run (device_param, kernel_accel, kernel_loops);
2846
2847 device_param->kernel_accel = kernel_accel;
2848 device_param->kernel_loops = kernel_loops;
2849
2850 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2851
2852 device_param->kernel_power = kernel_power;
2853
2854 return;
2855 }
2856
2857 // from here it's clear we are allowed to autotune
2858 // so let's init some fake words
2859
2860 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2861
2862 for (u32 i = 0; i < kernel_power_max; i++)
2863 {
2864 device_param->pws_buf[i].i[0] = i;
2865 device_param->pws_buf[i].i[1] = 0x01234567;
2866 device_param->pws_buf[i].pw_len = 7;
2867 }
2868
2869 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);
2870
2871 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2872 {
2873 run_kernel_amp (device_param, kernel_power_max);
2874 }
2875
2876 #define VERIFIER_CNT 1
2877
2878 // first find out highest kernel-loops that stays below target_ms
2879
2880 if (kernel_loops_min < kernel_loops_max)
2881 {
2882 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2883 {
2884 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2885
2886 for (int i = 0; i < VERIFIER_CNT; i++)
2887 {
2888 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2889
2890 exec_ms = MIN (exec_ms, exec_ms_v);
2891 }
2892
2893 if (exec_ms < target_ms) break;
2894 }
2895 }
2896
2897 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2898
2899 #define STEPS_CNT 10
2900
2901 if (kernel_accel_min < kernel_accel_max)
2902 {
2903 for (int i = 0; i < STEPS_CNT; i++)
2904 {
2905 const u32 kernel_accel_try = 1 << i;
2906
2907 if (kernel_accel_try < kernel_accel_min) continue;
2908 if (kernel_accel_try > kernel_accel_max) break;
2909
2910 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2911
2912 for (int i = 0; i < VERIFIER_CNT; i++)
2913 {
2914 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2915
2916 exec_ms = MIN (exec_ms, exec_ms_v);
2917 }
2918
2919 if (exec_ms > target_ms) break;
2920
2921 kernel_accel = kernel_accel_try;
2922 }
2923 }
2924
2925 // at this point we want to know the actual runtime for the following reason:
2926 // we need a reference for the balancing loop following up, and this
2927 // the balancing loop can have an effect that the creates a new opportunity, for example:
2928 // if the target is 95 ms and the current runtime is 48ms the above loop
2929 // stopped the execution because the previous exec_ms was > 95ms
2930 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2931 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2932
2933 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2934
2935 for (int i = 0; i < VERIFIER_CNT; i++)
2936 {
2937 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2938
2939 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2940 }
2941
2942 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2943 {
2944 for (u32 f = 2; f < 1024; f++)
2945 {
2946 const u32 kernel_accel_try = kernel_accel * f;
2947 const u32 kernel_loops_try = kernel_loops / f;
2948
2949 if (kernel_accel_try > kernel_accel_max) break;
2950 if (kernel_loops_try < kernel_loops_min) break;
2951
2952 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2953
2954 for (int i = 0; i < VERIFIER_CNT; i++)
2955 {
2956 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2957
2958 exec_ms = MIN (exec_ms, exec_ms_v);
2959 }
2960
2961 if (exec_ms < exec_ms_pre_final)
2962 {
2963 exec_ms_pre_final = exec_ms;
2964
2965 kernel_accel = kernel_accel_try;
2966 kernel_loops = kernel_loops_try;
2967 }
2968 }
2969 }
2970
2971 const double exec_left = target_ms / exec_ms_pre_final;
2972
2973 const double accel_left = kernel_accel_max / kernel_accel;
2974
2975 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2976
2977 if (exec_accel_min >= 1.0)
2978 {
2979 // this is safe to not overflow kernel_accel_max because of accel_left
2980
2981 kernel_accel = (double) kernel_accel * exec_accel_min;
2982 }
2983
2984 // reset them fake words
2985
2986 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2987
2988 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);
2989 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);
2990
2991 // reset timer
2992
2993 device_param->exec_pos = 0;
2994
2995 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2996
2997 // store
2998
2999 device_param->kernel_accel = kernel_accel;
3000 device_param->kernel_loops = kernel_loops;
3001
3002 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3003
3004 device_param->kernel_power = kernel_power;
3005
3006 #ifdef DEBUG
3007
3008 if (data.quiet == 0)
3009 {
3010 clear_prompt ();
3011
3012 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3013 "Device #%u: autotuned kernel-loops to %u\n",
3014 device_param->device_id + 1, kernel_accel,
3015 device_param->device_id + 1, kernel_loops);
3016
3017 fprintf (stdout, "%s", PROMPT);
3018
3019 fflush (stdout);
3020 }
3021
3022 #endif
3023 }
3024
3025 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3026 {
3027 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3028
3029 // init speed timer
3030
3031 uint speed_pos = device_param->speed_pos;
3032
3033 #ifdef _POSIX
3034 if (device_param->timer_speed.tv_sec == 0)
3035 {
3036 hc_timer_set (&device_param->timer_speed);
3037 }
3038 #endif
3039
3040 #ifdef _WIN
3041 if (device_param->timer_speed.QuadPart == 0)
3042 {
3043 hc_timer_set (&device_param->timer_speed);
3044 }
3045 #endif
3046
3047 // find higest password length, this is for optimization stuff
3048
3049 uint highest_pw_len = 0;
3050
3051 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3052 {
3053 }
3054 else if (data.attack_kern == ATTACK_KERN_COMBI)
3055 {
3056 }
3057 else if (data.attack_kern == ATTACK_KERN_BF)
3058 {
3059 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3060 + device_param->kernel_params_mp_l_buf32[5];
3061 }
3062
3063 // iteration type
3064
3065 uint innerloop_step = 0;
3066 uint innerloop_cnt = 0;
3067
3068 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3069 else innerloop_step = 1;
3070
3071 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3072 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3073 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3074
3075 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3076
3077 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3078 {
3079 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3080
3081 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3082
3083 if (data.devices_status == STATUS_CRACKED) break;
3084 if (data.devices_status == STATUS_ABORTED) break;
3085 if (data.devices_status == STATUS_QUIT) break;
3086 if (data.devices_status == STATUS_BYPASS) break;
3087
3088 salt_t *salt_buf = &data.salts_buf[salt_pos];
3089
3090 device_param->kernel_params_buf32[24] = salt_pos;
3091 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3092 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3093
3094 FILE *combs_fp = device_param->combs_fp;
3095
3096 if (data.attack_mode == ATTACK_MODE_COMBI)
3097 {
3098 rewind (combs_fp);
3099 }
3100
3101 // innerloops
3102
3103 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3104 {
3105 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3106
3107 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3108
3109 if (data.devices_status == STATUS_CRACKED) break;
3110 if (data.devices_status == STATUS_ABORTED) break;
3111 if (data.devices_status == STATUS_QUIT) break;
3112 if (data.devices_status == STATUS_BYPASS) break;
3113
3114 uint innerloop_left = innerloop_cnt - innerloop_pos;
3115
3116 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3117
3118 device_param->innerloop_pos = innerloop_pos;
3119 device_param->innerloop_left = innerloop_left;
3120
3121 device_param->kernel_params_buf32[27] = innerloop_left;
3122
3123 // i think we can get rid of this
3124 if (innerloop_left == 0)
3125 {
3126 puts ("bug, how should this happen????\n");
3127
3128 continue;
3129 }
3130
3131 if (data.salts_shown[salt_pos] == 1)
3132 {
3133 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3134
3135 continue;
3136 }
3137
3138 // initialize amplifiers
3139
3140 if (data.attack_mode == ATTACK_MODE_COMBI)
3141 {
3142 uint i = 0;
3143
3144 while (i < innerloop_left)
3145 {
3146 if (feof (combs_fp)) break;
3147
3148 int line_len = fgetl (combs_fp, line_buf);
3149
3150 if (line_len >= PW_MAX1) continue;
3151
3152 line_len = convert_from_hex (line_buf, line_len);
3153
3154 char *line_buf_new = line_buf;
3155
3156 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3157 {
3158 char rule_buf_out[BLOCK_SIZE] = { 0 };
3159
3160 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3161
3162 if (rule_len_out < 0)
3163 {
3164 data.words_progress_rejected[salt_pos] += pws_cnt;
3165
3166 continue;
3167 }
3168
3169 line_len = rule_len_out;
3170
3171 line_buf_new = rule_buf_out;
3172 }
3173
3174 line_len = MIN (line_len, PW_DICTMAX);
3175
3176 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3177
3178 memcpy (ptr, line_buf_new, line_len);
3179
3180 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3181
3182 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3183 {
3184 uppercase (ptr, line_len);
3185 }
3186
3187 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3188 {
3189 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3190 {
3191 ptr[line_len] = 0x80;
3192 }
3193
3194 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3195 {
3196 ptr[line_len] = 0x01;
3197 }
3198 }
3199
3200 device_param->combs_buf[i].pw_len = line_len;
3201
3202 i++;
3203 }
3204
3205 for (uint j = i; j < innerloop_left; j++)
3206 {
3207 device_param->combs_buf[j].i[0] = 0;
3208 device_param->combs_buf[j].i[1] = 0;
3209 device_param->combs_buf[j].i[2] = 0;
3210 device_param->combs_buf[j].i[3] = 0;
3211 device_param->combs_buf[j].i[4] = 0;
3212 device_param->combs_buf[j].i[5] = 0;
3213 device_param->combs_buf[j].i[6] = 0;
3214 device_param->combs_buf[j].i[7] = 0;
3215
3216 device_param->combs_buf[j].pw_len = 0;
3217 }
3218
3219 innerloop_left = i;
3220 }
3221 else if (data.attack_mode == ATTACK_MODE_BF)
3222 {
3223 u64 off = innerloop_pos;
3224
3225 device_param->kernel_params_mp_r_buf64[3] = off;
3226
3227 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3228 }
3229 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3230 {
3231 u64 off = innerloop_pos;
3232
3233 device_param->kernel_params_mp_buf64[3] = off;
3234
3235 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3236 }
3237 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3238 {
3239 u64 off = innerloop_pos;
3240
3241 device_param->kernel_params_mp_buf64[3] = off;
3242
3243 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3244 }
3245
3246 // copy amplifiers
3247
3248 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3249 {
3250 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);
3251 }
3252 else if (data.attack_mode == ATTACK_MODE_COMBI)
3253 {
3254 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);
3255 }
3256 else if (data.attack_mode == ATTACK_MODE_BF)
3257 {
3258 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);
3259 }
3260 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3261 {
3262 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);
3263 }
3264 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3265 {
3266 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);
3267 }
3268
3269 if (data.benchmark == 1)
3270 {
3271 hc_timer_set (&device_param->timer_speed);
3272 }
3273
3274 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3275
3276 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3277
3278 if (data.devices_status == STATUS_CRACKED) break;
3279 if (data.devices_status == STATUS_ABORTED) break;
3280 if (data.devices_status == STATUS_QUIT) break;
3281
3282 /**
3283 * result
3284 */
3285
3286 hc_thread_mutex_lock (mux_display);
3287
3288 check_cracked (device_param, salt_pos);
3289
3290 hc_thread_mutex_unlock (mux_display);
3291
3292 /**
3293 * progress
3294 */
3295
3296 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3297
3298 hc_thread_mutex_lock (mux_counter);
3299
3300 data.words_progress_done[salt_pos] += perf_sum_all;
3301
3302 hc_thread_mutex_unlock (mux_counter);
3303
3304 /**
3305 * speed
3306 */
3307
3308 double speed_ms;
3309
3310 hc_timer_get (device_param->timer_speed, speed_ms);
3311
3312 hc_timer_set (&device_param->timer_speed);
3313
3314 hc_thread_mutex_lock (mux_display);
3315
3316 // current speed
3317
3318 device_param->speed_cnt[speed_pos] = perf_sum_all;
3319
3320 device_param->speed_ms[speed_pos] = speed_ms;
3321
3322 hc_thread_mutex_unlock (mux_display);
3323
3324 speed_pos++;
3325
3326 if (speed_pos == SPEED_CACHE)
3327 {
3328 speed_pos = 0;
3329 }
3330
3331 /**
3332 * benchmark
3333 */
3334
3335 if (data.benchmark == 1) break;
3336 }
3337 }
3338
3339 device_param->speed_pos = speed_pos;
3340
3341 myfree (line_buf);
3342 }
3343
3344 static void load_segment (wl_data_t *wl_data, FILE *fd)
3345 {
3346 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3347
3348 wl_data->pos = 0;
3349
3350 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3351
3352 wl_data->buf[wl_data->cnt] = 0;
3353
3354 if (wl_data->cnt == 0) return;
3355
3356 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3357
3358 while (!feof (fd))
3359 {
3360 if (wl_data->cnt == wl_data->avail)
3361 {
3362 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3363
3364 wl_data->avail += wl_data->incr;
3365 }
3366
3367 const int c = fgetc (fd);
3368
3369 if (c == EOF) break;
3370
3371 wl_data->buf[wl_data->cnt] = (char) c;
3372
3373 wl_data->cnt++;
3374
3375 if (c == '\n') break;
3376 }
3377
3378 // ensure stream ends with a newline
3379
3380 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3381 {
3382 wl_data->cnt++;
3383
3384 wl_data->buf[wl_data->cnt - 1] = '\n';
3385 }
3386
3387 return;
3388 }
3389
3390 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3391 {
3392 char *ptr = buf;
3393
3394 for (u32 i = 0; i < sz; i++, ptr++)
3395 {
3396 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3397
3398 if (i == 7)
3399 {
3400 *off = i;
3401 *len = i;
3402
3403 return;
3404 }
3405
3406 if (*ptr != '\n') continue;
3407
3408 *off = i + 1;
3409
3410 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3411
3412 *len = i;
3413
3414 return;
3415 }
3416
3417 *off = sz;
3418 *len = sz;
3419 }
3420
3421 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3422 {
3423 char *ptr = buf;
3424
3425 for (u32 i = 0; i < sz; i++, ptr++)
3426 {
3427 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3428
3429 if (*ptr != '\n') continue;
3430
3431 *off = i + 1;
3432
3433 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3434
3435 *len = i;
3436
3437 return;
3438 }
3439
3440 *off = sz;
3441 *len = sz;
3442 }
3443
3444 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3445 {
3446 char *ptr = buf;
3447
3448 for (u32 i = 0; i < sz; i++, ptr++)
3449 {
3450 if (*ptr != '\n') continue;
3451
3452 *off = i + 1;
3453
3454 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3455
3456 *len = i;
3457
3458 return;
3459 }
3460
3461 *off = sz;
3462 *len = sz;
3463 }
3464
3465 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3466 {
3467 while (wl_data->pos < wl_data->cnt)
3468 {
3469 uint off;
3470 uint len;
3471
3472 char *ptr = wl_data->buf + wl_data->pos;
3473
3474 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3475
3476 wl_data->pos += off;
3477
3478 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3479 {
3480 char rule_buf_out[BLOCK_SIZE] = { 0 };
3481
3482 int rule_len_out = -1;
3483
3484 if (len < BLOCK_SIZE)
3485 {
3486 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3487 }
3488
3489 if (rule_len_out < 0)
3490 {
3491 continue;
3492 }
3493
3494 if (rule_len_out > PW_MAX)
3495 {
3496 continue;
3497 }
3498 }
3499 else
3500 {
3501 if (len > PW_MAX)
3502 {
3503 continue;
3504 }
3505 }
3506
3507 *out_buf = ptr;
3508 *out_len = len;
3509
3510 return;
3511 }
3512
3513 if (feof (fd))
3514 {
3515 fprintf (stderr, "BUG feof()!!\n");
3516
3517 return;
3518 }
3519
3520 load_segment (wl_data, fd);
3521
3522 get_next_word (wl_data, fd, out_buf, out_len);
3523 }
3524
3525 #ifdef _POSIX
3526 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3527 #endif
3528
3529 #ifdef _WIN
3530 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3531 #endif
3532 {
3533 hc_signal (NULL);
3534
3535 dictstat_t d;
3536
3537 d.cnt = 0;
3538
3539 #ifdef _POSIX
3540 fstat (fileno (fd), &d.stat);
3541 #endif
3542
3543 #ifdef _WIN
3544 _fstat64 (fileno (fd), &d.stat);
3545 #endif
3546
3547 d.stat.st_mode = 0;
3548 d.stat.st_nlink = 0;
3549 d.stat.st_uid = 0;
3550 d.stat.st_gid = 0;
3551 d.stat.st_rdev = 0;
3552 d.stat.st_atime = 0;
3553
3554 #ifdef _POSIX
3555 d.stat.st_blksize = 0;
3556 d.stat.st_blocks = 0;
3557 #endif
3558
3559 if (d.stat.st_size == 0) return 0;
3560
3561 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3562
3563 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3564 {
3565 if (d_cache)
3566 {
3567 u64 cnt = d_cache->cnt;
3568
3569 u64 keyspace = cnt;
3570
3571 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3572 {
3573 keyspace *= data.kernel_rules_cnt;
3574 }
3575 else if (data.attack_kern == ATTACK_KERN_COMBI)
3576 {
3577 keyspace *= data.combs_cnt;
3578 }
3579
3580 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);
3581 if (data.quiet == 0) log_info ("");
3582
3583 hc_signal (sigHandler_default);
3584
3585 return (keyspace);
3586 }
3587 }
3588
3589 time_t now = 0;
3590 time_t prev = 0;
3591
3592 u64 comp = 0;
3593 u64 cnt = 0;
3594 u64 cnt2 = 0;
3595
3596 while (!feof (fd))
3597 {
3598 load_segment (wl_data, fd);
3599
3600 comp += wl_data->cnt;
3601
3602 u32 i = 0;
3603
3604 while (i < wl_data->cnt)
3605 {
3606 u32 len;
3607 u32 off;
3608
3609 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3610
3611 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3612 {
3613 char rule_buf_out[BLOCK_SIZE] = { 0 };
3614
3615 int rule_len_out = -1;
3616
3617 if (len < BLOCK_SIZE)
3618 {
3619 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3620 }
3621
3622 if (rule_len_out < 0)
3623 {
3624 len = PW_MAX1;
3625 }
3626 else
3627 {
3628 len = rule_len_out;
3629 }
3630 }
3631
3632 if (len < PW_MAX1)
3633 {
3634 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3635 {
3636 cnt += data.kernel_rules_cnt;
3637 }
3638 else if (data.attack_kern == ATTACK_KERN_COMBI)
3639 {
3640 cnt += data.combs_cnt;
3641 }
3642
3643 d.cnt++;
3644 }
3645
3646 i += off;
3647
3648 cnt2++;
3649 }
3650
3651 time (&now);
3652
3653 if ((now - prev) == 0) continue;
3654
3655 float percent = (float) comp / (float) d.stat.st_size;
3656
3657 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);
3658
3659 time (&prev);
3660 }
3661
3662 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);
3663 if (data.quiet == 0) log_info ("");
3664
3665 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3666
3667 hc_signal (sigHandler_default);
3668
3669 return (cnt);
3670 }
3671
3672 static void *thread_monitor (void *p)
3673 {
3674 uint runtime_check = 0;
3675 uint remove_check = 0;
3676 uint status_check = 0;
3677 uint restore_check = 0;
3678
3679 uint restore_left = data.restore_timer;
3680 uint remove_left = data.remove_timer;
3681 uint status_left = data.status_timer;
3682
3683 #ifdef HAVE_HWMON
3684 uint hwmon_check = 0;
3685
3686 // these variables are mainly used for fan control (AMD only)
3687
3688 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3689
3690 // temperature controller "loopback" values
3691
3692 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3693 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3694
3695 #ifdef HAVE_ADL
3696 int temp_threshold = 1; // degrees celcius
3697
3698 int fan_speed_min = 15; // in percentage
3699 int fan_speed_max = 100;
3700 #endif // HAVE_ADL
3701
3702 time_t last_temp_check_time;
3703 #endif // HAVE_HWMON
3704
3705 uint sleep_time = 1;
3706
3707 if (data.runtime)
3708 {
3709 runtime_check = 1;
3710 }
3711
3712 if (data.restore_timer)
3713 {
3714 restore_check = 1;
3715 }
3716
3717 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3718 {
3719 remove_check = 1;
3720 }
3721
3722 if (data.status == 1)
3723 {
3724 status_check = 1;
3725 }
3726
3727 #ifdef HAVE_HWMON
3728 if (data.gpu_temp_disable == 0)
3729 {
3730 time (&last_temp_check_time);
3731
3732 hwmon_check = 1;
3733 }
3734 #endif
3735
3736 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3737 {
3738 #ifdef HAVE_HWMON
3739 if (hwmon_check == 0)
3740 #endif
3741 return (p);
3742 }
3743
3744 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3745 {
3746 hc_sleep (sleep_time);
3747
3748 if (data.devices_status != STATUS_RUNNING) continue;
3749
3750 #ifdef HAVE_HWMON
3751 if (hwmon_check == 1)
3752 {
3753 hc_thread_mutex_lock (mux_adl);
3754
3755 time_t temp_check_time;
3756
3757 time (&temp_check_time);
3758
3759 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3760
3761 if (Ta == 0) Ta = 1;
3762
3763 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3764 {
3765 hc_device_param_t *device_param = &data.devices_param[device_id];
3766
3767 if (device_param->skipped) continue;
3768
3769 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3770
3771 const int temperature = hm_get_temperature_with_device_id (device_id);
3772
3773 if (temperature > (int) data.gpu_temp_abort)
3774 {
3775 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3776
3777 if (data.devices_status != STATUS_QUIT) myabort ();
3778
3779 break;
3780 }
3781
3782 #ifdef HAVE_ADL
3783 const int gpu_temp_retain = data.gpu_temp_retain;
3784
3785 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3786 {
3787 if (data.hm_device[device_id].fan_supported == 1)
3788 {
3789 int temp_cur = temperature;
3790
3791 int temp_diff_new = gpu_temp_retain - temp_cur;
3792
3793 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3794
3795 // calculate Ta value (time difference in seconds between the last check and this check)
3796
3797 last_temp_check_time = temp_check_time;
3798
3799 float Kp = 1.8;
3800 float Ki = 0.005;
3801 float Kd = 6;
3802
3803 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3804
3805 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);
3806
3807 if (abs (fan_diff_required) >= temp_threshold)
3808 {
3809 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3810
3811 int fan_speed_level = fan_speed_cur;
3812
3813 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3814
3815 int fan_speed_new = fan_speed_level - fan_diff_required;
3816
3817 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3818 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3819
3820 if (fan_speed_new != fan_speed_cur)
3821 {
3822 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3823 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3824
3825 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3826 {
3827 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3828
3829 fan_speed_chgd[device_id] = 1;
3830 }
3831
3832 temp_diff_old[device_id] = temp_diff_new;
3833 }
3834 }
3835 }
3836 }
3837 #endif // HAVE_ADL
3838 }
3839
3840 hc_thread_mutex_unlock (mux_adl);
3841 }
3842 #endif // HAVE_HWMON
3843
3844 if (restore_check == 1)
3845 {
3846 restore_left--;
3847
3848 if (restore_left == 0)
3849 {
3850 if (data.restore_disable == 0) cycle_restore ();
3851
3852 restore_left = data.restore_timer;
3853 }
3854 }
3855
3856 if ((runtime_check == 1) && (data.runtime_start > 0))
3857 {
3858 time_t runtime_cur;
3859
3860 time (&runtime_cur);
3861
3862 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3863
3864 if (runtime_left <= 0)
3865 {
3866 if (data.benchmark == 0)
3867 {
3868 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3869 }
3870
3871 if (data.devices_status != STATUS_QUIT) myabort ();
3872 }
3873 }
3874
3875 if (remove_check == 1)
3876 {
3877 remove_left--;
3878
3879 if (remove_left == 0)
3880 {
3881 if (data.digests_saved != data.digests_done)
3882 {
3883 data.digests_saved = data.digests_done;
3884
3885 save_hash ();
3886 }
3887
3888 remove_left = data.remove_timer;
3889 }
3890 }
3891
3892 if (status_check == 1)
3893 {
3894 status_left--;
3895
3896 if (status_left == 0)
3897 {
3898 hc_thread_mutex_lock (mux_display);
3899
3900 if (data.quiet == 0) clear_prompt ();
3901
3902 if (data.quiet == 0) log_info ("");
3903
3904 status_display ();
3905
3906 if (data.quiet == 0) log_info ("");
3907
3908 hc_thread_mutex_unlock (mux_display);
3909
3910 status_left = data.status_timer;
3911 }
3912 }
3913 }
3914
3915 #ifdef HAVE_HWMON
3916 myfree (fan_speed_chgd);
3917
3918 myfree (temp_diff_old);
3919 myfree (temp_diff_sum);
3920 #endif
3921
3922 p = NULL;
3923
3924 return (p);
3925 }
3926
3927 static void *thread_outfile_remove (void *p)
3928 {
3929 // some hash-dependent constants
3930 char *outfile_dir = data.outfile_check_directory;
3931 uint dgst_size = data.dgst_size;
3932 uint isSalted = data.isSalted;
3933 uint esalt_size = data.esalt_size;
3934 uint hash_mode = data.hash_mode;
3935
3936 uint outfile_check_timer = data.outfile_check_timer;
3937
3938 char separator = data.separator;
3939
3940 // some hash-dependent functions
3941 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3942 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3943
3944 // buffers
3945 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3946
3947 hash_buf.digest = mymalloc (dgst_size);
3948
3949 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3950
3951 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3952
3953 uint digest_buf[64] = { 0 };
3954
3955 outfile_data_t *out_info = NULL;
3956
3957 char **out_files = NULL;
3958
3959 time_t folder_mtime = 0;
3960
3961 int out_cnt = 0;
3962
3963 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3964
3965 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3966 {
3967 hc_sleep (1);
3968
3969 if (data.devices_status != STATUS_RUNNING) continue;
3970
3971 check_left--;
3972
3973 if (check_left == 0)
3974 {
3975 struct stat outfile_check_stat;
3976
3977 if (stat (outfile_dir, &outfile_check_stat) == 0)
3978 {
3979 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3980
3981 if (is_dir == 1)
3982 {
3983 if (outfile_check_stat.st_mtime > folder_mtime)
3984 {
3985 char **out_files_new = scan_directory (outfile_dir);
3986
3987 int out_cnt_new = count_dictionaries (out_files_new);
3988
3989 outfile_data_t *out_info_new = NULL;
3990
3991 if (out_cnt_new > 0)
3992 {
3993 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3994
3995 for (int i = 0; i < out_cnt_new; i++)
3996 {
3997 out_info_new[i].file_name = out_files_new[i];
3998
3999 // check if there are files that we have seen/checked before (and not changed)
4000
4001 for (int j = 0; j < out_cnt; j++)
4002 {
4003 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4004 {
4005 struct stat outfile_stat;
4006
4007 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4008 {
4009 if (outfile_stat.st_ctime == out_info[j].ctime)
4010 {
4011 out_info_new[i].ctime = out_info[j].ctime;
4012 out_info_new[i].seek = out_info[j].seek;
4013 }
4014 }
4015 }
4016 }
4017 }
4018 }
4019
4020 local_free (out_info);
4021 local_free (out_files);
4022
4023 out_files = out_files_new;
4024 out_cnt = out_cnt_new;
4025 out_info = out_info_new;
4026
4027 folder_mtime = outfile_check_stat.st_mtime;
4028 }
4029
4030 for (int j = 0; j < out_cnt; j++)
4031 {
4032 FILE *fp = fopen (out_info[j].file_name, "rb");
4033
4034 if (fp != NULL)
4035 {
4036 //hc_thread_mutex_lock (mux_display);
4037
4038 #ifdef _POSIX
4039 struct stat outfile_stat;
4040
4041 fstat (fileno (fp), &outfile_stat);
4042 #endif
4043
4044 #ifdef _WIN
4045 struct stat64 outfile_stat;
4046
4047 _fstat64 (fileno (fp), &outfile_stat);
4048 #endif
4049
4050 if (outfile_stat.st_ctime > out_info[j].ctime)
4051 {
4052 out_info[j].ctime = outfile_stat.st_ctime;
4053 out_info[j].seek = 0;
4054 }
4055
4056 fseek (fp, out_info[j].seek, SEEK_SET);
4057
4058 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4059
4060 while (!feof (fp))
4061 {
4062 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4063
4064 if (ptr == NULL) break;
4065
4066 int line_len = strlen (line_buf);
4067
4068 if (line_len <= 0) continue;
4069
4070 int iter = MAX_CUT_TRIES;
4071
4072 for (uint i = line_len - 1; i && iter; i--, line_len--)
4073 {
4074 if (line_buf[i] != separator) continue;
4075
4076 int parser_status = PARSER_OK;
4077
4078 if ((hash_mode != 2500) && (hash_mode != 6800))
4079 {
4080 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4081 }
4082
4083 uint found = 0;
4084
4085 if (parser_status == PARSER_OK)
4086 {
4087 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4088 {
4089 if (data.salts_shown[salt_pos] == 1) continue;
4090
4091 salt_t *salt_buf = &data.salts_buf[salt_pos];
4092
4093 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4094 {
4095 uint idx = salt_buf->digests_offset + digest_pos;
4096
4097 if (data.digests_shown[idx] == 1) continue;
4098
4099 uint cracked = 0;
4100
4101 if (hash_mode == 6800)
4102 {
4103 if (i == salt_buf->salt_len)
4104 {
4105 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4106 }
4107 }
4108 else if (hash_mode == 2500)
4109 {
4110 // BSSID : MAC1 : MAC2 (:plain)
4111 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4112 {
4113 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4114
4115 if (!cracked) continue;
4116
4117 // now compare MAC1 and MAC2 too, since we have this additional info
4118 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4119 char *mac2_pos = mac1_pos + 12 + 1;
4120
4121 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4122 wpa_t *wpa = &wpas[salt_pos];
4123
4124 // compare hex string(s) vs binary MAC address(es)
4125
4126 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4127 {
4128 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4129 {
4130 cracked = 0;
4131
4132 break;
4133 }
4134 }
4135
4136 // early skip ;)
4137 if (!cracked) continue;
4138
4139 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4140 {
4141 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4142 {
4143 cracked = 0;
4144
4145 break;
4146 }
4147 }
4148 }
4149 }
4150 else
4151 {
4152 char *digests_buf_ptr = (char *) data.digests_buf;
4153
4154 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4155
4156 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4157 }
4158
4159 if (cracked == 1)
4160 {
4161 found = 1;
4162
4163 data.digests_shown[idx] = 1;
4164
4165 data.digests_done++;
4166
4167 salt_buf->digests_done++;
4168
4169 if (salt_buf->digests_done == salt_buf->digests_cnt)
4170 {
4171 data.salts_shown[salt_pos] = 1;
4172
4173 data.salts_done++;
4174
4175 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4176 }
4177 }
4178 }
4179
4180 if (data.devices_status == STATUS_CRACKED) break;
4181 }
4182 }
4183
4184 if (found) break;
4185
4186 if (data.devices_status == STATUS_CRACKED) break;
4187
4188 iter--;
4189 }
4190
4191 if (data.devices_status == STATUS_CRACKED) break;
4192 }
4193
4194 myfree (line_buf);
4195
4196 out_info[j].seek = ftell (fp);
4197
4198 //hc_thread_mutex_unlock (mux_display);
4199
4200 fclose (fp);
4201 }
4202 }
4203 }
4204 }
4205
4206 check_left = outfile_check_timer;
4207 }
4208 }
4209
4210 if (esalt_size) local_free (hash_buf.esalt);
4211
4212 if (isSalted) local_free (hash_buf.salt);
4213
4214 local_free (hash_buf.digest);
4215
4216 local_free (out_info);
4217
4218 local_free (out_files);
4219
4220 p = NULL;
4221
4222 return (p);
4223 }
4224
4225 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4226 {
4227 if (device_param->pws_cnt < device_param->kernel_power)
4228 {
4229 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4230
4231 u8 *ptr = (u8 *) pw->i;
4232
4233 memcpy (ptr, pw_buf, pw_len);
4234
4235 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4236
4237 pw->pw_len = pw_len;
4238
4239 device_param->pws_cnt++;
4240 }
4241 else
4242 {
4243 fprintf (stderr, "BUG pw_add()!!\n");
4244
4245 return;
4246 }
4247 }
4248
4249 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4250 {
4251 hc_thread_mutex_lock (mux_dispatcher);
4252
4253 const u64 words_cur = data.words_cur;
4254 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4255
4256 device_param->words_off = words_cur;
4257
4258 const u64 words_left = words_base - words_cur;
4259
4260 if (allow_div)
4261 {
4262 if (data.kernel_power_all > words_left)
4263 {
4264 if (data.kernel_power_div == 0)
4265 {
4266 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4267 }
4268 }
4269
4270 if (data.kernel_power_div)
4271 {
4272 if (device_param->kernel_power == device_param->kernel_power_user)
4273 {
4274 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4275
4276 if (kernel_power_new < device_param->kernel_power)
4277 {
4278 device_param->kernel_power = kernel_power_new;
4279 }
4280 }
4281 }
4282 }
4283
4284 const uint kernel_power = device_param->kernel_power;
4285
4286 uint work = MIN (words_left, kernel_power);
4287
4288 work = MIN (work, max);
4289
4290 data.words_cur += work;
4291
4292 hc_thread_mutex_unlock (mux_dispatcher);
4293
4294 return work;
4295 }
4296
4297 static void *thread_calc_stdin (void *p)
4298 {
4299 hc_device_param_t *device_param = (hc_device_param_t *) p;
4300
4301 if (device_param->skipped) return NULL;
4302
4303 autotune (device_param);
4304
4305 char *buf = (char *) mymalloc (HCBUFSIZ);
4306
4307 const uint attack_kern = data.attack_kern;
4308
4309 const uint kernel_power = device_param->kernel_power;
4310
4311 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4312 {
4313 hc_thread_mutex_lock (mux_dispatcher);
4314
4315 if (feof (stdin) != 0)
4316 {
4317 hc_thread_mutex_unlock (mux_dispatcher);
4318
4319 break;
4320 }
4321
4322 uint words_cur = 0;
4323
4324 while (words_cur < kernel_power)
4325 {
4326 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4327
4328 if (line_buf == NULL) break;
4329
4330 uint line_len = in_superchop (line_buf);
4331
4332 line_len = convert_from_hex (line_buf, line_len);
4333
4334 // post-process rule engine
4335
4336 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4337 {
4338 char rule_buf_out[BLOCK_SIZE] = { 0 };
4339
4340 int rule_len_out = -1;
4341
4342 if (line_len < BLOCK_SIZE)
4343 {
4344 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4345 }
4346
4347 if (rule_len_out < 0) continue;
4348
4349 line_buf = rule_buf_out;
4350 line_len = rule_len_out;
4351 }
4352
4353 if (line_len > PW_MAX)
4354 {
4355 continue;
4356 }
4357
4358 if (attack_kern == ATTACK_KERN_STRAIGHT)
4359 {
4360 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4361 {
4362 hc_thread_mutex_lock (mux_counter);
4363
4364 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4365 {
4366 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4367 }
4368
4369 hc_thread_mutex_unlock (mux_counter);
4370
4371 continue;
4372 }
4373 }
4374 else if (attack_kern == ATTACK_KERN_COMBI)
4375 {
4376 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4377 // since we still need to combine the plains
4378
4379 if (line_len > data.pw_max)
4380 {
4381 hc_thread_mutex_lock (mux_counter);
4382
4383 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4384 {
4385 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4386 }
4387
4388 hc_thread_mutex_unlock (mux_counter);
4389
4390 continue;
4391 }
4392 }
4393
4394 pw_add (device_param, (u8 *) line_buf, line_len);
4395
4396 words_cur++;
4397
4398 if (data.devices_status == STATUS_CRACKED) break;
4399 if (data.devices_status == STATUS_ABORTED) break;
4400 if (data.devices_status == STATUS_QUIT) break;
4401 if (data.devices_status == STATUS_BYPASS) break;
4402 }
4403
4404 hc_thread_mutex_unlock (mux_dispatcher);
4405
4406 if (data.devices_status == STATUS_CRACKED) break;
4407 if (data.devices_status == STATUS_ABORTED) break;
4408 if (data.devices_status == STATUS_QUIT) break;
4409 if (data.devices_status == STATUS_BYPASS) break;
4410
4411 // flush
4412
4413 const uint pws_cnt = device_param->pws_cnt;
4414
4415 if (pws_cnt)
4416 {
4417 run_copy (device_param, pws_cnt);
4418
4419 run_cracker (device_param, pws_cnt);
4420
4421 device_param->pws_cnt = 0;
4422
4423 /*
4424 still required?
4425 if (attack_kern == ATTACK_KERN_STRAIGHT)
4426 {
4427 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4428 }
4429 else if (attack_kern == ATTACK_KERN_COMBI)
4430 {
4431 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4432 }
4433 */
4434 }
4435 }
4436
4437 device_param->kernel_accel = 0;
4438 device_param->kernel_loops = 0;
4439
4440 myfree (buf);
4441
4442 return NULL;
4443 }
4444
4445 static void *thread_calc (void *p)
4446 {
4447 hc_device_param_t *device_param = (hc_device_param_t *) p;
4448
4449 if (device_param->skipped) return NULL;
4450
4451 autotune (device_param);
4452
4453 const uint attack_mode = data.attack_mode;
4454 const uint attack_kern = data.attack_kern;
4455
4456 if (attack_mode == ATTACK_MODE_BF)
4457 {
4458 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4459 {
4460 const uint work = get_work (device_param, -1, true);
4461
4462 if (work == 0) break;
4463
4464 const u64 words_off = device_param->words_off;
4465 const u64 words_fin = words_off + work;
4466
4467 const uint pws_cnt = work;
4468
4469 device_param->pws_cnt = pws_cnt;
4470
4471 if (pws_cnt)
4472 {
4473 run_copy (device_param, pws_cnt);
4474
4475 run_cracker (device_param, pws_cnt);
4476
4477 device_param->pws_cnt = 0;
4478
4479 /*
4480 still required?
4481 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4482 */
4483 }
4484
4485 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4486
4487 if (data.devices_status == STATUS_CRACKED) break;
4488 if (data.devices_status == STATUS_ABORTED) break;
4489 if (data.devices_status == STATUS_QUIT) break;
4490 if (data.devices_status == STATUS_BYPASS) break;
4491
4492 if (data.benchmark == 1) break;
4493
4494 device_param->words_done = words_fin;
4495 }
4496 }
4497 else
4498 {
4499 const uint segment_size = data.segment_size;
4500
4501 char *dictfile = data.dictfile;
4502
4503 if (attack_mode == ATTACK_MODE_COMBI)
4504 {
4505 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4506 {
4507 dictfile = data.dictfile2;
4508 }
4509 }
4510
4511 FILE *fd = fopen (dictfile, "rb");
4512
4513 if (fd == NULL)
4514 {
4515 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4516
4517 return NULL;
4518 }
4519
4520 if (attack_mode == ATTACK_MODE_COMBI)
4521 {
4522 const uint combs_mode = data.combs_mode;
4523
4524 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4525 {
4526 const char *dictfilec = data.dictfile2;
4527
4528 FILE *combs_fp = fopen (dictfilec, "rb");
4529
4530 if (combs_fp == NULL)
4531 {
4532 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4533
4534 fclose (fd);
4535
4536 return NULL;
4537 }
4538
4539 device_param->combs_fp = combs_fp;
4540 }
4541 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4542 {
4543 const char *dictfilec = data.dictfile;
4544
4545 FILE *combs_fp = fopen (dictfilec, "rb");
4546
4547 if (combs_fp == NULL)
4548 {
4549 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4550
4551 fclose (fd);
4552
4553 return NULL;
4554 }
4555
4556 device_param->combs_fp = combs_fp;
4557 }
4558 }
4559
4560 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4561
4562 wl_data->buf = (char *) mymalloc (segment_size);
4563 wl_data->avail = segment_size;
4564 wl_data->incr = segment_size;
4565 wl_data->cnt = 0;
4566 wl_data->pos = 0;
4567
4568 u64 words_cur = 0;
4569
4570 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4571 {
4572 u64 words_off = 0;
4573 u64 words_fin = 0;
4574
4575 bool allow_div = true;
4576
4577 u64 max = -1;
4578
4579 while (max)
4580 {
4581 const uint work = get_work (device_param, max, allow_div);
4582
4583 allow_div = false;
4584
4585 if (work == 0) break;
4586
4587 words_off = device_param->words_off;
4588 words_fin = words_off + work;
4589
4590 char *line_buf;
4591 uint line_len;
4592
4593 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4594
4595 max = 0;
4596
4597 for ( ; words_cur < words_fin; words_cur++)
4598 {
4599 get_next_word (wl_data, fd, &line_buf, &line_len);
4600
4601 line_len = convert_from_hex (line_buf, line_len);
4602
4603 // post-process rule engine
4604
4605 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4606 {
4607 char rule_buf_out[BLOCK_SIZE] = { 0 };
4608
4609 int rule_len_out = -1;
4610
4611 if (line_len < BLOCK_SIZE)
4612 {
4613 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4614 }
4615
4616 if (rule_len_out < 0) continue;
4617
4618 line_buf = rule_buf_out;
4619 line_len = rule_len_out;
4620 }
4621
4622 if (attack_kern == ATTACK_KERN_STRAIGHT)
4623 {
4624 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4625 {
4626 max++;
4627
4628 hc_thread_mutex_lock (mux_counter);
4629
4630 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4631 {
4632 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4633 }
4634
4635 hc_thread_mutex_unlock (mux_counter);
4636
4637 continue;
4638 }
4639 }
4640 else if (attack_kern == ATTACK_KERN_COMBI)
4641 {
4642 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4643 // since we still need to combine the plains
4644
4645 if (line_len > data.pw_max)
4646 {
4647 max++;
4648
4649 hc_thread_mutex_lock (mux_counter);
4650
4651 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4652 {
4653 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4654 }
4655
4656 hc_thread_mutex_unlock (mux_counter);
4657
4658 continue;
4659 }
4660 }
4661
4662 pw_add (device_param, (u8 *) line_buf, line_len);
4663
4664 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4665
4666 if (data.devices_status == STATUS_CRACKED) break;
4667 if (data.devices_status == STATUS_ABORTED) break;
4668 if (data.devices_status == STATUS_QUIT) break;
4669 if (data.devices_status == STATUS_BYPASS) break;
4670 }
4671
4672 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4673
4674 if (data.devices_status == STATUS_CRACKED) break;
4675 if (data.devices_status == STATUS_ABORTED) break;
4676 if (data.devices_status == STATUS_QUIT) break;
4677 if (data.devices_status == STATUS_BYPASS) break;
4678 }
4679
4680 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4681
4682 if (data.devices_status == STATUS_CRACKED) break;
4683 if (data.devices_status == STATUS_ABORTED) break;
4684 if (data.devices_status == STATUS_QUIT) break;
4685 if (data.devices_status == STATUS_BYPASS) break;
4686
4687 //
4688 // flush
4689 //
4690
4691 const uint pws_cnt = device_param->pws_cnt;
4692
4693 if (pws_cnt)
4694 {
4695 run_copy (device_param, pws_cnt);
4696
4697 run_cracker (device_param, pws_cnt);
4698
4699 device_param->pws_cnt = 0;
4700
4701 /*
4702 still required?
4703 if (attack_kern == ATTACK_KERN_STRAIGHT)
4704 {
4705 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4706 }
4707 else if (attack_kern == ATTACK_KERN_COMBI)
4708 {
4709 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4710 }
4711 */
4712 }
4713
4714 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4715
4716 if (data.devices_status == STATUS_CRACKED) break;
4717 if (data.devices_status == STATUS_ABORTED) break;
4718 if (data.devices_status == STATUS_QUIT) break;
4719 if (data.devices_status == STATUS_BYPASS) break;
4720
4721 if (words_fin == 0) break;
4722
4723 device_param->words_done = words_fin;
4724 }
4725
4726 if (attack_mode == ATTACK_MODE_COMBI)
4727 {
4728 fclose (device_param->combs_fp);
4729 }
4730
4731 free (wl_data->buf);
4732 free (wl_data);
4733
4734 fclose (fd);
4735 }
4736
4737 device_param->kernel_accel = 0;
4738 device_param->kernel_loops = 0;
4739
4740 return NULL;
4741 }
4742
4743 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4744 {
4745 if (!device_param)
4746 {
4747 log_error ("ERROR: %s : Invalid argument", __func__);
4748
4749 exit (-1);
4750 }
4751
4752 salt_t *salt_buf = &data.salts_buf[salt_pos];
4753
4754 device_param->kernel_params_buf32[24] = salt_pos;
4755 device_param->kernel_params_buf32[27] = 1;
4756 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4757 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4758 device_param->kernel_params_buf32[30] = 0;
4759 device_param->kernel_params_buf32[31] = 1;
4760
4761 char *dictfile_old = data.dictfile;
4762
4763 const char *weak_hash_check = "weak-hash-check";
4764
4765 data.dictfile = (char *) weak_hash_check;
4766
4767 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4768
4769 data.kernel_rules_buf[0].cmds[0] = 0;
4770
4771 /**
4772 * run the kernel
4773 */
4774
4775 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4776 {
4777 run_kernel (KERN_RUN_1, device_param, 1, false);
4778 }
4779 else
4780 {
4781 run_kernel (KERN_RUN_1, device_param, 1, false);
4782
4783 uint loop_step = 16;
4784
4785 const uint iter = salt_buf->salt_iter;
4786
4787 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4788 {
4789 uint loop_left = iter - loop_pos;
4790
4791 loop_left = MIN (loop_left, loop_step);
4792
4793 device_param->kernel_params_buf32[25] = loop_pos;
4794 device_param->kernel_params_buf32[26] = loop_left;
4795
4796 run_kernel (KERN_RUN_2, device_param, 1, false);
4797 }
4798
4799 run_kernel (KERN_RUN_3, device_param, 1, false);
4800 }
4801
4802 /**
4803 * result
4804 */
4805
4806 check_cracked (device_param, salt_pos);
4807
4808 /**
4809 * cleanup
4810 */
4811
4812 device_param->kernel_params_buf32[24] = 0;
4813 device_param->kernel_params_buf32[25] = 0;
4814 device_param->kernel_params_buf32[26] = 0;
4815 device_param->kernel_params_buf32[27] = 0;
4816 device_param->kernel_params_buf32[28] = 0;
4817 device_param->kernel_params_buf32[29] = 0;
4818 device_param->kernel_params_buf32[30] = 0;
4819 device_param->kernel_params_buf32[31] = 0;
4820
4821 data.dictfile = dictfile_old;
4822
4823 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4824 }
4825
4826 // hlfmt hashcat
4827
4828 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4829 {
4830 if (data.username == 0)
4831 {
4832 *hashbuf_pos = line_buf;
4833 *hashbuf_len = line_len;
4834 }
4835 else
4836 {
4837 char *pos = line_buf;
4838 int len = line_len;
4839
4840 for (int i = 0; i < line_len; i++, pos++, len--)
4841 {
4842 if (line_buf[i] == data.separator)
4843 {
4844 pos++;
4845
4846 len--;
4847
4848 break;
4849 }
4850 }
4851
4852 *hashbuf_pos = pos;
4853 *hashbuf_len = len;
4854 }
4855 }
4856
4857 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4858 {
4859 char *pos = NULL;
4860 int len = 0;
4861
4862 int sep_cnt = 0;
4863
4864 for (int i = 0; i < line_len; i++)
4865 {
4866 if (line_buf[i] == data.separator)
4867 {
4868 sep_cnt++;
4869
4870 continue;
4871 }
4872
4873 if (sep_cnt == 0)
4874 {
4875 if (pos == NULL) pos = line_buf + i;
4876
4877 len++;
4878 }
4879 }
4880
4881 *userbuf_pos = pos;
4882 *userbuf_len = len;
4883 }
4884
4885 // hlfmt pwdump
4886
4887 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4888 {
4889 int sep_cnt = 0;
4890
4891 int sep2_len = 0;
4892 int sep3_len = 0;
4893
4894 for (int i = 0; i < line_len; i++)
4895 {
4896 if (line_buf[i] == ':')
4897 {
4898 sep_cnt++;
4899
4900 continue;
4901 }
4902
4903 if (sep_cnt == 2) sep2_len++;
4904 if (sep_cnt == 3) sep3_len++;
4905 }
4906
4907 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4908
4909 return 0;
4910 }
4911
4912 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4913 {
4914 char *pos = NULL;
4915 int len = 0;
4916
4917 int sep_cnt = 0;
4918
4919 for (int i = 0; i < line_len; i++)
4920 {
4921 if (line_buf[i] == ':')
4922 {
4923 sep_cnt++;
4924
4925 continue;
4926 }
4927
4928 if (data.hash_mode == 1000)
4929 {
4930 if (sep_cnt == 3)
4931 {
4932 if (pos == NULL) pos = line_buf + i;
4933
4934 len++;
4935 }
4936 }
4937 else if (data.hash_mode == 3000)
4938 {
4939 if (sep_cnt == 2)
4940 {
4941 if (pos == NULL) pos = line_buf + i;
4942
4943 len++;
4944 }
4945 }
4946 }
4947
4948 *hashbuf_pos = pos;
4949 *hashbuf_len = len;
4950 }
4951
4952 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4953 {
4954 char *pos = NULL;
4955 int len = 0;
4956
4957 int sep_cnt = 0;
4958
4959 for (int i = 0; i < line_len; i++)
4960 {
4961 if (line_buf[i] == ':')
4962 {
4963 sep_cnt++;
4964
4965 continue;
4966 }
4967
4968 if (sep_cnt == 0)
4969 {
4970 if (pos == NULL) pos = line_buf + i;
4971
4972 len++;
4973 }
4974 }
4975
4976 *userbuf_pos = pos;
4977 *userbuf_len = len;
4978 }
4979
4980 // hlfmt passwd
4981
4982 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4983 {
4984 int sep_cnt = 0;
4985
4986 char sep5_first = 0;
4987 char sep6_first = 0;
4988
4989 for (int i = 0; i < line_len; i++)
4990 {
4991 if (line_buf[i] == ':')
4992 {
4993 sep_cnt++;
4994
4995 continue;
4996 }
4997
4998 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4999 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5000 }
5001
5002 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5003
5004 return 0;
5005 }
5006
5007 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5008 {
5009 char *pos = NULL;
5010 int len = 0;
5011
5012 int sep_cnt = 0;
5013
5014 for (int i = 0; i < line_len; i++)
5015 {
5016 if (line_buf[i] == ':')
5017 {
5018 sep_cnt++;
5019
5020 continue;
5021 }
5022
5023 if (sep_cnt == 1)
5024 {
5025 if (pos == NULL) pos = line_buf + i;
5026
5027 len++;
5028 }
5029 }
5030
5031 *hashbuf_pos = pos;
5032 *hashbuf_len = len;
5033 }
5034
5035 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5036 {
5037 char *pos = NULL;
5038 int len = 0;
5039
5040 int sep_cnt = 0;
5041
5042 for (int i = 0; i < line_len; i++)
5043 {
5044 if (line_buf[i] == ':')
5045 {
5046 sep_cnt++;
5047
5048 continue;
5049 }
5050
5051 if (sep_cnt == 0)
5052 {
5053 if (pos == NULL) pos = line_buf + i;
5054
5055 len++;
5056 }
5057 }
5058
5059 *userbuf_pos = pos;
5060 *userbuf_len = len;
5061 }
5062
5063 // hlfmt shadow
5064
5065 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5066 {
5067 int sep_cnt = 0;
5068
5069 for (int i = 0; i < line_len; i++)
5070 {
5071 if (line_buf[i] == ':') sep_cnt++;
5072 }
5073
5074 if (sep_cnt == 8) return 1;
5075
5076 return 0;
5077 }
5078
5079 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5080 {
5081 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5082 }
5083
5084 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5085 {
5086 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5087 }
5088
5089 // hlfmt main
5090
5091 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5092 {
5093 switch (hashfile_format)
5094 {
5095 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5096 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5097 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5098 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5099 }
5100 }
5101
5102 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5103 {
5104 switch (hashfile_format)
5105 {
5106 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5107 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5108 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5109 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5110 }
5111 }
5112
5113 char *strhlfmt (const uint hashfile_format)
5114 {
5115 switch (hashfile_format)
5116 {
5117 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5118 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5119 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5120 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5121 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5122 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5123 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5124 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5125 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5126 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5127 }
5128
5129 return ((char *) "Unknown");
5130 }
5131
5132 static uint hlfmt_detect (FILE *fp, uint max_check)
5133 {
5134 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5135
5136 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5137 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5138
5139 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5140
5141 uint num_check = 0;
5142
5143 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5144
5145 while (!feof (fp))
5146 {
5147 int line_len = fgetl (fp, line_buf);
5148
5149 if (line_len == 0) continue;
5150
5151 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5152 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5153 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5154
5155 if (num_check == max_check) break;
5156
5157 num_check++;
5158 }
5159
5160 myfree (line_buf);
5161
5162 uint hashlist_format = HLFMT_HASHCAT;
5163
5164 for (int i = 1; i < HLFMTS_CNT; i++)
5165 {
5166 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5167
5168 hashlist_format = i;
5169 }
5170
5171 free (formats_cnt);
5172
5173 return hashlist_format;
5174 }
5175
5176 /**
5177 * some further helper function
5178 */
5179
5180 // wrapper around mymalloc for ADL
5181
5182 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5183 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5184 {
5185 return mymalloc (iSize);
5186 }
5187 #endif
5188
5189 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)
5190 {
5191 u64 collisions = 0;
5192
5193 const uint dgst_pos0 = data.dgst_pos0;
5194 const uint dgst_pos1 = data.dgst_pos1;
5195 const uint dgst_pos2 = data.dgst_pos2;
5196 const uint dgst_pos3 = data.dgst_pos3;
5197
5198 memset (bitmap_a, 0, bitmap_size);
5199 memset (bitmap_b, 0, bitmap_size);
5200 memset (bitmap_c, 0, bitmap_size);
5201 memset (bitmap_d, 0, bitmap_size);
5202
5203 for (uint i = 0; i < digests_cnt; i++)
5204 {
5205 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5206
5207 uint *digest_ptr = (uint *) digests_buf_ptr;
5208
5209 digests_buf_ptr += dgst_size;
5210
5211 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5212 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5213 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5214 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5215
5216 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5217 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5218 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5219 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5220
5221 if (bitmap_a[idx0] & val0) collisions++;
5222 if (bitmap_b[idx1] & val1) collisions++;
5223 if (bitmap_c[idx2] & val2) collisions++;
5224 if (bitmap_d[idx3] & val3) collisions++;
5225
5226 bitmap_a[idx0] |= val0;
5227 bitmap_b[idx1] |= val1;
5228 bitmap_c[idx2] |= val2;
5229 bitmap_d[idx3] |= val3;
5230
5231 if (collisions >= collisions_max) return 0x7fffffff;
5232 }
5233
5234 return collisions;
5235 }
5236
5237 /**
5238 * main
5239 */
5240
5241 int main (int argc, char **argv)
5242 {
5243 /**
5244 * To help users a bit
5245 */
5246
5247 char *compute = getenv ("COMPUTE");
5248
5249 if (compute)
5250 {
5251 static char display[100];
5252
5253 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5254
5255 putenv (display);
5256 }
5257 else
5258 {
5259 if (getenv ("DISPLAY") == NULL)
5260 putenv ((char *) "DISPLAY=:0");
5261 }
5262
5263 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5264 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5265
5266 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5267 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5268
5269 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5270 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5271
5272 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5273 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5274
5275 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5276 putenv ((char *) "POCL_KERNEL_CACHE=0");
5277
5278 umask (077);
5279
5280 /**
5281 * Real init
5282 */
5283
5284 memset (&data, 0, sizeof (hc_global_data_t));
5285
5286 time_t proc_start;
5287
5288 time (&proc_start);
5289
5290 data.proc_start = proc_start;
5291
5292 int myargc = argc;
5293 char **myargv = argv;
5294
5295 hc_thread_mutex_init (mux_dispatcher);
5296 hc_thread_mutex_init (mux_counter);
5297 hc_thread_mutex_init (mux_display);
5298 hc_thread_mutex_init (mux_adl);
5299
5300 /**
5301 * commandline parameters
5302 */
5303
5304 uint usage = USAGE;
5305 uint version = VERSION;
5306 uint quiet = QUIET;
5307 uint benchmark = BENCHMARK;
5308 uint show = SHOW;
5309 uint left = LEFT;
5310 uint username = USERNAME;
5311 uint remove = REMOVE;
5312 uint remove_timer = REMOVE_TIMER;
5313 u64 skip = SKIP;
5314 u64 limit = LIMIT;
5315 uint keyspace = KEYSPACE;
5316 uint potfile_disable = POTFILE_DISABLE;
5317 char *potfile_path = NULL;
5318 uint debug_mode = DEBUG_MODE;
5319 char *debug_file = NULL;
5320 char *induction_dir = NULL;
5321 char *outfile_check_dir = NULL;
5322 uint force = FORCE;
5323 uint runtime = RUNTIME;
5324 uint hash_mode = HASH_MODE;
5325 uint attack_mode = ATTACK_MODE;
5326 uint markov_disable = MARKOV_DISABLE;
5327 uint markov_classic = MARKOV_CLASSIC;
5328 uint markov_threshold = MARKOV_THRESHOLD;
5329 char *markov_hcstat = NULL;
5330 char *outfile = NULL;
5331 uint outfile_format = OUTFILE_FORMAT;
5332 uint outfile_autohex = OUTFILE_AUTOHEX;
5333 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5334 uint restore = RESTORE;
5335 uint restore_timer = RESTORE_TIMER;
5336 uint restore_disable = RESTORE_DISABLE;
5337 uint status = STATUS;
5338 uint status_timer = STATUS_TIMER;
5339 uint status_automat = STATUS_AUTOMAT;
5340 uint loopback = LOOPBACK;
5341 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5342 char *session = NULL;
5343 uint hex_charset = HEX_CHARSET;
5344 uint hex_salt = HEX_SALT;
5345 uint hex_wordlist = HEX_WORDLIST;
5346 uint rp_gen = RP_GEN;
5347 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5348 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5349 uint rp_gen_seed = RP_GEN_SEED;
5350 char *rule_buf_l = (char *) RULE_BUF_L;
5351 char *rule_buf_r = (char *) RULE_BUF_R;
5352 uint increment = INCREMENT;
5353 uint increment_min = INCREMENT_MIN;
5354 uint increment_max = INCREMENT_MAX;
5355 char *cpu_affinity = NULL;
5356 OCL_PTR *ocl = NULL;
5357 char *opencl_devices = NULL;
5358 char *opencl_platforms = NULL;
5359 char *opencl_device_types = NULL;
5360 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5361 char *truecrypt_keyfiles = NULL;
5362 char *veracrypt_keyfiles = NULL;
5363 uint veracrypt_pim = 0;
5364 uint workload_profile = WORKLOAD_PROFILE;
5365 uint kernel_accel = KERNEL_ACCEL;
5366 uint kernel_loops = KERNEL_LOOPS;
5367 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5368 #ifdef HAVE_HWMON
5369 uint gpu_temp_abort = GPU_TEMP_ABORT;
5370 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5371 #ifdef HAVE_ADL
5372 uint powertune_enable = POWERTUNE_ENABLE;
5373 #endif
5374 #endif
5375 uint logfile_disable = LOGFILE_DISABLE;
5376 uint segment_size = SEGMENT_SIZE;
5377 uint scrypt_tmto = SCRYPT_TMTO;
5378 char separator = SEPARATOR;
5379 uint bitmap_min = BITMAP_MIN;
5380 uint bitmap_max = BITMAP_MAX;
5381 char *custom_charset_1 = NULL;
5382 char *custom_charset_2 = NULL;
5383 char *custom_charset_3 = NULL;
5384 char *custom_charset_4 = NULL;
5385
5386 #define IDX_HELP 'h'
5387 #define IDX_VERSION 'V'
5388 #define IDX_VERSION_LOWER 'v'
5389 #define IDX_QUIET 0xff02
5390 #define IDX_SHOW 0xff03
5391 #define IDX_LEFT 0xff04
5392 #define IDX_REMOVE 0xff05
5393 #define IDX_REMOVE_TIMER 0xff37
5394 #define IDX_SKIP 's'
5395 #define IDX_LIMIT 'l'
5396 #define IDX_KEYSPACE 0xff35
5397 #define IDX_POTFILE_DISABLE 0xff06
5398 #define IDX_POTFILE_PATH 0xffe0
5399 #define IDX_DEBUG_MODE 0xff43
5400 #define IDX_DEBUG_FILE 0xff44
5401 #define IDX_INDUCTION_DIR 0xff46
5402 #define IDX_OUTFILE_CHECK_DIR 0xff47
5403 #define IDX_USERNAME 0xff07
5404 #define IDX_FORCE 0xff08
5405 #define IDX_RUNTIME 0xff09
5406 #define IDX_BENCHMARK 'b'
5407 #define IDX_HASH_MODE 'm'
5408 #define IDX_ATTACK_MODE 'a'
5409 #define IDX_RP_FILE 'r'
5410 #define IDX_RP_GEN 'g'
5411 #define IDX_RP_GEN_FUNC_MIN 0xff10
5412 #define IDX_RP_GEN_FUNC_MAX 0xff11
5413 #define IDX_RP_GEN_SEED 0xff34
5414 #define IDX_RULE_BUF_L 'j'
5415 #define IDX_RULE_BUF_R 'k'
5416 #define IDX_INCREMENT 'i'
5417 #define IDX_INCREMENT_MIN 0xff12
5418 #define IDX_INCREMENT_MAX 0xff13
5419 #define IDX_OUTFILE 'o'
5420 #define IDX_OUTFILE_FORMAT 0xff14
5421 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5422 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5423 #define IDX_RESTORE 0xff15
5424 #define IDX_RESTORE_DISABLE 0xff27
5425 #define IDX_STATUS 0xff17
5426 #define IDX_STATUS_TIMER 0xff18
5427 #define IDX_STATUS_AUTOMAT 0xff50
5428 #define IDX_LOOPBACK 0xff38
5429 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5430 #define IDX_SESSION 0xff19
5431 #define IDX_HEX_CHARSET 0xff20
5432 #define IDX_HEX_SALT 0xff21
5433 #define IDX_HEX_WORDLIST 0xff40
5434 #define IDX_MARKOV_DISABLE 0xff22
5435 #define IDX_MARKOV_CLASSIC 0xff23
5436 #define IDX_MARKOV_THRESHOLD 't'
5437 #define IDX_MARKOV_HCSTAT 0xff24
5438 #define IDX_CPU_AFFINITY 0xff25
5439 #define IDX_OPENCL_DEVICES 'd'
5440 #define IDX_OPENCL_PLATFORMS 0xff72
5441 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5442 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5443 #define IDX_WORKLOAD_PROFILE 'w'
5444 #define IDX_KERNEL_ACCEL 'n'
5445 #define IDX_KERNEL_LOOPS 'u'
5446 #define IDX_GPU_TEMP_DISABLE 0xff29
5447 #define IDX_GPU_TEMP_ABORT 0xff30
5448 #define IDX_GPU_TEMP_RETAIN 0xff31
5449 #define IDX_POWERTUNE_ENABLE 0xff41
5450 #define IDX_LOGFILE_DISABLE 0xff51
5451 #define IDX_TRUECRYPT_KEYFILES 0xff52
5452 #define IDX_VERACRYPT_KEYFILES 0xff53
5453 #define IDX_VERACRYPT_PIM 0xff54
5454 #define IDX_SCRYPT_TMTO 0xff61
5455 #define IDX_SEGMENT_SIZE 'c'
5456 #define IDX_SEPARATOR 'p'
5457 #define IDX_BITMAP_MIN 0xff70
5458 #define IDX_BITMAP_MAX 0xff71
5459 #define IDX_CUSTOM_CHARSET_1 '1'
5460 #define IDX_CUSTOM_CHARSET_2 '2'
5461 #define IDX_CUSTOM_CHARSET_3 '3'
5462 #define IDX_CUSTOM_CHARSET_4 '4'
5463
5464 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5465
5466 struct option long_options[] =
5467 {
5468 {"help", no_argument, 0, IDX_HELP},
5469 {"version", no_argument, 0, IDX_VERSION},
5470 {"quiet", no_argument, 0, IDX_QUIET},
5471 {"show", no_argument, 0, IDX_SHOW},
5472 {"left", no_argument, 0, IDX_LEFT},
5473 {"username", no_argument, 0, IDX_USERNAME},
5474 {"remove", no_argument, 0, IDX_REMOVE},
5475 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5476 {"skip", required_argument, 0, IDX_SKIP},
5477 {"limit", required_argument, 0, IDX_LIMIT},
5478 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5479 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5480 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5481 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5482 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5483 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5484 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5485 {"force", no_argument, 0, IDX_FORCE},
5486 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5487 {"restore", no_argument, 0, IDX_RESTORE},
5488 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5489 {"status", no_argument, 0, IDX_STATUS},
5490 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5491 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5492 {"loopback", no_argument, 0, IDX_LOOPBACK},
5493 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5494 {"session", required_argument, 0, IDX_SESSION},
5495 {"runtime", required_argument, 0, IDX_RUNTIME},
5496 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5497 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5498 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5499 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5500 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5501 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5502 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5503 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5504 {"rules-file", required_argument, 0, IDX_RP_FILE},
5505 {"outfile", required_argument, 0, IDX_OUTFILE},
5506 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5507 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5508 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5509 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5510 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5511 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5512 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5513 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5514 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5515 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5516 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5517 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5518 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5519 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5520 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5521 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5522 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5523 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5524 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5525 #ifdef HAVE_HWMON
5526 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5527 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5528 #ifdef HAVE_ADL
5529 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5530 #endif
5531 #endif // HAVE_HWMON
5532 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5533 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5534 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5535 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5536 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5537 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5538 {"seperator", required_argument, 0, IDX_SEPARATOR},
5539 {"separator", required_argument, 0, IDX_SEPARATOR},
5540 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5541 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5542 {"increment", no_argument, 0, IDX_INCREMENT},
5543 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5544 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5545 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5546 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5547 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5548 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5549 {0, 0, 0, 0}
5550 };
5551
5552 uint rp_files_cnt = 0;
5553
5554 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5555
5556 int option_index = 0;
5557 int c = -1;
5558
5559 optind = 1;
5560 optopt = 0;
5561
5562 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5563 {
5564 switch (c)
5565 {
5566 case IDX_HELP: usage = 1; break;
5567 case IDX_VERSION:
5568 case IDX_VERSION_LOWER: version = 1; break;
5569 case IDX_RESTORE: restore = 1; break;
5570 case IDX_SESSION: session = optarg; break;
5571 case IDX_SHOW: show = 1; break;
5572 case IDX_LEFT: left = 1; break;
5573 case '?': return (-1);
5574 }
5575 }
5576
5577 if (optopt != 0)
5578 {
5579 log_error ("ERROR: Invalid argument specified");
5580
5581 return (-1);
5582 }
5583
5584 /**
5585 * exit functions
5586 */
5587
5588 if (version)
5589 {
5590 log_info ("%s", VERSION_TAG);
5591
5592 return (0);
5593 }
5594
5595 if (usage)
5596 {
5597 usage_big_print (PROGNAME);
5598
5599 return (0);
5600 }
5601
5602 /**
5603 * session needs to be set, always!
5604 */
5605
5606 if (session == NULL) session = (char *) PROGNAME;
5607
5608 /**
5609 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5610 */
5611
5612 char *exec_path = get_exec_path ();
5613
5614 #ifdef LINUX
5615
5616 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5617 char *resolved_exec_path = realpath (exec_path, NULL);
5618
5619 char *install_dir = get_install_dir (resolved_exec_path);
5620 char *profile_dir = NULL;
5621 char *session_dir = NULL;
5622 char *shared_dir = NULL;
5623
5624 if (strcmp (install_dir, resolved_install_folder) == 0)
5625 {
5626 struct passwd *pw = getpwuid (getuid ());
5627
5628 const char *homedir = pw->pw_dir;
5629
5630 profile_dir = get_profile_dir (homedir);
5631 session_dir = get_session_dir (profile_dir);
5632 shared_dir = strdup (SHARED_FOLDER);
5633
5634 mkdir (profile_dir, 0700);
5635 mkdir (session_dir, 0700);
5636 }
5637 else
5638 {
5639 profile_dir = install_dir;
5640 session_dir = install_dir;
5641 shared_dir = install_dir;
5642 }
5643
5644 myfree (resolved_install_folder);
5645 myfree (resolved_exec_path);
5646
5647 #else
5648
5649 char *install_dir = get_install_dir (exec_path);
5650 char *profile_dir = install_dir;
5651 char *session_dir = install_dir;
5652 char *shared_dir = install_dir;
5653
5654 #endif
5655
5656 data.install_dir = install_dir;
5657 data.profile_dir = profile_dir;
5658 data.session_dir = session_dir;
5659 data.shared_dir = shared_dir;
5660
5661 myfree (exec_path);
5662
5663 /**
5664 * kernel cache, we need to make sure folder exist
5665 */
5666
5667 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5668
5669 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5670
5671 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5672
5673 mkdir (kernels_folder, 0700);
5674
5675 myfree (kernels_folder);
5676
5677 /**
5678 * session
5679 */
5680
5681 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5682
5683 data.session = session;
5684
5685 char *eff_restore_file = (char *) mymalloc (session_size);
5686 char *new_restore_file = (char *) mymalloc (session_size);
5687
5688 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5689 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5690
5691 data.eff_restore_file = eff_restore_file;
5692 data.new_restore_file = new_restore_file;
5693
5694 if (((show == 1) || (left == 1)) && (restore == 1))
5695 {
5696 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5697 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5698
5699 return (-1);
5700 }
5701
5702 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5703 if ((show == 1) || (left == 1))
5704 {
5705 restore_disable = 1;
5706
5707 restore = 0;
5708 }
5709
5710 data.restore_disable = restore_disable;
5711
5712 restore_data_t *rd = init_restore (argc, argv);
5713
5714 data.rd = rd;
5715
5716 /**
5717 * restore file
5718 */
5719
5720 if (restore == 1)
5721 {
5722 read_restore (eff_restore_file, rd);
5723
5724 if (rd->version_bin < RESTORE_MIN)
5725 {
5726 log_error ("ERROR: Incompatible restore-file version");
5727
5728 return (-1);
5729 }
5730
5731 myargc = rd->argc;
5732 myargv = rd->argv;
5733
5734 #ifdef _POSIX
5735 rd->pid = getpid ();
5736 #elif _WIN
5737 rd->pid = GetCurrentProcessId ();
5738 #endif
5739 }
5740
5741 uint hash_mode_chgd = 0;
5742 uint runtime_chgd = 0;
5743 uint kernel_loops_chgd = 0;
5744 uint kernel_accel_chgd = 0;
5745 uint attack_mode_chgd = 0;
5746 uint outfile_format_chgd = 0;
5747 uint rp_gen_seed_chgd = 0;
5748 uint remove_timer_chgd = 0;
5749 uint increment_min_chgd = 0;
5750 uint increment_max_chgd = 0;
5751 uint workload_profile_chgd = 0;
5752 uint opencl_vector_width_chgd = 0;
5753
5754 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5755 uint gpu_temp_retain_chgd = 0;
5756 uint gpu_temp_abort_chgd = 0;
5757 #endif
5758
5759 optind = 1;
5760 optopt = 0;
5761 option_index = 0;
5762
5763 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5764 {
5765 switch (c)
5766 {
5767 //case IDX_HELP: usage = 1; break;
5768 //case IDX_VERSION: version = 1; break;
5769 //case IDX_RESTORE: restore = 1; break;
5770 case IDX_QUIET: quiet = 1; break;
5771 //case IDX_SHOW: show = 1; break;
5772 case IDX_SHOW: break;
5773 //case IDX_LEFT: left = 1; break;
5774 case IDX_LEFT: break;
5775 case IDX_USERNAME: username = 1; break;
5776 case IDX_REMOVE: remove = 1; break;
5777 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5778 remove_timer_chgd = 1; break;
5779 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5780 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5781 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5782 case IDX_DEBUG_FILE: debug_file = optarg; break;
5783 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5784 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5785 case IDX_FORCE: force = 1; break;
5786 case IDX_SKIP: skip = atoll (optarg); break;
5787 case IDX_LIMIT: limit = atoll (optarg); break;
5788 case IDX_KEYSPACE: keyspace = 1; break;
5789 case IDX_BENCHMARK: benchmark = 1; break;
5790 case IDX_RESTORE: break;
5791 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5792 case IDX_STATUS: status = 1; break;
5793 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5794 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5795 case IDX_LOOPBACK: loopback = 1; break;
5796 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5797 //case IDX_SESSION: session = optarg; break;
5798 case IDX_SESSION: break;
5799 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5800 hash_mode_chgd = 1; break;
5801 case IDX_RUNTIME: runtime = atoi (optarg);
5802 runtime_chgd = 1; break;
5803 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5804 attack_mode_chgd = 1; break;
5805 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5806 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5807 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5808 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5809 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5810 rp_gen_seed_chgd = 1; break;
5811 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5812 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5813 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5814 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5815 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5816 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5817 case IDX_OUTFILE: outfile = optarg; break;
5818 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5819 outfile_format_chgd = 1; break;
5820 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5821 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5822 case IDX_HEX_CHARSET: hex_charset = 1; break;
5823 case IDX_HEX_SALT: hex_salt = 1; break;
5824 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5825 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5826 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5827 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5828 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5829 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5830 opencl_vector_width_chgd = 1; break;
5831 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5832 workload_profile_chgd = 1; break;
5833 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5834 kernel_accel_chgd = 1; break;
5835 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5836 kernel_loops_chgd = 1; break;
5837 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5838 #ifdef HAVE_HWMON
5839 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5840 #ifdef HAVE_ADL
5841 gpu_temp_abort_chgd = 1;
5842 #endif
5843 break;
5844 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5845 #ifdef HAVE_ADL
5846 gpu_temp_retain_chgd = 1;
5847 #endif
5848 break;
5849 #ifdef HAVE_ADL
5850 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5851 #endif
5852 #endif // HAVE_HWMON
5853 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5854 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5855 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5856 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5857 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5858 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5859 case IDX_SEPARATOR: separator = optarg[0]; break;
5860 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5861 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5862 case IDX_INCREMENT: increment = 1; break;
5863 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5864 increment_min_chgd = 1; break;
5865 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5866 increment_max_chgd = 1; break;
5867 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5868 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5869 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5870 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5871
5872 default:
5873 log_error ("ERROR: Invalid argument specified");
5874 return (-1);
5875 }
5876 }
5877
5878 if (optopt != 0)
5879 {
5880 log_error ("ERROR: Invalid argument specified");
5881
5882 return (-1);
5883 }
5884
5885 /**
5886 * Inform user things getting started,
5887 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5888 * - we do not need to check algorithm_pos
5889 */
5890
5891 if (quiet == 0)
5892 {
5893 if (benchmark == 1)
5894 {
5895 if (status_automat == 0)
5896 {
5897 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5898 log_info ("");
5899 }
5900 else
5901 {
5902 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5903 }
5904 }
5905 else if (restore == 1)
5906 {
5907 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5908 log_info ("");
5909 }
5910 else
5911 {
5912 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5913 log_info ("");
5914 }
5915 }
5916
5917 /**
5918 * sanity check
5919 */
5920
5921 if (attack_mode > 7)
5922 {
5923 log_error ("ERROR: Invalid attack-mode specified");
5924
5925 return (-1);
5926 }
5927
5928 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5929 {
5930 log_error ("ERROR: Invalid runtime specified");
5931
5932 return (-1);
5933 }
5934
5935 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5936 {
5937 log_error ("ERROR: Invalid hash-type specified");
5938
5939 return (-1);
5940 }
5941
5942 // renamed hash modes
5943
5944 if (hash_mode_chgd)
5945 {
5946 int n = -1;
5947
5948 switch (hash_mode)
5949 {
5950 case 123: n = 124;
5951 break;
5952 }
5953
5954 if (n >= 0)
5955 {
5956 log_error ("Old -m specified, use -m %d instead", n);
5957
5958 return (-1);
5959 }
5960 }
5961
5962 if (username == 1)
5963 {
5964 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5965 {
5966 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5967
5968 return (-1);
5969 }
5970 }
5971
5972 if (outfile_format > 16)
5973 {
5974 log_error ("ERROR: Invalid outfile-format specified");
5975
5976 return (-1);
5977 }
5978
5979 if (left == 1)
5980 {
5981 if (outfile_format_chgd == 1)
5982 {
5983 if (outfile_format > 1)
5984 {
5985 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5986
5987 return (-1);
5988 }
5989 }
5990 else
5991 {
5992 outfile_format = OUTFILE_FMT_HASH;
5993 }
5994 }
5995
5996 if (show == 1)
5997 {
5998 if (outfile_format_chgd == 1)
5999 {
6000 if ((outfile_format > 7) && (outfile_format < 16))
6001 {
6002 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6003
6004 return (-1);
6005 }
6006 }
6007 }
6008
6009 if (increment_min < INCREMENT_MIN)
6010 {
6011 log_error ("ERROR: Invalid increment-min specified");
6012
6013 return (-1);
6014 }
6015
6016 if (increment_max > INCREMENT_MAX)
6017 {
6018 log_error ("ERROR: Invalid increment-max specified");
6019
6020 return (-1);
6021 }
6022
6023 if (increment_min > increment_max)
6024 {
6025 log_error ("ERROR: Invalid increment-min specified");
6026
6027 return (-1);
6028 }
6029
6030 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6031 {
6032 log_error ("ERROR: increment is not allowed in attack-mode 0");
6033
6034 return (-1);
6035 }
6036
6037 if ((increment == 0) && (increment_min_chgd == 1))
6038 {
6039 log_error ("ERROR: increment-min is only supported together with increment switch");
6040
6041 return (-1);
6042 }
6043
6044 if ((increment == 0) && (increment_max_chgd == 1))
6045 {
6046 log_error ("ERROR: increment-max is only supported together with increment switch");
6047
6048 return (-1);
6049 }
6050
6051 if (rp_files_cnt && rp_gen)
6052 {
6053 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6054
6055 return (-1);
6056 }
6057
6058 if (rp_files_cnt || rp_gen)
6059 {
6060 if (attack_mode != ATTACK_MODE_STRAIGHT)
6061 {
6062 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6063
6064 return (-1);
6065 }
6066 }
6067
6068 if (rp_gen_func_min > rp_gen_func_max)
6069 {
6070 log_error ("ERROR: Invalid rp-gen-func-min specified");
6071
6072 return (-1);
6073 }
6074
6075 if (kernel_accel_chgd == 1)
6076 {
6077 if (force == 0)
6078 {
6079 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6080 log_info ("Please consider using the option -w instead");
6081 log_info ("You can use --force to override this but do not post error reports if you do so");
6082 log_info ("");
6083
6084 return (-1);
6085 }
6086
6087 if (kernel_accel < 1)
6088 {
6089 log_error ("ERROR: Invalid kernel-accel specified");
6090
6091 return (-1);
6092 }
6093
6094 if (kernel_accel > 1024)
6095 {
6096 log_error ("ERROR: Invalid kernel-accel specified");
6097
6098 return (-1);
6099 }
6100 }
6101
6102 if (kernel_loops_chgd == 1)
6103 {
6104 if (force == 0)
6105 {
6106 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6107 log_info ("Please consider using the option -w instead");
6108 log_info ("You can use --force to override this but do not post error reports if you do so");
6109 log_info ("");
6110
6111 return (-1);
6112 }
6113
6114 if (kernel_loops < 1)
6115 {
6116 log_error ("ERROR: Invalid kernel-loops specified");
6117
6118 return (-1);
6119 }
6120
6121 if (kernel_loops > 1024)
6122 {
6123 log_error ("ERROR: Invalid kernel-loops specified");
6124
6125 return (-1);
6126 }
6127 }
6128
6129 if ((workload_profile < 1) || (workload_profile > 4))
6130 {
6131 log_error ("ERROR: workload-profile %i not available", workload_profile);
6132
6133 return (-1);
6134 }
6135
6136 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6137 {
6138 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6139
6140 return (-1);
6141 }
6142
6143 if (show == 1 || left == 1)
6144 {
6145 attack_mode = ATTACK_MODE_NONE;
6146
6147 if (remove == 1)
6148 {
6149 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6150
6151 return (-1);
6152 }
6153
6154 if (potfile_disable == 1)
6155 {
6156 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6157
6158 return (-1);
6159 }
6160 }
6161
6162 uint attack_kern = ATTACK_KERN_NONE;
6163
6164 switch (attack_mode)
6165 {
6166 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6167 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6168 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6169 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6170 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6171 }
6172
6173 if (benchmark == 0)
6174 {
6175 if (keyspace == 1)
6176 {
6177 int num_additional_params = 1;
6178
6179 if (attack_kern == ATTACK_KERN_COMBI)
6180 {
6181 num_additional_params = 2;
6182 }
6183
6184 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6185
6186 if (keyspace_wordlist_specified == 0) optind--;
6187 }
6188
6189 if (attack_kern == ATTACK_KERN_NONE)
6190 {
6191 if ((optind + 1) != myargc)
6192 {
6193 usage_mini_print (myargv[0]);
6194
6195 return (-1);
6196 }
6197 }
6198 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6199 {
6200 if ((optind + 1) > myargc)
6201 {
6202 usage_mini_print (myargv[0]);
6203
6204 return (-1);
6205 }
6206 }
6207 else if (attack_kern == ATTACK_KERN_COMBI)
6208 {
6209 if ((optind + 3) != myargc)
6210 {
6211 usage_mini_print (myargv[0]);
6212
6213 return (-1);
6214 }
6215 }
6216 else if (attack_kern == ATTACK_KERN_BF)
6217 {
6218 if ((optind + 1) > myargc)
6219 {
6220 usage_mini_print (myargv[0]);
6221
6222 return (-1);
6223 }
6224 }
6225 else
6226 {
6227 usage_mini_print (myargv[0]);
6228
6229 return (-1);
6230 }
6231 }
6232 else
6233 {
6234 if (myargv[optind] != 0)
6235 {
6236 log_error ("ERROR: Invalid argument for benchmark mode specified");
6237
6238 return (-1);
6239 }
6240
6241 if (attack_mode_chgd == 1)
6242 {
6243 if (attack_mode != ATTACK_MODE_BF)
6244 {
6245 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6246
6247 return (-1);
6248 }
6249 }
6250 }
6251
6252 if (skip != 0 && limit != 0)
6253 {
6254 limit += skip;
6255 }
6256
6257 if (keyspace == 1)
6258 {
6259 if (show == 1)
6260 {
6261 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6262
6263 return (-1);
6264 }
6265 else if (left == 1)
6266 {
6267 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6268
6269 return (-1);
6270 }
6271
6272 potfile_disable = 1;
6273
6274 restore_disable = 1;
6275
6276 restore = 0;
6277
6278 weak_hash_threshold = 0;
6279
6280 quiet = 1;
6281 }
6282
6283 if (remove_timer_chgd == 1)
6284 {
6285 if (remove == 0)
6286 {
6287 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6288
6289 return (-1);
6290 }
6291
6292 if (remove_timer < 1)
6293 {
6294 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6295
6296 return (-1);
6297 }
6298 }
6299
6300 if (loopback == 1)
6301 {
6302 if (attack_mode == ATTACK_MODE_STRAIGHT)
6303 {
6304 if ((rp_files_cnt == 0) && (rp_gen == 0))
6305 {
6306 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6307
6308 return (-1);
6309 }
6310 }
6311 else
6312 {
6313 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6314
6315 return (-1);
6316 }
6317 }
6318
6319 if (debug_mode > 0)
6320 {
6321 if (attack_mode != ATTACK_MODE_STRAIGHT)
6322 {
6323 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6324
6325 return (-1);
6326 }
6327
6328 if ((rp_files_cnt == 0) && (rp_gen == 0))
6329 {
6330 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6331
6332 return (-1);
6333 }
6334 }
6335
6336 if (debug_mode > 4)
6337 {
6338 log_error ("ERROR: Invalid debug-mode specified");
6339
6340 return (-1);
6341 }
6342
6343 if (debug_file != NULL)
6344 {
6345 if (debug_mode < 1)
6346 {
6347 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6348
6349 return (-1);
6350 }
6351 }
6352
6353 if (induction_dir != NULL)
6354 {
6355 if (attack_mode == ATTACK_MODE_BF)
6356 {
6357 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6358
6359 return (-1);
6360 }
6361 }
6362
6363 if (attack_mode != ATTACK_MODE_STRAIGHT)
6364 {
6365 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6366 {
6367 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6368
6369 return (-1);
6370 }
6371
6372 weak_hash_threshold = 0;
6373 }
6374
6375 /**
6376 * induction directory
6377 */
6378
6379 char *induction_directory = NULL;
6380
6381 if (attack_mode != ATTACK_MODE_BF)
6382 {
6383 if (induction_dir == NULL)
6384 {
6385 induction_directory = (char *) mymalloc (session_size);
6386
6387 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6388
6389 // create induction folder if it does not already exist
6390
6391 if (keyspace == 0)
6392 {
6393 if (rmdir (induction_directory) == -1)
6394 {
6395 if (errno == ENOENT)
6396 {
6397 // good, we can ignore
6398 }
6399 else if (errno == ENOTEMPTY)
6400 {
6401 char *induction_directory_mv = (char *) mymalloc (session_size);
6402
6403 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6404
6405 if (rename (induction_directory, induction_directory_mv) != 0)
6406 {
6407 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6408
6409 return (-1);
6410 }
6411 }
6412 else
6413 {
6414 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6415
6416 return (-1);
6417 }
6418 }
6419
6420 if (mkdir (induction_directory, 0700) == -1)
6421 {
6422 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6423
6424 return (-1);
6425 }
6426 }
6427 }
6428 else
6429 {
6430 induction_directory = induction_dir;
6431 }
6432 }
6433
6434 data.induction_directory = induction_directory;
6435
6436 /**
6437 * loopback
6438 */
6439
6440 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6441
6442 char *loopback_file = (char *) mymalloc (loopback_size);
6443
6444 /**
6445 * tuning db
6446 */
6447
6448 char tuning_db_file[256] = { 0 };
6449
6450 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6451
6452 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6453
6454 /**
6455 * outfile-check directory
6456 */
6457
6458 char *outfile_check_directory = NULL;
6459
6460 if (outfile_check_dir == NULL)
6461 {
6462 outfile_check_directory = (char *) mymalloc (session_size);
6463
6464 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6465 }
6466 else
6467 {
6468 outfile_check_directory = outfile_check_dir;
6469 }
6470
6471 data.outfile_check_directory = outfile_check_directory;
6472
6473 if (keyspace == 0)
6474 {
6475 struct stat outfile_check_stat;
6476
6477 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6478 {
6479 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6480
6481 if (is_dir == 0)
6482 {
6483 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6484
6485 return (-1);
6486 }
6487 }
6488 else if (outfile_check_dir == NULL)
6489 {
6490 if (mkdir (outfile_check_directory, 0700) == -1)
6491 {
6492 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6493
6494 return (-1);
6495 }
6496 }
6497 }
6498
6499 /**
6500 * special other stuff
6501 */
6502
6503 if (hash_mode == 9710)
6504 {
6505 outfile_format = 5;
6506 outfile_format_chgd = 1;
6507 }
6508
6509 if (hash_mode == 9810)
6510 {
6511 outfile_format = 5;
6512 outfile_format_chgd = 1;
6513 }
6514
6515 if (hash_mode == 10410)
6516 {
6517 outfile_format = 5;
6518 outfile_format_chgd = 1;
6519 }
6520
6521 /**
6522 * store stuff
6523 */
6524
6525 data.hash_mode = hash_mode;
6526 data.restore = restore;
6527 data.restore_timer = restore_timer;
6528 data.restore_disable = restore_disable;
6529 data.status = status;
6530 data.status_timer = status_timer;
6531 data.status_automat = status_automat;
6532 data.loopback = loopback;
6533 data.runtime = runtime;
6534 data.remove = remove;
6535 data.remove_timer = remove_timer;
6536 data.debug_mode = debug_mode;
6537 data.debug_file = debug_file;
6538 data.username = username;
6539 data.quiet = quiet;
6540 data.outfile = outfile;
6541 data.outfile_format = outfile_format;
6542 data.outfile_autohex = outfile_autohex;
6543 data.hex_charset = hex_charset;
6544 data.hex_salt = hex_salt;
6545 data.hex_wordlist = hex_wordlist;
6546 data.separator = separator;
6547 data.rp_files = rp_files;
6548 data.rp_files_cnt = rp_files_cnt;
6549 data.rp_gen = rp_gen;
6550 data.rp_gen_seed = rp_gen_seed;
6551 data.force = force;
6552 data.benchmark = benchmark;
6553 data.skip = skip;
6554 data.limit = limit;
6555 #ifdef HAVE_HWMON
6556 #ifdef HAVE_ADL
6557 data.powertune_enable = powertune_enable;
6558 #endif
6559 #endif
6560 data.logfile_disable = logfile_disable;
6561 data.truecrypt_keyfiles = truecrypt_keyfiles;
6562 data.veracrypt_keyfiles = veracrypt_keyfiles;
6563 data.veracrypt_pim = veracrypt_pim;
6564 data.scrypt_tmto = scrypt_tmto;
6565 data.workload_profile = workload_profile;
6566
6567 /**
6568 * cpu affinity
6569 */
6570
6571 if (cpu_affinity)
6572 {
6573 set_cpu_affinity (cpu_affinity);
6574 }
6575
6576 if (rp_gen_seed_chgd == 0)
6577 {
6578 srand (proc_start);
6579 }
6580 else
6581 {
6582 srand (rp_gen_seed);
6583 }
6584
6585 /**
6586 * logfile init
6587 */
6588
6589 if (logfile_disable == 0)
6590 {
6591 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6592
6593 char *logfile = (char *) mymalloc (logfile_size);
6594
6595 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6596
6597 data.logfile = logfile;
6598
6599 char *topid = logfile_generate_topid ();
6600
6601 data.topid = topid;
6602 }
6603
6604 // logfile_append() checks for logfile_disable internally to make it easier from here
6605
6606 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6607 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6608 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6609 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6610 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6611 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6612 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6613 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6614 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6615 #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));
6616
6617 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6618 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6619 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6620 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6621 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6622 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6623 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6624 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6625
6626 logfile_top_msg ("START");
6627
6628 logfile_top_uint (attack_mode);
6629 logfile_top_uint (attack_kern);
6630 logfile_top_uint (benchmark);
6631 logfile_top_uint (bitmap_min);
6632 logfile_top_uint (bitmap_max);
6633 logfile_top_uint (debug_mode);
6634 logfile_top_uint (force);
6635 logfile_top_uint (kernel_accel);
6636 logfile_top_uint (kernel_loops);
6637 logfile_top_uint (gpu_temp_disable);
6638 #ifdef HAVE_HWMON
6639 logfile_top_uint (gpu_temp_abort);
6640 logfile_top_uint (gpu_temp_retain);
6641 #endif
6642 logfile_top_uint (hash_mode);
6643 logfile_top_uint (hex_charset);
6644 logfile_top_uint (hex_salt);
6645 logfile_top_uint (hex_wordlist);
6646 logfile_top_uint (increment);
6647 logfile_top_uint (increment_max);
6648 logfile_top_uint (increment_min);
6649 logfile_top_uint (keyspace);
6650 logfile_top_uint (left);
6651 logfile_top_uint (logfile_disable);
6652 logfile_top_uint (loopback);
6653 logfile_top_uint (markov_classic);
6654 logfile_top_uint (markov_disable);
6655 logfile_top_uint (markov_threshold);
6656 logfile_top_uint (outfile_autohex);
6657 logfile_top_uint (outfile_check_timer);
6658 logfile_top_uint (outfile_format);
6659 logfile_top_uint (potfile_disable);
6660 logfile_top_string (potfile_path);
6661 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6662 logfile_top_uint (powertune_enable);
6663 #endif
6664 logfile_top_uint (scrypt_tmto);
6665 logfile_top_uint (quiet);
6666 logfile_top_uint (remove);
6667 logfile_top_uint (remove_timer);
6668 logfile_top_uint (restore);
6669 logfile_top_uint (restore_disable);
6670 logfile_top_uint (restore_timer);
6671 logfile_top_uint (rp_gen);
6672 logfile_top_uint (rp_gen_func_max);
6673 logfile_top_uint (rp_gen_func_min);
6674 logfile_top_uint (rp_gen_seed);
6675 logfile_top_uint (runtime);
6676 logfile_top_uint (segment_size);
6677 logfile_top_uint (show);
6678 logfile_top_uint (status);
6679 logfile_top_uint (status_automat);
6680 logfile_top_uint (status_timer);
6681 logfile_top_uint (usage);
6682 logfile_top_uint (username);
6683 logfile_top_uint (version);
6684 logfile_top_uint (weak_hash_threshold);
6685 logfile_top_uint (workload_profile);
6686 logfile_top_uint64 (limit);
6687 logfile_top_uint64 (skip);
6688 logfile_top_char (separator);
6689 logfile_top_string (cpu_affinity);
6690 logfile_top_string (custom_charset_1);
6691 logfile_top_string (custom_charset_2);
6692 logfile_top_string (custom_charset_3);
6693 logfile_top_string (custom_charset_4);
6694 logfile_top_string (debug_file);
6695 logfile_top_string (opencl_devices);
6696 logfile_top_string (opencl_platforms);
6697 logfile_top_string (opencl_device_types);
6698 logfile_top_uint (opencl_vector_width);
6699 logfile_top_string (induction_dir);
6700 logfile_top_string (markov_hcstat);
6701 logfile_top_string (outfile);
6702 logfile_top_string (outfile_check_dir);
6703 logfile_top_string (rule_buf_l);
6704 logfile_top_string (rule_buf_r);
6705 logfile_top_string (session);
6706 logfile_top_string (truecrypt_keyfiles);
6707 logfile_top_string (veracrypt_keyfiles);
6708 logfile_top_uint (veracrypt_pim);
6709
6710 /**
6711 * Init OpenCL library loader
6712 */
6713
6714 if (keyspace == 0)
6715 {
6716 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6717
6718 ocl_init (ocl);
6719
6720 data.ocl = ocl;
6721 }
6722
6723 /**
6724 * OpenCL platform selection
6725 */
6726
6727 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6728
6729 /**
6730 * OpenCL device selection
6731 */
6732
6733 u32 devices_filter = setup_devices_filter (opencl_devices);
6734
6735 /**
6736 * OpenCL device type selection
6737 */
6738
6739 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6740
6741 /**
6742 * benchmark
6743 */
6744
6745 if (benchmark == 1)
6746 {
6747 /**
6748 * disable useless stuff for benchmark
6749 */
6750
6751 status_timer = 0;
6752 restore_timer = 0;
6753 restore_disable = 1;
6754 potfile_disable = 1;
6755 weak_hash_threshold = 0;
6756 gpu_temp_disable = 1;
6757
6758 data.status_timer = status_timer;
6759 data.restore_timer = restore_timer;
6760 data.restore_disable = restore_disable;
6761
6762 /**
6763 * force attack mode to be bruteforce
6764 */
6765
6766 attack_mode = ATTACK_MODE_BF;
6767 attack_kern = ATTACK_KERN_BF;
6768
6769 if (workload_profile_chgd == 0)
6770 {
6771 workload_profile = 3;
6772
6773 data.workload_profile = workload_profile;
6774 }
6775 }
6776
6777 /**
6778 * config
6779 */
6780
6781 uint hash_type = 0;
6782 uint salt_type = 0;
6783 uint attack_exec = 0;
6784 uint opts_type = 0;
6785 uint kern_type = 0;
6786 uint dgst_size = 0;
6787 uint esalt_size = 0;
6788 uint opti_type = 0;
6789 uint dgst_pos0 = -1;
6790 uint dgst_pos1 = -1;
6791 uint dgst_pos2 = -1;
6792 uint dgst_pos3 = -1;
6793
6794 int (*parse_func) (char *, uint, hash_t *);
6795 int (*sort_by_digest) (const void *, const void *);
6796
6797 uint algorithm_pos = 0;
6798 uint algorithm_max = 1;
6799
6800 uint *algorithms = default_benchmark_algorithms;
6801
6802 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6803
6804 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6805 {
6806 /*
6807 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6808 * the following algos are skipped entirely
6809 */
6810
6811 if (algorithm_pos > 0)
6812 {
6813 local_free (rd);
6814
6815 rd = init_restore (argc, argv);
6816
6817 data.rd = rd;
6818 }
6819
6820 /**
6821 * update hash_mode in case of multihash benchmark
6822 */
6823
6824 if (benchmark == 1)
6825 {
6826 if (hash_mode_chgd == 0)
6827 {
6828 hash_mode = algorithms[algorithm_pos];
6829
6830 data.hash_mode = hash_mode;
6831 }
6832
6833 quiet = 1;
6834
6835 data.quiet = quiet;
6836 }
6837
6838 switch (hash_mode)
6839 {
6840 case 0: hash_type = HASH_TYPE_MD5;
6841 salt_type = SALT_TYPE_NONE;
6842 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6843 opts_type = OPTS_TYPE_PT_GENERATE_LE
6844 | OPTS_TYPE_PT_ADD80
6845 | OPTS_TYPE_PT_ADDBITS14;
6846 kern_type = KERN_TYPE_MD5;
6847 dgst_size = DGST_SIZE_4_4;
6848 parse_func = md5_parse_hash;
6849 sort_by_digest = sort_by_digest_4_4;
6850 opti_type = OPTI_TYPE_ZERO_BYTE
6851 | OPTI_TYPE_PRECOMPUTE_INIT
6852 | OPTI_TYPE_PRECOMPUTE_MERKLE
6853 | OPTI_TYPE_MEET_IN_MIDDLE
6854 | OPTI_TYPE_EARLY_SKIP
6855 | OPTI_TYPE_NOT_ITERATED
6856 | OPTI_TYPE_NOT_SALTED
6857 | OPTI_TYPE_RAW_HASH;
6858 dgst_pos0 = 0;
6859 dgst_pos1 = 3;
6860 dgst_pos2 = 2;
6861 dgst_pos3 = 1;
6862 break;
6863
6864 case 10: hash_type = HASH_TYPE_MD5;
6865 salt_type = SALT_TYPE_INTERN;
6866 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6867 opts_type = OPTS_TYPE_PT_GENERATE_LE
6868 | OPTS_TYPE_ST_ADD80
6869 | OPTS_TYPE_ST_ADDBITS14;
6870 kern_type = KERN_TYPE_MD5_PWSLT;
6871 dgst_size = DGST_SIZE_4_4;
6872 parse_func = md5s_parse_hash;
6873 sort_by_digest = sort_by_digest_4_4;
6874 opti_type = OPTI_TYPE_ZERO_BYTE
6875 | OPTI_TYPE_PRECOMPUTE_INIT
6876 | OPTI_TYPE_PRECOMPUTE_MERKLE
6877 | OPTI_TYPE_MEET_IN_MIDDLE
6878 | OPTI_TYPE_EARLY_SKIP
6879 | OPTI_TYPE_NOT_ITERATED
6880 | OPTI_TYPE_APPENDED_SALT
6881 | OPTI_TYPE_RAW_HASH;
6882 dgst_pos0 = 0;
6883 dgst_pos1 = 3;
6884 dgst_pos2 = 2;
6885 dgst_pos3 = 1;
6886 break;
6887
6888 case 11: hash_type = HASH_TYPE_MD5;
6889 salt_type = SALT_TYPE_INTERN;
6890 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6891 opts_type = OPTS_TYPE_PT_GENERATE_LE
6892 | OPTS_TYPE_ST_ADD80
6893 | OPTS_TYPE_ST_ADDBITS14;
6894 kern_type = KERN_TYPE_MD5_PWSLT;
6895 dgst_size = DGST_SIZE_4_4;
6896 parse_func = joomla_parse_hash;
6897 sort_by_digest = sort_by_digest_4_4;
6898 opti_type = OPTI_TYPE_ZERO_BYTE
6899 | OPTI_TYPE_PRECOMPUTE_INIT
6900 | OPTI_TYPE_PRECOMPUTE_MERKLE
6901 | OPTI_TYPE_MEET_IN_MIDDLE
6902 | OPTI_TYPE_EARLY_SKIP
6903 | OPTI_TYPE_NOT_ITERATED
6904 | OPTI_TYPE_APPENDED_SALT
6905 | OPTI_TYPE_RAW_HASH;
6906 dgst_pos0 = 0;
6907 dgst_pos1 = 3;
6908 dgst_pos2 = 2;
6909 dgst_pos3 = 1;
6910 break;
6911
6912 case 12: hash_type = HASH_TYPE_MD5;
6913 salt_type = SALT_TYPE_INTERN;
6914 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6915 opts_type = OPTS_TYPE_PT_GENERATE_LE
6916 | OPTS_TYPE_ST_ADD80
6917 | OPTS_TYPE_ST_ADDBITS14;
6918 kern_type = KERN_TYPE_MD5_PWSLT;
6919 dgst_size = DGST_SIZE_4_4;
6920 parse_func = postgresql_parse_hash;
6921 sort_by_digest = sort_by_digest_4_4;
6922 opti_type = OPTI_TYPE_ZERO_BYTE
6923 | OPTI_TYPE_PRECOMPUTE_INIT
6924 | OPTI_TYPE_PRECOMPUTE_MERKLE
6925 | OPTI_TYPE_MEET_IN_MIDDLE
6926 | OPTI_TYPE_EARLY_SKIP
6927 | OPTI_TYPE_NOT_ITERATED
6928 | OPTI_TYPE_APPENDED_SALT
6929 | OPTI_TYPE_RAW_HASH;
6930 dgst_pos0 = 0;
6931 dgst_pos1 = 3;
6932 dgst_pos2 = 2;
6933 dgst_pos3 = 1;
6934 break;
6935
6936 case 20: hash_type = HASH_TYPE_MD5;
6937 salt_type = SALT_TYPE_INTERN;
6938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6939 opts_type = OPTS_TYPE_PT_GENERATE_LE
6940 | OPTS_TYPE_PT_ADD80
6941 | OPTS_TYPE_PT_ADDBITS14;
6942 kern_type = KERN_TYPE_MD5_SLTPW;
6943 dgst_size = DGST_SIZE_4_4;
6944 parse_func = md5s_parse_hash;
6945 sort_by_digest = sort_by_digest_4_4;
6946 opti_type = OPTI_TYPE_ZERO_BYTE
6947 | OPTI_TYPE_PRECOMPUTE_INIT
6948 | OPTI_TYPE_PRECOMPUTE_MERKLE
6949 | OPTI_TYPE_EARLY_SKIP
6950 | OPTI_TYPE_NOT_ITERATED
6951 | OPTI_TYPE_PREPENDED_SALT
6952 | OPTI_TYPE_RAW_HASH;
6953 dgst_pos0 = 0;
6954 dgst_pos1 = 3;
6955 dgst_pos2 = 2;
6956 dgst_pos3 = 1;
6957 break;
6958
6959 case 21: hash_type = HASH_TYPE_MD5;
6960 salt_type = SALT_TYPE_INTERN;
6961 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6962 opts_type = OPTS_TYPE_PT_GENERATE_LE
6963 | OPTS_TYPE_PT_ADD80
6964 | OPTS_TYPE_PT_ADDBITS14;
6965 kern_type = KERN_TYPE_MD5_SLTPW;
6966 dgst_size = DGST_SIZE_4_4;
6967 parse_func = osc_parse_hash;
6968 sort_by_digest = sort_by_digest_4_4;
6969 opti_type = OPTI_TYPE_ZERO_BYTE
6970 | OPTI_TYPE_PRECOMPUTE_INIT
6971 | OPTI_TYPE_PRECOMPUTE_MERKLE
6972 | OPTI_TYPE_EARLY_SKIP
6973 | OPTI_TYPE_NOT_ITERATED
6974 | OPTI_TYPE_PREPENDED_SALT
6975 | OPTI_TYPE_RAW_HASH;
6976 dgst_pos0 = 0;
6977 dgst_pos1 = 3;
6978 dgst_pos2 = 2;
6979 dgst_pos3 = 1;
6980 break;
6981
6982 case 22: hash_type = HASH_TYPE_MD5;
6983 salt_type = SALT_TYPE_EMBEDDED;
6984 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6985 opts_type = OPTS_TYPE_PT_GENERATE_LE
6986 | OPTS_TYPE_PT_ADD80
6987 | OPTS_TYPE_PT_ADDBITS14;
6988 kern_type = KERN_TYPE_MD5_SLTPW;
6989 dgst_size = DGST_SIZE_4_4;
6990 parse_func = netscreen_parse_hash;
6991 sort_by_digest = sort_by_digest_4_4;
6992 opti_type = OPTI_TYPE_ZERO_BYTE
6993 | OPTI_TYPE_PRECOMPUTE_INIT
6994 | OPTI_TYPE_PRECOMPUTE_MERKLE
6995 | OPTI_TYPE_EARLY_SKIP
6996 | OPTI_TYPE_NOT_ITERATED
6997 | OPTI_TYPE_PREPENDED_SALT
6998 | OPTI_TYPE_RAW_HASH;
6999 dgst_pos0 = 0;
7000 dgst_pos1 = 3;
7001 dgst_pos2 = 2;
7002 dgst_pos3 = 1;
7003 break;
7004
7005 case 23: hash_type = HASH_TYPE_MD5;
7006 salt_type = SALT_TYPE_EMBEDDED;
7007 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7008 opts_type = OPTS_TYPE_PT_GENERATE_LE
7009 | OPTS_TYPE_PT_ADD80
7010 | OPTS_TYPE_PT_ADDBITS14;
7011 kern_type = KERN_TYPE_MD5_SLTPW;
7012 dgst_size = DGST_SIZE_4_4;
7013 parse_func = skype_parse_hash;
7014 sort_by_digest = sort_by_digest_4_4;
7015 opti_type = OPTI_TYPE_ZERO_BYTE
7016 | OPTI_TYPE_PRECOMPUTE_INIT
7017 | OPTI_TYPE_PRECOMPUTE_MERKLE
7018 | OPTI_TYPE_EARLY_SKIP
7019 | OPTI_TYPE_NOT_ITERATED
7020 | OPTI_TYPE_PREPENDED_SALT
7021 | OPTI_TYPE_RAW_HASH;
7022 dgst_pos0 = 0;
7023 dgst_pos1 = 3;
7024 dgst_pos2 = 2;
7025 dgst_pos3 = 1;
7026 break;
7027
7028 case 30: hash_type = HASH_TYPE_MD5;
7029 salt_type = SALT_TYPE_INTERN;
7030 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7031 opts_type = OPTS_TYPE_PT_GENERATE_LE
7032 | OPTS_TYPE_PT_UNICODE
7033 | OPTS_TYPE_ST_ADD80
7034 | OPTS_TYPE_ST_ADDBITS14;
7035 kern_type = KERN_TYPE_MD5_PWUSLT;
7036 dgst_size = DGST_SIZE_4_4;
7037 parse_func = md5s_parse_hash;
7038 sort_by_digest = sort_by_digest_4_4;
7039 opti_type = OPTI_TYPE_ZERO_BYTE
7040 | OPTI_TYPE_PRECOMPUTE_INIT
7041 | OPTI_TYPE_PRECOMPUTE_MERKLE
7042 | OPTI_TYPE_MEET_IN_MIDDLE
7043 | OPTI_TYPE_EARLY_SKIP
7044 | OPTI_TYPE_NOT_ITERATED
7045 | OPTI_TYPE_APPENDED_SALT
7046 | OPTI_TYPE_RAW_HASH;
7047 dgst_pos0 = 0;
7048 dgst_pos1 = 3;
7049 dgst_pos2 = 2;
7050 dgst_pos3 = 1;
7051 break;
7052
7053 case 40: hash_type = HASH_TYPE_MD5;
7054 salt_type = SALT_TYPE_INTERN;
7055 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7056 opts_type = OPTS_TYPE_PT_GENERATE_LE
7057 | OPTS_TYPE_PT_ADD80
7058 | OPTS_TYPE_PT_ADDBITS14
7059 | OPTS_TYPE_PT_UNICODE;
7060 kern_type = KERN_TYPE_MD5_SLTPWU;
7061 dgst_size = DGST_SIZE_4_4;
7062 parse_func = md5s_parse_hash;
7063 sort_by_digest = sort_by_digest_4_4;
7064 opti_type = OPTI_TYPE_ZERO_BYTE
7065 | OPTI_TYPE_PRECOMPUTE_INIT
7066 | OPTI_TYPE_PRECOMPUTE_MERKLE
7067 | OPTI_TYPE_EARLY_SKIP
7068 | OPTI_TYPE_NOT_ITERATED
7069 | OPTI_TYPE_PREPENDED_SALT
7070 | OPTI_TYPE_RAW_HASH;
7071 dgst_pos0 = 0;
7072 dgst_pos1 = 3;
7073 dgst_pos2 = 2;
7074 dgst_pos3 = 1;
7075 break;
7076
7077 case 50: hash_type = HASH_TYPE_MD5;
7078 salt_type = SALT_TYPE_INTERN;
7079 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7080 opts_type = OPTS_TYPE_PT_GENERATE_LE
7081 | OPTS_TYPE_ST_ADD80
7082 | OPTS_TYPE_ST_ADDBITS14;
7083 kern_type = KERN_TYPE_HMACMD5_PW;
7084 dgst_size = DGST_SIZE_4_4;
7085 parse_func = hmacmd5_parse_hash;
7086 sort_by_digest = sort_by_digest_4_4;
7087 opti_type = OPTI_TYPE_ZERO_BYTE
7088 | OPTI_TYPE_NOT_ITERATED;
7089 dgst_pos0 = 0;
7090 dgst_pos1 = 3;
7091 dgst_pos2 = 2;
7092 dgst_pos3 = 1;
7093 break;
7094
7095 case 60: hash_type = HASH_TYPE_MD5;
7096 salt_type = SALT_TYPE_INTERN;
7097 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7098 opts_type = OPTS_TYPE_PT_GENERATE_LE
7099 | OPTS_TYPE_PT_ADD80
7100 | OPTS_TYPE_PT_ADDBITS14;
7101 kern_type = KERN_TYPE_HMACMD5_SLT;
7102 dgst_size = DGST_SIZE_4_4;
7103 parse_func = hmacmd5_parse_hash;
7104 sort_by_digest = sort_by_digest_4_4;
7105 opti_type = OPTI_TYPE_ZERO_BYTE
7106 | OPTI_TYPE_NOT_ITERATED;
7107 dgst_pos0 = 0;
7108 dgst_pos1 = 3;
7109 dgst_pos2 = 2;
7110 dgst_pos3 = 1;
7111 break;
7112
7113 case 100: hash_type = HASH_TYPE_SHA1;
7114 salt_type = SALT_TYPE_NONE;
7115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7116 opts_type = OPTS_TYPE_PT_GENERATE_BE
7117 | OPTS_TYPE_PT_ADD80
7118 | OPTS_TYPE_PT_ADDBITS15;
7119 kern_type = KERN_TYPE_SHA1;
7120 dgst_size = DGST_SIZE_4_5;
7121 parse_func = sha1_parse_hash;
7122 sort_by_digest = sort_by_digest_4_5;
7123 opti_type = OPTI_TYPE_ZERO_BYTE
7124 | OPTI_TYPE_PRECOMPUTE_INIT
7125 | OPTI_TYPE_PRECOMPUTE_MERKLE
7126 | OPTI_TYPE_EARLY_SKIP
7127 | OPTI_TYPE_NOT_ITERATED
7128 | OPTI_TYPE_NOT_SALTED
7129 | OPTI_TYPE_RAW_HASH;
7130 dgst_pos0 = 3;
7131 dgst_pos1 = 4;
7132 dgst_pos2 = 2;
7133 dgst_pos3 = 1;
7134 break;
7135
7136 case 101: hash_type = HASH_TYPE_SHA1;
7137 salt_type = SALT_TYPE_NONE;
7138 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7139 opts_type = OPTS_TYPE_PT_GENERATE_BE
7140 | OPTS_TYPE_PT_ADD80
7141 | OPTS_TYPE_PT_ADDBITS15;
7142 kern_type = KERN_TYPE_SHA1;
7143 dgst_size = DGST_SIZE_4_5;
7144 parse_func = sha1b64_parse_hash;
7145 sort_by_digest = sort_by_digest_4_5;
7146 opti_type = OPTI_TYPE_ZERO_BYTE
7147 | OPTI_TYPE_PRECOMPUTE_INIT
7148 | OPTI_TYPE_PRECOMPUTE_MERKLE
7149 | OPTI_TYPE_EARLY_SKIP
7150 | OPTI_TYPE_NOT_ITERATED
7151 | OPTI_TYPE_NOT_SALTED
7152 | OPTI_TYPE_RAW_HASH;
7153 dgst_pos0 = 3;
7154 dgst_pos1 = 4;
7155 dgst_pos2 = 2;
7156 dgst_pos3 = 1;
7157 break;
7158
7159 case 110: hash_type = HASH_TYPE_SHA1;
7160 salt_type = SALT_TYPE_INTERN;
7161 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7162 opts_type = OPTS_TYPE_PT_GENERATE_BE
7163 | OPTS_TYPE_ST_ADD80
7164 | OPTS_TYPE_ST_ADDBITS15;
7165 kern_type = KERN_TYPE_SHA1_PWSLT;
7166 dgst_size = DGST_SIZE_4_5;
7167 parse_func = sha1s_parse_hash;
7168 sort_by_digest = sort_by_digest_4_5;
7169 opti_type = OPTI_TYPE_ZERO_BYTE
7170 | OPTI_TYPE_PRECOMPUTE_INIT
7171 | OPTI_TYPE_PRECOMPUTE_MERKLE
7172 | OPTI_TYPE_EARLY_SKIP
7173 | OPTI_TYPE_NOT_ITERATED
7174 | OPTI_TYPE_APPENDED_SALT
7175 | OPTI_TYPE_RAW_HASH;
7176 dgst_pos0 = 3;
7177 dgst_pos1 = 4;
7178 dgst_pos2 = 2;
7179 dgst_pos3 = 1;
7180 break;
7181
7182 case 111: hash_type = HASH_TYPE_SHA1;
7183 salt_type = SALT_TYPE_EMBEDDED;
7184 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7185 opts_type = OPTS_TYPE_PT_GENERATE_BE
7186 | OPTS_TYPE_ST_ADD80
7187 | OPTS_TYPE_ST_ADDBITS15;
7188 kern_type = KERN_TYPE_SHA1_PWSLT;
7189 dgst_size = DGST_SIZE_4_5;
7190 parse_func = sha1b64s_parse_hash;
7191 sort_by_digest = sort_by_digest_4_5;
7192 opti_type = OPTI_TYPE_ZERO_BYTE
7193 | OPTI_TYPE_PRECOMPUTE_INIT
7194 | OPTI_TYPE_PRECOMPUTE_MERKLE
7195 | OPTI_TYPE_EARLY_SKIP
7196 | OPTI_TYPE_NOT_ITERATED
7197 | OPTI_TYPE_APPENDED_SALT
7198 | OPTI_TYPE_RAW_HASH;
7199 dgst_pos0 = 3;
7200 dgst_pos1 = 4;
7201 dgst_pos2 = 2;
7202 dgst_pos3 = 1;
7203 break;
7204
7205 case 112: hash_type = HASH_TYPE_SHA1;
7206 salt_type = SALT_TYPE_INTERN;
7207 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7208 opts_type = OPTS_TYPE_PT_GENERATE_BE
7209 | OPTS_TYPE_ST_ADD80
7210 | OPTS_TYPE_ST_ADDBITS15
7211 | OPTS_TYPE_ST_HEX;
7212 kern_type = KERN_TYPE_SHA1_PWSLT;
7213 dgst_size = DGST_SIZE_4_5;
7214 parse_func = oracles_parse_hash;
7215 sort_by_digest = sort_by_digest_4_5;
7216 opti_type = OPTI_TYPE_ZERO_BYTE
7217 | OPTI_TYPE_PRECOMPUTE_INIT
7218 | OPTI_TYPE_PRECOMPUTE_MERKLE
7219 | OPTI_TYPE_EARLY_SKIP
7220 | OPTI_TYPE_NOT_ITERATED
7221 | OPTI_TYPE_APPENDED_SALT
7222 | OPTI_TYPE_RAW_HASH;
7223 dgst_pos0 = 3;
7224 dgst_pos1 = 4;
7225 dgst_pos2 = 2;
7226 dgst_pos3 = 1;
7227 break;
7228
7229 case 120: hash_type = HASH_TYPE_SHA1;
7230 salt_type = SALT_TYPE_INTERN;
7231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7232 opts_type = OPTS_TYPE_PT_GENERATE_BE
7233 | OPTS_TYPE_PT_ADD80
7234 | OPTS_TYPE_PT_ADDBITS15;
7235 kern_type = KERN_TYPE_SHA1_SLTPW;
7236 dgst_size = DGST_SIZE_4_5;
7237 parse_func = sha1s_parse_hash;
7238 sort_by_digest = sort_by_digest_4_5;
7239 opti_type = OPTI_TYPE_ZERO_BYTE
7240 | OPTI_TYPE_PRECOMPUTE_INIT
7241 | OPTI_TYPE_PRECOMPUTE_MERKLE
7242 | OPTI_TYPE_EARLY_SKIP
7243 | OPTI_TYPE_NOT_ITERATED
7244 | OPTI_TYPE_PREPENDED_SALT
7245 | OPTI_TYPE_RAW_HASH;
7246 dgst_pos0 = 3;
7247 dgst_pos1 = 4;
7248 dgst_pos2 = 2;
7249 dgst_pos3 = 1;
7250 break;
7251
7252 case 121: hash_type = HASH_TYPE_SHA1;
7253 salt_type = SALT_TYPE_INTERN;
7254 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7255 opts_type = OPTS_TYPE_PT_GENERATE_BE
7256 | OPTS_TYPE_PT_ADD80
7257 | OPTS_TYPE_PT_ADDBITS15
7258 | OPTS_TYPE_ST_LOWER;
7259 kern_type = KERN_TYPE_SHA1_SLTPW;
7260 dgst_size = DGST_SIZE_4_5;
7261 parse_func = smf_parse_hash;
7262 sort_by_digest = sort_by_digest_4_5;
7263 opti_type = OPTI_TYPE_ZERO_BYTE
7264 | OPTI_TYPE_PRECOMPUTE_INIT
7265 | OPTI_TYPE_PRECOMPUTE_MERKLE
7266 | OPTI_TYPE_EARLY_SKIP
7267 | OPTI_TYPE_NOT_ITERATED
7268 | OPTI_TYPE_PREPENDED_SALT
7269 | OPTI_TYPE_RAW_HASH;
7270 dgst_pos0 = 3;
7271 dgst_pos1 = 4;
7272 dgst_pos2 = 2;
7273 dgst_pos3 = 1;
7274 break;
7275
7276 case 122: hash_type = HASH_TYPE_SHA1;
7277 salt_type = SALT_TYPE_EMBEDDED;
7278 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7279 opts_type = OPTS_TYPE_PT_GENERATE_BE
7280 | OPTS_TYPE_PT_ADD80
7281 | OPTS_TYPE_PT_ADDBITS15
7282 | OPTS_TYPE_ST_HEX;
7283 kern_type = KERN_TYPE_SHA1_SLTPW;
7284 dgst_size = DGST_SIZE_4_5;
7285 parse_func = osx1_parse_hash;
7286 sort_by_digest = sort_by_digest_4_5;
7287 opti_type = OPTI_TYPE_ZERO_BYTE
7288 | OPTI_TYPE_PRECOMPUTE_INIT
7289 | OPTI_TYPE_PRECOMPUTE_MERKLE
7290 | OPTI_TYPE_EARLY_SKIP
7291 | OPTI_TYPE_NOT_ITERATED
7292 | OPTI_TYPE_PREPENDED_SALT
7293 | OPTI_TYPE_RAW_HASH;
7294 dgst_pos0 = 3;
7295 dgst_pos1 = 4;
7296 dgst_pos2 = 2;
7297 dgst_pos3 = 1;
7298 break;
7299
7300 case 124: hash_type = HASH_TYPE_SHA1;
7301 salt_type = SALT_TYPE_EMBEDDED;
7302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7303 opts_type = OPTS_TYPE_PT_GENERATE_BE
7304 | OPTS_TYPE_PT_ADD80
7305 | OPTS_TYPE_PT_ADDBITS15;
7306 kern_type = KERN_TYPE_SHA1_SLTPW;
7307 dgst_size = DGST_SIZE_4_5;
7308 parse_func = djangosha1_parse_hash;
7309 sort_by_digest = sort_by_digest_4_5;
7310 opti_type = OPTI_TYPE_ZERO_BYTE
7311 | OPTI_TYPE_PRECOMPUTE_INIT
7312 | OPTI_TYPE_PRECOMPUTE_MERKLE
7313 | OPTI_TYPE_EARLY_SKIP
7314 | OPTI_TYPE_NOT_ITERATED
7315 | OPTI_TYPE_PREPENDED_SALT
7316 | OPTI_TYPE_RAW_HASH;
7317 dgst_pos0 = 3;
7318 dgst_pos1 = 4;
7319 dgst_pos2 = 2;
7320 dgst_pos3 = 1;
7321 break;
7322
7323 case 125: hash_type = HASH_TYPE_SHA1;
7324 salt_type = SALT_TYPE_EMBEDDED;
7325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7326 opts_type = OPTS_TYPE_PT_GENERATE_BE
7327 | OPTS_TYPE_PT_ADD80
7328 | OPTS_TYPE_PT_ADDBITS15
7329 | OPTS_TYPE_ST_HEX;
7330 kern_type = KERN_TYPE_SHA1_SLTPW;
7331 dgst_size = DGST_SIZE_4_5;
7332 parse_func = arubaos_parse_hash;
7333 sort_by_digest = sort_by_digest_4_5;
7334 opti_type = OPTI_TYPE_ZERO_BYTE
7335 | OPTI_TYPE_PRECOMPUTE_INIT
7336 | OPTI_TYPE_PRECOMPUTE_MERKLE
7337 | OPTI_TYPE_EARLY_SKIP
7338 | OPTI_TYPE_NOT_ITERATED
7339 | OPTI_TYPE_PREPENDED_SALT
7340 | OPTI_TYPE_RAW_HASH;
7341 dgst_pos0 = 3;
7342 dgst_pos1 = 4;
7343 dgst_pos2 = 2;
7344 dgst_pos3 = 1;
7345 break;
7346
7347 case 130: hash_type = HASH_TYPE_SHA1;
7348 salt_type = SALT_TYPE_INTERN;
7349 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7350 opts_type = OPTS_TYPE_PT_GENERATE_BE
7351 | OPTS_TYPE_PT_UNICODE
7352 | OPTS_TYPE_ST_ADD80
7353 | OPTS_TYPE_ST_ADDBITS15;
7354 kern_type = KERN_TYPE_SHA1_PWUSLT;
7355 dgst_size = DGST_SIZE_4_5;
7356 parse_func = sha1s_parse_hash;
7357 sort_by_digest = sort_by_digest_4_5;
7358 opti_type = OPTI_TYPE_ZERO_BYTE
7359 | OPTI_TYPE_PRECOMPUTE_INIT
7360 | OPTI_TYPE_PRECOMPUTE_MERKLE
7361 | OPTI_TYPE_EARLY_SKIP
7362 | OPTI_TYPE_NOT_ITERATED
7363 | OPTI_TYPE_APPENDED_SALT
7364 | OPTI_TYPE_RAW_HASH;
7365 dgst_pos0 = 3;
7366 dgst_pos1 = 4;
7367 dgst_pos2 = 2;
7368 dgst_pos3 = 1;
7369 break;
7370
7371 case 131: hash_type = HASH_TYPE_SHA1;
7372 salt_type = SALT_TYPE_EMBEDDED;
7373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7374 opts_type = OPTS_TYPE_PT_GENERATE_BE
7375 | OPTS_TYPE_PT_UNICODE
7376 | OPTS_TYPE_PT_UPPER
7377 | OPTS_TYPE_ST_ADD80
7378 | OPTS_TYPE_ST_ADDBITS15
7379 | OPTS_TYPE_ST_HEX;
7380 kern_type = KERN_TYPE_SHA1_PWUSLT;
7381 dgst_size = DGST_SIZE_4_5;
7382 parse_func = mssql2000_parse_hash;
7383 sort_by_digest = sort_by_digest_4_5;
7384 opti_type = OPTI_TYPE_ZERO_BYTE
7385 | OPTI_TYPE_PRECOMPUTE_INIT
7386 | OPTI_TYPE_PRECOMPUTE_MERKLE
7387 | OPTI_TYPE_EARLY_SKIP
7388 | OPTI_TYPE_NOT_ITERATED
7389 | OPTI_TYPE_APPENDED_SALT
7390 | OPTI_TYPE_RAW_HASH;
7391 dgst_pos0 = 3;
7392 dgst_pos1 = 4;
7393 dgst_pos2 = 2;
7394 dgst_pos3 = 1;
7395 break;
7396
7397 case 132: hash_type = HASH_TYPE_SHA1;
7398 salt_type = SALT_TYPE_EMBEDDED;
7399 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7400 opts_type = OPTS_TYPE_PT_GENERATE_BE
7401 | OPTS_TYPE_PT_UNICODE
7402 | OPTS_TYPE_ST_ADD80
7403 | OPTS_TYPE_ST_ADDBITS15
7404 | OPTS_TYPE_ST_HEX;
7405 kern_type = KERN_TYPE_SHA1_PWUSLT;
7406 dgst_size = DGST_SIZE_4_5;
7407 parse_func = mssql2005_parse_hash;
7408 sort_by_digest = sort_by_digest_4_5;
7409 opti_type = OPTI_TYPE_ZERO_BYTE
7410 | OPTI_TYPE_PRECOMPUTE_INIT
7411 | OPTI_TYPE_PRECOMPUTE_MERKLE
7412 | OPTI_TYPE_EARLY_SKIP
7413 | OPTI_TYPE_NOT_ITERATED
7414 | OPTI_TYPE_APPENDED_SALT
7415 | OPTI_TYPE_RAW_HASH;
7416 dgst_pos0 = 3;
7417 dgst_pos1 = 4;
7418 dgst_pos2 = 2;
7419 dgst_pos3 = 1;
7420 break;
7421
7422 case 133: hash_type = HASH_TYPE_SHA1;
7423 salt_type = SALT_TYPE_EMBEDDED;
7424 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7425 opts_type = OPTS_TYPE_PT_GENERATE_BE
7426 | OPTS_TYPE_PT_UNICODE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15;
7429 kern_type = KERN_TYPE_SHA1_PWUSLT;
7430 dgst_size = DGST_SIZE_4_5;
7431 parse_func = peoplesoft_parse_hash;
7432 sort_by_digest = sort_by_digest_4_5;
7433 opti_type = OPTI_TYPE_ZERO_BYTE
7434 | OPTI_TYPE_PRECOMPUTE_INIT
7435 | OPTI_TYPE_PRECOMPUTE_MERKLE
7436 | OPTI_TYPE_EARLY_SKIP
7437 | OPTI_TYPE_NOT_ITERATED
7438 | OPTI_TYPE_APPENDED_SALT
7439 | OPTI_TYPE_RAW_HASH;
7440 dgst_pos0 = 3;
7441 dgst_pos1 = 4;
7442 dgst_pos2 = 2;
7443 dgst_pos3 = 1;
7444 break;
7445
7446 case 140: hash_type = HASH_TYPE_SHA1;
7447 salt_type = SALT_TYPE_INTERN;
7448 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7449 opts_type = OPTS_TYPE_PT_GENERATE_BE
7450 | OPTS_TYPE_PT_ADD80
7451 | OPTS_TYPE_PT_ADDBITS15
7452 | OPTS_TYPE_PT_UNICODE;
7453 kern_type = KERN_TYPE_SHA1_SLTPWU;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = sha1s_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 141: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_EMBEDDED;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_PT_UNICODE
7477 | OPTS_TYPE_ST_BASE64;
7478 kern_type = KERN_TYPE_SHA1_SLTPWU;
7479 dgst_size = DGST_SIZE_4_5;
7480 parse_func = episerver_parse_hash;
7481 sort_by_digest = sort_by_digest_4_5;
7482 opti_type = OPTI_TYPE_ZERO_BYTE
7483 | OPTI_TYPE_PRECOMPUTE_INIT
7484 | OPTI_TYPE_PRECOMPUTE_MERKLE
7485 | OPTI_TYPE_EARLY_SKIP
7486 | OPTI_TYPE_NOT_ITERATED
7487 | OPTI_TYPE_PREPENDED_SALT
7488 | OPTI_TYPE_RAW_HASH;
7489 dgst_pos0 = 3;
7490 dgst_pos1 = 4;
7491 dgst_pos2 = 2;
7492 dgst_pos3 = 1;
7493 break;
7494
7495 case 150: hash_type = HASH_TYPE_SHA1;
7496 salt_type = SALT_TYPE_INTERN;
7497 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7498 opts_type = OPTS_TYPE_PT_GENERATE_BE
7499 | OPTS_TYPE_ST_ADD80
7500 | OPTS_TYPE_ST_ADDBITS15;
7501 kern_type = KERN_TYPE_HMACSHA1_PW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = hmacsha1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_NOT_ITERATED;
7507 dgst_pos0 = 3;
7508 dgst_pos1 = 4;
7509 dgst_pos2 = 2;
7510 dgst_pos3 = 1;
7511 break;
7512
7513 case 160: hash_type = HASH_TYPE_SHA1;
7514 salt_type = SALT_TYPE_INTERN;
7515 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7516 opts_type = OPTS_TYPE_PT_GENERATE_BE
7517 | OPTS_TYPE_PT_ADD80
7518 | OPTS_TYPE_PT_ADDBITS15;
7519 kern_type = KERN_TYPE_HMACSHA1_SLT;
7520 dgst_size = DGST_SIZE_4_5;
7521 parse_func = hmacsha1_parse_hash;
7522 sort_by_digest = sort_by_digest_4_5;
7523 opti_type = OPTI_TYPE_ZERO_BYTE
7524 | OPTI_TYPE_NOT_ITERATED;
7525 dgst_pos0 = 3;
7526 dgst_pos1 = 4;
7527 dgst_pos2 = 2;
7528 dgst_pos3 = 1;
7529 break;
7530
7531 case 190: hash_type = HASH_TYPE_SHA1;
7532 salt_type = SALT_TYPE_NONE;
7533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7534 opts_type = OPTS_TYPE_PT_GENERATE_BE
7535 | OPTS_TYPE_PT_ADD80
7536 | OPTS_TYPE_PT_ADDBITS15;
7537 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7538 dgst_size = DGST_SIZE_4_5;
7539 parse_func = sha1linkedin_parse_hash;
7540 sort_by_digest = sort_by_digest_4_5;
7541 opti_type = OPTI_TYPE_ZERO_BYTE
7542 | OPTI_TYPE_PRECOMPUTE_INIT
7543 | OPTI_TYPE_EARLY_SKIP
7544 | OPTI_TYPE_NOT_ITERATED
7545 | OPTI_TYPE_NOT_SALTED;
7546 dgst_pos0 = 0;
7547 dgst_pos1 = 4;
7548 dgst_pos2 = 3;
7549 dgst_pos3 = 2;
7550 break;
7551
7552 case 200: hash_type = HASH_TYPE_MYSQL;
7553 salt_type = SALT_TYPE_NONE;
7554 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7555 opts_type = 0;
7556 kern_type = KERN_TYPE_MYSQL;
7557 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7558 parse_func = mysql323_parse_hash;
7559 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7560 opti_type = OPTI_TYPE_ZERO_BYTE;
7561 dgst_pos0 = 0;
7562 dgst_pos1 = 1;
7563 dgst_pos2 = 2;
7564 dgst_pos3 = 3;
7565 break;
7566
7567 case 300: hash_type = HASH_TYPE_SHA1;
7568 salt_type = SALT_TYPE_NONE;
7569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7570 opts_type = OPTS_TYPE_PT_GENERATE_BE
7571 | OPTS_TYPE_PT_ADD80
7572 | OPTS_TYPE_PT_ADDBITS15;
7573 kern_type = KERN_TYPE_MYSQL41;
7574 dgst_size = DGST_SIZE_4_5;
7575 parse_func = sha1_parse_hash;
7576 sort_by_digest = sort_by_digest_4_5;
7577 opti_type = OPTI_TYPE_ZERO_BYTE
7578 | OPTI_TYPE_PRECOMPUTE_INIT
7579 | OPTI_TYPE_PRECOMPUTE_MERKLE
7580 | OPTI_TYPE_EARLY_SKIP
7581 | OPTI_TYPE_NOT_ITERATED
7582 | OPTI_TYPE_NOT_SALTED;
7583 dgst_pos0 = 3;
7584 dgst_pos1 = 4;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 400: hash_type = HASH_TYPE_MD5;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7593 kern_type = KERN_TYPE_PHPASS;
7594 dgst_size = DGST_SIZE_4_4;
7595 parse_func = phpass_parse_hash;
7596 sort_by_digest = sort_by_digest_4_4;
7597 opti_type = OPTI_TYPE_ZERO_BYTE
7598 | OPTI_TYPE_SLOW_HASH_SIMD;
7599 dgst_pos0 = 0;
7600 dgst_pos1 = 1;
7601 dgst_pos2 = 2;
7602 dgst_pos3 = 3;
7603 break;
7604
7605 case 500: hash_type = HASH_TYPE_MD5;
7606 salt_type = SALT_TYPE_EMBEDDED;
7607 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7608 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7609 kern_type = KERN_TYPE_MD5CRYPT;
7610 dgst_size = DGST_SIZE_4_4;
7611 parse_func = md5crypt_parse_hash;
7612 sort_by_digest = sort_by_digest_4_4;
7613 opti_type = OPTI_TYPE_ZERO_BYTE;
7614 dgst_pos0 = 0;
7615 dgst_pos1 = 1;
7616 dgst_pos2 = 2;
7617 dgst_pos3 = 3;
7618 break;
7619
7620 case 501: hash_type = HASH_TYPE_MD5;
7621 salt_type = SALT_TYPE_EMBEDDED;
7622 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7623 opts_type = OPTS_TYPE_PT_GENERATE_LE
7624 | OPTS_TYPE_HASH_COPY;
7625 kern_type = KERN_TYPE_MD5CRYPT;
7626 dgst_size = DGST_SIZE_4_4;
7627 parse_func = juniper_parse_hash;
7628 sort_by_digest = sort_by_digest_4_4;
7629 opti_type = OPTI_TYPE_ZERO_BYTE;
7630 dgst_pos0 = 0;
7631 dgst_pos1 = 1;
7632 dgst_pos2 = 2;
7633 dgst_pos3 = 3;
7634 break;
7635
7636 case 900: hash_type = HASH_TYPE_MD4;
7637 salt_type = SALT_TYPE_NONE;
7638 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7639 opts_type = OPTS_TYPE_PT_GENERATE_LE
7640 | OPTS_TYPE_PT_ADD80
7641 | OPTS_TYPE_PT_ADDBITS14;
7642 kern_type = KERN_TYPE_MD4;
7643 dgst_size = DGST_SIZE_4_4;
7644 parse_func = md4_parse_hash;
7645 sort_by_digest = sort_by_digest_4_4;
7646 opti_type = OPTI_TYPE_ZERO_BYTE
7647 | OPTI_TYPE_PRECOMPUTE_INIT
7648 | OPTI_TYPE_PRECOMPUTE_MERKLE
7649 | OPTI_TYPE_MEET_IN_MIDDLE
7650 | OPTI_TYPE_EARLY_SKIP
7651 | OPTI_TYPE_NOT_ITERATED
7652 | OPTI_TYPE_NOT_SALTED
7653 | OPTI_TYPE_RAW_HASH;
7654 dgst_pos0 = 0;
7655 dgst_pos1 = 3;
7656 dgst_pos2 = 2;
7657 dgst_pos3 = 1;
7658 break;
7659
7660 case 1000: hash_type = HASH_TYPE_MD4;
7661 salt_type = SALT_TYPE_NONE;
7662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7663 opts_type = OPTS_TYPE_PT_GENERATE_LE
7664 | OPTS_TYPE_PT_ADD80
7665 | OPTS_TYPE_PT_ADDBITS14
7666 | OPTS_TYPE_PT_UNICODE;
7667 kern_type = KERN_TYPE_MD4_PWU;
7668 dgst_size = DGST_SIZE_4_4;
7669 parse_func = md4_parse_hash;
7670 sort_by_digest = sort_by_digest_4_4;
7671 opti_type = OPTI_TYPE_ZERO_BYTE
7672 | OPTI_TYPE_PRECOMPUTE_INIT
7673 | OPTI_TYPE_PRECOMPUTE_MERKLE
7674 | OPTI_TYPE_MEET_IN_MIDDLE
7675 | OPTI_TYPE_EARLY_SKIP
7676 | OPTI_TYPE_NOT_ITERATED
7677 | OPTI_TYPE_NOT_SALTED
7678 | OPTI_TYPE_RAW_HASH;
7679 dgst_pos0 = 0;
7680 dgst_pos1 = 3;
7681 dgst_pos2 = 2;
7682 dgst_pos3 = 1;
7683 break;
7684
7685 case 1100: hash_type = HASH_TYPE_MD4;
7686 salt_type = SALT_TYPE_INTERN;
7687 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7688 opts_type = OPTS_TYPE_PT_GENERATE_LE
7689 | OPTS_TYPE_PT_ADD80
7690 | OPTS_TYPE_PT_ADDBITS14
7691 | OPTS_TYPE_PT_UNICODE
7692 | OPTS_TYPE_ST_ADD80
7693 | OPTS_TYPE_ST_UNICODE
7694 | OPTS_TYPE_ST_LOWER;
7695 kern_type = KERN_TYPE_MD44_PWUSLT;
7696 dgst_size = DGST_SIZE_4_4;
7697 parse_func = dcc_parse_hash;
7698 sort_by_digest = sort_by_digest_4_4;
7699 opti_type = OPTI_TYPE_ZERO_BYTE
7700 | OPTI_TYPE_PRECOMPUTE_INIT
7701 | OPTI_TYPE_PRECOMPUTE_MERKLE
7702 | OPTI_TYPE_EARLY_SKIP
7703 | OPTI_TYPE_NOT_ITERATED;
7704 dgst_pos0 = 0;
7705 dgst_pos1 = 3;
7706 dgst_pos2 = 2;
7707 dgst_pos3 = 1;
7708 break;
7709
7710 case 1400: hash_type = HASH_TYPE_SHA256;
7711 salt_type = SALT_TYPE_NONE;
7712 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7713 opts_type = OPTS_TYPE_PT_GENERATE_BE
7714 | OPTS_TYPE_PT_ADD80
7715 | OPTS_TYPE_PT_ADDBITS15;
7716 kern_type = KERN_TYPE_SHA256;
7717 dgst_size = DGST_SIZE_4_8;
7718 parse_func = sha256_parse_hash;
7719 sort_by_digest = sort_by_digest_4_8;
7720 opti_type = OPTI_TYPE_ZERO_BYTE
7721 | OPTI_TYPE_PRECOMPUTE_INIT
7722 | OPTI_TYPE_PRECOMPUTE_MERKLE
7723 | OPTI_TYPE_EARLY_SKIP
7724 | OPTI_TYPE_NOT_ITERATED
7725 | OPTI_TYPE_NOT_SALTED
7726 | OPTI_TYPE_RAW_HASH;
7727 dgst_pos0 = 3;
7728 dgst_pos1 = 7;
7729 dgst_pos2 = 2;
7730 dgst_pos3 = 6;
7731 break;
7732
7733 case 1410: hash_type = HASH_TYPE_SHA256;
7734 salt_type = SALT_TYPE_INTERN;
7735 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7736 opts_type = OPTS_TYPE_PT_GENERATE_BE
7737 | OPTS_TYPE_ST_ADD80
7738 | OPTS_TYPE_ST_ADDBITS15;
7739 kern_type = KERN_TYPE_SHA256_PWSLT;
7740 dgst_size = DGST_SIZE_4_8;
7741 parse_func = sha256s_parse_hash;
7742 sort_by_digest = sort_by_digest_4_8;
7743 opti_type = OPTI_TYPE_ZERO_BYTE
7744 | OPTI_TYPE_PRECOMPUTE_INIT
7745 | OPTI_TYPE_PRECOMPUTE_MERKLE
7746 | OPTI_TYPE_EARLY_SKIP
7747 | OPTI_TYPE_NOT_ITERATED
7748 | OPTI_TYPE_APPENDED_SALT
7749 | OPTI_TYPE_RAW_HASH;
7750 dgst_pos0 = 3;
7751 dgst_pos1 = 7;
7752 dgst_pos2 = 2;
7753 dgst_pos3 = 6;
7754 break;
7755
7756 case 1420: hash_type = HASH_TYPE_SHA256;
7757 salt_type = SALT_TYPE_INTERN;
7758 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7759 opts_type = OPTS_TYPE_PT_GENERATE_BE
7760 | OPTS_TYPE_PT_ADD80
7761 | OPTS_TYPE_PT_ADDBITS15;
7762 kern_type = KERN_TYPE_SHA256_SLTPW;
7763 dgst_size = DGST_SIZE_4_8;
7764 parse_func = sha256s_parse_hash;
7765 sort_by_digest = sort_by_digest_4_8;
7766 opti_type = OPTI_TYPE_ZERO_BYTE
7767 | OPTI_TYPE_PRECOMPUTE_INIT
7768 | OPTI_TYPE_PRECOMPUTE_MERKLE
7769 | OPTI_TYPE_EARLY_SKIP
7770 | OPTI_TYPE_NOT_ITERATED
7771 | OPTI_TYPE_PREPENDED_SALT
7772 | OPTI_TYPE_RAW_HASH;
7773 dgst_pos0 = 3;
7774 dgst_pos1 = 7;
7775 dgst_pos2 = 2;
7776 dgst_pos3 = 6;
7777 break;
7778
7779 case 1421: hash_type = HASH_TYPE_SHA256;
7780 salt_type = SALT_TYPE_EMBEDDED;
7781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7782 opts_type = OPTS_TYPE_PT_GENERATE_BE
7783 | OPTS_TYPE_PT_ADD80
7784 | OPTS_TYPE_PT_ADDBITS15;
7785 kern_type = KERN_TYPE_SHA256_SLTPW;
7786 dgst_size = DGST_SIZE_4_8;
7787 parse_func = hmailserver_parse_hash;
7788 sort_by_digest = sort_by_digest_4_8;
7789 opti_type = OPTI_TYPE_ZERO_BYTE
7790 | OPTI_TYPE_PRECOMPUTE_INIT
7791 | OPTI_TYPE_PRECOMPUTE_MERKLE
7792 | OPTI_TYPE_EARLY_SKIP
7793 | OPTI_TYPE_NOT_ITERATED
7794 | OPTI_TYPE_PREPENDED_SALT
7795 | OPTI_TYPE_RAW_HASH;
7796 dgst_pos0 = 3;
7797 dgst_pos1 = 7;
7798 dgst_pos2 = 2;
7799 dgst_pos3 = 6;
7800 break;
7801
7802 case 1430: hash_type = HASH_TYPE_SHA256;
7803 salt_type = SALT_TYPE_INTERN;
7804 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7805 opts_type = OPTS_TYPE_PT_GENERATE_BE
7806 | OPTS_TYPE_PT_UNICODE
7807 | OPTS_TYPE_ST_ADD80
7808 | OPTS_TYPE_ST_ADDBITS15;
7809 kern_type = KERN_TYPE_SHA256_PWUSLT;
7810 dgst_size = DGST_SIZE_4_8;
7811 parse_func = sha256s_parse_hash;
7812 sort_by_digest = sort_by_digest_4_8;
7813 opti_type = OPTI_TYPE_ZERO_BYTE
7814 | OPTI_TYPE_PRECOMPUTE_INIT
7815 | OPTI_TYPE_PRECOMPUTE_MERKLE
7816 | OPTI_TYPE_EARLY_SKIP
7817 | OPTI_TYPE_NOT_ITERATED
7818 | OPTI_TYPE_APPENDED_SALT
7819 | OPTI_TYPE_RAW_HASH;
7820 dgst_pos0 = 3;
7821 dgst_pos1 = 7;
7822 dgst_pos2 = 2;
7823 dgst_pos3 = 6;
7824 break;
7825
7826 case 1440: hash_type = HASH_TYPE_SHA256;
7827 salt_type = SALT_TYPE_INTERN;
7828 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7829 opts_type = OPTS_TYPE_PT_GENERATE_BE
7830 | OPTS_TYPE_PT_ADD80
7831 | OPTS_TYPE_PT_ADDBITS15
7832 | OPTS_TYPE_PT_UNICODE;
7833 kern_type = KERN_TYPE_SHA256_SLTPWU;
7834 dgst_size = DGST_SIZE_4_8;
7835 parse_func = sha256s_parse_hash;
7836 sort_by_digest = sort_by_digest_4_8;
7837 opti_type = OPTI_TYPE_ZERO_BYTE
7838 | OPTI_TYPE_PRECOMPUTE_INIT
7839 | OPTI_TYPE_PRECOMPUTE_MERKLE
7840 | OPTI_TYPE_EARLY_SKIP
7841 | OPTI_TYPE_NOT_ITERATED
7842 | OPTI_TYPE_PREPENDED_SALT
7843 | OPTI_TYPE_RAW_HASH;
7844 dgst_pos0 = 3;
7845 dgst_pos1 = 7;
7846 dgst_pos2 = 2;
7847 dgst_pos3 = 6;
7848 break;
7849
7850 case 1441: hash_type = HASH_TYPE_SHA256;
7851 salt_type = SALT_TYPE_EMBEDDED;
7852 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7853 opts_type = OPTS_TYPE_PT_GENERATE_BE
7854 | OPTS_TYPE_PT_ADD80
7855 | OPTS_TYPE_PT_ADDBITS15
7856 | OPTS_TYPE_PT_UNICODE
7857 | OPTS_TYPE_ST_BASE64;
7858 kern_type = KERN_TYPE_SHA256_SLTPWU;
7859 dgst_size = DGST_SIZE_4_8;
7860 parse_func = episerver4_parse_hash;
7861 sort_by_digest = sort_by_digest_4_8;
7862 opti_type = OPTI_TYPE_ZERO_BYTE
7863 | OPTI_TYPE_PRECOMPUTE_INIT
7864 | OPTI_TYPE_PRECOMPUTE_MERKLE
7865 | OPTI_TYPE_EARLY_SKIP
7866 | OPTI_TYPE_NOT_ITERATED
7867 | OPTI_TYPE_PREPENDED_SALT
7868 | OPTI_TYPE_RAW_HASH;
7869 dgst_pos0 = 3;
7870 dgst_pos1 = 7;
7871 dgst_pos2 = 2;
7872 dgst_pos3 = 6;
7873 break;
7874
7875 case 1450: hash_type = HASH_TYPE_SHA256;
7876 salt_type = SALT_TYPE_INTERN;
7877 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7878 opts_type = OPTS_TYPE_PT_GENERATE_BE
7879 | OPTS_TYPE_ST_ADD80;
7880 kern_type = KERN_TYPE_HMACSHA256_PW;
7881 dgst_size = DGST_SIZE_4_8;
7882 parse_func = hmacsha256_parse_hash;
7883 sort_by_digest = sort_by_digest_4_8;
7884 opti_type = OPTI_TYPE_ZERO_BYTE
7885 | OPTI_TYPE_NOT_ITERATED;
7886 dgst_pos0 = 3;
7887 dgst_pos1 = 7;
7888 dgst_pos2 = 2;
7889 dgst_pos3 = 6;
7890 break;
7891
7892 case 1460: hash_type = HASH_TYPE_SHA256;
7893 salt_type = SALT_TYPE_INTERN;
7894 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7895 opts_type = OPTS_TYPE_PT_GENERATE_BE
7896 | OPTS_TYPE_PT_ADD80
7897 | OPTS_TYPE_PT_ADDBITS15;
7898 kern_type = KERN_TYPE_HMACSHA256_SLT;
7899 dgst_size = DGST_SIZE_4_8;
7900 parse_func = hmacsha256_parse_hash;
7901 sort_by_digest = sort_by_digest_4_8;
7902 opti_type = OPTI_TYPE_ZERO_BYTE
7903 | OPTI_TYPE_NOT_ITERATED;
7904 dgst_pos0 = 3;
7905 dgst_pos1 = 7;
7906 dgst_pos2 = 2;
7907 dgst_pos3 = 6;
7908 break;
7909
7910 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7911 salt_type = SALT_TYPE_EMBEDDED;
7912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7913 opts_type = OPTS_TYPE_PT_GENERATE_LE
7914 | OPTS_TYPE_PT_BITSLICE;
7915 kern_type = KERN_TYPE_DESCRYPT;
7916 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7917 parse_func = descrypt_parse_hash;
7918 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7919 opti_type = OPTI_TYPE_ZERO_BYTE
7920 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7921 dgst_pos0 = 0;
7922 dgst_pos1 = 1;
7923 dgst_pos2 = 2;
7924 dgst_pos3 = 3;
7925 break;
7926
7927 case 1600: hash_type = HASH_TYPE_MD5;
7928 salt_type = SALT_TYPE_EMBEDDED;
7929 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7930 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7931 kern_type = KERN_TYPE_APR1CRYPT;
7932 dgst_size = DGST_SIZE_4_4;
7933 parse_func = md5apr1_parse_hash;
7934 sort_by_digest = sort_by_digest_4_4;
7935 opti_type = OPTI_TYPE_ZERO_BYTE;
7936 dgst_pos0 = 0;
7937 dgst_pos1 = 1;
7938 dgst_pos2 = 2;
7939 dgst_pos3 = 3;
7940 break;
7941
7942 case 1700: hash_type = HASH_TYPE_SHA512;
7943 salt_type = SALT_TYPE_NONE;
7944 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7945 opts_type = OPTS_TYPE_PT_GENERATE_BE
7946 | OPTS_TYPE_PT_ADD80
7947 | OPTS_TYPE_PT_ADDBITS15;
7948 kern_type = KERN_TYPE_SHA512;
7949 dgst_size = DGST_SIZE_8_8;
7950 parse_func = sha512_parse_hash;
7951 sort_by_digest = sort_by_digest_8_8;
7952 opti_type = OPTI_TYPE_ZERO_BYTE
7953 | OPTI_TYPE_PRECOMPUTE_INIT
7954 | OPTI_TYPE_PRECOMPUTE_MERKLE
7955 | OPTI_TYPE_EARLY_SKIP
7956 | OPTI_TYPE_NOT_ITERATED
7957 | OPTI_TYPE_NOT_SALTED
7958 | OPTI_TYPE_USES_BITS_64
7959 | OPTI_TYPE_RAW_HASH;
7960 dgst_pos0 = 14;
7961 dgst_pos1 = 15;
7962 dgst_pos2 = 6;
7963 dgst_pos3 = 7;
7964 break;
7965
7966 case 1710: hash_type = HASH_TYPE_SHA512;
7967 salt_type = SALT_TYPE_INTERN;
7968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7969 opts_type = OPTS_TYPE_PT_GENERATE_BE
7970 | OPTS_TYPE_ST_ADD80
7971 | OPTS_TYPE_ST_ADDBITS15;
7972 kern_type = KERN_TYPE_SHA512_PWSLT;
7973 dgst_size = DGST_SIZE_8_8;
7974 parse_func = sha512s_parse_hash;
7975 sort_by_digest = sort_by_digest_8_8;
7976 opti_type = OPTI_TYPE_ZERO_BYTE
7977 | OPTI_TYPE_PRECOMPUTE_INIT
7978 | OPTI_TYPE_PRECOMPUTE_MERKLE
7979 | OPTI_TYPE_EARLY_SKIP
7980 | OPTI_TYPE_NOT_ITERATED
7981 | OPTI_TYPE_APPENDED_SALT
7982 | OPTI_TYPE_USES_BITS_64
7983 | OPTI_TYPE_RAW_HASH;
7984 dgst_pos0 = 14;
7985 dgst_pos1 = 15;
7986 dgst_pos2 = 6;
7987 dgst_pos3 = 7;
7988 break;
7989
7990 case 1711: hash_type = HASH_TYPE_SHA512;
7991 salt_type = SALT_TYPE_EMBEDDED;
7992 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7993 opts_type = OPTS_TYPE_PT_GENERATE_BE
7994 | OPTS_TYPE_ST_ADD80
7995 | OPTS_TYPE_ST_ADDBITS15;
7996 kern_type = KERN_TYPE_SHA512_PWSLT;
7997 dgst_size = DGST_SIZE_8_8;
7998 parse_func = sha512b64s_parse_hash;
7999 sort_by_digest = sort_by_digest_8_8;
8000 opti_type = OPTI_TYPE_ZERO_BYTE
8001 | OPTI_TYPE_PRECOMPUTE_INIT
8002 | OPTI_TYPE_PRECOMPUTE_MERKLE
8003 | OPTI_TYPE_EARLY_SKIP
8004 | OPTI_TYPE_NOT_ITERATED
8005 | OPTI_TYPE_APPENDED_SALT
8006 | OPTI_TYPE_USES_BITS_64
8007 | OPTI_TYPE_RAW_HASH;
8008 dgst_pos0 = 14;
8009 dgst_pos1 = 15;
8010 dgst_pos2 = 6;
8011 dgst_pos3 = 7;
8012 break;
8013
8014 case 1720: hash_type = HASH_TYPE_SHA512;
8015 salt_type = SALT_TYPE_INTERN;
8016 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8017 opts_type = OPTS_TYPE_PT_GENERATE_BE
8018 | OPTS_TYPE_PT_ADD80
8019 | OPTS_TYPE_PT_ADDBITS15;
8020 kern_type = KERN_TYPE_SHA512_SLTPW;
8021 dgst_size = DGST_SIZE_8_8;
8022 parse_func = sha512s_parse_hash;
8023 sort_by_digest = sort_by_digest_8_8;
8024 opti_type = OPTI_TYPE_ZERO_BYTE
8025 | OPTI_TYPE_PRECOMPUTE_INIT
8026 | OPTI_TYPE_PRECOMPUTE_MERKLE
8027 | OPTI_TYPE_EARLY_SKIP
8028 | OPTI_TYPE_NOT_ITERATED
8029 | OPTI_TYPE_PREPENDED_SALT
8030 | OPTI_TYPE_USES_BITS_64
8031 | OPTI_TYPE_RAW_HASH;
8032 dgst_pos0 = 14;
8033 dgst_pos1 = 15;
8034 dgst_pos2 = 6;
8035 dgst_pos3 = 7;
8036 break;
8037
8038 case 1722: hash_type = HASH_TYPE_SHA512;
8039 salt_type = SALT_TYPE_EMBEDDED;
8040 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8041 opts_type = OPTS_TYPE_PT_GENERATE_BE
8042 | OPTS_TYPE_PT_ADD80
8043 | OPTS_TYPE_PT_ADDBITS15
8044 | OPTS_TYPE_ST_HEX;
8045 kern_type = KERN_TYPE_SHA512_SLTPW;
8046 dgst_size = DGST_SIZE_8_8;
8047 parse_func = osx512_parse_hash;
8048 sort_by_digest = sort_by_digest_8_8;
8049 opti_type = OPTI_TYPE_ZERO_BYTE
8050 | OPTI_TYPE_PRECOMPUTE_INIT
8051 | OPTI_TYPE_PRECOMPUTE_MERKLE
8052 | OPTI_TYPE_EARLY_SKIP
8053 | OPTI_TYPE_NOT_ITERATED
8054 | OPTI_TYPE_PREPENDED_SALT
8055 | OPTI_TYPE_USES_BITS_64
8056 | OPTI_TYPE_RAW_HASH;
8057 dgst_pos0 = 14;
8058 dgst_pos1 = 15;
8059 dgst_pos2 = 6;
8060 dgst_pos3 = 7;
8061 break;
8062
8063 case 1730: hash_type = HASH_TYPE_SHA512;
8064 salt_type = SALT_TYPE_INTERN;
8065 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8066 opts_type = OPTS_TYPE_PT_GENERATE_BE
8067 | OPTS_TYPE_PT_UNICODE
8068 | OPTS_TYPE_ST_ADD80
8069 | OPTS_TYPE_ST_ADDBITS15;
8070 kern_type = KERN_TYPE_SHA512_PWSLTU;
8071 dgst_size = DGST_SIZE_8_8;
8072 parse_func = sha512s_parse_hash;
8073 sort_by_digest = sort_by_digest_8_8;
8074 opti_type = OPTI_TYPE_ZERO_BYTE
8075 | OPTI_TYPE_PRECOMPUTE_INIT
8076 | OPTI_TYPE_PRECOMPUTE_MERKLE
8077 | OPTI_TYPE_EARLY_SKIP
8078 | OPTI_TYPE_NOT_ITERATED
8079 | OPTI_TYPE_APPENDED_SALT
8080 | OPTI_TYPE_USES_BITS_64
8081 | OPTI_TYPE_RAW_HASH;
8082 dgst_pos0 = 14;
8083 dgst_pos1 = 15;
8084 dgst_pos2 = 6;
8085 dgst_pos3 = 7;
8086 break;
8087
8088 case 1731: hash_type = HASH_TYPE_SHA512;
8089 salt_type = SALT_TYPE_EMBEDDED;
8090 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8091 opts_type = OPTS_TYPE_PT_GENERATE_BE
8092 | OPTS_TYPE_PT_UNICODE
8093 | OPTS_TYPE_ST_ADD80
8094 | OPTS_TYPE_ST_ADDBITS15
8095 | OPTS_TYPE_ST_HEX;
8096 kern_type = KERN_TYPE_SHA512_PWSLTU;
8097 dgst_size = DGST_SIZE_8_8;
8098 parse_func = mssql2012_parse_hash;
8099 sort_by_digest = sort_by_digest_8_8;
8100 opti_type = OPTI_TYPE_ZERO_BYTE
8101 | OPTI_TYPE_PRECOMPUTE_INIT
8102 | OPTI_TYPE_PRECOMPUTE_MERKLE
8103 | OPTI_TYPE_EARLY_SKIP
8104 | OPTI_TYPE_NOT_ITERATED
8105 | OPTI_TYPE_APPENDED_SALT
8106 | OPTI_TYPE_USES_BITS_64
8107 | OPTI_TYPE_RAW_HASH;
8108 dgst_pos0 = 14;
8109 dgst_pos1 = 15;
8110 dgst_pos2 = 6;
8111 dgst_pos3 = 7;
8112 break;
8113
8114 case 1740: hash_type = HASH_TYPE_SHA512;
8115 salt_type = SALT_TYPE_INTERN;
8116 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8117 opts_type = OPTS_TYPE_PT_GENERATE_BE
8118 | OPTS_TYPE_PT_ADD80
8119 | OPTS_TYPE_PT_ADDBITS15
8120 | OPTS_TYPE_PT_UNICODE;
8121 kern_type = KERN_TYPE_SHA512_SLTPWU;
8122 dgst_size = DGST_SIZE_8_8;
8123 parse_func = sha512s_parse_hash;
8124 sort_by_digest = sort_by_digest_8_8;
8125 opti_type = OPTI_TYPE_ZERO_BYTE
8126 | OPTI_TYPE_PRECOMPUTE_INIT
8127 | OPTI_TYPE_PRECOMPUTE_MERKLE
8128 | OPTI_TYPE_EARLY_SKIP
8129 | OPTI_TYPE_NOT_ITERATED
8130 | OPTI_TYPE_PREPENDED_SALT
8131 | OPTI_TYPE_USES_BITS_64
8132 | OPTI_TYPE_RAW_HASH;
8133 dgst_pos0 = 14;
8134 dgst_pos1 = 15;
8135 dgst_pos2 = 6;
8136 dgst_pos3 = 7;
8137 break;
8138
8139 case 1750: hash_type = HASH_TYPE_SHA512;
8140 salt_type = SALT_TYPE_INTERN;
8141 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8142 opts_type = OPTS_TYPE_PT_GENERATE_BE
8143 | OPTS_TYPE_ST_ADD80;
8144 kern_type = KERN_TYPE_HMACSHA512_PW;
8145 dgst_size = DGST_SIZE_8_8;
8146 parse_func = hmacsha512_parse_hash;
8147 sort_by_digest = sort_by_digest_8_8;
8148 opti_type = OPTI_TYPE_ZERO_BYTE
8149 | OPTI_TYPE_USES_BITS_64
8150 | OPTI_TYPE_NOT_ITERATED;
8151 dgst_pos0 = 14;
8152 dgst_pos1 = 15;
8153 dgst_pos2 = 6;
8154 dgst_pos3 = 7;
8155 break;
8156
8157 case 1760: hash_type = HASH_TYPE_SHA512;
8158 salt_type = SALT_TYPE_INTERN;
8159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8160 opts_type = OPTS_TYPE_PT_GENERATE_BE
8161 | OPTS_TYPE_PT_ADD80
8162 | OPTS_TYPE_PT_ADDBITS15;
8163 kern_type = KERN_TYPE_HMACSHA512_SLT;
8164 dgst_size = DGST_SIZE_8_8;
8165 parse_func = hmacsha512_parse_hash;
8166 sort_by_digest = sort_by_digest_8_8;
8167 opti_type = OPTI_TYPE_ZERO_BYTE
8168 | OPTI_TYPE_USES_BITS_64
8169 | OPTI_TYPE_NOT_ITERATED;
8170 dgst_pos0 = 14;
8171 dgst_pos1 = 15;
8172 dgst_pos2 = 6;
8173 dgst_pos3 = 7;
8174 break;
8175
8176 case 1800: hash_type = HASH_TYPE_SHA512;
8177 salt_type = SALT_TYPE_EMBEDDED;
8178 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8179 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8180 kern_type = KERN_TYPE_SHA512CRYPT;
8181 dgst_size = DGST_SIZE_8_8;
8182 parse_func = sha512crypt_parse_hash;
8183 sort_by_digest = sort_by_digest_8_8;
8184 opti_type = OPTI_TYPE_ZERO_BYTE
8185 | OPTI_TYPE_USES_BITS_64;
8186 dgst_pos0 = 0;
8187 dgst_pos1 = 1;
8188 dgst_pos2 = 2;
8189 dgst_pos3 = 3;
8190 break;
8191
8192 case 2100: hash_type = HASH_TYPE_DCC2;
8193 salt_type = SALT_TYPE_EMBEDDED;
8194 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8195 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8196 | OPTS_TYPE_ST_LOWER
8197 | OPTS_TYPE_ST_UNICODE;
8198 kern_type = KERN_TYPE_DCC2;
8199 dgst_size = DGST_SIZE_4_4;
8200 parse_func = dcc2_parse_hash;
8201 sort_by_digest = sort_by_digest_4_4;
8202 opti_type = OPTI_TYPE_ZERO_BYTE
8203 | OPTI_TYPE_SLOW_HASH_SIMD;
8204 dgst_pos0 = 0;
8205 dgst_pos1 = 1;
8206 dgst_pos2 = 2;
8207 dgst_pos3 = 3;
8208 break;
8209
8210 case 2400: hash_type = HASH_TYPE_MD5;
8211 salt_type = SALT_TYPE_NONE;
8212 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8213 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8214 kern_type = KERN_TYPE_MD5PIX;
8215 dgst_size = DGST_SIZE_4_4;
8216 parse_func = md5pix_parse_hash;
8217 sort_by_digest = sort_by_digest_4_4;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_NOT_SALTED;
8224 dgst_pos0 = 0;
8225 dgst_pos1 = 3;
8226 dgst_pos2 = 2;
8227 dgst_pos3 = 1;
8228 break;
8229
8230 case 2410: hash_type = HASH_TYPE_MD5;
8231 salt_type = SALT_TYPE_INTERN;
8232 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8233 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8234 kern_type = KERN_TYPE_MD5ASA;
8235 dgst_size = DGST_SIZE_4_4;
8236 parse_func = md5asa_parse_hash;
8237 sort_by_digest = sort_by_digest_4_4;
8238 opti_type = OPTI_TYPE_ZERO_BYTE
8239 | OPTI_TYPE_PRECOMPUTE_INIT
8240 | OPTI_TYPE_PRECOMPUTE_MERKLE
8241 | OPTI_TYPE_EARLY_SKIP
8242 | OPTI_TYPE_NOT_ITERATED;
8243 dgst_pos0 = 0;
8244 dgst_pos1 = 3;
8245 dgst_pos2 = 2;
8246 dgst_pos3 = 1;
8247 break;
8248
8249 case 2500: hash_type = HASH_TYPE_WPA;
8250 salt_type = SALT_TYPE_EMBEDDED;
8251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8252 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8253 kern_type = KERN_TYPE_WPA;
8254 dgst_size = DGST_SIZE_4_4;
8255 parse_func = wpa_parse_hash;
8256 sort_by_digest = sort_by_digest_4_4;
8257 opti_type = OPTI_TYPE_ZERO_BYTE
8258 | OPTI_TYPE_SLOW_HASH_SIMD;
8259 dgst_pos0 = 0;
8260 dgst_pos1 = 1;
8261 dgst_pos2 = 2;
8262 dgst_pos3 = 3;
8263 break;
8264
8265 case 2600: hash_type = HASH_TYPE_MD5;
8266 salt_type = SALT_TYPE_VIRTUAL;
8267 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8268 opts_type = OPTS_TYPE_PT_GENERATE_LE
8269 | OPTS_TYPE_PT_ADD80
8270 | OPTS_TYPE_PT_ADDBITS14
8271 | OPTS_TYPE_ST_ADD80;
8272 kern_type = KERN_TYPE_MD55_PWSLT1;
8273 dgst_size = DGST_SIZE_4_4;
8274 parse_func = md5md5_parse_hash;
8275 sort_by_digest = sort_by_digest_4_4;
8276 opti_type = OPTI_TYPE_ZERO_BYTE
8277 | OPTI_TYPE_PRECOMPUTE_INIT
8278 | OPTI_TYPE_PRECOMPUTE_MERKLE
8279 | OPTI_TYPE_EARLY_SKIP;
8280 dgst_pos0 = 0;
8281 dgst_pos1 = 3;
8282 dgst_pos2 = 2;
8283 dgst_pos3 = 1;
8284 break;
8285
8286 case 2611: hash_type = HASH_TYPE_MD5;
8287 salt_type = SALT_TYPE_INTERN;
8288 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8289 opts_type = OPTS_TYPE_PT_GENERATE_LE
8290 | OPTS_TYPE_PT_ADD80
8291 | OPTS_TYPE_PT_ADDBITS14
8292 | OPTS_TYPE_ST_ADD80;
8293 kern_type = KERN_TYPE_MD55_PWSLT1;
8294 dgst_size = DGST_SIZE_4_4;
8295 parse_func = vb3_parse_hash;
8296 sort_by_digest = sort_by_digest_4_4;
8297 opti_type = OPTI_TYPE_ZERO_BYTE
8298 | OPTI_TYPE_PRECOMPUTE_INIT
8299 | OPTI_TYPE_PRECOMPUTE_MERKLE
8300 | OPTI_TYPE_EARLY_SKIP;
8301 dgst_pos0 = 0;
8302 dgst_pos1 = 3;
8303 dgst_pos2 = 2;
8304 dgst_pos3 = 1;
8305 break;
8306
8307 case 2612: hash_type = HASH_TYPE_MD5;
8308 salt_type = SALT_TYPE_EMBEDDED;
8309 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8310 opts_type = OPTS_TYPE_PT_GENERATE_LE
8311 | OPTS_TYPE_PT_ADD80
8312 | OPTS_TYPE_PT_ADDBITS14
8313 | OPTS_TYPE_ST_ADD80
8314 | OPTS_TYPE_ST_HEX;
8315 kern_type = KERN_TYPE_MD55_PWSLT1;
8316 dgst_size = DGST_SIZE_4_4;
8317 parse_func = phps_parse_hash;
8318 sort_by_digest = sort_by_digest_4_4;
8319 opti_type = OPTI_TYPE_ZERO_BYTE
8320 | OPTI_TYPE_PRECOMPUTE_INIT
8321 | OPTI_TYPE_PRECOMPUTE_MERKLE
8322 | OPTI_TYPE_EARLY_SKIP;
8323 dgst_pos0 = 0;
8324 dgst_pos1 = 3;
8325 dgst_pos2 = 2;
8326 dgst_pos3 = 1;
8327 break;
8328
8329 case 2711: hash_type = HASH_TYPE_MD5;
8330 salt_type = SALT_TYPE_INTERN;
8331 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8332 opts_type = OPTS_TYPE_PT_GENERATE_LE
8333 | OPTS_TYPE_PT_ADD80
8334 | OPTS_TYPE_PT_ADDBITS14
8335 | OPTS_TYPE_ST_ADD80;
8336 kern_type = KERN_TYPE_MD55_PWSLT2;
8337 dgst_size = DGST_SIZE_4_4;
8338 parse_func = vb30_parse_hash;
8339 sort_by_digest = sort_by_digest_4_4;
8340 opti_type = OPTI_TYPE_ZERO_BYTE
8341 | OPTI_TYPE_PRECOMPUTE_INIT
8342 | OPTI_TYPE_EARLY_SKIP;
8343 dgst_pos0 = 0;
8344 dgst_pos1 = 3;
8345 dgst_pos2 = 2;
8346 dgst_pos3 = 1;
8347 break;
8348
8349 case 2811: hash_type = HASH_TYPE_MD5;
8350 salt_type = SALT_TYPE_INTERN;
8351 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8352 opts_type = OPTS_TYPE_PT_GENERATE_LE
8353 | OPTS_TYPE_PT_ADD80
8354 | OPTS_TYPE_PT_ADDBITS14;
8355 kern_type = KERN_TYPE_MD55_SLTPW;
8356 dgst_size = DGST_SIZE_4_4;
8357 parse_func = ipb2_parse_hash;
8358 sort_by_digest = sort_by_digest_4_4;
8359 opti_type = OPTI_TYPE_ZERO_BYTE
8360 | OPTI_TYPE_PRECOMPUTE_INIT
8361 | OPTI_TYPE_EARLY_SKIP;
8362 dgst_pos0 = 0;
8363 dgst_pos1 = 3;
8364 dgst_pos2 = 2;
8365 dgst_pos3 = 1;
8366 break;
8367
8368 case 3000: hash_type = HASH_TYPE_LM;
8369 salt_type = SALT_TYPE_NONE;
8370 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8371 opts_type = OPTS_TYPE_PT_GENERATE_LE
8372 | OPTS_TYPE_PT_UPPER
8373 | OPTS_TYPE_PT_BITSLICE;
8374 kern_type = KERN_TYPE_LM;
8375 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8376 parse_func = lm_parse_hash;
8377 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8378 opti_type = OPTI_TYPE_ZERO_BYTE
8379 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8380 dgst_pos0 = 0;
8381 dgst_pos1 = 1;
8382 dgst_pos2 = 2;
8383 dgst_pos3 = 3;
8384 break;
8385
8386 case 3100: hash_type = HASH_TYPE_ORACLEH;
8387 salt_type = SALT_TYPE_INTERN;
8388 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8389 opts_type = OPTS_TYPE_PT_GENERATE_LE
8390 | OPTS_TYPE_PT_UPPER
8391 | OPTS_TYPE_ST_UPPER;
8392 kern_type = KERN_TYPE_ORACLEH;
8393 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8394 parse_func = oracleh_parse_hash;
8395 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8396 opti_type = OPTI_TYPE_ZERO_BYTE;
8397 dgst_pos0 = 0;
8398 dgst_pos1 = 1;
8399 dgst_pos2 = 2;
8400 dgst_pos3 = 3;
8401 break;
8402
8403 case 3200: hash_type = HASH_TYPE_BCRYPT;
8404 salt_type = SALT_TYPE_EMBEDDED;
8405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8406 opts_type = OPTS_TYPE_PT_GENERATE_LE
8407 | OPTS_TYPE_ST_GENERATE_LE;
8408 kern_type = KERN_TYPE_BCRYPT;
8409 dgst_size = DGST_SIZE_4_6;
8410 parse_func = bcrypt_parse_hash;
8411 sort_by_digest = sort_by_digest_4_6;
8412 opti_type = OPTI_TYPE_ZERO_BYTE;
8413 dgst_pos0 = 0;
8414 dgst_pos1 = 1;
8415 dgst_pos2 = 2;
8416 dgst_pos3 = 3;
8417 break;
8418
8419 case 3710: hash_type = HASH_TYPE_MD5;
8420 salt_type = SALT_TYPE_INTERN;
8421 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8422 opts_type = OPTS_TYPE_PT_GENERATE_LE
8423 | OPTS_TYPE_PT_ADD80
8424 | OPTS_TYPE_PT_ADDBITS14;
8425 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8426 dgst_size = DGST_SIZE_4_4;
8427 parse_func = md5s_parse_hash;
8428 sort_by_digest = sort_by_digest_4_4;
8429 opti_type = OPTI_TYPE_ZERO_BYTE
8430 | OPTI_TYPE_PRECOMPUTE_INIT
8431 | OPTI_TYPE_PRECOMPUTE_MERKLE
8432 | OPTI_TYPE_EARLY_SKIP;
8433 dgst_pos0 = 0;
8434 dgst_pos1 = 3;
8435 dgst_pos2 = 2;
8436 dgst_pos3 = 1;
8437 break;
8438
8439 case 3711: hash_type = HASH_TYPE_MD5;
8440 salt_type = SALT_TYPE_EMBEDDED;
8441 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8442 opts_type = OPTS_TYPE_PT_GENERATE_LE
8443 | OPTS_TYPE_PT_ADD80
8444 | OPTS_TYPE_PT_ADDBITS14;
8445 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8446 dgst_size = DGST_SIZE_4_4;
8447 parse_func = mediawiki_b_parse_hash;
8448 sort_by_digest = sort_by_digest_4_4;
8449 opti_type = OPTI_TYPE_ZERO_BYTE
8450 | OPTI_TYPE_PRECOMPUTE_INIT
8451 | OPTI_TYPE_PRECOMPUTE_MERKLE
8452 | OPTI_TYPE_EARLY_SKIP;
8453 dgst_pos0 = 0;
8454 dgst_pos1 = 3;
8455 dgst_pos2 = 2;
8456 dgst_pos3 = 1;
8457 break;
8458
8459 case 3800: hash_type = HASH_TYPE_MD5;
8460 salt_type = SALT_TYPE_INTERN;
8461 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8462 opts_type = OPTS_TYPE_PT_GENERATE_LE
8463 | OPTS_TYPE_ST_ADDBITS14;
8464 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8465 dgst_size = DGST_SIZE_4_4;
8466 parse_func = md5s_parse_hash;
8467 sort_by_digest = sort_by_digest_4_4;
8468 opti_type = OPTI_TYPE_ZERO_BYTE
8469 | OPTI_TYPE_PRECOMPUTE_INIT
8470 | OPTI_TYPE_PRECOMPUTE_MERKLE
8471 | OPTI_TYPE_EARLY_SKIP
8472 | OPTI_TYPE_NOT_ITERATED
8473 | OPTI_TYPE_RAW_HASH;
8474 dgst_pos0 = 0;
8475 dgst_pos1 = 3;
8476 dgst_pos2 = 2;
8477 dgst_pos3 = 1;
8478 break;
8479
8480 case 4300: hash_type = HASH_TYPE_MD5;
8481 salt_type = SALT_TYPE_VIRTUAL;
8482 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8483 opts_type = OPTS_TYPE_PT_GENERATE_LE
8484 | OPTS_TYPE_PT_ADD80
8485 | OPTS_TYPE_PT_ADDBITS14
8486 | OPTS_TYPE_ST_ADD80;
8487 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8488 dgst_size = DGST_SIZE_4_4;
8489 parse_func = md5md5_parse_hash;
8490 sort_by_digest = sort_by_digest_4_4;
8491 opti_type = OPTI_TYPE_ZERO_BYTE
8492 | OPTI_TYPE_PRECOMPUTE_INIT
8493 | OPTI_TYPE_PRECOMPUTE_MERKLE
8494 | OPTI_TYPE_EARLY_SKIP;
8495 dgst_pos0 = 0;
8496 dgst_pos1 = 3;
8497 dgst_pos2 = 2;
8498 dgst_pos3 = 1;
8499 break;
8500
8501
8502 case 4400: hash_type = HASH_TYPE_MD5;
8503 salt_type = SALT_TYPE_NONE;
8504 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8505 opts_type = OPTS_TYPE_PT_GENERATE_BE
8506 | OPTS_TYPE_PT_ADD80
8507 | OPTS_TYPE_PT_ADDBITS15;
8508 kern_type = KERN_TYPE_MD5_SHA1;
8509 dgst_size = DGST_SIZE_4_4;
8510 parse_func = md5_parse_hash;
8511 sort_by_digest = sort_by_digest_4_4;
8512 opti_type = OPTI_TYPE_ZERO_BYTE
8513 | OPTI_TYPE_PRECOMPUTE_INIT
8514 | OPTI_TYPE_PRECOMPUTE_MERKLE
8515 | OPTI_TYPE_EARLY_SKIP
8516 | OPTI_TYPE_NOT_ITERATED
8517 | OPTI_TYPE_NOT_SALTED
8518 | OPTI_TYPE_RAW_HASH;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 4500: hash_type = HASH_TYPE_SHA1;
8526 salt_type = SALT_TYPE_NONE;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_BE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS15;
8531 kern_type = KERN_TYPE_SHA11;
8532 dgst_size = DGST_SIZE_4_5;
8533 parse_func = sha1_parse_hash;
8534 sort_by_digest = sort_by_digest_4_5;
8535 opti_type = OPTI_TYPE_ZERO_BYTE
8536 | OPTI_TYPE_PRECOMPUTE_INIT
8537 | OPTI_TYPE_PRECOMPUTE_MERKLE
8538 | OPTI_TYPE_EARLY_SKIP
8539 | OPTI_TYPE_NOT_SALTED;
8540 dgst_pos0 = 3;
8541 dgst_pos1 = 4;
8542 dgst_pos2 = 2;
8543 dgst_pos3 = 1;
8544 break;
8545
8546 case 4700: hash_type = HASH_TYPE_SHA1;
8547 salt_type = SALT_TYPE_NONE;
8548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8549 opts_type = OPTS_TYPE_PT_GENERATE_LE
8550 | OPTS_TYPE_PT_ADD80
8551 | OPTS_TYPE_PT_ADDBITS14;
8552 kern_type = KERN_TYPE_SHA1_MD5;
8553 dgst_size = DGST_SIZE_4_5;
8554 parse_func = sha1_parse_hash;
8555 sort_by_digest = sort_by_digest_4_5;
8556 opti_type = OPTI_TYPE_ZERO_BYTE
8557 | OPTI_TYPE_PRECOMPUTE_INIT
8558 | OPTI_TYPE_PRECOMPUTE_MERKLE
8559 | OPTI_TYPE_EARLY_SKIP
8560 | OPTI_TYPE_NOT_ITERATED
8561 | OPTI_TYPE_NOT_SALTED
8562 | OPTI_TYPE_RAW_HASH;
8563 dgst_pos0 = 3;
8564 dgst_pos1 = 4;
8565 dgst_pos2 = 2;
8566 dgst_pos3 = 1;
8567 break;
8568
8569 case 4800: hash_type = HASH_TYPE_MD5;
8570 salt_type = SALT_TYPE_EMBEDDED;
8571 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8572 opts_type = OPTS_TYPE_PT_GENERATE_LE
8573 | OPTS_TYPE_PT_ADDBITS14;
8574 kern_type = KERN_TYPE_MD5_CHAP;
8575 dgst_size = DGST_SIZE_4_4;
8576 parse_func = chap_parse_hash;
8577 sort_by_digest = sort_by_digest_4_4;
8578 opti_type = OPTI_TYPE_ZERO_BYTE
8579 | OPTI_TYPE_PRECOMPUTE_INIT
8580 | OPTI_TYPE_PRECOMPUTE_MERKLE
8581 | OPTI_TYPE_MEET_IN_MIDDLE
8582 | OPTI_TYPE_EARLY_SKIP
8583 | OPTI_TYPE_NOT_ITERATED
8584 | OPTI_TYPE_RAW_HASH;
8585 dgst_pos0 = 0;
8586 dgst_pos1 = 3;
8587 dgst_pos2 = 2;
8588 dgst_pos3 = 1;
8589 break;
8590
8591 case 4900: hash_type = HASH_TYPE_SHA1;
8592 salt_type = SALT_TYPE_INTERN;
8593 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8594 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8595 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8596 dgst_size = DGST_SIZE_4_5;
8597 parse_func = sha1s_parse_hash;
8598 sort_by_digest = sort_by_digest_4_5;
8599 opti_type = OPTI_TYPE_ZERO_BYTE
8600 | OPTI_TYPE_PRECOMPUTE_INIT
8601 | OPTI_TYPE_PRECOMPUTE_MERKLE
8602 | OPTI_TYPE_EARLY_SKIP;
8603 dgst_pos0 = 3;
8604 dgst_pos1 = 4;
8605 dgst_pos2 = 2;
8606 dgst_pos3 = 1;
8607 break;
8608
8609 case 5000: hash_type = HASH_TYPE_KECCAK;
8610 salt_type = SALT_TYPE_EMBEDDED;
8611 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8612 opts_type = OPTS_TYPE_PT_GENERATE_LE
8613 | OPTS_TYPE_PT_ADD01;
8614 kern_type = KERN_TYPE_KECCAK;
8615 dgst_size = DGST_SIZE_8_25;
8616 parse_func = keccak_parse_hash;
8617 sort_by_digest = sort_by_digest_8_25;
8618 opti_type = OPTI_TYPE_ZERO_BYTE
8619 | OPTI_TYPE_USES_BITS_64
8620 | OPTI_TYPE_RAW_HASH;
8621 dgst_pos0 = 2;
8622 dgst_pos1 = 3;
8623 dgst_pos2 = 4;
8624 dgst_pos3 = 5;
8625 break;
8626
8627 case 5100: hash_type = HASH_TYPE_MD5H;
8628 salt_type = SALT_TYPE_NONE;
8629 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8630 opts_type = OPTS_TYPE_PT_GENERATE_LE
8631 | OPTS_TYPE_PT_ADD80
8632 | OPTS_TYPE_PT_ADDBITS14;
8633 kern_type = KERN_TYPE_MD5H;
8634 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8635 parse_func = md5half_parse_hash;
8636 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8637 opti_type = OPTI_TYPE_ZERO_BYTE
8638 | OPTI_TYPE_RAW_HASH;
8639 dgst_pos0 = 0;
8640 dgst_pos1 = 1;
8641 dgst_pos2 = 2;
8642 dgst_pos3 = 3;
8643 break;
8644
8645 case 5200: hash_type = HASH_TYPE_SHA256;
8646 salt_type = SALT_TYPE_EMBEDDED;
8647 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8648 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8649 kern_type = KERN_TYPE_PSAFE3;
8650 dgst_size = DGST_SIZE_4_8;
8651 parse_func = psafe3_parse_hash;
8652 sort_by_digest = sort_by_digest_4_8;
8653 opti_type = OPTI_TYPE_ZERO_BYTE;
8654 dgst_pos0 = 0;
8655 dgst_pos1 = 1;
8656 dgst_pos2 = 2;
8657 dgst_pos3 = 3;
8658 break;
8659
8660 case 5300: hash_type = HASH_TYPE_MD5;
8661 salt_type = SALT_TYPE_EMBEDDED;
8662 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8663 opts_type = OPTS_TYPE_PT_GENERATE_LE
8664 | OPTS_TYPE_ST_ADD80;
8665 kern_type = KERN_TYPE_IKEPSK_MD5;
8666 dgst_size = DGST_SIZE_4_4;
8667 parse_func = ikepsk_md5_parse_hash;
8668 sort_by_digest = sort_by_digest_4_4;
8669 opti_type = OPTI_TYPE_ZERO_BYTE;
8670 dgst_pos0 = 0;
8671 dgst_pos1 = 3;
8672 dgst_pos2 = 2;
8673 dgst_pos3 = 1;
8674 break;
8675
8676 case 5400: hash_type = HASH_TYPE_SHA1;
8677 salt_type = SALT_TYPE_EMBEDDED;
8678 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8679 opts_type = OPTS_TYPE_PT_GENERATE_BE
8680 | OPTS_TYPE_ST_ADD80;
8681 kern_type = KERN_TYPE_IKEPSK_SHA1;
8682 dgst_size = DGST_SIZE_4_5;
8683 parse_func = ikepsk_sha1_parse_hash;
8684 sort_by_digest = sort_by_digest_4_5;
8685 opti_type = OPTI_TYPE_ZERO_BYTE;
8686 dgst_pos0 = 3;
8687 dgst_pos1 = 4;
8688 dgst_pos2 = 2;
8689 dgst_pos3 = 1;
8690 break;
8691
8692 case 5500: hash_type = HASH_TYPE_NETNTLM;
8693 salt_type = SALT_TYPE_EMBEDDED;
8694 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8695 opts_type = OPTS_TYPE_PT_GENERATE_LE
8696 | OPTS_TYPE_PT_ADD80
8697 | OPTS_TYPE_PT_ADDBITS14
8698 | OPTS_TYPE_PT_UNICODE
8699 | OPTS_TYPE_ST_HEX;
8700 kern_type = KERN_TYPE_NETNTLMv1;
8701 dgst_size = DGST_SIZE_4_4;
8702 parse_func = netntlmv1_parse_hash;
8703 sort_by_digest = sort_by_digest_4_4;
8704 opti_type = OPTI_TYPE_ZERO_BYTE
8705 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8706 dgst_pos0 = 0;
8707 dgst_pos1 = 1;
8708 dgst_pos2 = 2;
8709 dgst_pos3 = 3;
8710 break;
8711
8712 case 5600: hash_type = HASH_TYPE_MD5;
8713 salt_type = SALT_TYPE_EMBEDDED;
8714 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8715 opts_type = OPTS_TYPE_PT_GENERATE_LE
8716 | OPTS_TYPE_PT_ADD80
8717 | OPTS_TYPE_PT_ADDBITS14
8718 | OPTS_TYPE_PT_UNICODE;
8719 kern_type = KERN_TYPE_NETNTLMv2;
8720 dgst_size = DGST_SIZE_4_4;
8721 parse_func = netntlmv2_parse_hash;
8722 sort_by_digest = sort_by_digest_4_4;
8723 opti_type = OPTI_TYPE_ZERO_BYTE;
8724 dgst_pos0 = 0;
8725 dgst_pos1 = 3;
8726 dgst_pos2 = 2;
8727 dgst_pos3 = 1;
8728 break;
8729
8730 case 5700: hash_type = HASH_TYPE_SHA256;
8731 salt_type = SALT_TYPE_NONE;
8732 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8733 opts_type = OPTS_TYPE_PT_GENERATE_BE
8734 | OPTS_TYPE_PT_ADD80
8735 | OPTS_TYPE_PT_ADDBITS15;
8736 kern_type = KERN_TYPE_SHA256;
8737 dgst_size = DGST_SIZE_4_8;
8738 parse_func = cisco4_parse_hash;
8739 sort_by_digest = sort_by_digest_4_8;
8740 opti_type = OPTI_TYPE_ZERO_BYTE
8741 | OPTI_TYPE_PRECOMPUTE_INIT
8742 | OPTI_TYPE_PRECOMPUTE_MERKLE
8743 | OPTI_TYPE_EARLY_SKIP
8744 | OPTI_TYPE_NOT_ITERATED
8745 | OPTI_TYPE_NOT_SALTED
8746 | OPTI_TYPE_RAW_HASH;
8747 dgst_pos0 = 3;
8748 dgst_pos1 = 7;
8749 dgst_pos2 = 2;
8750 dgst_pos3 = 6;
8751 break;
8752
8753 case 5800: hash_type = HASH_TYPE_SHA1;
8754 salt_type = SALT_TYPE_INTERN;
8755 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8756 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8757 | OPTS_TYPE_ST_ADD80;
8758 kern_type = KERN_TYPE_ANDROIDPIN;
8759 dgst_size = DGST_SIZE_4_5;
8760 parse_func = androidpin_parse_hash;
8761 sort_by_digest = sort_by_digest_4_5;
8762 opti_type = OPTI_TYPE_ZERO_BYTE;
8763 dgst_pos0 = 0;
8764 dgst_pos1 = 1;
8765 dgst_pos2 = 2;
8766 dgst_pos3 = 3;
8767 break;
8768
8769 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8770 salt_type = SALT_TYPE_NONE;
8771 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8772 opts_type = OPTS_TYPE_PT_GENERATE_LE
8773 | OPTS_TYPE_PT_ADD80;
8774 kern_type = KERN_TYPE_RIPEMD160;
8775 dgst_size = DGST_SIZE_4_5;
8776 parse_func = ripemd160_parse_hash;
8777 sort_by_digest = sort_by_digest_4_5;
8778 opti_type = OPTI_TYPE_ZERO_BYTE;
8779 dgst_pos0 = 0;
8780 dgst_pos1 = 1;
8781 dgst_pos2 = 2;
8782 dgst_pos3 = 3;
8783 break;
8784
8785 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8786 salt_type = SALT_TYPE_NONE;
8787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8788 opts_type = OPTS_TYPE_PT_GENERATE_BE
8789 | OPTS_TYPE_PT_ADD80;
8790 kern_type = KERN_TYPE_WHIRLPOOL;
8791 dgst_size = DGST_SIZE_4_16;
8792 parse_func = whirlpool_parse_hash;
8793 sort_by_digest = sort_by_digest_4_16;
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 6211: hash_type = HASH_TYPE_RIPEMD160;
8802 salt_type = SALT_TYPE_EMBEDDED;
8803 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8804 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8805 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8806 dgst_size = DGST_SIZE_4_5;
8807 parse_func = truecrypt_parse_hash_2k;
8808 sort_by_digest = sort_by_digest_4_5;
8809 opti_type = OPTI_TYPE_ZERO_BYTE;
8810 dgst_pos0 = 0;
8811 dgst_pos1 = 1;
8812 dgst_pos2 = 2;
8813 dgst_pos3 = 3;
8814 break;
8815
8816 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8817 salt_type = SALT_TYPE_EMBEDDED;
8818 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8819 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8820 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8821 dgst_size = DGST_SIZE_4_5;
8822 parse_func = truecrypt_parse_hash_2k;
8823 sort_by_digest = sort_by_digest_4_5;
8824 opti_type = OPTI_TYPE_ZERO_BYTE;
8825 dgst_pos0 = 0;
8826 dgst_pos1 = 1;
8827 dgst_pos2 = 2;
8828 dgst_pos3 = 3;
8829 break;
8830
8831 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8832 salt_type = SALT_TYPE_EMBEDDED;
8833 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8834 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8835 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8836 dgst_size = DGST_SIZE_4_5;
8837 parse_func = truecrypt_parse_hash_2k;
8838 sort_by_digest = sort_by_digest_4_5;
8839 opti_type = OPTI_TYPE_ZERO_BYTE;
8840 dgst_pos0 = 0;
8841 dgst_pos1 = 1;
8842 dgst_pos2 = 2;
8843 dgst_pos3 = 3;
8844 break;
8845
8846 case 6221: hash_type = HASH_TYPE_SHA512;
8847 salt_type = SALT_TYPE_EMBEDDED;
8848 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8849 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8850 kern_type = KERN_TYPE_TCSHA512_XTS512;
8851 dgst_size = DGST_SIZE_8_8;
8852 parse_func = truecrypt_parse_hash_1k;
8853 sort_by_digest = sort_by_digest_8_8;
8854 opti_type = OPTI_TYPE_ZERO_BYTE
8855 | OPTI_TYPE_USES_BITS_64;
8856 dgst_pos0 = 0;
8857 dgst_pos1 = 1;
8858 dgst_pos2 = 2;
8859 dgst_pos3 = 3;
8860 break;
8861
8862 case 6222: hash_type = HASH_TYPE_SHA512;
8863 salt_type = SALT_TYPE_EMBEDDED;
8864 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8865 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8866 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8867 dgst_size = DGST_SIZE_8_8;
8868 parse_func = truecrypt_parse_hash_1k;
8869 sort_by_digest = sort_by_digest_8_8;
8870 opti_type = OPTI_TYPE_ZERO_BYTE
8871 | OPTI_TYPE_USES_BITS_64;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 6223: 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_XTS1536;
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 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8898 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8899 dgst_size = DGST_SIZE_4_8;
8900 parse_func = truecrypt_parse_hash_1k;
8901 sort_by_digest = sort_by_digest_4_8;
8902 opti_type = OPTI_TYPE_ZERO_BYTE;
8903 dgst_pos0 = 0;
8904 dgst_pos1 = 1;
8905 dgst_pos2 = 2;
8906 dgst_pos3 = 3;
8907 break;
8908
8909 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8910 salt_type = SALT_TYPE_EMBEDDED;
8911 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8912 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8913 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8914 dgst_size = DGST_SIZE_4_8;
8915 parse_func = truecrypt_parse_hash_1k;
8916 sort_by_digest = sort_by_digest_4_8;
8917 opti_type = OPTI_TYPE_ZERO_BYTE;
8918 dgst_pos0 = 0;
8919 dgst_pos1 = 1;
8920 dgst_pos2 = 2;
8921 dgst_pos3 = 3;
8922 break;
8923
8924 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8925 salt_type = SALT_TYPE_EMBEDDED;
8926 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8927 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8928 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8929 dgst_size = DGST_SIZE_4_8;
8930 parse_func = truecrypt_parse_hash_1k;
8931 sort_by_digest = sort_by_digest_4_8;
8932 opti_type = OPTI_TYPE_ZERO_BYTE;
8933 dgst_pos0 = 0;
8934 dgst_pos1 = 1;
8935 dgst_pos2 = 2;
8936 dgst_pos3 = 3;
8937 break;
8938
8939 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8940 salt_type = SALT_TYPE_EMBEDDED;
8941 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8942 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8943 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8944 dgst_size = DGST_SIZE_4_5;
8945 parse_func = truecrypt_parse_hash_1k;
8946 sort_by_digest = sort_by_digest_4_5;
8947 opti_type = OPTI_TYPE_ZERO_BYTE;
8948 dgst_pos0 = 0;
8949 dgst_pos1 = 1;
8950 dgst_pos2 = 2;
8951 dgst_pos3 = 3;
8952 break;
8953
8954 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8955 salt_type = SALT_TYPE_EMBEDDED;
8956 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8957 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8958 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8959 dgst_size = DGST_SIZE_4_5;
8960 parse_func = truecrypt_parse_hash_1k;
8961 sort_by_digest = sort_by_digest_4_5;
8962 opti_type = OPTI_TYPE_ZERO_BYTE;
8963 dgst_pos0 = 0;
8964 dgst_pos1 = 1;
8965 dgst_pos2 = 2;
8966 dgst_pos3 = 3;
8967 break;
8968
8969 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8970 salt_type = SALT_TYPE_EMBEDDED;
8971 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8972 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8973 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8974 dgst_size = DGST_SIZE_4_5;
8975 parse_func = truecrypt_parse_hash_1k;
8976 sort_by_digest = sort_by_digest_4_5;
8977 opti_type = OPTI_TYPE_ZERO_BYTE;
8978 dgst_pos0 = 0;
8979 dgst_pos1 = 1;
8980 dgst_pos2 = 2;
8981 dgst_pos3 = 3;
8982 break;
8983
8984 case 6300: hash_type = HASH_TYPE_MD5;
8985 salt_type = SALT_TYPE_EMBEDDED;
8986 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8987 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8988 kern_type = KERN_TYPE_MD5AIX;
8989 dgst_size = DGST_SIZE_4_4;
8990 parse_func = md5aix_parse_hash;
8991 sort_by_digest = sort_by_digest_4_4;
8992 opti_type = OPTI_TYPE_ZERO_BYTE;
8993 dgst_pos0 = 0;
8994 dgst_pos1 = 1;
8995 dgst_pos2 = 2;
8996 dgst_pos3 = 3;
8997 break;
8998
8999 case 6400: hash_type = HASH_TYPE_SHA256;
9000 salt_type = SALT_TYPE_EMBEDDED;
9001 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9002 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9003 kern_type = KERN_TYPE_SHA256AIX;
9004 dgst_size = DGST_SIZE_4_8;
9005 parse_func = sha256aix_parse_hash;
9006 sort_by_digest = sort_by_digest_4_8;
9007 opti_type = OPTI_TYPE_ZERO_BYTE;
9008 dgst_pos0 = 0;
9009 dgst_pos1 = 1;
9010 dgst_pos2 = 2;
9011 dgst_pos3 = 3;
9012 break;
9013
9014 case 6500: hash_type = HASH_TYPE_SHA512;
9015 salt_type = SALT_TYPE_EMBEDDED;
9016 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9017 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9018 kern_type = KERN_TYPE_SHA512AIX;
9019 dgst_size = DGST_SIZE_8_8;
9020 parse_func = sha512aix_parse_hash;
9021 sort_by_digest = sort_by_digest_8_8;
9022 opti_type = OPTI_TYPE_ZERO_BYTE
9023 | OPTI_TYPE_USES_BITS_64;
9024 dgst_pos0 = 0;
9025 dgst_pos1 = 1;
9026 dgst_pos2 = 2;
9027 dgst_pos3 = 3;
9028 break;
9029
9030 case 6600: hash_type = HASH_TYPE_AES;
9031 salt_type = SALT_TYPE_EMBEDDED;
9032 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9033 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9034 kern_type = KERN_TYPE_AGILEKEY;
9035 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9036 parse_func = agilekey_parse_hash;
9037 sort_by_digest = sort_by_digest_4_5;
9038 opti_type = OPTI_TYPE_ZERO_BYTE;
9039 dgst_pos0 = 0;
9040 dgst_pos1 = 1;
9041 dgst_pos2 = 2;
9042 dgst_pos3 = 3;
9043 break;
9044
9045 case 6700: hash_type = HASH_TYPE_SHA1;
9046 salt_type = SALT_TYPE_EMBEDDED;
9047 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9048 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9049 kern_type = KERN_TYPE_SHA1AIX;
9050 dgst_size = DGST_SIZE_4_5;
9051 parse_func = sha1aix_parse_hash;
9052 sort_by_digest = sort_by_digest_4_5;
9053 opti_type = OPTI_TYPE_ZERO_BYTE;
9054 dgst_pos0 = 0;
9055 dgst_pos1 = 1;
9056 dgst_pos2 = 2;
9057 dgst_pos3 = 3;
9058 break;
9059
9060 case 6800: hash_type = HASH_TYPE_AES;
9061 salt_type = SALT_TYPE_EMBEDDED;
9062 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9063 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9064 kern_type = KERN_TYPE_LASTPASS;
9065 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9066 parse_func = lastpass_parse_hash;
9067 sort_by_digest = sort_by_digest_4_8;
9068 opti_type = OPTI_TYPE_ZERO_BYTE;
9069 dgst_pos0 = 0;
9070 dgst_pos1 = 1;
9071 dgst_pos2 = 2;
9072 dgst_pos3 = 3;
9073 break;
9074
9075 case 6900: hash_type = HASH_TYPE_GOST;
9076 salt_type = SALT_TYPE_NONE;
9077 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9078 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9079 kern_type = KERN_TYPE_GOST;
9080 dgst_size = DGST_SIZE_4_8;
9081 parse_func = gost_parse_hash;
9082 sort_by_digest = sort_by_digest_4_8;
9083 opti_type = OPTI_TYPE_ZERO_BYTE;
9084 dgst_pos0 = 0;
9085 dgst_pos1 = 1;
9086 dgst_pos2 = 2;
9087 dgst_pos3 = 3;
9088 break;
9089
9090 case 7100: hash_type = HASH_TYPE_SHA512;
9091 salt_type = SALT_TYPE_EMBEDDED;
9092 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9093 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9094 kern_type = KERN_TYPE_PBKDF2_SHA512;
9095 dgst_size = DGST_SIZE_8_16;
9096 parse_func = sha512osx_parse_hash;
9097 sort_by_digest = sort_by_digest_8_16;
9098 opti_type = OPTI_TYPE_ZERO_BYTE
9099 | OPTI_TYPE_USES_BITS_64
9100 | OPTI_TYPE_SLOW_HASH_SIMD;
9101 dgst_pos0 = 0;
9102 dgst_pos1 = 1;
9103 dgst_pos2 = 2;
9104 dgst_pos3 = 3;
9105 break;
9106
9107 case 7200: hash_type = HASH_TYPE_SHA512;
9108 salt_type = SALT_TYPE_EMBEDDED;
9109 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9110 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9111 kern_type = KERN_TYPE_PBKDF2_SHA512;
9112 dgst_size = DGST_SIZE_8_16;
9113 parse_func = sha512grub_parse_hash;
9114 sort_by_digest = sort_by_digest_8_16;
9115 opti_type = OPTI_TYPE_ZERO_BYTE
9116 | OPTI_TYPE_USES_BITS_64
9117 | OPTI_TYPE_SLOW_HASH_SIMD;
9118 dgst_pos0 = 0;
9119 dgst_pos1 = 1;
9120 dgst_pos2 = 2;
9121 dgst_pos3 = 3;
9122 break;
9123
9124 case 7300: hash_type = HASH_TYPE_SHA1;
9125 salt_type = SALT_TYPE_EMBEDDED;
9126 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9127 opts_type = OPTS_TYPE_PT_GENERATE_BE
9128 | OPTS_TYPE_ST_ADD80
9129 | OPTS_TYPE_ST_ADDBITS15;
9130 kern_type = KERN_TYPE_RAKP;
9131 dgst_size = DGST_SIZE_4_5;
9132 parse_func = rakp_parse_hash;
9133 sort_by_digest = sort_by_digest_4_5;
9134 opti_type = OPTI_TYPE_ZERO_BYTE
9135 | OPTI_TYPE_NOT_ITERATED;
9136 dgst_pos0 = 3;
9137 dgst_pos1 = 4;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 1;
9140 break;
9141
9142 case 7400: hash_type = HASH_TYPE_SHA256;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9146 kern_type = KERN_TYPE_SHA256CRYPT;
9147 dgst_size = DGST_SIZE_4_8;
9148 parse_func = sha256crypt_parse_hash;
9149 sort_by_digest = sort_by_digest_4_8;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 7500: hash_type = HASH_TYPE_KRB5PA;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9161 kern_type = KERN_TYPE_KRB5PA;
9162 dgst_size = DGST_SIZE_4_4;
9163 parse_func = krb5pa_parse_hash;
9164 sort_by_digest = sort_by_digest_4_4;
9165 opti_type = OPTI_TYPE_ZERO_BYTE
9166 | OPTI_TYPE_NOT_ITERATED;
9167 dgst_pos0 = 0;
9168 dgst_pos1 = 1;
9169 dgst_pos2 = 2;
9170 dgst_pos3 = 3;
9171 break;
9172
9173 case 7600: hash_type = HASH_TYPE_SHA1;
9174 salt_type = SALT_TYPE_INTERN;
9175 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9176 opts_type = OPTS_TYPE_PT_GENERATE_BE
9177 | OPTS_TYPE_PT_ADD80
9178 | OPTS_TYPE_PT_ADDBITS15;
9179 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9180 dgst_size = DGST_SIZE_4_5;
9181 parse_func = redmine_parse_hash;
9182 sort_by_digest = sort_by_digest_4_5;
9183 opti_type = OPTI_TYPE_ZERO_BYTE
9184 | OPTI_TYPE_PRECOMPUTE_INIT
9185 | OPTI_TYPE_EARLY_SKIP
9186 | OPTI_TYPE_NOT_ITERATED
9187 | OPTI_TYPE_PREPENDED_SALT;
9188 dgst_pos0 = 3;
9189 dgst_pos1 = 4;
9190 dgst_pos2 = 2;
9191 dgst_pos3 = 1;
9192 break;
9193
9194 case 7700: hash_type = HASH_TYPE_SAPB;
9195 salt_type = SALT_TYPE_EMBEDDED;
9196 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9197 opts_type = OPTS_TYPE_PT_GENERATE_LE
9198 | OPTS_TYPE_PT_UPPER
9199 | OPTS_TYPE_ST_UPPER;
9200 kern_type = KERN_TYPE_SAPB;
9201 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9202 parse_func = sapb_parse_hash;
9203 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9204 opti_type = OPTI_TYPE_ZERO_BYTE
9205 | OPTI_TYPE_PRECOMPUTE_INIT
9206 | OPTI_TYPE_NOT_ITERATED;
9207 dgst_pos0 = 0;
9208 dgst_pos1 = 1;
9209 dgst_pos2 = 2;
9210 dgst_pos3 = 3;
9211 break;
9212
9213 case 7800: hash_type = HASH_TYPE_SAPG;
9214 salt_type = SALT_TYPE_EMBEDDED;
9215 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9216 opts_type = OPTS_TYPE_PT_GENERATE_BE
9217 | OPTS_TYPE_ST_ADD80
9218 | OPTS_TYPE_ST_UPPER;
9219 kern_type = KERN_TYPE_SAPG;
9220 dgst_size = DGST_SIZE_4_5;
9221 parse_func = sapg_parse_hash;
9222 sort_by_digest = sort_by_digest_4_5;
9223 opti_type = OPTI_TYPE_ZERO_BYTE
9224 | OPTI_TYPE_PRECOMPUTE_INIT
9225 | OPTI_TYPE_NOT_ITERATED;
9226 dgst_pos0 = 3;
9227 dgst_pos1 = 4;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 1;
9230 break;
9231
9232 case 7900: hash_type = HASH_TYPE_SHA512;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9236 kern_type = KERN_TYPE_DRUPAL7;
9237 dgst_size = DGST_SIZE_8_8;
9238 parse_func = drupal7_parse_hash;
9239 sort_by_digest = sort_by_digest_8_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_USES_BITS_64;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 8000: hash_type = HASH_TYPE_SHA256;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_BE
9252 | OPTS_TYPE_PT_UNICODE
9253 | OPTS_TYPE_ST_ADD80
9254 | OPTS_TYPE_ST_HEX;
9255 kern_type = KERN_TYPE_SYBASEASE;
9256 dgst_size = DGST_SIZE_4_8;
9257 parse_func = sybasease_parse_hash;
9258 sort_by_digest = sort_by_digest_4_8;
9259 opti_type = OPTI_TYPE_ZERO_BYTE
9260 | OPTI_TYPE_PRECOMPUTE_INIT
9261 | OPTI_TYPE_EARLY_SKIP
9262 | OPTI_TYPE_NOT_ITERATED
9263 | OPTI_TYPE_RAW_HASH;
9264 dgst_pos0 = 3;
9265 dgst_pos1 = 7;
9266 dgst_pos2 = 2;
9267 dgst_pos3 = 6;
9268 break;
9269
9270 case 8100: hash_type = HASH_TYPE_SHA1;
9271 salt_type = SALT_TYPE_EMBEDDED;
9272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9273 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9274 kern_type = KERN_TYPE_NETSCALER;
9275 dgst_size = DGST_SIZE_4_5;
9276 parse_func = netscaler_parse_hash;
9277 sort_by_digest = sort_by_digest_4_5;
9278 opti_type = OPTI_TYPE_ZERO_BYTE
9279 | OPTI_TYPE_PRECOMPUTE_INIT
9280 | OPTI_TYPE_PRECOMPUTE_MERKLE
9281 | OPTI_TYPE_EARLY_SKIP
9282 | OPTI_TYPE_NOT_ITERATED
9283 | OPTI_TYPE_PREPENDED_SALT
9284 | OPTI_TYPE_RAW_HASH;
9285 dgst_pos0 = 3;
9286 dgst_pos1 = 4;
9287 dgst_pos2 = 2;
9288 dgst_pos3 = 1;
9289 break;
9290
9291 case 8200: hash_type = HASH_TYPE_SHA256;
9292 salt_type = SALT_TYPE_EMBEDDED;
9293 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9294 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9295 kern_type = KERN_TYPE_CLOUDKEY;
9296 dgst_size = DGST_SIZE_4_8;
9297 parse_func = cloudkey_parse_hash;
9298 sort_by_digest = sort_by_digest_4_8;
9299 opti_type = OPTI_TYPE_ZERO_BYTE;
9300 dgst_pos0 = 0;
9301 dgst_pos1 = 1;
9302 dgst_pos2 = 2;
9303 dgst_pos3 = 3;
9304 break;
9305
9306 case 8300: hash_type = HASH_TYPE_SHA1;
9307 salt_type = SALT_TYPE_EMBEDDED;
9308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9309 opts_type = OPTS_TYPE_PT_GENERATE_BE
9310 | OPTS_TYPE_ST_HEX
9311 | OPTS_TYPE_ST_ADD80;
9312 kern_type = KERN_TYPE_NSEC3;
9313 dgst_size = DGST_SIZE_4_5;
9314 parse_func = nsec3_parse_hash;
9315 sort_by_digest = sort_by_digest_4_5;
9316 opti_type = OPTI_TYPE_ZERO_BYTE;
9317 dgst_pos0 = 3;
9318 dgst_pos1 = 4;
9319 dgst_pos2 = 2;
9320 dgst_pos3 = 1;
9321 break;
9322
9323 case 8400: hash_type = HASH_TYPE_SHA1;
9324 salt_type = SALT_TYPE_INTERN;
9325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9326 opts_type = OPTS_TYPE_PT_GENERATE_BE
9327 | OPTS_TYPE_PT_ADD80
9328 | OPTS_TYPE_PT_ADDBITS15;
9329 kern_type = KERN_TYPE_WBB3;
9330 dgst_size = DGST_SIZE_4_5;
9331 parse_func = wbb3_parse_hash;
9332 sort_by_digest = sort_by_digest_4_5;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_PRECOMPUTE_INIT
9335 | OPTI_TYPE_NOT_ITERATED;
9336 dgst_pos0 = 3;
9337 dgst_pos1 = 4;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 1;
9340 break;
9341
9342 case 8500: hash_type = HASH_TYPE_DESRACF;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_LE
9346 | OPTS_TYPE_ST_UPPER;
9347 kern_type = KERN_TYPE_RACF;
9348 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9349 parse_func = racf_parse_hash;
9350 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9351 opti_type = OPTI_TYPE_ZERO_BYTE
9352 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9353 dgst_pos0 = 0;
9354 dgst_pos1 = 1;
9355 dgst_pos2 = 2;
9356 dgst_pos3 = 3;
9357 break;
9358
9359 case 8600: hash_type = HASH_TYPE_LOTUS5;
9360 salt_type = SALT_TYPE_NONE;
9361 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9362 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9363 kern_type = KERN_TYPE_LOTUS5;
9364 dgst_size = DGST_SIZE_4_4;
9365 parse_func = lotus5_parse_hash;
9366 sort_by_digest = sort_by_digest_4_4;
9367 opti_type = OPTI_TYPE_EARLY_SKIP
9368 | OPTI_TYPE_NOT_ITERATED
9369 | OPTI_TYPE_NOT_SALTED
9370 | OPTI_TYPE_RAW_HASH;
9371 dgst_pos0 = 0;
9372 dgst_pos1 = 1;
9373 dgst_pos2 = 2;
9374 dgst_pos3 = 3;
9375 break;
9376
9377 case 8700: hash_type = HASH_TYPE_LOTUS6;
9378 salt_type = SALT_TYPE_EMBEDDED;
9379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9380 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9381 kern_type = KERN_TYPE_LOTUS6;
9382 dgst_size = DGST_SIZE_4_4;
9383 parse_func = lotus6_parse_hash;
9384 sort_by_digest = sort_by_digest_4_4;
9385 opti_type = OPTI_TYPE_EARLY_SKIP
9386 | OPTI_TYPE_NOT_ITERATED
9387 | OPTI_TYPE_RAW_HASH;
9388 dgst_pos0 = 0;
9389 dgst_pos1 = 1;
9390 dgst_pos2 = 2;
9391 dgst_pos3 = 3;
9392 break;
9393
9394 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9395 salt_type = SALT_TYPE_EMBEDDED;
9396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9397 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9398 kern_type = KERN_TYPE_ANDROIDFDE;
9399 dgst_size = DGST_SIZE_4_4;
9400 parse_func = androidfde_parse_hash;
9401 sort_by_digest = sort_by_digest_4_4;
9402 opti_type = OPTI_TYPE_ZERO_BYTE;
9403 dgst_pos0 = 0;
9404 dgst_pos1 = 1;
9405 dgst_pos2 = 2;
9406 dgst_pos3 = 3;
9407 break;
9408
9409 case 8900: hash_type = HASH_TYPE_SCRYPT;
9410 salt_type = SALT_TYPE_EMBEDDED;
9411 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9412 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9413 kern_type = KERN_TYPE_SCRYPT;
9414 dgst_size = DGST_SIZE_4_8;
9415 parse_func = scrypt_parse_hash;
9416 sort_by_digest = sort_by_digest_4_8;
9417 opti_type = OPTI_TYPE_ZERO_BYTE;
9418 dgst_pos0 = 0;
9419 dgst_pos1 = 1;
9420 dgst_pos2 = 2;
9421 dgst_pos3 = 3;
9422 break;
9423
9424 case 9000: hash_type = HASH_TYPE_SHA1;
9425 salt_type = SALT_TYPE_EMBEDDED;
9426 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9427 opts_type = OPTS_TYPE_PT_GENERATE_LE
9428 | OPTS_TYPE_ST_GENERATE_LE;
9429 kern_type = KERN_TYPE_PSAFE2;
9430 dgst_size = DGST_SIZE_4_5;
9431 parse_func = psafe2_parse_hash;
9432 sort_by_digest = sort_by_digest_4_5;
9433 opti_type = OPTI_TYPE_ZERO_BYTE;
9434 dgst_pos0 = 0;
9435 dgst_pos1 = 1;
9436 dgst_pos2 = 2;
9437 dgst_pos3 = 3;
9438 break;
9439
9440 case 9100: hash_type = HASH_TYPE_LOTUS8;
9441 salt_type = SALT_TYPE_EMBEDDED;
9442 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9443 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9444 kern_type = KERN_TYPE_LOTUS8;
9445 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9446 parse_func = lotus8_parse_hash;
9447 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9448 opti_type = OPTI_TYPE_ZERO_BYTE;
9449 dgst_pos0 = 0;
9450 dgst_pos1 = 1;
9451 dgst_pos2 = 2;
9452 dgst_pos3 = 3;
9453 break;
9454
9455 case 9200: hash_type = HASH_TYPE_SHA256;
9456 salt_type = SALT_TYPE_EMBEDDED;
9457 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9458 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9459 kern_type = KERN_TYPE_PBKDF2_SHA256;
9460 dgst_size = DGST_SIZE_4_32;
9461 parse_func = cisco8_parse_hash;
9462 sort_by_digest = sort_by_digest_4_32;
9463 opti_type = OPTI_TYPE_ZERO_BYTE
9464 | OPTI_TYPE_SLOW_HASH_SIMD;
9465 dgst_pos0 = 0;
9466 dgst_pos1 = 1;
9467 dgst_pos2 = 2;
9468 dgst_pos3 = 3;
9469 break;
9470
9471 case 9300: hash_type = HASH_TYPE_SCRYPT;
9472 salt_type = SALT_TYPE_EMBEDDED;
9473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9475 kern_type = KERN_TYPE_SCRYPT;
9476 dgst_size = DGST_SIZE_4_8;
9477 parse_func = cisco9_parse_hash;
9478 sort_by_digest = sort_by_digest_4_8;
9479 opti_type = OPTI_TYPE_ZERO_BYTE;
9480 dgst_pos0 = 0;
9481 dgst_pos1 = 1;
9482 dgst_pos2 = 2;
9483 dgst_pos3 = 3;
9484 break;
9485
9486 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9487 salt_type = SALT_TYPE_EMBEDDED;
9488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9490 kern_type = KERN_TYPE_OFFICE2007;
9491 dgst_size = DGST_SIZE_4_4;
9492 parse_func = office2007_parse_hash;
9493 sort_by_digest = sort_by_digest_4_4;
9494 opti_type = OPTI_TYPE_ZERO_BYTE;
9495 dgst_pos0 = 0;
9496 dgst_pos1 = 1;
9497 dgst_pos2 = 2;
9498 dgst_pos3 = 3;
9499 break;
9500
9501 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9502 salt_type = SALT_TYPE_EMBEDDED;
9503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9505 kern_type = KERN_TYPE_OFFICE2010;
9506 dgst_size = DGST_SIZE_4_4;
9507 parse_func = office2010_parse_hash;
9508 sort_by_digest = sort_by_digest_4_4;
9509 opti_type = OPTI_TYPE_ZERO_BYTE;
9510 dgst_pos0 = 0;
9511 dgst_pos1 = 1;
9512 dgst_pos2 = 2;
9513 dgst_pos3 = 3;
9514 break;
9515
9516 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9517 salt_type = SALT_TYPE_EMBEDDED;
9518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9519 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9520 kern_type = KERN_TYPE_OFFICE2013;
9521 dgst_size = DGST_SIZE_4_4;
9522 parse_func = office2013_parse_hash;
9523 sort_by_digest = sort_by_digest_4_4;
9524 opti_type = OPTI_TYPE_ZERO_BYTE;
9525 dgst_pos0 = 0;
9526 dgst_pos1 = 1;
9527 dgst_pos2 = 2;
9528 dgst_pos3 = 3;
9529 break;
9530
9531 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9532 salt_type = SALT_TYPE_EMBEDDED;
9533 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9534 opts_type = OPTS_TYPE_PT_GENERATE_LE
9535 | OPTS_TYPE_PT_ADD80
9536 | OPTS_TYPE_PT_UNICODE;
9537 kern_type = KERN_TYPE_OLDOFFICE01;
9538 dgst_size = DGST_SIZE_4_4;
9539 parse_func = oldoffice01_parse_hash;
9540 sort_by_digest = sort_by_digest_4_4;
9541 opti_type = OPTI_TYPE_ZERO_BYTE
9542 | OPTI_TYPE_PRECOMPUTE_INIT
9543 | OPTI_TYPE_NOT_ITERATED;
9544 dgst_pos0 = 0;
9545 dgst_pos1 = 1;
9546 dgst_pos2 = 2;
9547 dgst_pos3 = 3;
9548 break;
9549
9550 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9551 salt_type = SALT_TYPE_EMBEDDED;
9552 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9553 opts_type = OPTS_TYPE_PT_GENERATE_LE
9554 | OPTS_TYPE_PT_ADD80;
9555 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9556 dgst_size = DGST_SIZE_4_4;
9557 parse_func = oldoffice01cm1_parse_hash;
9558 sort_by_digest = sort_by_digest_4_4;
9559 opti_type = OPTI_TYPE_ZERO_BYTE
9560 | OPTI_TYPE_PRECOMPUTE_INIT
9561 | OPTI_TYPE_NOT_ITERATED;
9562 dgst_pos0 = 0;
9563 dgst_pos1 = 1;
9564 dgst_pos2 = 2;
9565 dgst_pos3 = 3;
9566 break;
9567
9568 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9569 salt_type = SALT_TYPE_EMBEDDED;
9570 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9571 opts_type = OPTS_TYPE_PT_GENERATE_LE
9572 | OPTS_TYPE_PT_ADD80
9573 | OPTS_TYPE_PT_UNICODE
9574 | OPTS_TYPE_PT_NEVERCRACK;
9575 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9576 dgst_size = DGST_SIZE_4_4;
9577 parse_func = oldoffice01cm2_parse_hash;
9578 sort_by_digest = sort_by_digest_4_4;
9579 opti_type = OPTI_TYPE_ZERO_BYTE
9580 | OPTI_TYPE_PRECOMPUTE_INIT
9581 | OPTI_TYPE_NOT_ITERATED;
9582 dgst_pos0 = 0;
9583 dgst_pos1 = 1;
9584 dgst_pos2 = 2;
9585 dgst_pos3 = 3;
9586 break;
9587
9588 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9589 salt_type = SALT_TYPE_EMBEDDED;
9590 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9591 opts_type = OPTS_TYPE_PT_GENERATE_BE
9592 | OPTS_TYPE_PT_ADD80
9593 | OPTS_TYPE_PT_UNICODE;
9594 kern_type = KERN_TYPE_OLDOFFICE34;
9595 dgst_size = DGST_SIZE_4_4;
9596 parse_func = oldoffice34_parse_hash;
9597 sort_by_digest = sort_by_digest_4_4;
9598 opti_type = OPTI_TYPE_ZERO_BYTE
9599 | OPTI_TYPE_PRECOMPUTE_INIT
9600 | OPTI_TYPE_NOT_ITERATED;
9601 dgst_pos0 = 0;
9602 dgst_pos1 = 1;
9603 dgst_pos2 = 2;
9604 dgst_pos3 = 3;
9605 break;
9606
9607 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9608 salt_type = SALT_TYPE_EMBEDDED;
9609 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9610 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9611 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9612 dgst_size = DGST_SIZE_4_4;
9613 parse_func = oldoffice34cm1_parse_hash;
9614 sort_by_digest = sort_by_digest_4_4;
9615 opti_type = OPTI_TYPE_ZERO_BYTE
9616 | OPTI_TYPE_PRECOMPUTE_INIT
9617 | OPTI_TYPE_NOT_ITERATED;
9618 dgst_pos0 = 0;
9619 dgst_pos1 = 1;
9620 dgst_pos2 = 2;
9621 dgst_pos3 = 3;
9622 break;
9623
9624 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9625 salt_type = SALT_TYPE_EMBEDDED;
9626 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9627 opts_type = OPTS_TYPE_PT_GENERATE_BE
9628 | OPTS_TYPE_PT_ADD80
9629 | OPTS_TYPE_PT_UNICODE
9630 | OPTS_TYPE_PT_NEVERCRACK;
9631 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9632 dgst_size = DGST_SIZE_4_4;
9633 parse_func = oldoffice34cm2_parse_hash;
9634 sort_by_digest = sort_by_digest_4_4;
9635 opti_type = OPTI_TYPE_ZERO_BYTE
9636 | OPTI_TYPE_PRECOMPUTE_INIT
9637 | OPTI_TYPE_NOT_ITERATED;
9638 dgst_pos0 = 0;
9639 dgst_pos1 = 1;
9640 dgst_pos2 = 2;
9641 dgst_pos3 = 3;
9642 break;
9643
9644 case 9900: hash_type = HASH_TYPE_MD5;
9645 salt_type = SALT_TYPE_NONE;
9646 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9648 kern_type = KERN_TYPE_RADMIN2;
9649 dgst_size = DGST_SIZE_4_4;
9650 parse_func = radmin2_parse_hash;
9651 sort_by_digest = sort_by_digest_4_4;
9652 opti_type = OPTI_TYPE_ZERO_BYTE
9653 | OPTI_TYPE_PRECOMPUTE_INIT
9654 | OPTI_TYPE_EARLY_SKIP
9655 | OPTI_TYPE_NOT_ITERATED
9656 | OPTI_TYPE_NOT_SALTED;
9657 dgst_pos0 = 0;
9658 dgst_pos1 = 3;
9659 dgst_pos2 = 2;
9660 dgst_pos3 = 1;
9661 break;
9662
9663 case 10000: hash_type = HASH_TYPE_SHA256;
9664 salt_type = SALT_TYPE_EMBEDDED;
9665 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9666 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9667 kern_type = KERN_TYPE_PBKDF2_SHA256;
9668 dgst_size = DGST_SIZE_4_32;
9669 parse_func = djangopbkdf2_parse_hash;
9670 sort_by_digest = sort_by_digest_4_32;
9671 opti_type = OPTI_TYPE_ZERO_BYTE
9672 | OPTI_TYPE_SLOW_HASH_SIMD;
9673 dgst_pos0 = 0;
9674 dgst_pos1 = 1;
9675 dgst_pos2 = 2;
9676 dgst_pos3 = 3;
9677 break;
9678
9679 case 10100: hash_type = HASH_TYPE_SIPHASH;
9680 salt_type = SALT_TYPE_EMBEDDED;
9681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9682 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9683 kern_type = KERN_TYPE_SIPHASH;
9684 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9685 parse_func = siphash_parse_hash;
9686 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9687 opti_type = OPTI_TYPE_ZERO_BYTE
9688 | OPTI_TYPE_NOT_ITERATED
9689 | OPTI_TYPE_RAW_HASH;
9690 dgst_pos0 = 0;
9691 dgst_pos1 = 1;
9692 dgst_pos2 = 2;
9693 dgst_pos3 = 3;
9694 break;
9695
9696 case 10200: hash_type = HASH_TYPE_MD5;
9697 salt_type = SALT_TYPE_EMBEDDED;
9698 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9699 opts_type = OPTS_TYPE_PT_GENERATE_LE
9700 | OPTS_TYPE_ST_ADD80
9701 | OPTS_TYPE_ST_ADDBITS14;
9702 kern_type = KERN_TYPE_HMACMD5_PW;
9703 dgst_size = DGST_SIZE_4_4;
9704 parse_func = crammd5_parse_hash;
9705 sort_by_digest = sort_by_digest_4_4;
9706 opti_type = OPTI_TYPE_ZERO_BYTE
9707 | OPTI_TYPE_NOT_ITERATED;
9708 dgst_pos0 = 0;
9709 dgst_pos1 = 3;
9710 dgst_pos2 = 2;
9711 dgst_pos3 = 1;
9712 break;
9713
9714 case 10300: hash_type = HASH_TYPE_SHA1;
9715 salt_type = SALT_TYPE_EMBEDDED;
9716 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9717 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9718 kern_type = KERN_TYPE_SAPH_SHA1;
9719 dgst_size = DGST_SIZE_4_5;
9720 parse_func = saph_sha1_parse_hash;
9721 sort_by_digest = sort_by_digest_4_5;
9722 opti_type = OPTI_TYPE_ZERO_BYTE;
9723 dgst_pos0 = 0;
9724 dgst_pos1 = 1;
9725 dgst_pos2 = 2;
9726 dgst_pos3 = 3;
9727 break;
9728
9729 case 10400: hash_type = HASH_TYPE_PDFU16;
9730 salt_type = SALT_TYPE_EMBEDDED;
9731 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9732 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9733 kern_type = KERN_TYPE_PDF11;
9734 dgst_size = DGST_SIZE_4_4;
9735 parse_func = pdf11_parse_hash;
9736 sort_by_digest = sort_by_digest_4_4;
9737 opti_type = OPTI_TYPE_ZERO_BYTE
9738 | OPTI_TYPE_NOT_ITERATED;
9739 dgst_pos0 = 0;
9740 dgst_pos1 = 1;
9741 dgst_pos2 = 2;
9742 dgst_pos3 = 3;
9743 break;
9744
9745 case 10410: hash_type = HASH_TYPE_PDFU16;
9746 salt_type = SALT_TYPE_EMBEDDED;
9747 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9748 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9749 kern_type = KERN_TYPE_PDF11CM1;
9750 dgst_size = DGST_SIZE_4_4;
9751 parse_func = pdf11cm1_parse_hash;
9752 sort_by_digest = sort_by_digest_4_4;
9753 opti_type = OPTI_TYPE_ZERO_BYTE
9754 | OPTI_TYPE_NOT_ITERATED;
9755 dgst_pos0 = 0;
9756 dgst_pos1 = 1;
9757 dgst_pos2 = 2;
9758 dgst_pos3 = 3;
9759 break;
9760
9761 case 10420: 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_PDF11CM2;
9766 dgst_size = DGST_SIZE_4_4;
9767 parse_func = pdf11cm2_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 10500: hash_type = HASH_TYPE_PDFU16;
9778 salt_type = SALT_TYPE_EMBEDDED;
9779 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9780 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9781 kern_type = KERN_TYPE_PDF14;
9782 dgst_size = DGST_SIZE_4_4;
9783 parse_func = pdf14_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 10600: hash_type = HASH_TYPE_SHA256;
9794 salt_type = SALT_TYPE_EMBEDDED;
9795 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9796 opts_type = OPTS_TYPE_PT_GENERATE_BE
9797 | OPTS_TYPE_ST_ADD80
9798 | OPTS_TYPE_ST_ADDBITS15
9799 | OPTS_TYPE_HASH_COPY;
9800 kern_type = KERN_TYPE_SHA256_PWSLT;
9801 dgst_size = DGST_SIZE_4_8;
9802 parse_func = pdf17l3_parse_hash;
9803 sort_by_digest = sort_by_digest_4_8;
9804 opti_type = OPTI_TYPE_ZERO_BYTE
9805 | OPTI_TYPE_PRECOMPUTE_INIT
9806 | OPTI_TYPE_PRECOMPUTE_MERKLE
9807 | OPTI_TYPE_EARLY_SKIP
9808 | OPTI_TYPE_NOT_ITERATED
9809 | OPTI_TYPE_APPENDED_SALT
9810 | OPTI_TYPE_RAW_HASH;
9811 dgst_pos0 = 3;
9812 dgst_pos1 = 7;
9813 dgst_pos2 = 2;
9814 dgst_pos3 = 6;
9815 break;
9816
9817 case 10700: hash_type = HASH_TYPE_PDFU32;
9818 salt_type = SALT_TYPE_EMBEDDED;
9819 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9820 opts_type = OPTS_TYPE_PT_GENERATE_LE
9821 | OPTS_TYPE_HASH_COPY;
9822 kern_type = KERN_TYPE_PDF17L8;
9823 dgst_size = DGST_SIZE_4_8;
9824 parse_func = pdf17l8_parse_hash;
9825 sort_by_digest = sort_by_digest_4_8;
9826 opti_type = OPTI_TYPE_ZERO_BYTE
9827 | OPTI_TYPE_NOT_ITERATED;
9828 dgst_pos0 = 0;
9829 dgst_pos1 = 1;
9830 dgst_pos2 = 2;
9831 dgst_pos3 = 3;
9832 break;
9833
9834 case 10800: hash_type = HASH_TYPE_SHA384;
9835 salt_type = SALT_TYPE_NONE;
9836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9837 opts_type = OPTS_TYPE_PT_GENERATE_BE
9838 | OPTS_TYPE_PT_ADD80
9839 | OPTS_TYPE_PT_ADDBITS15;
9840 kern_type = KERN_TYPE_SHA384;
9841 dgst_size = DGST_SIZE_8_8;
9842 parse_func = sha384_parse_hash;
9843 sort_by_digest = sort_by_digest_8_8;
9844 opti_type = OPTI_TYPE_ZERO_BYTE
9845 | OPTI_TYPE_PRECOMPUTE_INIT
9846 | OPTI_TYPE_PRECOMPUTE_MERKLE
9847 | OPTI_TYPE_EARLY_SKIP
9848 | OPTI_TYPE_NOT_ITERATED
9849 | OPTI_TYPE_NOT_SALTED
9850 | OPTI_TYPE_USES_BITS_64
9851 | OPTI_TYPE_RAW_HASH;
9852 dgst_pos0 = 6;
9853 dgst_pos1 = 7;
9854 dgst_pos2 = 4;
9855 dgst_pos3 = 5;
9856 break;
9857
9858 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9859 salt_type = SALT_TYPE_EMBEDDED;
9860 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9861 opts_type = OPTS_TYPE_PT_GENERATE_LE
9862 | OPTS_TYPE_ST_BASE64
9863 | OPTS_TYPE_HASH_COPY;
9864 kern_type = KERN_TYPE_PBKDF2_SHA256;
9865 dgst_size = DGST_SIZE_4_32;
9866 parse_func = pbkdf2_sha256_parse_hash;
9867 sort_by_digest = sort_by_digest_4_32;
9868 opti_type = OPTI_TYPE_ZERO_BYTE
9869 | OPTI_TYPE_SLOW_HASH_SIMD;
9870 dgst_pos0 = 0;
9871 dgst_pos1 = 1;
9872 dgst_pos2 = 2;
9873 dgst_pos3 = 3;
9874 break;
9875
9876 case 11000: hash_type = HASH_TYPE_MD5;
9877 salt_type = SALT_TYPE_INTERN;
9878 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9879 opts_type = OPTS_TYPE_PT_GENERATE_LE
9880 | OPTS_TYPE_PT_ADD80;
9881 kern_type = KERN_TYPE_PRESTASHOP;
9882 dgst_size = DGST_SIZE_4_4;
9883 parse_func = prestashop_parse_hash;
9884 sort_by_digest = sort_by_digest_4_4;
9885 opti_type = OPTI_TYPE_ZERO_BYTE
9886 | OPTI_TYPE_PRECOMPUTE_INIT
9887 | OPTI_TYPE_NOT_ITERATED
9888 | OPTI_TYPE_PREPENDED_SALT;
9889 dgst_pos0 = 0;
9890 dgst_pos1 = 3;
9891 dgst_pos2 = 2;
9892 dgst_pos3 = 1;
9893 break;
9894
9895 case 11100: hash_type = HASH_TYPE_MD5;
9896 salt_type = SALT_TYPE_EMBEDDED;
9897 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9898 opts_type = OPTS_TYPE_PT_GENERATE_LE
9899 | OPTS_TYPE_ST_ADD80;
9900 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9901 dgst_size = DGST_SIZE_4_4;
9902 parse_func = postgresql_auth_parse_hash;
9903 sort_by_digest = sort_by_digest_4_4;
9904 opti_type = OPTI_TYPE_ZERO_BYTE
9905 | OPTI_TYPE_PRECOMPUTE_INIT
9906 | OPTI_TYPE_PRECOMPUTE_MERKLE
9907 | OPTI_TYPE_EARLY_SKIP;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 3;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 1;
9912 break;
9913
9914 case 11200: hash_type = HASH_TYPE_SHA1;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_BE
9918 | OPTS_TYPE_PT_ADD80
9919 | OPTS_TYPE_ST_HEX;
9920 kern_type = KERN_TYPE_MYSQL_AUTH;
9921 dgst_size = DGST_SIZE_4_5;
9922 parse_func = mysql_auth_parse_hash;
9923 sort_by_digest = sort_by_digest_4_5;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_EARLY_SKIP;
9926 dgst_pos0 = 3;
9927 dgst_pos1 = 4;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE
9936 | OPTS_TYPE_ST_HEX
9937 | OPTS_TYPE_ST_ADD80;
9938 kern_type = KERN_TYPE_BITCOIN_WALLET;
9939 dgst_size = DGST_SIZE_4_4;
9940 parse_func = bitcoin_wallet_parse_hash;
9941 sort_by_digest = sort_by_digest_4_4;
9942 opti_type = OPTI_TYPE_ZERO_BYTE;
9943 dgst_pos0 = 0;
9944 dgst_pos1 = 1;
9945 dgst_pos2 = 2;
9946 dgst_pos3 = 3;
9947 break;
9948
9949 case 11400: hash_type = HASH_TYPE_MD5;
9950 salt_type = SALT_TYPE_EMBEDDED;
9951 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9952 opts_type = OPTS_TYPE_PT_GENERATE_LE
9953 | OPTS_TYPE_PT_ADD80
9954 | OPTS_TYPE_HASH_COPY;
9955 kern_type = KERN_TYPE_SIP_AUTH;
9956 dgst_size = DGST_SIZE_4_4;
9957 parse_func = sip_auth_parse_hash;
9958 sort_by_digest = sort_by_digest_4_4;
9959 opti_type = OPTI_TYPE_ZERO_BYTE;
9960 dgst_pos0 = 0;
9961 dgst_pos1 = 3;
9962 dgst_pos2 = 2;
9963 dgst_pos3 = 1;
9964 break;
9965
9966 case 11500: hash_type = HASH_TYPE_CRC32;
9967 salt_type = SALT_TYPE_INTERN;
9968 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9969 opts_type = OPTS_TYPE_PT_GENERATE_LE
9970 | OPTS_TYPE_ST_GENERATE_LE
9971 | OPTS_TYPE_ST_HEX;
9972 kern_type = KERN_TYPE_CRC32;
9973 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9974 parse_func = crc32_parse_hash;
9975 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9976 opti_type = OPTI_TYPE_ZERO_BYTE;
9977 dgst_pos0 = 0;
9978 dgst_pos1 = 1;
9979 dgst_pos2 = 2;
9980 dgst_pos3 = 3;
9981 break;
9982
9983 case 11600: hash_type = HASH_TYPE_AES;
9984 salt_type = SALT_TYPE_EMBEDDED;
9985 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9986 opts_type = OPTS_TYPE_PT_GENERATE_LE
9987 | OPTS_TYPE_PT_NEVERCRACK;
9988 kern_type = KERN_TYPE_SEVEN_ZIP;
9989 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9990 parse_func = seven_zip_parse_hash;
9991 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9992 opti_type = OPTI_TYPE_ZERO_BYTE;
9993 dgst_pos0 = 0;
9994 dgst_pos1 = 1;
9995 dgst_pos2 = 2;
9996 dgst_pos3 = 3;
9997 break;
9998
9999 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10000 salt_type = SALT_TYPE_NONE;
10001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10002 opts_type = OPTS_TYPE_PT_GENERATE_LE
10003 | OPTS_TYPE_PT_ADD01;
10004 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10005 dgst_size = DGST_SIZE_4_8;
10006 parse_func = gost2012sbog_256_parse_hash;
10007 sort_by_digest = sort_by_digest_4_8;
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 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10016 salt_type = SALT_TYPE_NONE;
10017 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10018 opts_type = OPTS_TYPE_PT_GENERATE_LE
10019 | OPTS_TYPE_PT_ADD01;
10020 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10021 dgst_size = DGST_SIZE_4_16;
10022 parse_func = gost2012sbog_512_parse_hash;
10023 sort_by_digest = sort_by_digest_4_16;
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 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10032 salt_type = SALT_TYPE_EMBEDDED;
10033 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10034 opts_type = OPTS_TYPE_PT_GENERATE_LE
10035 | OPTS_TYPE_ST_BASE64
10036 | OPTS_TYPE_HASH_COPY;
10037 kern_type = KERN_TYPE_PBKDF2_MD5;
10038 dgst_size = DGST_SIZE_4_32;
10039 parse_func = pbkdf2_md5_parse_hash;
10040 sort_by_digest = sort_by_digest_4_32;
10041 opti_type = OPTI_TYPE_ZERO_BYTE
10042 | OPTI_TYPE_SLOW_HASH_SIMD;
10043 dgst_pos0 = 0;
10044 dgst_pos1 = 1;
10045 dgst_pos2 = 2;
10046 dgst_pos3 = 3;
10047 break;
10048
10049 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10050 salt_type = SALT_TYPE_EMBEDDED;
10051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10052 opts_type = OPTS_TYPE_PT_GENERATE_LE
10053 | OPTS_TYPE_ST_BASE64
10054 | OPTS_TYPE_HASH_COPY;
10055 kern_type = KERN_TYPE_PBKDF2_SHA1;
10056 dgst_size = DGST_SIZE_4_32;
10057 parse_func = pbkdf2_sha1_parse_hash;
10058 sort_by_digest = sort_by_digest_4_32;
10059 opti_type = OPTI_TYPE_ZERO_BYTE
10060 | OPTI_TYPE_SLOW_HASH_SIMD;
10061 dgst_pos0 = 0;
10062 dgst_pos1 = 1;
10063 dgst_pos2 = 2;
10064 dgst_pos3 = 3;
10065 break;
10066
10067 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10068 salt_type = SALT_TYPE_EMBEDDED;
10069 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10070 opts_type = OPTS_TYPE_PT_GENERATE_LE
10071 | OPTS_TYPE_ST_BASE64
10072 | OPTS_TYPE_HASH_COPY;
10073 kern_type = KERN_TYPE_PBKDF2_SHA512;
10074 dgst_size = DGST_SIZE_8_16;
10075 parse_func = pbkdf2_sha512_parse_hash;
10076 sort_by_digest = sort_by_digest_8_16;
10077 opti_type = OPTI_TYPE_ZERO_BYTE
10078 | OPTI_TYPE_USES_BITS_64
10079 | OPTI_TYPE_SLOW_HASH_SIMD;
10080 dgst_pos0 = 0;
10081 dgst_pos1 = 1;
10082 dgst_pos2 = 2;
10083 dgst_pos3 = 3;
10084 break;
10085
10086 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10087 salt_type = SALT_TYPE_EMBEDDED;
10088 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10089 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10090 kern_type = KERN_TYPE_ECRYPTFS;
10091 dgst_size = DGST_SIZE_8_8;
10092 parse_func = ecryptfs_parse_hash;
10093 sort_by_digest = sort_by_digest_8_8;
10094 opti_type = OPTI_TYPE_ZERO_BYTE
10095 | OPTI_TYPE_USES_BITS_64;
10096 dgst_pos0 = 0;
10097 dgst_pos1 = 1;
10098 dgst_pos2 = 2;
10099 dgst_pos3 = 3;
10100 break;
10101
10102 case 12300: hash_type = HASH_TYPE_ORACLET;
10103 salt_type = SALT_TYPE_EMBEDDED;
10104 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10105 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10106 kern_type = KERN_TYPE_ORACLET;
10107 dgst_size = DGST_SIZE_8_16;
10108 parse_func = oraclet_parse_hash;
10109 sort_by_digest = sort_by_digest_8_16;
10110 opti_type = OPTI_TYPE_ZERO_BYTE
10111 | OPTI_TYPE_USES_BITS_64;
10112 dgst_pos0 = 0;
10113 dgst_pos1 = 1;
10114 dgst_pos2 = 2;
10115 dgst_pos3 = 3;
10116 break;
10117
10118 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
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_BSDICRYPT;
10123 dgst_size = DGST_SIZE_4_4;
10124 parse_func = bsdicrypt_parse_hash;
10125 sort_by_digest = sort_by_digest_4_4;
10126 opti_type = OPTI_TYPE_ZERO_BYTE
10127 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10128 dgst_pos0 = 0;
10129 dgst_pos1 = 1;
10130 dgst_pos2 = 2;
10131 dgst_pos3 = 3;
10132 break;
10133
10134 case 12500: hash_type = HASH_TYPE_RAR3HP;
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_RAR3;
10139 dgst_size = DGST_SIZE_4_4;
10140 parse_func = rar3hp_parse_hash;
10141 sort_by_digest = sort_by_digest_4_4;
10142 opti_type = OPTI_TYPE_ZERO_BYTE;
10143 dgst_pos0 = 0;
10144 dgst_pos1 = 1;
10145 dgst_pos2 = 2;
10146 dgst_pos3 = 3;
10147 break;
10148
10149 case 12600: hash_type = HASH_TYPE_SHA256;
10150 salt_type = SALT_TYPE_INTERN;
10151 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10152 opts_type = OPTS_TYPE_PT_GENERATE_BE
10153 | OPTS_TYPE_PT_ADD80;
10154 kern_type = KERN_TYPE_CF10;
10155 dgst_size = DGST_SIZE_4_8;
10156 parse_func = cf10_parse_hash;
10157 sort_by_digest = sort_by_digest_4_8;
10158 opti_type = OPTI_TYPE_ZERO_BYTE
10159 | OPTI_TYPE_PRECOMPUTE_INIT
10160 | OPTI_TYPE_EARLY_SKIP
10161 | OPTI_TYPE_NOT_ITERATED;
10162 dgst_pos0 = 3;
10163 dgst_pos1 = 7;
10164 dgst_pos2 = 2;
10165 dgst_pos3 = 6;
10166 break;
10167
10168 case 12700: hash_type = HASH_TYPE_AES;
10169 salt_type = SALT_TYPE_EMBEDDED;
10170 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10171 opts_type = OPTS_TYPE_PT_GENERATE_LE
10172 | OPTS_TYPE_HASH_COPY;
10173 kern_type = KERN_TYPE_MYWALLET;
10174 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10175 parse_func = mywallet_parse_hash;
10176 sort_by_digest = sort_by_digest_4_5;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 1;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 3;
10182 break;
10183
10184 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10185 salt_type = SALT_TYPE_EMBEDDED;
10186 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10188 kern_type = KERN_TYPE_MS_DRSR;
10189 dgst_size = DGST_SIZE_4_8;
10190 parse_func = ms_drsr_parse_hash;
10191 sort_by_digest = sort_by_digest_4_8;
10192 opti_type = OPTI_TYPE_ZERO_BYTE;
10193 dgst_pos0 = 0;
10194 dgst_pos1 = 1;
10195 dgst_pos2 = 2;
10196 dgst_pos3 = 3;
10197 break;
10198
10199 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10200 salt_type = SALT_TYPE_EMBEDDED;
10201 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10202 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10203 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10204 dgst_size = DGST_SIZE_4_8;
10205 parse_func = androidfde_samsung_parse_hash;
10206 sort_by_digest = sort_by_digest_4_8;
10207 opti_type = OPTI_TYPE_ZERO_BYTE;
10208 dgst_pos0 = 0;
10209 dgst_pos1 = 1;
10210 dgst_pos2 = 2;
10211 dgst_pos3 = 3;
10212 break;
10213
10214 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10215 salt_type = SALT_TYPE_EMBEDDED;
10216 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10217 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10218 kern_type = KERN_TYPE_RAR5;
10219 dgst_size = DGST_SIZE_4_4;
10220 parse_func = rar5_parse_hash;
10221 sort_by_digest = sort_by_digest_4_4;
10222 opti_type = OPTI_TYPE_ZERO_BYTE;
10223 dgst_pos0 = 0;
10224 dgst_pos1 = 1;
10225 dgst_pos2 = 2;
10226 dgst_pos3 = 3;
10227 break;
10228
10229 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10230 salt_type = SALT_TYPE_EMBEDDED;
10231 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10232 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10233 kern_type = KERN_TYPE_KRB5TGS;
10234 dgst_size = DGST_SIZE_4_4;
10235 parse_func = krb5tgs_parse_hash;
10236 sort_by_digest = sort_by_digest_4_4;
10237 opti_type = OPTI_TYPE_ZERO_BYTE
10238 | OPTI_TYPE_NOT_ITERATED;
10239 dgst_pos0 = 0;
10240 dgst_pos1 = 1;
10241 dgst_pos2 = 2;
10242 dgst_pos3 = 3;
10243 break;
10244
10245 case 13200: hash_type = HASH_TYPE_AES;
10246 salt_type = SALT_TYPE_EMBEDDED;
10247 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10248 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10249 kern_type = KERN_TYPE_AXCRYPT;
10250 dgst_size = DGST_SIZE_4_4;
10251 parse_func = axcrypt_parse_hash;
10252 sort_by_digest = sort_by_digest_4_4;
10253 opti_type = OPTI_TYPE_ZERO_BYTE;
10254 dgst_pos0 = 0;
10255 dgst_pos1 = 1;
10256 dgst_pos2 = 2;
10257 dgst_pos3 = 3;
10258 break;
10259
10260 case 13300: hash_type = HASH_TYPE_SHA1;
10261 salt_type = SALT_TYPE_NONE;
10262 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10263 opts_type = OPTS_TYPE_PT_GENERATE_BE
10264 | OPTS_TYPE_PT_ADD80
10265 | OPTS_TYPE_PT_ADDBITS15;
10266 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10267 dgst_size = DGST_SIZE_4_5;
10268 parse_func = sha1axcrypt_parse_hash;
10269 sort_by_digest = sort_by_digest_4_5;
10270 opti_type = OPTI_TYPE_ZERO_BYTE
10271 | OPTI_TYPE_PRECOMPUTE_INIT
10272 | OPTI_TYPE_EARLY_SKIP
10273 | OPTI_TYPE_NOT_ITERATED
10274 | OPTI_TYPE_NOT_SALTED;
10275 dgst_pos0 = 0;
10276 dgst_pos1 = 4;
10277 dgst_pos2 = 3;
10278 dgst_pos3 = 2;
10279 break;
10280
10281 case 13400: hash_type = HASH_TYPE_AES;
10282 salt_type = SALT_TYPE_EMBEDDED;
10283 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10284 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10285 kern_type = KERN_TYPE_KEEPASS;
10286 dgst_size = DGST_SIZE_4_4;
10287 parse_func = keepass_parse_hash;
10288 sort_by_digest = sort_by_digest_4_4;
10289 opti_type = OPTI_TYPE_ZERO_BYTE;
10290 dgst_pos0 = 0;
10291 dgst_pos1 = 1;
10292 dgst_pos2 = 2;
10293 dgst_pos3 = 3;
10294 break;
10295
10296 case 13500: hash_type = HASH_TYPE_SHA1;
10297 salt_type = SALT_TYPE_EMBEDDED;
10298 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10299 opts_type = OPTS_TYPE_PT_GENERATE_BE
10300 | OPTS_TYPE_PT_UNICODE
10301 | OPTS_TYPE_PT_ADD80;
10302 kern_type = KERN_TYPE_PSTOKEN;
10303 dgst_size = DGST_SIZE_4_5;
10304 parse_func = pstoken_parse_hash;
10305 sort_by_digest = sort_by_digest_4_5;
10306 opti_type = OPTI_TYPE_ZERO_BYTE
10307 | OPTI_TYPE_PRECOMPUTE_INIT
10308 | OPTI_TYPE_EARLY_SKIP
10309 | OPTI_TYPE_NOT_ITERATED
10310 | OPTI_TYPE_PREPENDED_SALT
10311 | OPTI_TYPE_RAW_HASH;
10312 dgst_pos0 = 3;
10313 dgst_pos1 = 4;
10314 dgst_pos2 = 2;
10315 dgst_pos3 = 1;
10316 break;
10317
10318 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10319 salt_type = SALT_TYPE_EMBEDDED;
10320 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10321 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10322 kern_type = KERN_TYPE_ZIP2;
10323 dgst_size = DGST_SIZE_4_4;
10324 parse_func = zip2_parse_hash;
10325 sort_by_digest = sort_by_digest_4_4;
10326 opti_type = OPTI_TYPE_ZERO_BYTE;
10327 dgst_pos0 = 0;
10328 dgst_pos1 = 1;
10329 dgst_pos2 = 2;
10330 dgst_pos3 = 3;
10331 break;
10332
10333 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10334 salt_type = SALT_TYPE_EMBEDDED;
10335 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10336 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10337 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10338 dgst_size = DGST_SIZE_4_5;
10339 parse_func = veracrypt_parse_hash_655331;
10340 sort_by_digest = sort_by_digest_4_5;
10341 opti_type = OPTI_TYPE_ZERO_BYTE;
10342 dgst_pos0 = 0;
10343 dgst_pos1 = 1;
10344 dgst_pos2 = 2;
10345 dgst_pos3 = 3;
10346 break;
10347
10348 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10349 salt_type = SALT_TYPE_EMBEDDED;
10350 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10351 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10352 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10353 dgst_size = DGST_SIZE_4_5;
10354 parse_func = veracrypt_parse_hash_655331;
10355 sort_by_digest = sort_by_digest_4_5;
10356 opti_type = OPTI_TYPE_ZERO_BYTE;
10357 dgst_pos0 = 0;
10358 dgst_pos1 = 1;
10359 dgst_pos2 = 2;
10360 dgst_pos3 = 3;
10361 break;
10362
10363 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10364 salt_type = SALT_TYPE_EMBEDDED;
10365 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10366 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10367 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10368 dgst_size = DGST_SIZE_4_5;
10369 parse_func = veracrypt_parse_hash_655331;
10370 sort_by_digest = sort_by_digest_4_5;
10371 opti_type = OPTI_TYPE_ZERO_BYTE;
10372 dgst_pos0 = 0;
10373 dgst_pos1 = 1;
10374 dgst_pos2 = 2;
10375 dgst_pos3 = 3;
10376 break;
10377
10378 case 13721: hash_type = HASH_TYPE_SHA512;
10379 salt_type = SALT_TYPE_EMBEDDED;
10380 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10381 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10382 kern_type = KERN_TYPE_TCSHA512_XTS512;
10383 dgst_size = DGST_SIZE_8_8;
10384 parse_func = veracrypt_parse_hash_500000;
10385 sort_by_digest = sort_by_digest_8_8;
10386 opti_type = OPTI_TYPE_ZERO_BYTE
10387 | OPTI_TYPE_USES_BITS_64;
10388 dgst_pos0 = 0;
10389 dgst_pos1 = 1;
10390 dgst_pos2 = 2;
10391 dgst_pos3 = 3;
10392 break;
10393
10394 case 13722: hash_type = HASH_TYPE_SHA512;
10395 salt_type = SALT_TYPE_EMBEDDED;
10396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10397 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10398 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10399 dgst_size = DGST_SIZE_8_8;
10400 parse_func = veracrypt_parse_hash_500000;
10401 sort_by_digest = sort_by_digest_8_8;
10402 opti_type = OPTI_TYPE_ZERO_BYTE
10403 | OPTI_TYPE_USES_BITS_64;
10404 dgst_pos0 = 0;
10405 dgst_pos1 = 1;
10406 dgst_pos2 = 2;
10407 dgst_pos3 = 3;
10408 break;
10409
10410 case 13723: 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_XTS1536;
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 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10427 salt_type = SALT_TYPE_EMBEDDED;
10428 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10429 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10430 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10431 dgst_size = DGST_SIZE_4_8;
10432 parse_func = veracrypt_parse_hash_500000;
10433 sort_by_digest = sort_by_digest_4_8;
10434 opti_type = OPTI_TYPE_ZERO_BYTE;
10435 dgst_pos0 = 0;
10436 dgst_pos1 = 1;
10437 dgst_pos2 = 2;
10438 dgst_pos3 = 3;
10439 break;
10440
10441 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10442 salt_type = SALT_TYPE_EMBEDDED;
10443 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10444 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10445 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10446 dgst_size = DGST_SIZE_4_8;
10447 parse_func = veracrypt_parse_hash_500000;
10448 sort_by_digest = sort_by_digest_4_8;
10449 opti_type = OPTI_TYPE_ZERO_BYTE;
10450 dgst_pos0 = 0;
10451 dgst_pos1 = 1;
10452 dgst_pos2 = 2;
10453 dgst_pos3 = 3;
10454 break;
10455
10456 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10457 salt_type = SALT_TYPE_EMBEDDED;
10458 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10459 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10460 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10461 dgst_size = DGST_SIZE_4_8;
10462 parse_func = veracrypt_parse_hash_500000;
10463 sort_by_digest = sort_by_digest_4_8;
10464 opti_type = OPTI_TYPE_ZERO_BYTE;
10465 dgst_pos0 = 0;
10466 dgst_pos1 = 1;
10467 dgst_pos2 = 2;
10468 dgst_pos3 = 3;
10469 break;
10470
10471 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10472 salt_type = SALT_TYPE_EMBEDDED;
10473 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10474 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10475 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10476 dgst_size = DGST_SIZE_4_5;
10477 parse_func = veracrypt_parse_hash_327661;
10478 sort_by_digest = sort_by_digest_4_5;
10479 opti_type = OPTI_TYPE_ZERO_BYTE;
10480 dgst_pos0 = 0;
10481 dgst_pos1 = 1;
10482 dgst_pos2 = 2;
10483 dgst_pos3 = 3;
10484 break;
10485
10486 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10487 salt_type = SALT_TYPE_EMBEDDED;
10488 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10489 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10490 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10491 dgst_size = DGST_SIZE_4_5;
10492 parse_func = veracrypt_parse_hash_327661;
10493 sort_by_digest = sort_by_digest_4_5;
10494 opti_type = OPTI_TYPE_ZERO_BYTE;
10495 dgst_pos0 = 0;
10496 dgst_pos1 = 1;
10497 dgst_pos2 = 2;
10498 dgst_pos3 = 3;
10499 break;
10500
10501 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10502 salt_type = SALT_TYPE_EMBEDDED;
10503 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10504 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10505 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10506 dgst_size = DGST_SIZE_4_5;
10507 parse_func = veracrypt_parse_hash_327661;
10508 sort_by_digest = sort_by_digest_4_5;
10509 opti_type = OPTI_TYPE_ZERO_BYTE;
10510 dgst_pos0 = 0;
10511 dgst_pos1 = 1;
10512 dgst_pos2 = 2;
10513 dgst_pos3 = 3;
10514 break;
10515
10516 case 13751: hash_type = HASH_TYPE_SHA256;
10517 salt_type = SALT_TYPE_EMBEDDED;
10518 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10519 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10520 kern_type = KERN_TYPE_VCSHA256_XTS512;
10521 dgst_size = DGST_SIZE_4_8;
10522 parse_func = veracrypt_parse_hash_500000;
10523 sort_by_digest = sort_by_digest_4_8;
10524 opti_type = OPTI_TYPE_ZERO_BYTE;
10525 dgst_pos0 = 0;
10526 dgst_pos1 = 1;
10527 dgst_pos2 = 2;
10528 dgst_pos3 = 3;
10529 break;
10530
10531 case 13752: hash_type = HASH_TYPE_SHA256;
10532 salt_type = SALT_TYPE_EMBEDDED;
10533 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10534 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10535 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10536 dgst_size = DGST_SIZE_4_8;
10537 parse_func = veracrypt_parse_hash_500000;
10538 sort_by_digest = sort_by_digest_4_8;
10539 opti_type = OPTI_TYPE_ZERO_BYTE;
10540 dgst_pos0 = 0;
10541 dgst_pos1 = 1;
10542 dgst_pos2 = 2;
10543 dgst_pos3 = 3;
10544 break;
10545
10546 case 13753: hash_type = HASH_TYPE_SHA256;
10547 salt_type = SALT_TYPE_EMBEDDED;
10548 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10549 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10550 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10551 dgst_size = DGST_SIZE_4_8;
10552 parse_func = veracrypt_parse_hash_500000;
10553 sort_by_digest = sort_by_digest_4_8;
10554 opti_type = OPTI_TYPE_ZERO_BYTE;
10555 dgst_pos0 = 0;
10556 dgst_pos1 = 1;
10557 dgst_pos2 = 2;
10558 dgst_pos3 = 3;
10559 break;
10560
10561 case 13761: hash_type = HASH_TYPE_SHA256;
10562 salt_type = SALT_TYPE_EMBEDDED;
10563 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10564 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10565 kern_type = KERN_TYPE_VCSHA256_XTS512;
10566 dgst_size = DGST_SIZE_4_8;
10567 parse_func = veracrypt_parse_hash_200000;
10568 sort_by_digest = sort_by_digest_4_8;
10569 opti_type = OPTI_TYPE_ZERO_BYTE;
10570 dgst_pos0 = 0;
10571 dgst_pos1 = 1;
10572 dgst_pos2 = 2;
10573 dgst_pos3 = 3;
10574 break;
10575
10576 case 13762: hash_type = HASH_TYPE_SHA256;
10577 salt_type = SALT_TYPE_EMBEDDED;
10578 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10579 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10580 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10581 dgst_size = DGST_SIZE_4_8;
10582 parse_func = veracrypt_parse_hash_200000;
10583 sort_by_digest = sort_by_digest_4_8;
10584 opti_type = OPTI_TYPE_ZERO_BYTE;
10585 dgst_pos0 = 0;
10586 dgst_pos1 = 1;
10587 dgst_pos2 = 2;
10588 dgst_pos3 = 3;
10589 break;
10590
10591 case 13763: hash_type = HASH_TYPE_SHA256;
10592 salt_type = SALT_TYPE_EMBEDDED;
10593 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10594 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10595 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10596 dgst_size = DGST_SIZE_4_8;
10597 parse_func = veracrypt_parse_hash_200000;
10598 sort_by_digest = sort_by_digest_4_8;
10599 opti_type = OPTI_TYPE_ZERO_BYTE;
10600 dgst_pos0 = 0;
10601 dgst_pos1 = 1;
10602 dgst_pos2 = 2;
10603 dgst_pos3 = 3;
10604 break;
10605
10606
10607 default: usage_mini_print (PROGNAME); return (-1);
10608 }
10609
10610 /**
10611 * parser
10612 */
10613
10614 data.parse_func = parse_func;
10615
10616 /**
10617 * misc stuff
10618 */
10619
10620 if (hex_salt)
10621 {
10622 if (salt_type == SALT_TYPE_INTERN)
10623 {
10624 opts_type |= OPTS_TYPE_ST_HEX;
10625 }
10626 else
10627 {
10628 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10629
10630 return (-1);
10631 }
10632 }
10633
10634 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10635 | (salt_type == SALT_TYPE_EXTERN)
10636 | (salt_type == SALT_TYPE_EMBEDDED)
10637 | (salt_type == SALT_TYPE_VIRTUAL));
10638
10639 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10640
10641 data.hash_type = hash_type;
10642 data.attack_mode = attack_mode;
10643 data.attack_kern = attack_kern;
10644 data.attack_exec = attack_exec;
10645 data.kern_type = kern_type;
10646 data.opts_type = opts_type;
10647 data.dgst_size = dgst_size;
10648 data.salt_type = salt_type;
10649 data.isSalted = isSalted;
10650 data.sort_by_digest = sort_by_digest;
10651 data.dgst_pos0 = dgst_pos0;
10652 data.dgst_pos1 = dgst_pos1;
10653 data.dgst_pos2 = dgst_pos2;
10654 data.dgst_pos3 = dgst_pos3;
10655
10656 esalt_size = 0;
10657
10658 switch (hash_mode)
10659 {
10660 case 2500: esalt_size = sizeof (wpa_t); break;
10661 case 5300: esalt_size = sizeof (ikepsk_t); break;
10662 case 5400: esalt_size = sizeof (ikepsk_t); break;
10663 case 5500: esalt_size = sizeof (netntlm_t); break;
10664 case 5600: esalt_size = sizeof (netntlm_t); break;
10665 case 6211: esalt_size = sizeof (tc_t); break;
10666 case 6212: esalt_size = sizeof (tc_t); break;
10667 case 6213: esalt_size = sizeof (tc_t); break;
10668 case 6221: esalt_size = sizeof (tc_t); break;
10669 case 6222: esalt_size = sizeof (tc_t); break;
10670 case 6223: esalt_size = sizeof (tc_t); break;
10671 case 6231: esalt_size = sizeof (tc_t); break;
10672 case 6232: esalt_size = sizeof (tc_t); break;
10673 case 6233: esalt_size = sizeof (tc_t); break;
10674 case 6241: esalt_size = sizeof (tc_t); break;
10675 case 6242: esalt_size = sizeof (tc_t); break;
10676 case 6243: esalt_size = sizeof (tc_t); break;
10677 case 6600: esalt_size = sizeof (agilekey_t); break;
10678 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10679 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10680 case 7300: esalt_size = sizeof (rakp_t); break;
10681 case 7500: esalt_size = sizeof (krb5pa_t); break;
10682 case 8200: esalt_size = sizeof (cloudkey_t); break;
10683 case 8800: esalt_size = sizeof (androidfde_t); break;
10684 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10685 case 9400: esalt_size = sizeof (office2007_t); break;
10686 case 9500: esalt_size = sizeof (office2010_t); break;
10687 case 9600: esalt_size = sizeof (office2013_t); break;
10688 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10689 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10690 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10691 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10692 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10693 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10694 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10695 case 10200: esalt_size = sizeof (cram_md5_t); break;
10696 case 10400: esalt_size = sizeof (pdf_t); break;
10697 case 10410: esalt_size = sizeof (pdf_t); break;
10698 case 10420: esalt_size = sizeof (pdf_t); break;
10699 case 10500: esalt_size = sizeof (pdf_t); break;
10700 case 10600: esalt_size = sizeof (pdf_t); break;
10701 case 10700: esalt_size = sizeof (pdf_t); break;
10702 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10703 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10704 case 11400: esalt_size = sizeof (sip_t); break;
10705 case 11600: esalt_size = sizeof (seven_zip_t); break;
10706 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10707 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10708 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10709 case 13000: esalt_size = sizeof (rar5_t); break;
10710 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10711 case 13400: esalt_size = sizeof (keepass_t); break;
10712 case 13500: esalt_size = sizeof (pstoken_t); break;
10713 case 13600: esalt_size = sizeof (zip2_t); break;
10714 case 13711: esalt_size = sizeof (tc_t); break;
10715 case 13712: esalt_size = sizeof (tc_t); break;
10716 case 13713: esalt_size = sizeof (tc_t); break;
10717 case 13721: esalt_size = sizeof (tc_t); break;
10718 case 13722: esalt_size = sizeof (tc_t); break;
10719 case 13723: esalt_size = sizeof (tc_t); break;
10720 case 13731: esalt_size = sizeof (tc_t); break;
10721 case 13732: esalt_size = sizeof (tc_t); break;
10722 case 13733: esalt_size = sizeof (tc_t); break;
10723 case 13741: esalt_size = sizeof (tc_t); break;
10724 case 13742: esalt_size = sizeof (tc_t); break;
10725 case 13743: esalt_size = sizeof (tc_t); break;
10726 case 13751: esalt_size = sizeof (tc_t); break;
10727 case 13752: esalt_size = sizeof (tc_t); break;
10728 case 13753: esalt_size = sizeof (tc_t); break;
10729 case 13761: esalt_size = sizeof (tc_t); break;
10730 case 13762: esalt_size = sizeof (tc_t); break;
10731 case 13763: esalt_size = sizeof (tc_t); break;
10732 }
10733
10734 data.esalt_size = esalt_size;
10735
10736 /**
10737 * choose dictionary parser
10738 */
10739
10740 if (hash_type == HASH_TYPE_LM)
10741 {
10742 get_next_word_func = get_next_word_lm;
10743 }
10744 else if (opts_type & OPTS_TYPE_PT_UPPER)
10745 {
10746 get_next_word_func = get_next_word_uc;
10747 }
10748 else
10749 {
10750 get_next_word_func = get_next_word_std;
10751 }
10752
10753 /**
10754 * dictstat
10755 */
10756
10757 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10758
10759 #ifdef _POSIX
10760 size_t dictstat_nmemb = 0;
10761 #endif
10762
10763 #ifdef _WIN
10764 uint dictstat_nmemb = 0;
10765 #endif
10766
10767 char dictstat[256] = { 0 };
10768
10769 FILE *dictstat_fp = NULL;
10770
10771 if (keyspace == 0)
10772 {
10773 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10774
10775 dictstat_fp = fopen (dictstat, "rb");
10776
10777 if (dictstat_fp)
10778 {
10779 #ifdef _POSIX
10780 struct stat tmpstat;
10781
10782 fstat (fileno (dictstat_fp), &tmpstat);
10783 #endif
10784
10785 #ifdef _WIN
10786 struct stat64 tmpstat;
10787
10788 _fstat64 (fileno (dictstat_fp), &tmpstat);
10789 #endif
10790
10791 if (tmpstat.st_mtime < COMPTIME)
10792 {
10793 /* with v0.15 the format changed so we have to ensure user is using a good version
10794 since there is no version-header in the dictstat file */
10795
10796 fclose (dictstat_fp);
10797
10798 unlink (dictstat);
10799 }
10800 else
10801 {
10802 while (!feof (dictstat_fp))
10803 {
10804 dictstat_t d;
10805
10806 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10807
10808 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10809
10810 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10811 {
10812 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10813
10814 return -1;
10815 }
10816 }
10817
10818 fclose (dictstat_fp);
10819 }
10820 }
10821 }
10822
10823 /**
10824 * potfile
10825 */
10826
10827 char potfile[256] = { 0 };
10828
10829 if (potfile_path == NULL)
10830 {
10831 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10832 }
10833 else
10834 {
10835 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10836 }
10837
10838 data.pot_fp = NULL;
10839
10840 FILE *out_fp = NULL;
10841 FILE *pot_fp = NULL;
10842
10843 if (show == 1 || left == 1)
10844 {
10845 pot_fp = fopen (potfile, "rb");
10846
10847 if (pot_fp == NULL)
10848 {
10849 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10850
10851 return (-1);
10852 }
10853
10854 if (outfile != NULL)
10855 {
10856 if ((out_fp = fopen (outfile, "ab")) == NULL)
10857 {
10858 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10859
10860 fclose (pot_fp);
10861
10862 return (-1);
10863 }
10864 }
10865 else
10866 {
10867 out_fp = stdout;
10868 }
10869 }
10870 else
10871 {
10872 if (potfile_disable == 0)
10873 {
10874 pot_fp = fopen (potfile, "ab");
10875
10876 if (pot_fp == NULL)
10877 {
10878 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10879
10880 return (-1);
10881 }
10882
10883 data.pot_fp = pot_fp;
10884 }
10885 }
10886
10887 pot_t *pot = NULL;
10888
10889 uint pot_cnt = 0;
10890 uint pot_avail = 0;
10891
10892 if (show == 1 || left == 1)
10893 {
10894 SUPPRESS_OUTPUT = 1;
10895
10896 pot_avail = count_lines (pot_fp);
10897
10898 rewind (pot_fp);
10899
10900 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10901
10902 uint pot_hashes_avail = 0;
10903
10904 uint line_num = 0;
10905
10906 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10907
10908 while (!feof (pot_fp))
10909 {
10910 line_num++;
10911
10912 int line_len = fgetl (pot_fp, line_buf);
10913
10914 if (line_len == 0) continue;
10915
10916 char *plain_buf = line_buf + line_len;
10917
10918 pot_t *pot_ptr = &pot[pot_cnt];
10919
10920 hash_t *hashes_buf = &pot_ptr->hash;
10921
10922 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10923 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10924
10925 if (pot_cnt == pot_hashes_avail)
10926 {
10927 uint pos = 0;
10928
10929 for (pos = 0; pos < INCR_POT; pos++)
10930 {
10931 if ((pot_cnt + pos) >= pot_avail) break;
10932
10933 pot_t *tmp_pot = &pot[pot_cnt + pos];
10934
10935 hash_t *tmp_hash = &tmp_pot->hash;
10936
10937 tmp_hash->digest = mymalloc (dgst_size);
10938
10939 if (isSalted)
10940 {
10941 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10942 }
10943
10944 if (esalt_size)
10945 {
10946 tmp_hash->esalt = mymalloc (esalt_size);
10947 }
10948
10949 pot_hashes_avail++;
10950 }
10951 }
10952
10953 int plain_len = 0;
10954
10955 int parser_status;
10956
10957 int iter = MAX_CUT_TRIES;
10958
10959 do
10960 {
10961 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10962 {
10963 if (line_buf[i] == ':')
10964 {
10965 line_len--;
10966
10967 break;
10968 }
10969 }
10970
10971 if (data.hash_mode != 2500)
10972 {
10973 parser_status = parse_func (line_buf, line_len, hashes_buf);
10974 }
10975 else
10976 {
10977 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10978
10979 if (line_len > max_salt_size)
10980 {
10981 parser_status = PARSER_GLOBAL_LENGTH;
10982 }
10983 else
10984 {
10985 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10986
10987 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10988
10989 hashes_buf->salt->salt_len = line_len;
10990
10991 parser_status = PARSER_OK;
10992 }
10993 }
10994
10995 // if NOT parsed without error, we add the ":" to the plain
10996
10997 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10998 {
10999 plain_len++;
11000 plain_buf--;
11001 }
11002
11003 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11004
11005 if (parser_status < PARSER_GLOBAL_ZERO)
11006 {
11007 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11008
11009 continue;
11010 }
11011
11012 if (plain_len >= 255) continue;
11013
11014 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11015
11016 pot_ptr->plain_len = plain_len;
11017
11018 pot_cnt++;
11019 }
11020
11021 myfree (line_buf);
11022
11023 fclose (pot_fp);
11024
11025 SUPPRESS_OUTPUT = 0;
11026
11027 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11028 }
11029
11030 /**
11031 * word len
11032 */
11033
11034 uint pw_min = PW_MIN;
11035 uint pw_max = PW_MAX;
11036
11037 switch (hash_mode)
11038 {
11039 case 125: if (pw_max > 32) pw_max = 32;
11040 break;
11041 case 400: if (pw_max > 40) pw_max = 40;
11042 break;
11043 case 500: if (pw_max > 16) pw_max = 16;
11044 break;
11045 case 1500: if (pw_max > 8) pw_max = 8;
11046 break;
11047 case 1600: if (pw_max > 16) pw_max = 16;
11048 break;
11049 case 1800: if (pw_max > 16) pw_max = 16;
11050 break;
11051 case 2100: if (pw_max > 16) pw_max = 16;
11052 break;
11053 case 2500: if (pw_min < 8) pw_min = 8;
11054 break;
11055 case 3000: if (pw_max > 7) pw_max = 7;
11056 break;
11057 case 5200: if (pw_max > 24) pw_max = 24;
11058 break;
11059 case 5800: if (pw_max > 16) pw_max = 16;
11060 break;
11061 case 6300: if (pw_max > 16) pw_max = 16;
11062 break;
11063 case 7400: if (pw_max > 16) pw_max = 16;
11064 break;
11065 case 7900: if (pw_max > 48) pw_max = 48;
11066 break;
11067 case 8500: if (pw_max > 8) pw_max = 8;
11068 break;
11069 case 8600: if (pw_max > 16) pw_max = 16;
11070 break;
11071 case 9710: pw_min = 5;
11072 pw_max = 5;
11073 break;
11074 case 9810: pw_min = 5;
11075 pw_max = 5;
11076 break;
11077 case 10410: pw_min = 5;
11078 pw_max = 5;
11079 break;
11080 case 10300: if (pw_max < 3) pw_min = 3;
11081 if (pw_max > 40) pw_max = 40;
11082 break;
11083 case 10500: if (pw_max < 3) pw_min = 3;
11084 if (pw_max > 40) pw_max = 40;
11085 break;
11086 case 10700: if (pw_max > 16) pw_max = 16;
11087 break;
11088 case 11300: if (pw_max > 40) pw_max = 40;
11089 break;
11090 case 11600: if (pw_max > 32) pw_max = 32;
11091 break;
11092 case 12500: if (pw_max > 20) pw_max = 20;
11093 break;
11094 case 12800: if (pw_max > 24) pw_max = 24;
11095 break;
11096 }
11097
11098 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11099 {
11100 switch (attack_kern)
11101 {
11102 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11103 break;
11104 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11105 break;
11106 }
11107 }
11108
11109 /**
11110 * charsets : keep them together for more easy maintainnce
11111 */
11112
11113 cs_t mp_sys[6] = { { { 0 }, 0 } };
11114 cs_t mp_usr[4] = { { { 0 }, 0 } };
11115
11116 mp_setup_sys (mp_sys);
11117
11118 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11119 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11120 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11121 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11122
11123 /**
11124 * load hashes, part I: find input mode, count hashes
11125 */
11126
11127 uint hashlist_mode = 0;
11128 uint hashlist_format = HLFMT_HASHCAT;
11129
11130 uint hashes_avail = 0;
11131
11132 if (benchmark == 0)
11133 {
11134 struct stat f;
11135
11136 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11137
11138 if ((hash_mode == 2500) ||
11139 (hash_mode == 5200) ||
11140 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11141 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11142 (hash_mode == 9000))
11143 {
11144 hashlist_mode = HL_MODE_ARG;
11145
11146 char *hashfile = myargv[optind];
11147
11148 data.hashfile = hashfile;
11149
11150 logfile_top_var_string ("target", hashfile);
11151 }
11152
11153 if (hashlist_mode == HL_MODE_ARG)
11154 {
11155 if (hash_mode == 2500)
11156 {
11157 struct stat st;
11158
11159 if (stat (data.hashfile, &st) == -1)
11160 {
11161 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11162
11163 return (-1);
11164 }
11165
11166 hashes_avail = st.st_size / sizeof (hccap_t);
11167 }
11168 else
11169 {
11170 hashes_avail = 1;
11171 }
11172 }
11173 else if (hashlist_mode == HL_MODE_FILE)
11174 {
11175 char *hashfile = myargv[optind];
11176
11177 data.hashfile = hashfile;
11178
11179 logfile_top_var_string ("target", hashfile);
11180
11181 FILE *fp = NULL;
11182
11183 if ((fp = fopen (hashfile, "rb")) == NULL)
11184 {
11185 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11186
11187 return (-1);
11188 }
11189
11190 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11191
11192 hashes_avail = count_lines (fp);
11193
11194 rewind (fp);
11195
11196 if (hashes_avail == 0)
11197 {
11198 log_error ("ERROR: hashfile is empty or corrupt");
11199
11200 fclose (fp);
11201
11202 return (-1);
11203 }
11204
11205 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11206
11207 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11208 {
11209 log_error ("ERROR: remove not supported in native hashfile-format mode");
11210
11211 fclose (fp);
11212
11213 return (-1);
11214 }
11215
11216 fclose (fp);
11217 }
11218 }
11219 else
11220 {
11221 hashlist_mode = HL_MODE_ARG;
11222
11223 hashes_avail = 1;
11224 }
11225
11226 if (hash_mode == 3000) hashes_avail *= 2;
11227
11228 data.hashlist_mode = hashlist_mode;
11229 data.hashlist_format = hashlist_format;
11230
11231 logfile_top_uint (hashlist_mode);
11232 logfile_top_uint (hashlist_format);
11233
11234 /**
11235 * load hashes, part II: allocate required memory, set pointers
11236 */
11237
11238 hash_t *hashes_buf = NULL;
11239 void *digests_buf = NULL;
11240 salt_t *salts_buf = NULL;
11241 void *esalts_buf = NULL;
11242
11243 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11244
11245 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11246
11247 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11248 {
11249 u32 hash_pos;
11250
11251 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11252 {
11253 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11254
11255 hashes_buf[hash_pos].hash_info = hash_info;
11256
11257 if (username && (remove || show || left))
11258 {
11259 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11260 }
11261
11262 if (benchmark)
11263 {
11264 hash_info->orighash = (char *) mymalloc (256);
11265 }
11266 }
11267 }
11268
11269 if (isSalted)
11270 {
11271 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11272
11273 if (esalt_size)
11274 {
11275 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11276 }
11277 }
11278 else
11279 {
11280 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11281 }
11282
11283 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11284 {
11285 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11286
11287 if (isSalted)
11288 {
11289 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11290
11291 if (esalt_size)
11292 {
11293 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11294 }
11295 }
11296 else
11297 {
11298 hashes_buf[hash_pos].salt = &salts_buf[0];
11299 }
11300 }
11301
11302 /**
11303 * load hashes, part III: parse hashes or generate them if benchmark
11304 */
11305
11306 uint hashes_cnt = 0;
11307
11308 if (benchmark == 0)
11309 {
11310 if (keyspace == 1)
11311 {
11312 // useless to read hash file for keyspace, cheat a little bit w/ optind
11313 }
11314 else if (hashes_avail == 0)
11315 {
11316 }
11317 else if (hashlist_mode == HL_MODE_ARG)
11318 {
11319 char *input_buf = myargv[optind];
11320
11321 uint input_len = strlen (input_buf);
11322
11323 logfile_top_var_string ("target", input_buf);
11324
11325 char *hash_buf = NULL;
11326 int hash_len = 0;
11327
11328 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11329
11330 bool hash_fmt_error = 0;
11331
11332 if (hash_len < 1) hash_fmt_error = 1;
11333 if (hash_buf == NULL) hash_fmt_error = 1;
11334
11335 if (hash_fmt_error)
11336 {
11337 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11338 }
11339 else
11340 {
11341 if (opts_type & OPTS_TYPE_HASH_COPY)
11342 {
11343 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11344
11345 hash_info_tmp->orighash = mystrdup (hash_buf);
11346 }
11347
11348 if (isSalted)
11349 {
11350 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11351 }
11352
11353 int parser_status = PARSER_OK;
11354
11355 if (hash_mode == 2500)
11356 {
11357 if (hash_len == 0)
11358 {
11359 log_error ("ERROR: hccap file not specified");
11360
11361 return (-1);
11362 }
11363
11364 hashlist_mode = HL_MODE_FILE;
11365
11366 data.hashlist_mode = hashlist_mode;
11367
11368 FILE *fp = fopen (hash_buf, "rb");
11369
11370 if (fp == NULL)
11371 {
11372 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11373
11374 return (-1);
11375 }
11376
11377 if (hashes_avail < 1)
11378 {
11379 log_error ("ERROR: hccap file is empty or corrupt");
11380
11381 fclose (fp);
11382
11383 return (-1);
11384 }
11385
11386 uint hccap_size = sizeof (hccap_t);
11387
11388 char *in = (char *) mymalloc (hccap_size);
11389
11390 while (!feof (fp))
11391 {
11392 int n = fread (in, hccap_size, 1, fp);
11393
11394 if (n != 1)
11395 {
11396 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11397
11398 break;
11399 }
11400
11401 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11402
11403 if (parser_status != PARSER_OK)
11404 {
11405 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11406
11407 continue;
11408 }
11409
11410 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11411
11412 if ((show == 1) || (left == 1))
11413 {
11414 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11415
11416 char *salt_ptr = (char *) tmp_salt->salt_buf;
11417
11418 int cur_pos = tmp_salt->salt_len;
11419 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11420
11421 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11422
11423 // do the appending task
11424
11425 snprintf (salt_ptr + cur_pos,
11426 rem_len,
11427 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11428 wpa->orig_mac1[0],
11429 wpa->orig_mac1[1],
11430 wpa->orig_mac1[2],
11431 wpa->orig_mac1[3],
11432 wpa->orig_mac1[4],
11433 wpa->orig_mac1[5],
11434 wpa->orig_mac2[0],
11435 wpa->orig_mac2[1],
11436 wpa->orig_mac2[2],
11437 wpa->orig_mac2[3],
11438 wpa->orig_mac2[4],
11439 wpa->orig_mac2[5]);
11440
11441 // memset () the remaining part of the salt
11442
11443 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11444 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11445
11446 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11447
11448 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11449 }
11450
11451 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);
11452 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);
11453
11454 hashes_cnt++;
11455 }
11456
11457 fclose (fp);
11458
11459 myfree (in);
11460 }
11461 else if (hash_mode == 3000)
11462 {
11463 if (hash_len == 32)
11464 {
11465 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11466
11467 hash_t *lm_hash_left = NULL;
11468
11469 if (parser_status == PARSER_OK)
11470 {
11471 lm_hash_left = &hashes_buf[hashes_cnt];
11472
11473 hashes_cnt++;
11474 }
11475 else
11476 {
11477 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11478 }
11479
11480 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11481
11482 hash_t *lm_hash_right = NULL;
11483
11484 if (parser_status == PARSER_OK)
11485 {
11486 lm_hash_right = &hashes_buf[hashes_cnt];
11487
11488 hashes_cnt++;
11489 }
11490 else
11491 {
11492 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11493 }
11494
11495 // show / left
11496
11497 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11498 {
11499 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);
11500 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);
11501 }
11502 }
11503 else
11504 {
11505 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11506
11507 if (parser_status == PARSER_OK)
11508 {
11509 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11510 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11511 }
11512
11513 if (parser_status == PARSER_OK)
11514 {
11515 hashes_cnt++;
11516 }
11517 else
11518 {
11519 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11520 }
11521 }
11522 }
11523 else
11524 {
11525 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11526
11527 if (parser_status == PARSER_OK)
11528 {
11529 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11530 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11531 }
11532
11533 if (parser_status == PARSER_OK)
11534 {
11535 hashes_cnt++;
11536 }
11537 else
11538 {
11539 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11540 }
11541 }
11542 }
11543 }
11544 else if (hashlist_mode == HL_MODE_FILE)
11545 {
11546 char *hashfile = data.hashfile;
11547
11548 FILE *fp;
11549
11550 if ((fp = fopen (hashfile, "rb")) == NULL)
11551 {
11552 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11553
11554 return (-1);
11555 }
11556
11557 uint line_num = 0;
11558
11559 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11560
11561 while (!feof (fp))
11562 {
11563 line_num++;
11564
11565 int line_len = fgetl (fp, line_buf);
11566
11567 if (line_len == 0) continue;
11568
11569 char *hash_buf = NULL;
11570 int hash_len = 0;
11571
11572 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11573
11574 bool hash_fmt_error = 0;
11575
11576 if (hash_len < 1) hash_fmt_error = 1;
11577 if (hash_buf == NULL) hash_fmt_error = 1;
11578
11579 if (hash_fmt_error)
11580 {
11581 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11582
11583 continue;
11584 }
11585
11586 if (username)
11587 {
11588 char *user_buf = NULL;
11589 int user_len = 0;
11590
11591 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11592
11593 if (remove || show)
11594 {
11595 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11596
11597 *user = (user_t *) mymalloc (sizeof (user_t));
11598
11599 user_t *user_ptr = *user;
11600
11601 if (user_buf != NULL)
11602 {
11603 user_ptr->user_name = mystrdup (user_buf);
11604 }
11605 else
11606 {
11607 user_ptr->user_name = mystrdup ("");
11608 }
11609
11610 user_ptr->user_len = user_len;
11611 }
11612 }
11613
11614 if (opts_type & OPTS_TYPE_HASH_COPY)
11615 {
11616 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11617
11618 hash_info_tmp->orighash = mystrdup (hash_buf);
11619 }
11620
11621 if (isSalted)
11622 {
11623 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11624 }
11625
11626 if (hash_mode == 3000)
11627 {
11628 if (hash_len == 32)
11629 {
11630 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11631
11632 if (parser_status < PARSER_GLOBAL_ZERO)
11633 {
11634 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11635
11636 continue;
11637 }
11638
11639 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11640
11641 hashes_cnt++;
11642
11643 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11644
11645 if (parser_status < PARSER_GLOBAL_ZERO)
11646 {
11647 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11648
11649 continue;
11650 }
11651
11652 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11653
11654 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);
11655
11656 hashes_cnt++;
11657
11658 // show / left
11659
11660 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);
11661 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);
11662 }
11663 else
11664 {
11665 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11666
11667 if (parser_status < PARSER_GLOBAL_ZERO)
11668 {
11669 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11670
11671 continue;
11672 }
11673
11674 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);
11675
11676 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11677 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11678
11679 hashes_cnt++;
11680 }
11681 }
11682 else
11683 {
11684 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11685
11686 if (parser_status < PARSER_GLOBAL_ZERO)
11687 {
11688 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11689
11690 continue;
11691 }
11692
11693 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);
11694
11695 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11696 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11697
11698 hashes_cnt++;
11699 }
11700 }
11701
11702 myfree (line_buf);
11703
11704 fclose (fp);
11705
11706 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11707
11708 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11709 }
11710 }
11711 else
11712 {
11713 if (isSalted)
11714 {
11715 hashes_buf[0].salt->salt_len = 8;
11716
11717 // special salt handling
11718
11719 switch (hash_mode)
11720 {
11721 case 1500: hashes_buf[0].salt->salt_len = 2;
11722 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11723 break;
11724 case 1731: hashes_buf[0].salt->salt_len = 4;
11725 break;
11726 case 2410: hashes_buf[0].salt->salt_len = 4;
11727 break;
11728 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11729 break;
11730 case 3100: hashes_buf[0].salt->salt_len = 1;
11731 break;
11732 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11733 break;
11734 case 5800: hashes_buf[0].salt->salt_len = 16;
11735 break;
11736 case 6800: hashes_buf[0].salt->salt_len = 32;
11737 break;
11738 case 8400: hashes_buf[0].salt->salt_len = 40;
11739 break;
11740 case 8800: hashes_buf[0].salt->salt_len = 16;
11741 break;
11742 case 8900: hashes_buf[0].salt->salt_len = 16;
11743 hashes_buf[0].salt->scrypt_N = 1024;
11744 hashes_buf[0].salt->scrypt_r = 1;
11745 hashes_buf[0].salt->scrypt_p = 1;
11746 break;
11747 case 9100: hashes_buf[0].salt->salt_len = 16;
11748 break;
11749 case 9300: hashes_buf[0].salt->salt_len = 14;
11750 hashes_buf[0].salt->scrypt_N = 16384;
11751 hashes_buf[0].salt->scrypt_r = 1;
11752 hashes_buf[0].salt->scrypt_p = 1;
11753 break;
11754 case 9400: hashes_buf[0].salt->salt_len = 16;
11755 break;
11756 case 9500: hashes_buf[0].salt->salt_len = 16;
11757 break;
11758 case 9600: hashes_buf[0].salt->salt_len = 16;
11759 break;
11760 case 9700: hashes_buf[0].salt->salt_len = 16;
11761 break;
11762 case 9710: hashes_buf[0].salt->salt_len = 16;
11763 break;
11764 case 9720: hashes_buf[0].salt->salt_len = 16;
11765 break;
11766 case 9800: hashes_buf[0].salt->salt_len = 16;
11767 break;
11768 case 9810: hashes_buf[0].salt->salt_len = 16;
11769 break;
11770 case 9820: hashes_buf[0].salt->salt_len = 16;
11771 break;
11772 case 10300: hashes_buf[0].salt->salt_len = 12;
11773 break;
11774 case 11500: hashes_buf[0].salt->salt_len = 4;
11775 break;
11776 case 11600: hashes_buf[0].salt->salt_len = 4;
11777 break;
11778 case 12400: hashes_buf[0].salt->salt_len = 4;
11779 break;
11780 case 12500: hashes_buf[0].salt->salt_len = 8;
11781 break;
11782 case 12600: hashes_buf[0].salt->salt_len = 64;
11783 break;
11784 }
11785
11786 // special esalt handling
11787
11788 switch (hash_mode)
11789 {
11790 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11791 break;
11792 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11793 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11794 break;
11795 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11796 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11797 break;
11798 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11799 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11800 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11801 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11802 break;
11803 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11804 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11805 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11806 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11807 break;
11808 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11809 break;
11810 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11811 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11812 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11813 break;
11814 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11815 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11816 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11817 break;
11818 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11819 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11820 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11821 break;
11822 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11823 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11824 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11825 break;
11826 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11827 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11828 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11829 break;
11830 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11831 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11832 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11833 break;
11834 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11835 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11836 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11837 break;
11838 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11839 break;
11840 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11841 break;
11842 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11843 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11844 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11845 break;
11846 }
11847 }
11848
11849 // set hashfile
11850
11851 switch (hash_mode)
11852 {
11853 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11854 break;
11855 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11856 break;
11857 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11858 break;
11859 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11860 break;
11861 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11862 break;
11863 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11864 break;
11865 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11866 break;
11867 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11868 break;
11869 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11870 break;
11871 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11872 break;
11873 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11874 break;
11875 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11876 break;
11877 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11878 break;
11879 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11880 break;
11881 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11882 break;
11883 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11884 break;
11885 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11886 break;
11887 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11888 break;
11889 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11898 break;
11899 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11900 break;
11901 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11902 break;
11903 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11904 break;
11905 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11906 break;
11907 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11908 break;
11909 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11910 break;
11911 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11912 break;
11913 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11914 break;
11915 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11916 break;
11917 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11918 break;
11919 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11920 break;
11921 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11922 break;
11923 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11924 break;
11925 }
11926
11927 // set default iterations
11928
11929 switch (hash_mode)
11930 {
11931 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11932 break;
11933 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11934 break;
11935 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11936 break;
11937 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11938 break;
11939 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11940 break;
11941 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11942 break;
11943 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11944 break;
11945 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11946 break;
11947 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11948 break;
11949 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11950 break;
11951 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11952 break;
11953 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11954 break;
11955 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11956 break;
11957 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11958 break;
11959 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11960 break;
11961 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11962 break;
11963 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11964 break;
11965 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11966 break;
11967 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11968 break;
11969 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11970 break;
11971 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11972 break;
11973 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11974 break;
11975 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11976 break;
11977 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11978 break;
11979 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11980 break;
11981 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11982 break;
11983 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11984 break;
11985 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11986 break;
11987 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11988 break;
11989 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11990 break;
11991 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11992 break;
11993 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11994 break;
11995 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11996 break;
11997 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11998 break;
11999 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12000 break;
12001 case 8900: hashes_buf[0].salt->salt_iter = 1;
12002 break;
12003 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12004 break;
12005 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12006 break;
12007 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12008 break;
12009 case 9300: hashes_buf[0].salt->salt_iter = 1;
12010 break;
12011 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12012 break;
12013 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12014 break;
12015 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12016 break;
12017 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12018 break;
12019 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12020 break;
12021 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12022 break;
12023 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12024 break;
12025 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12026 break;
12027 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12028 break;
12029 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12030 break;
12031 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12032 break;
12033 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12034 break;
12035 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12036 break;
12037 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12038 break;
12039 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12040 break;
12041 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12042 break;
12043 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12044 break;
12045 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12046 break;
12047 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12048 break;
12049 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12050 break;
12051 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12052 break;
12053 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12054 break;
12055 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12056 break;
12057 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12058 break;
12059 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12060 break;
12061 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12062 break;
12063 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12064 break;
12065 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12066 break;
12067 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12068 break;
12069 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12070 break;
12071 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12072 break;
12073 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12074 break;
12075 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12076 break;
12077 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12078 break;
12079 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12080 break;
12081 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12082 break;
12083 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12084 break;
12085 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12086 break;
12087 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12088 break;
12089 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12090 break;
12091 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12092 break;
12093 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12094 break;
12095 }
12096
12097 hashes_cnt = 1;
12098 }
12099
12100 if (show == 1 || left == 1)
12101 {
12102 for (uint i = 0; i < pot_cnt; i++)
12103 {
12104 pot_t *pot_ptr = &pot[i];
12105
12106 hash_t *hashes_buf = &pot_ptr->hash;
12107
12108 local_free (hashes_buf->digest);
12109
12110 if (isSalted)
12111 {
12112 local_free (hashes_buf->salt);
12113 }
12114 }
12115
12116 local_free (pot);
12117
12118 if (data.quiet == 0) log_info_nn ("");
12119
12120 return (0);
12121 }
12122
12123 if (keyspace == 0)
12124 {
12125 if (hashes_cnt == 0)
12126 {
12127 log_error ("ERROR: No hashes loaded");
12128
12129 return (-1);
12130 }
12131 }
12132
12133 /**
12134 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12135 */
12136
12137 if (data.outfile != NULL)
12138 {
12139 if (data.hashfile != NULL)
12140 {
12141 #ifdef _POSIX
12142 struct stat tmpstat_outfile;
12143 struct stat tmpstat_hashfile;
12144 #endif
12145
12146 #ifdef _WIN
12147 struct stat64 tmpstat_outfile;
12148 struct stat64 tmpstat_hashfile;
12149 #endif
12150
12151 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12152
12153 if (tmp_outfile_fp)
12154 {
12155 #ifdef _POSIX
12156 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12157 #endif
12158
12159 #ifdef _WIN
12160 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12161 #endif
12162
12163 fclose (tmp_outfile_fp);
12164 }
12165
12166 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12167
12168 if (tmp_hashfile_fp)
12169 {
12170 #ifdef _POSIX
12171 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12172 #endif
12173
12174 #ifdef _WIN
12175 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12176 #endif
12177
12178 fclose (tmp_hashfile_fp);
12179 }
12180
12181 if (tmp_outfile_fp && tmp_outfile_fp)
12182 {
12183 tmpstat_outfile.st_mode = 0;
12184 tmpstat_outfile.st_nlink = 0;
12185 tmpstat_outfile.st_uid = 0;
12186 tmpstat_outfile.st_gid = 0;
12187 tmpstat_outfile.st_rdev = 0;
12188 tmpstat_outfile.st_atime = 0;
12189
12190 tmpstat_hashfile.st_mode = 0;
12191 tmpstat_hashfile.st_nlink = 0;
12192 tmpstat_hashfile.st_uid = 0;
12193 tmpstat_hashfile.st_gid = 0;
12194 tmpstat_hashfile.st_rdev = 0;
12195 tmpstat_hashfile.st_atime = 0;
12196
12197 #ifdef _POSIX
12198 tmpstat_outfile.st_blksize = 0;
12199 tmpstat_outfile.st_blocks = 0;
12200
12201 tmpstat_hashfile.st_blksize = 0;
12202 tmpstat_hashfile.st_blocks = 0;
12203 #endif
12204
12205 #ifdef _POSIX
12206 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12207 {
12208 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12209
12210 return (-1);
12211 }
12212 #endif
12213
12214 #ifdef _WIN
12215 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12216 {
12217 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12218
12219 return (-1);
12220 }
12221 #endif
12222 }
12223 }
12224 }
12225
12226 /**
12227 * Remove duplicates
12228 */
12229
12230 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12231
12232 if (isSalted)
12233 {
12234 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12235 }
12236 else
12237 {
12238 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12239 }
12240
12241 uint hashes_cnt_orig = hashes_cnt;
12242
12243 hashes_cnt = 1;
12244
12245 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12246 {
12247 if (isSalted)
12248 {
12249 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12250 {
12251 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12252 }
12253 }
12254 else
12255 {
12256 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12257 }
12258
12259 if (hashes_pos > hashes_cnt)
12260 {
12261 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12262 }
12263
12264 hashes_cnt++;
12265 }
12266
12267 /**
12268 * Potfile removes
12269 */
12270
12271 uint potfile_remove_cracks = 0;
12272
12273 if (potfile_disable == 0)
12274 {
12275 hash_t hash_buf;
12276
12277 hash_buf.digest = mymalloc (dgst_size);
12278 hash_buf.salt = NULL;
12279 hash_buf.esalt = NULL;
12280 hash_buf.hash_info = NULL;
12281 hash_buf.cracked = 0;
12282
12283 if (isSalted)
12284 {
12285 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12286 }
12287
12288 if (esalt_size)
12289 {
12290 hash_buf.esalt = mymalloc (esalt_size);
12291 }
12292
12293 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12294
12295 // no solution for these special hash types (for instane because they use hashfile in output etc)
12296 if ((hash_mode != 5200) &&
12297 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12298 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12299 (hash_mode != 9000))
12300 {
12301 FILE *fp = fopen (potfile, "rb");
12302
12303 if (fp != NULL)
12304 {
12305 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12306
12307 // to be safe work with a copy (because of line_len loop, i etc)
12308 // moved up here because it's easier to handle continue case
12309 // it's just 64kb
12310
12311 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12312
12313 while (!feof (fp))
12314 {
12315 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12316
12317 if (ptr == NULL) break;
12318
12319 int line_len = strlen (line_buf);
12320
12321 if (line_len == 0) continue;
12322
12323 int iter = MAX_CUT_TRIES;
12324
12325 for (int i = line_len - 1; i && iter; i--, line_len--)
12326 {
12327 if (line_buf[i] != ':') continue;
12328
12329 if (isSalted)
12330 {
12331 memset (hash_buf.salt, 0, sizeof (salt_t));
12332 }
12333
12334 hash_t *found = NULL;
12335
12336 if (hash_mode == 6800)
12337 {
12338 if (i < 64) // 64 = 16 * uint in salt_buf[]
12339 {
12340 // manipulate salt_buf
12341 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12342
12343 hash_buf.salt->salt_len = i;
12344
12345 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12346 }
12347 }
12348 else if (hash_mode == 2500)
12349 {
12350 if (i < 64) // 64 = 16 * uint in salt_buf[]
12351 {
12352 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12353 // manipulate salt_buf
12354
12355 memcpy (line_buf_cpy, line_buf, i);
12356
12357 char *mac2_pos = strrchr (line_buf_cpy, ':');
12358
12359 if (mac2_pos == NULL) continue;
12360
12361 mac2_pos[0] = 0;
12362 mac2_pos++;
12363
12364 if (strlen (mac2_pos) != 12) continue;
12365
12366 char *mac1_pos = strrchr (line_buf_cpy, ':');
12367
12368 if (mac1_pos == NULL) continue;
12369
12370 mac1_pos[0] = 0;
12371 mac1_pos++;
12372
12373 if (strlen (mac1_pos) != 12) continue;
12374
12375 uint essid_length = mac1_pos - line_buf_cpy - 1;
12376
12377 // here we need the ESSID
12378 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12379
12380 hash_buf.salt->salt_len = essid_length;
12381
12382 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12383
12384 if (found)
12385 {
12386 wpa_t *wpa = (wpa_t *) found->esalt;
12387
12388 // compare hex string(s) vs binary MAC address(es)
12389
12390 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12391 {
12392 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12393 {
12394 found = NULL;
12395
12396 break;
12397 }
12398 }
12399
12400 // early skip ;)
12401 if (!found) continue;
12402
12403 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12404 {
12405 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12406 {
12407 found = NULL;
12408
12409 break;
12410 }
12411 }
12412 }
12413 }
12414 }
12415 else
12416 {
12417 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12418
12419 if (parser_status == PARSER_OK)
12420 {
12421 if (isSalted)
12422 {
12423 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12424 }
12425 else
12426 {
12427 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12428 }
12429 }
12430 }
12431
12432 if (found == NULL) continue;
12433
12434 if (!found->cracked) potfile_remove_cracks++;
12435
12436 found->cracked = 1;
12437
12438 if (found) break;
12439
12440 iter--;
12441 }
12442 }
12443
12444 myfree (line_buf_cpy);
12445
12446 myfree (line_buf);
12447
12448 fclose (fp);
12449 }
12450 }
12451
12452 if (esalt_size)
12453 {
12454 local_free (hash_buf.esalt);
12455 }
12456
12457 if (isSalted)
12458 {
12459 local_free (hash_buf.salt);
12460 }
12461
12462 local_free (hash_buf.digest);
12463 }
12464
12465 /**
12466 * Now generate all the buffers required for later
12467 */
12468
12469 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12470
12471 salt_t *salts_buf_new = NULL;
12472 void *esalts_buf_new = NULL;
12473
12474 if (isSalted)
12475 {
12476 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12477
12478 if (esalt_size)
12479 {
12480 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12481 }
12482 }
12483 else
12484 {
12485 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12486 }
12487
12488 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12489
12490 uint digests_cnt = hashes_cnt;
12491 uint digests_done = 0;
12492
12493 size_t size_digests = digests_cnt * dgst_size;
12494 size_t size_shown = digests_cnt * sizeof (uint);
12495
12496 uint *digests_shown = (uint *) mymalloc (size_shown);
12497 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12498
12499 uint salts_cnt = 0;
12500 uint salts_done = 0;
12501
12502 hashinfo_t **hash_info = NULL;
12503
12504 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12505 {
12506 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12507
12508 if (username && (remove || show))
12509 {
12510 uint user_pos;
12511
12512 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12513 {
12514 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12515
12516 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12517 }
12518 }
12519 }
12520
12521 uint *salts_shown = (uint *) mymalloc (size_shown);
12522
12523 salt_t *salt_buf;
12524
12525 {
12526 // copied from inner loop
12527
12528 salt_buf = &salts_buf_new[salts_cnt];
12529
12530 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12531
12532 if (esalt_size)
12533 {
12534 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12535 }
12536
12537 salt_buf->digests_cnt = 0;
12538 salt_buf->digests_done = 0;
12539 salt_buf->digests_offset = 0;
12540
12541 salts_cnt++;
12542 }
12543
12544 if (hashes_buf[0].cracked == 1)
12545 {
12546 digests_shown[0] = 1;
12547
12548 digests_done++;
12549
12550 salt_buf->digests_done++;
12551 }
12552
12553 salt_buf->digests_cnt++;
12554
12555 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12556
12557 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12558 {
12559 hash_info[0] = hashes_buf[0].hash_info;
12560 }
12561
12562 // copy from inner loop
12563
12564 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12565 {
12566 if (isSalted)
12567 {
12568 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12569 {
12570 salt_buf = &salts_buf_new[salts_cnt];
12571
12572 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12573
12574 if (esalt_size)
12575 {
12576 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12577 }
12578
12579 salt_buf->digests_cnt = 0;
12580 salt_buf->digests_done = 0;
12581 salt_buf->digests_offset = hashes_pos;
12582
12583 salts_cnt++;
12584 }
12585 }
12586
12587 if (hashes_buf[hashes_pos].cracked == 1)
12588 {
12589 digests_shown[hashes_pos] = 1;
12590
12591 digests_done++;
12592
12593 salt_buf->digests_done++;
12594 }
12595
12596 salt_buf->digests_cnt++;
12597
12598 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12599
12600 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12601 {
12602 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12603 }
12604 }
12605
12606 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12607 {
12608 salt_t *salt_buf = &salts_buf_new[salt_pos];
12609
12610 if (salt_buf->digests_done == salt_buf->digests_cnt)
12611 {
12612 salts_shown[salt_pos] = 1;
12613
12614 salts_done++;
12615 }
12616
12617 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12618 }
12619
12620 local_free (digests_buf);
12621 local_free (salts_buf);
12622 local_free (esalts_buf);
12623
12624 digests_buf = digests_buf_new;
12625 salts_buf = salts_buf_new;
12626 esalts_buf = esalts_buf_new;
12627
12628 local_free (hashes_buf);
12629
12630 /**
12631 * special modification not set from parser
12632 */
12633
12634 switch (hash_mode)
12635 {
12636 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12637 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12638 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12639 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12640 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12641 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12642 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12643 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12644 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12645 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12646 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12647 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12648 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12649 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12650 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12651 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12652 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12653 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12654 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12655 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12656 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12657 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12658 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12659 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12660 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12661 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12662 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12663 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12664 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12665 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12666 }
12667
12668 if (truecrypt_keyfiles)
12669 {
12670 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12671
12672 char *keyfiles = strdup (truecrypt_keyfiles);
12673
12674 char *keyfile = strtok (keyfiles, ",");
12675
12676 do
12677 {
12678 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12679
12680 } while ((keyfile = strtok (NULL, ",")) != NULL);
12681
12682 free (keyfiles);
12683 }
12684
12685 if (veracrypt_keyfiles)
12686 {
12687 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12688
12689 char *keyfiles = strdup (veracrypt_keyfiles);
12690
12691 char *keyfile = strtok (keyfiles, ",");
12692
12693 do
12694 {
12695 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12696
12697 } while ((keyfile = strtok (NULL, ",")) != NULL);
12698
12699 free (keyfiles);
12700 }
12701
12702 data.digests_cnt = digests_cnt;
12703 data.digests_done = digests_done;
12704 data.digests_buf = digests_buf;
12705 data.digests_shown = digests_shown;
12706 data.digests_shown_tmp = digests_shown_tmp;
12707
12708 data.salts_cnt = salts_cnt;
12709 data.salts_done = salts_done;
12710 data.salts_buf = salts_buf;
12711 data.salts_shown = salts_shown;
12712
12713 data.esalts_buf = esalts_buf;
12714 data.hash_info = hash_info;
12715
12716 /**
12717 * Automatic Optimizers
12718 */
12719
12720 if (salts_cnt == 1)
12721 opti_type |= OPTI_TYPE_SINGLE_SALT;
12722
12723 if (digests_cnt == 1)
12724 opti_type |= OPTI_TYPE_SINGLE_HASH;
12725
12726 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12727 opti_type |= OPTI_TYPE_NOT_ITERATED;
12728
12729 if (attack_mode == ATTACK_MODE_BF)
12730 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12731
12732 data.opti_type = opti_type;
12733
12734 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12735 {
12736 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12737 {
12738 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12739 {
12740 if (opts_type & OPTS_TYPE_ST_ADD80)
12741 {
12742 opts_type &= ~OPTS_TYPE_ST_ADD80;
12743 opts_type |= OPTS_TYPE_PT_ADD80;
12744 }
12745
12746 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12747 {
12748 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12749 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12750 }
12751
12752 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12753 {
12754 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12755 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12756 }
12757 }
12758 }
12759 }
12760
12761 /**
12762 * Some algorithm, like descrypt, can benefit from JIT compilation
12763 */
12764
12765 int force_jit_compilation = -1;
12766
12767 if (hash_mode == 8900)
12768 {
12769 force_jit_compilation = 8900;
12770 }
12771 else if (hash_mode == 9300)
12772 {
12773 force_jit_compilation = 8900;
12774 }
12775 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12776 {
12777 force_jit_compilation = 1500;
12778 }
12779
12780 /**
12781 * generate bitmap tables
12782 */
12783
12784 const uint bitmap_shift1 = 5;
12785 const uint bitmap_shift2 = 13;
12786
12787 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12788
12789 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12790 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12791 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12792 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12793 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12794 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12795 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12796 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12797
12798 uint bitmap_bits;
12799 uint bitmap_nums;
12800 uint bitmap_mask;
12801 uint bitmap_size;
12802
12803 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12804 {
12805 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12806
12807 bitmap_nums = 1 << bitmap_bits;
12808
12809 bitmap_mask = bitmap_nums - 1;
12810
12811 bitmap_size = bitmap_nums * sizeof (uint);
12812
12813 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12814
12815 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;
12816 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;
12817
12818 break;
12819 }
12820
12821 bitmap_nums = 1 << bitmap_bits;
12822
12823 bitmap_mask = bitmap_nums - 1;
12824
12825 bitmap_size = bitmap_nums * sizeof (uint);
12826
12827 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);
12828 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);
12829
12830 /**
12831 * prepare quick rule
12832 */
12833
12834 data.rule_buf_l = rule_buf_l;
12835 data.rule_buf_r = rule_buf_r;
12836
12837 int rule_len_l = (int) strlen (rule_buf_l);
12838 int rule_len_r = (int) strlen (rule_buf_r);
12839
12840 data.rule_len_l = rule_len_l;
12841 data.rule_len_r = rule_len_r;
12842
12843 /**
12844 * load rules
12845 */
12846
12847 uint *all_kernel_rules_cnt = NULL;
12848
12849 kernel_rule_t **all_kernel_rules_buf = NULL;
12850
12851 if (rp_files_cnt)
12852 {
12853 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12854
12855 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12856 }
12857
12858 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12859
12860 int rule_len = 0;
12861
12862 for (uint i = 0; i < rp_files_cnt; i++)
12863 {
12864 uint kernel_rules_avail = 0;
12865
12866 uint kernel_rules_cnt = 0;
12867
12868 kernel_rule_t *kernel_rules_buf = NULL;
12869
12870 char *rp_file = rp_files[i];
12871
12872 char in[BLOCK_SIZE] = { 0 };
12873 char out[BLOCK_SIZE] = { 0 };
12874
12875 FILE *fp = NULL;
12876
12877 uint rule_line = 0;
12878
12879 if ((fp = fopen (rp_file, "rb")) == NULL)
12880 {
12881 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12882
12883 return (-1);
12884 }
12885
12886 while (!feof (fp))
12887 {
12888 memset (rule_buf, 0, HCBUFSIZ);
12889
12890 rule_len = fgetl (fp, rule_buf);
12891
12892 rule_line++;
12893
12894 if (rule_len == 0) continue;
12895
12896 if (rule_buf[0] == '#') continue;
12897
12898 if (kernel_rules_avail == kernel_rules_cnt)
12899 {
12900 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12901
12902 kernel_rules_avail += INCR_RULES;
12903 }
12904
12905 memset (in, 0, BLOCK_SIZE);
12906 memset (out, 0, BLOCK_SIZE);
12907
12908 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12909
12910 if (result == -1)
12911 {
12912 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12913
12914 continue;
12915 }
12916
12917 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12918 {
12919 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12920
12921 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12922
12923 continue;
12924 }
12925
12926 /* its so slow
12927 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12928 {
12929 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12930
12931 continue;
12932 }
12933 */
12934
12935 kernel_rules_cnt++;
12936 }
12937
12938 fclose (fp);
12939
12940 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12941
12942 all_kernel_rules_buf[i] = kernel_rules_buf;
12943 }
12944
12945 /**
12946 * merge rules or automatic rule generator
12947 */
12948
12949 uint kernel_rules_cnt = 0;
12950
12951 kernel_rule_t *kernel_rules_buf = NULL;
12952
12953 if (attack_mode == ATTACK_MODE_STRAIGHT)
12954 {
12955 if (rp_files_cnt)
12956 {
12957 kernel_rules_cnt = 1;
12958
12959 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12960
12961 repeats[0] = kernel_rules_cnt;
12962
12963 for (uint i = 0; i < rp_files_cnt; i++)
12964 {
12965 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12966
12967 repeats[i + 1] = kernel_rules_cnt;
12968 }
12969
12970 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12971
12972 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12973
12974 for (uint i = 0; i < kernel_rules_cnt; i++)
12975 {
12976 uint out_pos = 0;
12977
12978 kernel_rule_t *out = &kernel_rules_buf[i];
12979
12980 for (uint j = 0; j < rp_files_cnt; j++)
12981 {
12982 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12983 uint in_pos;
12984
12985 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12986
12987 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12988 {
12989 if (out_pos == RULES_MAX - 1)
12990 {
12991 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12992
12993 break;
12994 }
12995
12996 out->cmds[out_pos] = in->cmds[in_pos];
12997 }
12998 }
12999 }
13000
13001 local_free (repeats);
13002 }
13003 else if (rp_gen)
13004 {
13005 uint kernel_rules_avail = 0;
13006
13007 while (kernel_rules_cnt < rp_gen)
13008 {
13009 if (kernel_rules_avail == kernel_rules_cnt)
13010 {
13011 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13012
13013 kernel_rules_avail += INCR_RULES;
13014 }
13015
13016 memset (rule_buf, 0, HCBUFSIZ);
13017
13018 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13019
13020 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13021
13022 kernel_rules_cnt++;
13023 }
13024 }
13025 }
13026
13027 myfree (rule_buf);
13028
13029 /**
13030 * generate NOP rules
13031 */
13032
13033 if (kernel_rules_cnt == 0)
13034 {
13035 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13036
13037 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13038
13039 kernel_rules_cnt++;
13040 }
13041
13042 data.kernel_rules_cnt = kernel_rules_cnt;
13043 data.kernel_rules_buf = kernel_rules_buf;
13044
13045 /**
13046 * OpenCL platforms: detect
13047 */
13048
13049 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13050 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13051
13052 cl_uint platforms_cnt = 0;
13053 cl_uint platform_devices_cnt = 0;
13054
13055 if (keyspace == 0)
13056 {
13057 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13058
13059 if (platforms_cnt == 0)
13060 {
13061 log_info ("");
13062 log_info ("ATTENTION! No OpenCL compatible platform found");
13063 log_info ("");
13064 log_info ("You're probably missing the OpenCL runtime installation");
13065 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13066 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13067 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13068 log_info ("");
13069
13070 return (-1);
13071 }
13072
13073 if (opencl_platforms_filter != (uint) -1)
13074 {
13075 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13076
13077 if (opencl_platforms_filter > platform_cnt_mask)
13078 {
13079 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13080
13081 return (-1);
13082 }
13083 }
13084 }
13085
13086 /**
13087 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13088 */
13089
13090 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13091 {
13092 cl_platform_id platform = platforms[platform_id];
13093
13094 char platform_vendor[INFOSZ] = { 0 };
13095
13096 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13097
13098 #ifdef HAVE_HWMON
13099 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13100 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13101 {
13102 // make sure that we do not directly control the fan for NVidia
13103
13104 gpu_temp_retain = 0;
13105
13106 data.gpu_temp_retain = gpu_temp_retain;
13107 }
13108 #endif // HAVE_NVML || HAVE_NVAPI
13109 #endif
13110 }
13111
13112 /**
13113 * OpenCL device types:
13114 * 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.
13115 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13116 */
13117
13118 if (opencl_device_types == NULL)
13119 {
13120 cl_device_type device_types_all = 0;
13121
13122 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13123 {
13124 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13125
13126 cl_platform_id platform = platforms[platform_id];
13127
13128 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13129
13130 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13131 {
13132 cl_device_id device = platform_devices[platform_devices_id];
13133
13134 cl_device_type device_type;
13135
13136 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13137
13138 device_types_all |= device_type;
13139 }
13140 }
13141
13142 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13143 {
13144 device_types_filter |= CL_DEVICE_TYPE_CPU;
13145 }
13146 }
13147
13148 /**
13149 * OpenCL devices: simply push all devices from all platforms into the same device array
13150 */
13151
13152 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13153
13154 data.devices_param = devices_param;
13155
13156 uint devices_cnt = 0;
13157
13158 uint devices_active = 0;
13159
13160 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13161 {
13162 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13163
13164 cl_platform_id platform = platforms[platform_id];
13165
13166 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13167
13168 char platform_vendor[INFOSZ] = { 0 };
13169
13170 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13171
13172 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13173 // this causes trouble with vendor id based macros
13174 // we'll assign generic to those without special optimization available
13175
13176 cl_uint vendor_id = 0;
13177
13178 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13179 {
13180 vendor_id = VENDOR_ID_AMD;
13181 }
13182 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13183 {
13184 vendor_id = VENDOR_ID_APPLE;
13185 }
13186 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13187 {
13188 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13189 }
13190 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13191 {
13192 vendor_id = VENDOR_ID_INTEL_SDK;
13193 }
13194 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13195 {
13196 vendor_id = VENDOR_ID_MESA;
13197 }
13198 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13199 {
13200 vendor_id = VENDOR_ID_NV;
13201 }
13202 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13203 {
13204 vendor_id = VENDOR_ID_POCL;
13205 }
13206 else
13207 {
13208 vendor_id = VENDOR_ID_GENERIC;
13209 }
13210
13211 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13212 {
13213 size_t param_value_size = 0;
13214
13215 const uint device_id = devices_cnt;
13216
13217 hc_device_param_t *device_param = &data.devices_param[device_id];
13218
13219 device_param->vendor_id = vendor_id;
13220
13221 device_param->device = platform_devices[platform_devices_id];
13222
13223 device_param->device_id = device_id;
13224
13225 device_param->platform_devices_id = platform_devices_id;
13226
13227 // device_type
13228
13229 cl_device_type device_type;
13230
13231 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13232
13233 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13234
13235 device_param->device_type = device_type;
13236
13237 // device_name
13238
13239 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13240
13241 char *device_name = (char *) mymalloc (param_value_size);
13242
13243 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13244
13245 device_param->device_name = device_name;
13246
13247 // tuning db
13248
13249 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13250
13251 // device_version
13252
13253 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13254
13255 char *device_version = (char *) mymalloc (param_value_size);
13256
13257 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13258
13259 device_param->device_version = device_version;
13260
13261 // device_opencl_version
13262
13263 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13264
13265 char *device_opencl_version = (char *) mymalloc (param_value_size);
13266
13267 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13268
13269 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13270
13271 myfree (device_opencl_version);
13272
13273 // vector_width
13274
13275 cl_uint vector_width;
13276
13277 if (opencl_vector_width_chgd == 0)
13278 {
13279 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13280 {
13281 if (opti_type & OPTI_TYPE_USES_BITS_64)
13282 {
13283 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13284 }
13285 else
13286 {
13287 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13288 }
13289 }
13290 else
13291 {
13292 vector_width = (cl_uint) tuningdb_entry->vector_width;
13293 }
13294 }
13295 else
13296 {
13297 vector_width = opencl_vector_width;
13298 }
13299
13300 if (vector_width > 16) vector_width = 16;
13301
13302 device_param->vector_width = vector_width;
13303
13304 // max_compute_units
13305
13306 cl_uint device_processors;
13307
13308 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13309
13310 device_param->device_processors = device_processors;
13311
13312 // device_maxmem_alloc
13313 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13314
13315 cl_ulong device_maxmem_alloc;
13316
13317 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13318
13319 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13320
13321 // device_global_mem
13322
13323 cl_ulong device_global_mem;
13324
13325 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13326
13327 device_param->device_global_mem = device_global_mem;
13328
13329 // max_work_group_size
13330
13331 size_t device_maxworkgroup_size;
13332
13333 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13334
13335 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13336
13337 // max_clock_frequency
13338
13339 cl_uint device_maxclock_frequency;
13340
13341 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13342
13343 device_param->device_maxclock_frequency = device_maxclock_frequency;
13344
13345 // device_endian_little
13346
13347 cl_bool device_endian_little;
13348
13349 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13350
13351 if (device_endian_little == CL_FALSE)
13352 {
13353 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13354
13355 device_param->skipped = 1;
13356 }
13357
13358 // device_available
13359
13360 cl_bool device_available;
13361
13362 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13363
13364 if (device_available == CL_FALSE)
13365 {
13366 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13367
13368 device_param->skipped = 1;
13369 }
13370
13371 // device_compiler_available
13372
13373 cl_bool device_compiler_available;
13374
13375 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13376
13377 if (device_compiler_available == CL_FALSE)
13378 {
13379 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13380
13381 device_param->skipped = 1;
13382 }
13383
13384 // device_execution_capabilities
13385
13386 cl_device_exec_capabilities device_execution_capabilities;
13387
13388 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13389
13390 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13391 {
13392 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13393
13394 device_param->skipped = 1;
13395 }
13396
13397 // device_extensions
13398
13399 size_t device_extensions_size;
13400
13401 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13402
13403 char *device_extensions = mymalloc (device_extensions_size + 1);
13404
13405 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13406
13407 if (strstr (device_extensions, "base_atomics") == 0)
13408 {
13409 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13410
13411 device_param->skipped = 1;
13412 }
13413
13414 if (strstr (device_extensions, "byte_addressable_store") == 0)
13415 {
13416 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13417
13418 device_param->skipped = 1;
13419 }
13420
13421 myfree (device_extensions);
13422
13423 // device_local_mem_size
13424
13425 cl_ulong device_local_mem_size;
13426
13427 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13428
13429 if (device_local_mem_size < 32768)
13430 {
13431 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13432
13433 device_param->skipped = 1;
13434 }
13435
13436
13437 // skipped
13438
13439 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13440 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13441
13442 // driver_version
13443
13444 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13445
13446 char *driver_version = (char *) mymalloc (param_value_size);
13447
13448 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13449
13450 device_param->driver_version = driver_version;
13451
13452 // device_name_chksum
13453
13454 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13455
13456 #if __x86_64__
13457 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);
13458 #else
13459 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);
13460 #endif
13461
13462 uint device_name_digest[4] = { 0 };
13463
13464 md5_64 ((uint *) device_name_chksum, device_name_digest);
13465
13466 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13467
13468 device_param->device_name_chksum = device_name_chksum;
13469
13470 // device_processor_cores
13471
13472 if (device_type & CL_DEVICE_TYPE_CPU)
13473 {
13474 cl_uint device_processor_cores = 1;
13475
13476 device_param->device_processor_cores = device_processor_cores;
13477 }
13478
13479 if (device_type & CL_DEVICE_TYPE_GPU)
13480 {
13481 if (vendor_id == VENDOR_ID_AMD)
13482 {
13483 cl_uint device_processor_cores = 0;
13484
13485 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13486
13487 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13488
13489 device_param->device_processor_cores = device_processor_cores;
13490 }
13491 else if (vendor_id == VENDOR_ID_NV)
13492 {
13493 cl_uint kernel_exec_timeout = 0;
13494
13495 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13496
13497 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13498
13499 device_param->kernel_exec_timeout = kernel_exec_timeout;
13500
13501 cl_uint device_processor_cores = 0;
13502
13503 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13504
13505 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13506
13507 device_param->device_processor_cores = device_processor_cores;
13508
13509 cl_uint sm_minor = 0;
13510 cl_uint sm_major = 0;
13511
13512 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13513 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13514
13515 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13516 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13517
13518 device_param->sm_minor = sm_minor;
13519 device_param->sm_major = sm_major;
13520 }
13521 else
13522 {
13523 cl_uint device_processor_cores = 1;
13524
13525 device_param->device_processor_cores = device_processor_cores;
13526 }
13527 }
13528
13529 // display results
13530
13531 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13532 {
13533 if (status_automat == 0)
13534 {
13535 if (device_param->skipped == 0)
13536 {
13537 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13538 device_id + 1,
13539 device_name,
13540 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13541 (unsigned int) (device_global_mem / 1024 / 1024),
13542 (unsigned int) (device_maxclock_frequency),
13543 (unsigned int) device_processors);
13544 }
13545 else
13546 {
13547 log_info ("Device #%u: %s, skipped",
13548 device_id + 1,
13549 device_name);
13550 }
13551 }
13552 }
13553
13554 // common driver check
13555
13556 if (device_param->skipped == 0)
13557 {
13558 if (device_type & CL_DEVICE_TYPE_GPU)
13559 {
13560 if (vendor_id == VENDOR_ID_AMD)
13561 {
13562 int catalyst_check = (force == 1) ? 0 : 1;
13563
13564 int catalyst_warn = 0;
13565
13566 int catalyst_broken = 0;
13567
13568 if (catalyst_check == 1)
13569 {
13570 catalyst_warn = 1;
13571
13572 // v14.9 and higher
13573 if (atoi (device_param->driver_version) >= 1573)
13574 {
13575 catalyst_warn = 0;
13576 }
13577
13578 catalyst_check = 0;
13579 }
13580
13581 if (catalyst_broken == 1)
13582 {
13583 log_info ("");
13584 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13585 log_info ("It will pass over cracked hashes and does not report them as cracked");
13586 log_info ("You are STRONGLY encouraged not to use it");
13587 log_info ("You can use --force to override this but do not post error reports if you do so");
13588 log_info ("");
13589
13590 return (-1);
13591 }
13592
13593 if (catalyst_warn == 1)
13594 {
13595 log_info ("");
13596 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13597 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13598 log_info ("See hashcat's homepage for official supported catalyst drivers");
13599 #ifdef _WIN
13600 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13601 #endif
13602 log_info ("You can use --force to override this but do not post error reports if you do so");
13603 log_info ("");
13604
13605 return (-1);
13606 }
13607 }
13608 else if (vendor_id == VENDOR_ID_NV)
13609 {
13610 if (device_param->kernel_exec_timeout != 0)
13611 {
13612 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);
13613 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13614 }
13615 }
13616 }
13617
13618 if (device_type & CL_DEVICE_TYPE_CPU)
13619 {
13620 if (vendor_id == VENDOR_ID_AMD)
13621 {
13622 if (force == 0)
13623 {
13624 log_info ("");
13625 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13626 log_info ("You are STRONGLY encouraged not to use it");
13627 log_info ("You can use --force to override this but do not post error reports if you do so");
13628 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13629 log_info ("");
13630
13631 return (-1);
13632 }
13633 }
13634 }
13635
13636 /**
13637 * kernel accel and loops tuning db adjustment
13638 */
13639
13640 device_param->kernel_accel_min = 1;
13641 device_param->kernel_accel_max = 1024;
13642
13643 device_param->kernel_loops_min = 1;
13644 device_param->kernel_loops_max = 1024;
13645
13646 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13647
13648 if (tuningdb_entry)
13649 {
13650 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13651 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13652
13653 if (_kernel_accel)
13654 {
13655 device_param->kernel_accel_min = _kernel_accel;
13656 device_param->kernel_accel_max = _kernel_accel;
13657 }
13658
13659 if (_kernel_loops)
13660 {
13661 if (workload_profile == 1)
13662 {
13663 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13664 }
13665 else if (workload_profile == 2)
13666 {
13667 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13668 }
13669
13670 device_param->kernel_loops_min = _kernel_loops;
13671 device_param->kernel_loops_max = _kernel_loops;
13672 }
13673 }
13674
13675 // commandline parameters overwrite tuningdb entries
13676
13677 if (kernel_accel)
13678 {
13679 device_param->kernel_accel_min = kernel_accel;
13680 device_param->kernel_accel_max = kernel_accel;
13681 }
13682
13683 if (kernel_loops)
13684 {
13685 device_param->kernel_loops_min = kernel_loops;
13686 device_param->kernel_loops_max = kernel_loops;
13687 }
13688
13689 /**
13690 * activate device
13691 */
13692
13693 devices_active++;
13694 }
13695
13696 // next please
13697
13698 devices_cnt++;
13699 }
13700 }
13701
13702 if (keyspace == 0 && devices_active == 0)
13703 {
13704 log_error ("ERROR: No devices found/left");
13705
13706 return (-1);
13707 }
13708
13709 // 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)
13710
13711 if (devices_filter != (uint) -1)
13712 {
13713 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13714
13715 if (devices_filter > devices_cnt_mask)
13716 {
13717 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13718
13719 return (-1);
13720 }
13721 }
13722
13723 data.devices_cnt = devices_cnt;
13724
13725 data.devices_active = devices_active;
13726
13727 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13728 {
13729 if (status_automat == 0)
13730 {
13731 log_info ("");
13732 }
13733 }
13734
13735 /**
13736 * HM devices: init
13737 */
13738
13739 #ifdef HAVE_HWMON
13740 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13741 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13742 #endif
13743
13744 #ifdef HAVE_ADL
13745 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13746 #endif
13747
13748 if (gpu_temp_disable == 0)
13749 {
13750 #if defined(WIN) && defined(HAVE_NVAPI)
13751 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13752
13753 if (nvapi_init (nvapi) == 0)
13754 data.hm_nv = nvapi;
13755
13756 if (data.hm_nv)
13757 {
13758 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13759 {
13760 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13761
13762 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13763
13764 int tmp_out = 0;
13765
13766 for (int i = 0; i < tmp_in; i++)
13767 {
13768 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13769 }
13770
13771 for (int i = 0; i < tmp_out; i++)
13772 {
13773 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13774
13775 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13776
13777 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;
13778 }
13779 }
13780 }
13781 #endif // WIN && HAVE_NVAPI
13782
13783 #if defined(LINUX) && defined(HAVE_NVML)
13784 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13785
13786 if (nvml_init (nvml) == 0)
13787 data.hm_nv = nvml;
13788
13789 if (data.hm_nv)
13790 {
13791 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13792 {
13793 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13794
13795 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13796
13797 int tmp_out = 0;
13798
13799 for (int i = 0; i < tmp_in; i++)
13800 {
13801 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13802 }
13803
13804 for (int i = 0; i < tmp_out; i++)
13805 {
13806 unsigned int speed;
13807
13808 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;
13809 }
13810 }
13811 }
13812 #endif // LINUX && HAVE_NVML
13813
13814 data.hm_amd = NULL;
13815
13816 #ifdef HAVE_ADL
13817 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13818
13819 if (adl_init (adl) == 0)
13820 data.hm_amd = adl;
13821
13822 if (data.hm_amd)
13823 {
13824 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13825 {
13826 // total number of adapters
13827
13828 int hm_adapters_num;
13829
13830 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13831
13832 // adapter info
13833
13834 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13835
13836 if (lpAdapterInfo == NULL) return (-1);
13837
13838 // get a list (of ids of) valid/usable adapters
13839
13840 int num_adl_adapters = 0;
13841
13842 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13843
13844 if (num_adl_adapters > 0)
13845 {
13846 hc_thread_mutex_lock (mux_adl);
13847
13848 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13849
13850 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13851
13852 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13853 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13854
13855 hc_thread_mutex_unlock (mux_adl);
13856 }
13857
13858 myfree (valid_adl_device_list);
13859 myfree (lpAdapterInfo);
13860 }
13861 }
13862 #endif // HAVE_ADL
13863
13864 if (data.hm_amd == NULL && data.hm_nv == NULL)
13865 {
13866 gpu_temp_disable = 1;
13867 }
13868 }
13869
13870 /**
13871 * OpenCL devices: allocate buffer for device specific information
13872 */
13873
13874 #ifdef HAVE_HWMON
13875 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13876
13877 #ifdef HAVE_ADL
13878 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13879
13880 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13881 #endif // ADL
13882 #endif
13883
13884 /**
13885 * enable custom signal handler(s)
13886 */
13887
13888 if (benchmark == 0)
13889 {
13890 hc_signal (sigHandler_default);
13891 }
13892 else
13893 {
13894 hc_signal (sigHandler_benchmark);
13895 }
13896
13897 /**
13898 * User-defined GPU temp handling
13899 */
13900
13901 #ifdef HAVE_HWMON
13902 if (gpu_temp_disable == 1)
13903 {
13904 gpu_temp_abort = 0;
13905 gpu_temp_retain = 0;
13906 }
13907
13908 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13909 {
13910 if (gpu_temp_abort < gpu_temp_retain)
13911 {
13912 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13913
13914 return (-1);
13915 }
13916 }
13917
13918 data.gpu_temp_disable = gpu_temp_disable;
13919 data.gpu_temp_abort = gpu_temp_abort;
13920 data.gpu_temp_retain = gpu_temp_retain;
13921 #endif
13922
13923 /**
13924 * inform the user
13925 */
13926
13927 if (data.quiet == 0)
13928 {
13929 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13930
13931 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);
13932
13933 if (attack_mode == ATTACK_MODE_STRAIGHT)
13934 {
13935 log_info ("Rules: %u", kernel_rules_cnt);
13936 }
13937
13938 if (opti_type)
13939 {
13940 log_info ("Applicable Optimizers:");
13941
13942 for (uint i = 0; i < 32; i++)
13943 {
13944 const uint opti_bit = 1u << i;
13945
13946 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13947 }
13948 }
13949
13950 /**
13951 * Watchdog and Temperature balance
13952 */
13953
13954 #ifdef HAVE_HWMON
13955 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13956 {
13957 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13958 }
13959
13960 if (gpu_temp_abort == 0)
13961 {
13962 log_info ("Watchdog: Temperature abort trigger disabled");
13963 }
13964 else
13965 {
13966 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13967 }
13968
13969 if (gpu_temp_retain == 0)
13970 {
13971 log_info ("Watchdog: Temperature retain trigger disabled");
13972 }
13973 else
13974 {
13975 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13976 }
13977
13978 if (data.quiet == 0) log_info ("");
13979 #endif
13980 }
13981
13982 /**
13983 * HM devices: copy
13984 */
13985
13986 if (gpu_temp_disable == 0)
13987 {
13988 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13989 {
13990 hc_device_param_t *device_param = &data.devices_param[device_id];
13991
13992 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13993
13994 if (device_param->skipped) continue;
13995
13996 const uint platform_devices_id = device_param->platform_devices_id;
13997
13998 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13999 if (device_param->vendor_id == VENDOR_ID_NV)
14000 {
14001 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14002 }
14003 #endif
14004
14005 #ifdef HAVE_ADL
14006 if (device_param->vendor_id == VENDOR_ID_AMD)
14007 {
14008 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14009 }
14010 #endif
14011 }
14012 }
14013
14014 /*
14015 * Temporary fix:
14016 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14017 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14018 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14019 * Driver / ADL bug?
14020 */
14021
14022 #ifdef HAVE_ADL
14023 if (powertune_enable == 1)
14024 {
14025 hc_thread_mutex_lock (mux_adl);
14026
14027 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14028 {
14029 hc_device_param_t *device_param = &data.devices_param[device_id];
14030
14031 if (device_param->skipped) continue;
14032
14033 if (data.hm_device[device_id].od_version == 6)
14034 {
14035 // set powertune value only
14036
14037 int powertune_supported = 0;
14038
14039 int ADL_rc = 0;
14040
14041 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14042 {
14043 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14044
14045 return (-1);
14046 }
14047
14048 if (powertune_supported != 0)
14049 {
14050 // powertune set
14051 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14052
14053 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14054 {
14055 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14056
14057 return (-1);
14058 }
14059
14060 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14061 {
14062 log_error ("ERROR: Failed to set new ADL PowerControl values");
14063
14064 return (-1);
14065 }
14066 }
14067 }
14068 }
14069
14070 hc_thread_mutex_unlock (mux_adl);
14071 }
14072 #endif // HAVE_ADK
14073 #endif // HAVE_HWMON
14074
14075 #ifdef DEBUG
14076 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14077 #endif
14078
14079 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14080
14081 uint kernel_power_all = 0;
14082
14083 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14084 {
14085 /**
14086 * host buffer
14087 */
14088
14089 hc_device_param_t *device_param = &data.devices_param[device_id];
14090
14091 if (device_param->skipped) continue;
14092
14093 /**
14094 * device properties
14095 */
14096
14097 const char *device_name_chksum = device_param->device_name_chksum;
14098 const u32 device_processors = device_param->device_processors;
14099 const u32 device_processor_cores = device_param->device_processor_cores;
14100
14101 /**
14102 * create context for each device
14103 */
14104
14105 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14106
14107 /**
14108 * create command-queue
14109 */
14110
14111 // not supported with NV
14112 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14113
14114 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14115
14116 /**
14117 * kernel threads: some algorithms need a fixed kernel-threads count
14118 * because of shared memory usage or bitslice
14119 * there needs to be some upper limit, otherwise there's too much overhead
14120 */
14121
14122 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14123
14124 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14125 {
14126 kernel_threads = KERNEL_THREADS_MAX_CPU;
14127 }
14128
14129 if (hash_mode == 1500) kernel_threads = 64; // DES
14130 if (hash_mode == 3000) kernel_threads = 64; // DES
14131 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14132 if (hash_mode == 7500) kernel_threads = 64; // RC4
14133 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14134 if (hash_mode == 9700) kernel_threads = 64; // RC4
14135 if (hash_mode == 9710) kernel_threads = 64; // RC4
14136 if (hash_mode == 9800) kernel_threads = 64; // RC4
14137 if (hash_mode == 9810) kernel_threads = 64; // RC4
14138 if (hash_mode == 10400) kernel_threads = 64; // RC4
14139 if (hash_mode == 10410) kernel_threads = 64; // RC4
14140 if (hash_mode == 10500) kernel_threads = 64; // RC4
14141 if (hash_mode == 13100) kernel_threads = 64; // RC4
14142
14143 /**
14144 * create input buffers on device : calculate size of fixed memory buffers
14145 */
14146
14147 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14148 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14149
14150 device_param->size_root_css = size_root_css;
14151 device_param->size_markov_css = size_markov_css;
14152
14153 size_t size_results = sizeof (uint);
14154
14155 device_param->size_results = size_results;
14156
14157 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14158 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14159
14160 size_t size_plains = digests_cnt * sizeof (plain_t);
14161 size_t size_salts = salts_cnt * sizeof (salt_t);
14162 size_t size_esalts = salts_cnt * esalt_size;
14163
14164 device_param->size_plains = size_plains;
14165 device_param->size_digests = size_digests;
14166 device_param->size_shown = size_shown;
14167 device_param->size_salts = size_salts;
14168
14169 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14170 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14171 size_t size_tm = 32 * sizeof (bs_word_t);
14172
14173 // scryptV stuff
14174
14175 size_t size_scryptV = 1;
14176
14177 if ((hash_mode == 8900) || (hash_mode == 9300))
14178 {
14179 uint tmto_start = 0;
14180 uint tmto_stop = 10;
14181
14182 if (scrypt_tmto)
14183 {
14184 tmto_start = scrypt_tmto;
14185 }
14186 else
14187 {
14188 // in case the user did not specify the tmto manually
14189 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14190 // but set the lower end only in case the user has a device with too less memory
14191
14192 if (hash_mode == 8900)
14193 {
14194 if (device_param->vendor_id == VENDOR_ID_AMD)
14195 {
14196 tmto_start = 1;
14197 }
14198 else if (device_param->vendor_id == VENDOR_ID_NV)
14199 {
14200 tmto_start = 2;
14201 }
14202 }
14203 else if (hash_mode == 9300)
14204 {
14205 if (device_param->vendor_id == VENDOR_ID_AMD)
14206 {
14207 tmto_start = 2;
14208 }
14209 else if (device_param->vendor_id == VENDOR_ID_NV)
14210 {
14211 tmto_start = 2;
14212 }
14213 }
14214 }
14215
14216 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14217 {
14218 // TODO: in theory the following calculation needs to be done per salt, not global
14219 // we assume all hashes have the same scrypt settings
14220
14221 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14222
14223 size_scryptV /= 1 << tmto;
14224
14225 size_scryptV *= device_processors * device_processor_cores;
14226
14227 if (size_scryptV > device_param->device_maxmem_alloc)
14228 {
14229 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14230
14231 continue;
14232 }
14233
14234 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14235 {
14236 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14237 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14238 }
14239
14240 break;
14241 }
14242
14243 if (data.salts_buf[0].scrypt_phy == 0)
14244 {
14245 log_error ("ERROR: can't allocate enough device memory");
14246
14247 return -1;
14248 }
14249
14250 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14251 }
14252
14253 /**
14254 * some algorithms need a fixed kernel-loops count
14255 */
14256
14257 if (hash_mode == 1500)
14258 {
14259 const u32 kernel_loops_fixed = 1024;
14260
14261 device_param->kernel_loops_min = kernel_loops_fixed;
14262 device_param->kernel_loops_max = kernel_loops_fixed;
14263 }
14264
14265 if (hash_mode == 3000)
14266 {
14267 const u32 kernel_loops_fixed = 1024;
14268
14269 device_param->kernel_loops_min = kernel_loops_fixed;
14270 device_param->kernel_loops_max = kernel_loops_fixed;
14271 }
14272
14273 if (hash_mode == 8900)
14274 {
14275 const u32 kernel_loops_fixed = 1;
14276
14277 device_param->kernel_loops_min = kernel_loops_fixed;
14278 device_param->kernel_loops_max = kernel_loops_fixed;
14279 }
14280
14281 if (hash_mode == 9300)
14282 {
14283 const u32 kernel_loops_fixed = 1;
14284
14285 device_param->kernel_loops_min = kernel_loops_fixed;
14286 device_param->kernel_loops_max = kernel_loops_fixed;
14287 }
14288
14289 if (hash_mode == 12500)
14290 {
14291 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14292
14293 device_param->kernel_loops_min = kernel_loops_fixed;
14294 device_param->kernel_loops_max = kernel_loops_fixed;
14295 }
14296
14297 /**
14298 * some algorithms have a maximum kernel-loops count
14299 */
14300
14301 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14302 {
14303 u32 innerloop_cnt = 0;
14304
14305 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14306 {
14307 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14308 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14309 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14310 }
14311 else
14312 {
14313 innerloop_cnt = data.salts_buf[0].salt_iter;
14314 }
14315
14316 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14317 (innerloop_cnt <= device_param->kernel_loops_max))
14318 {
14319 device_param->kernel_loops_max = innerloop_cnt;
14320 }
14321 }
14322
14323 u32 kernel_accel_min = device_param->kernel_accel_min;
14324 u32 kernel_accel_max = device_param->kernel_accel_max;
14325
14326 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14327
14328 size_t size_pws = 4;
14329 size_t size_tmps = 4;
14330 size_t size_hooks = 4;
14331
14332 while (kernel_accel_max >= kernel_accel_min)
14333 {
14334 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14335
14336 // size_pws
14337
14338 size_pws = kernel_power_max * sizeof (pw_t);
14339
14340 // size_tmps
14341
14342 switch (hash_mode)
14343 {
14344 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14345 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14346 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14347 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14348 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14349 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14350 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14351 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14352 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14353 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14354 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14355 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14356 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14357 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14358 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14359 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14360 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14361 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14362 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14363 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14364 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14365 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14366 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14367 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14368 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14369 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14370 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14371 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14372 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14373 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14374 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14375 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14376 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14377 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14378 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14379 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14380 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14381 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14382 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14383 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14384 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14385 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14386 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14387 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14388 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14389 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14390 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14391 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14392 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14393 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14394 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14395 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14396 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14397 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14398 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14399 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14400 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14401 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14402 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14403 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14404 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14405 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14406 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14407 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14408 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14409 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14410 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14411 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14412 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14413 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14414 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14415 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14416 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14417 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14418 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14419 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14420 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14421 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14422 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14423 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14424 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14425 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14426 };
14427
14428 // size_hooks
14429
14430 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14431 {
14432 // none yet
14433 }
14434
14435 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14436 // if not, decrease amplifier and try again
14437
14438 int skip = 0;
14439
14440 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14441 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14442 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14443
14444 if (( bitmap_size
14445 + bitmap_size
14446 + bitmap_size
14447 + bitmap_size
14448 + bitmap_size
14449 + bitmap_size
14450 + bitmap_size
14451 + bitmap_size
14452 + size_bfs
14453 + size_combs
14454 + size_digests
14455 + size_esalts
14456 + size_hooks
14457 + size_markov_css
14458 + size_plains
14459 + size_pws
14460 + size_pws // not a bug
14461 + size_results
14462 + size_root_css
14463 + size_rules
14464 + size_rules_c
14465 + size_salts
14466 + size_scryptV
14467 + size_shown
14468 + size_tm
14469 + size_tmps) > device_param->device_global_mem) skip = 1;
14470
14471 if (skip == 1)
14472 {
14473 kernel_accel_max--;
14474
14475 continue;
14476 }
14477
14478 break;
14479 }
14480
14481 /*
14482 if (kernel_accel_max == 0)
14483 {
14484 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14485
14486 return -1;
14487 }
14488 */
14489
14490 device_param->kernel_accel_min = kernel_accel_min;
14491 device_param->kernel_accel_max = kernel_accel_max;
14492
14493 /*
14494 if (kernel_accel_max < kernel_accel)
14495 {
14496 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14497
14498 device_param->kernel_accel = kernel_accel_max;
14499 }
14500 */
14501
14502 device_param->size_bfs = size_bfs;
14503 device_param->size_combs = size_combs;
14504 device_param->size_rules = size_rules;
14505 device_param->size_rules_c = size_rules_c;
14506 device_param->size_pws = size_pws;
14507 device_param->size_tmps = size_tmps;
14508 device_param->size_hooks = size_hooks;
14509
14510 // do not confuse kernel_accel_max with kernel_accel here
14511
14512 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14513
14514 device_param->kernel_threads = kernel_threads;
14515 device_param->kernel_power_user = kernel_power;
14516
14517 kernel_power_all += kernel_power;
14518
14519 /**
14520 * default building options
14521 */
14522
14523 char build_opts[1024] = { 0 };
14524
14525 // we don't have sm_* on vendors not NV but it doesn't matter
14526
14527 snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14528
14529 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14530 {
14531 // we do vectorizing much better than the auto-vectorizer
14532
14533 char build_opts_new[1024] = { 0 };
14534
14535 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14536
14537 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14538 }
14539
14540 #ifdef DEBUG
14541 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14542 #endif
14543
14544 /**
14545 * main kernel
14546 */
14547
14548 {
14549 /**
14550 * kernel source filename
14551 */
14552
14553 char source_file[256] = { 0 };
14554
14555 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14556
14557 struct stat sst;
14558
14559 if (stat (source_file, &sst) == -1)
14560 {
14561 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14562
14563 return -1;
14564 }
14565
14566 /**
14567 * kernel cached filename
14568 */
14569
14570 char cached_file[256] = { 0 };
14571
14572 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14573
14574 int cached = 1;
14575
14576 struct stat cst;
14577
14578 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14579 {
14580 cached = 0;
14581 }
14582
14583 /**
14584 * kernel compile or load
14585 */
14586
14587 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14588
14589 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14590
14591 if (force_jit_compilation == -1)
14592 {
14593 if (cached == 0)
14594 {
14595 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14596
14597 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14598
14599 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14600
14601 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14602
14603 #ifdef DEBUG
14604 size_t build_log_size = 0;
14605
14606 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14607
14608 if (build_log_size > 1)
14609 {
14610 char *build_log = (char *) malloc (build_log_size + 1);
14611
14612 memset (build_log, 0, build_log_size + 1);
14613
14614 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14615
14616 puts (build_log);
14617
14618 free (build_log);
14619 }
14620 #endif
14621
14622 if (rc != 0)
14623 {
14624 device_param->skipped = true;
14625
14626 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14627
14628 continue;
14629 }
14630
14631 size_t binary_size;
14632
14633 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14634
14635 u8 *binary = (u8 *) mymalloc (binary_size);
14636
14637 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14638
14639 writeProgramBin (cached_file, binary, binary_size);
14640
14641 local_free (binary);
14642 }
14643 else
14644 {
14645 #ifdef DEBUG
14646 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14647 #endif
14648
14649 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14650
14651 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14652
14653 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14654 }
14655 }
14656 else
14657 {
14658 #ifdef DEBUG
14659 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14660 #endif
14661
14662 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14663
14664 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14665
14666 char build_opts_update[1024] = { 0 };
14667
14668 if (force_jit_compilation == 1500)
14669 {
14670 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14671 }
14672 else if (force_jit_compilation == 8900)
14673 {
14674 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);
14675 }
14676 else
14677 {
14678 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14679 }
14680
14681 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14682
14683 #ifdef DEBUG
14684 size_t build_log_size = 0;
14685
14686 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14687
14688 if (build_log_size > 1)
14689 {
14690 char *build_log = (char *) malloc (build_log_size + 1);
14691
14692 memset (build_log, 0, build_log_size + 1);
14693
14694 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14695
14696 puts (build_log);
14697
14698 free (build_log);
14699 }
14700 #endif
14701
14702 if (rc != 0)
14703 {
14704 device_param->skipped = true;
14705
14706 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14707 }
14708 }
14709
14710 local_free (kernel_lengths);
14711 local_free (kernel_sources[0]);
14712 local_free (kernel_sources);
14713 }
14714
14715 /**
14716 * word generator kernel
14717 */
14718
14719 if (attack_mode != ATTACK_MODE_STRAIGHT)
14720 {
14721 /**
14722 * kernel mp source filename
14723 */
14724
14725 char source_file[256] = { 0 };
14726
14727 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14728
14729 struct stat sst;
14730
14731 if (stat (source_file, &sst) == -1)
14732 {
14733 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14734
14735 return -1;
14736 }
14737
14738 /**
14739 * kernel mp cached filename
14740 */
14741
14742 char cached_file[256] = { 0 };
14743
14744 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14745
14746 int cached = 1;
14747
14748 struct stat cst;
14749
14750 if (stat (cached_file, &cst) == -1)
14751 {
14752 cached = 0;
14753 }
14754
14755 /**
14756 * kernel compile or load
14757 */
14758
14759 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14760
14761 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14762
14763 if (cached == 0)
14764 {
14765 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14766 if (quiet == 0) log_info ("");
14767
14768 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14769
14770 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14771
14772 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14773
14774 if (rc != 0)
14775 {
14776 device_param->skipped = true;
14777
14778 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14779
14780 continue;
14781 }
14782
14783 size_t binary_size;
14784
14785 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14786
14787 u8 *binary = (u8 *) mymalloc (binary_size);
14788
14789 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14790
14791 writeProgramBin (cached_file, binary, binary_size);
14792
14793 local_free (binary);
14794 }
14795 else
14796 {
14797 #ifdef DEBUG
14798 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14799 #endif
14800
14801 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14802
14803 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14804
14805 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14806 }
14807
14808 local_free (kernel_lengths);
14809 local_free (kernel_sources[0]);
14810 local_free (kernel_sources);
14811 }
14812
14813 /**
14814 * amplifier kernel
14815 */
14816
14817 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14818 {
14819
14820 }
14821 else
14822 {
14823 /**
14824 * kernel amp source filename
14825 */
14826
14827 char source_file[256] = { 0 };
14828
14829 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14830
14831 struct stat sst;
14832
14833 if (stat (source_file, &sst) == -1)
14834 {
14835 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14836
14837 return -1;
14838 }
14839
14840 /**
14841 * kernel amp cached filename
14842 */
14843
14844 char cached_file[256] = { 0 };
14845
14846 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14847
14848 int cached = 1;
14849
14850 struct stat cst;
14851
14852 if (stat (cached_file, &cst) == -1)
14853 {
14854 cached = 0;
14855 }
14856
14857 /**
14858 * kernel compile or load
14859 */
14860
14861 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14862
14863 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14864
14865 if (cached == 0)
14866 {
14867 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14868 if (quiet == 0) log_info ("");
14869
14870 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14871
14872 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14873
14874 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14875
14876 if (rc != 0)
14877 {
14878 device_param->skipped = true;
14879
14880 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14881
14882 continue;
14883 }
14884
14885 size_t binary_size;
14886
14887 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14888
14889 u8 *binary = (u8 *) mymalloc (binary_size);
14890
14891 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14892
14893 writeProgramBin (cached_file, binary, binary_size);
14894
14895 local_free (binary);
14896 }
14897 else
14898 {
14899 #ifdef DEBUG
14900 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14901 #endif
14902
14903 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14904
14905 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14906
14907 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14908 }
14909
14910 local_free (kernel_lengths);
14911 local_free (kernel_sources[0]);
14912 local_free (kernel_sources);
14913 }
14914
14915 // some algorithm collide too fast, make that impossible
14916
14917 if (benchmark == 1)
14918 {
14919 ((uint *) digests_buf)[0] = -1;
14920 ((uint *) digests_buf)[1] = -1;
14921 ((uint *) digests_buf)[2] = -1;
14922 ((uint *) digests_buf)[3] = -1;
14923 }
14924
14925 /**
14926 * global buffers
14927 */
14928
14929 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14930 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14931 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14932 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14933 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14934 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14935 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14936 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14937 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14938 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14939 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14940 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14941 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14942 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14943 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14944 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14945 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14946 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14947
14948 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);
14949 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);
14950 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);
14951 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);
14952 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);
14953 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);
14954 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);
14955 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);
14956 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14957 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14958 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14959
14960 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14961 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14962 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14963 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14964 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14965 run_kernel_bzero (device_param, device_param->d_result, size_results);
14966
14967 /**
14968 * special buffers
14969 */
14970
14971 if (attack_kern == ATTACK_KERN_STRAIGHT)
14972 {
14973 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14974 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14975
14976 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14977
14978 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14979 }
14980 else if (attack_kern == ATTACK_KERN_COMBI)
14981 {
14982 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14983 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14984 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14985 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14986
14987 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14988 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14989 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14990 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14991 }
14992 else if (attack_kern == ATTACK_KERN_BF)
14993 {
14994 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14995 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14996 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14997 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14998 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14999
15000 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15001 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15002 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15003 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15004 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15005 }
15006
15007 if (size_esalts)
15008 {
15009 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15010
15011 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15012 }
15013
15014 /**
15015 * main host data
15016 */
15017
15018 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15019
15020 device_param->pws_buf = pws_buf;
15021
15022 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15023
15024 device_param->combs_buf = combs_buf;
15025
15026 void *hooks_buf = mymalloc (size_hooks);
15027
15028 device_param->hooks_buf = hooks_buf;
15029
15030 /**
15031 * kernel args
15032 */
15033
15034 device_param->kernel_params_buf32[21] = bitmap_mask;
15035 device_param->kernel_params_buf32[22] = bitmap_shift1;
15036 device_param->kernel_params_buf32[23] = bitmap_shift2;
15037 device_param->kernel_params_buf32[24] = 0; // salt_pos
15038 device_param->kernel_params_buf32[25] = 0; // loop_pos
15039 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15040 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15041 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15042 device_param->kernel_params_buf32[29] = 0; // digests_offset
15043 device_param->kernel_params_buf32[30] = 0; // combs_mode
15044 device_param->kernel_params_buf32[31] = 0; // gid_max
15045
15046 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15047 ? &device_param->d_pws_buf
15048 : &device_param->d_pws_amp_buf;
15049 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15050 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15051 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15052 device_param->kernel_params[ 4] = &device_param->d_tmps;
15053 device_param->kernel_params[ 5] = &device_param->d_hooks;
15054 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15055 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15056 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15057 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15058 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15059 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15060 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15061 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15062 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15063 device_param->kernel_params[15] = &device_param->d_digests_buf;
15064 device_param->kernel_params[16] = &device_param->d_digests_shown;
15065 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15066 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15067 device_param->kernel_params[19] = &device_param->d_result;
15068 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15069 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15070 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15071 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15072 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15073 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15074 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15075 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15076 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15077 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15078 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15079 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15080
15081 device_param->kernel_params_mp_buf64[3] = 0;
15082 device_param->kernel_params_mp_buf32[4] = 0;
15083 device_param->kernel_params_mp_buf32[5] = 0;
15084 device_param->kernel_params_mp_buf32[6] = 0;
15085 device_param->kernel_params_mp_buf32[7] = 0;
15086 device_param->kernel_params_mp_buf32[8] = 0;
15087
15088 device_param->kernel_params_mp[0] = NULL;
15089 device_param->kernel_params_mp[1] = NULL;
15090 device_param->kernel_params_mp[2] = NULL;
15091 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15092 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15093 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15094 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15095 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15096 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15097
15098 device_param->kernel_params_mp_l_buf64[3] = 0;
15099 device_param->kernel_params_mp_l_buf32[4] = 0;
15100 device_param->kernel_params_mp_l_buf32[5] = 0;
15101 device_param->kernel_params_mp_l_buf32[6] = 0;
15102 device_param->kernel_params_mp_l_buf32[7] = 0;
15103 device_param->kernel_params_mp_l_buf32[8] = 0;
15104 device_param->kernel_params_mp_l_buf32[9] = 0;
15105
15106 device_param->kernel_params_mp_l[0] = NULL;
15107 device_param->kernel_params_mp_l[1] = NULL;
15108 device_param->kernel_params_mp_l[2] = NULL;
15109 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15110 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15111 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15112 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15113 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15114 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15115 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15116
15117 device_param->kernel_params_mp_r_buf64[3] = 0;
15118 device_param->kernel_params_mp_r_buf32[4] = 0;
15119 device_param->kernel_params_mp_r_buf32[5] = 0;
15120 device_param->kernel_params_mp_r_buf32[6] = 0;
15121 device_param->kernel_params_mp_r_buf32[7] = 0;
15122 device_param->kernel_params_mp_r_buf32[8] = 0;
15123
15124 device_param->kernel_params_mp_r[0] = NULL;
15125 device_param->kernel_params_mp_r[1] = NULL;
15126 device_param->kernel_params_mp_r[2] = NULL;
15127 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15128 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15129 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15130 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15131 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15132 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15133
15134 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15135 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15136
15137 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15138 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15139 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15140 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15141 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15142 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15143 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15144
15145 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15146 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15147
15148 /**
15149 * kernel name
15150 */
15151
15152 size_t kernel_wgs_tmp;
15153
15154 char kernel_name[64] = { 0 };
15155
15156 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15157 {
15158 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15159 {
15160 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15161
15162 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15163
15164 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15165
15166 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15167
15168 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15169
15170 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15171 }
15172 else
15173 {
15174 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15175
15176 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15177
15178 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15179
15180 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15181
15182 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15183
15184 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15185 }
15186
15187 if (data.attack_mode == ATTACK_MODE_BF)
15188 {
15189 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15190 {
15191 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15192
15193 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15194
15195 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);
15196 }
15197 }
15198 }
15199 else
15200 {
15201 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15202
15203 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15204
15205 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15206
15207 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15208
15209 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15210
15211 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15212
15213 if (opts_type & OPTS_TYPE_HOOK12)
15214 {
15215 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15216
15217 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15218
15219 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);
15220 }
15221
15222 if (opts_type & OPTS_TYPE_HOOK23)
15223 {
15224 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15225
15226 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15227
15228 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);
15229 }
15230 }
15231
15232 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);
15233 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);
15234 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);
15235
15236 for (uint i = 0; i <= 20; i++)
15237 {
15238 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15239 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15240 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15241
15242 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15243 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15244 }
15245
15246 for (uint i = 21; i <= 31; i++)
15247 {
15248 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15249 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15250 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15251
15252 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15253 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15254 }
15255
15256 if (attack_mode == ATTACK_MODE_BF)
15257 {
15258 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15259 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15260
15261 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);
15262 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);
15263
15264 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15265 {
15266 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15267 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15268 }
15269 }
15270 else if (attack_mode == ATTACK_MODE_HYBRID1)
15271 {
15272 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15273
15274 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);
15275 }
15276 else if (attack_mode == ATTACK_MODE_HYBRID2)
15277 {
15278 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15279
15280 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);
15281 }
15282
15283 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15284 {
15285 // nothing to do
15286 }
15287 else
15288 {
15289 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15290
15291 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);
15292 }
15293
15294 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15295 {
15296 // nothing to do
15297 }
15298 else
15299 {
15300 for (uint i = 0; i < 5; i++)
15301 {
15302 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15303 }
15304
15305 for (uint i = 5; i < 7; i++)
15306 {
15307 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15308 }
15309 }
15310
15311 // maybe this has been updated by clGetKernelWorkGroupInfo()
15312 // value can only be decreased, so we don't need to reallocate buffers
15313
15314 device_param->kernel_threads = kernel_threads;
15315
15316 /**
15317 * Store initial fanspeed if gpu_temp_retain is enabled
15318 */
15319
15320 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15321 int gpu_temp_retain_set = 0;
15322
15323 if (gpu_temp_disable == 0)
15324 {
15325 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15326 {
15327 hc_thread_mutex_lock (mux_adl);
15328
15329 if (data.hm_device[device_id].fan_supported == 1)
15330 {
15331 if (gpu_temp_retain_chgd == 0)
15332 {
15333 uint cur_temp = 0;
15334 uint default_temp = 0;
15335
15336 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);
15337
15338 if (ADL_rc == ADL_OK)
15339 {
15340 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15341
15342 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15343
15344 // special case with multi gpu setups: always use minimum retain
15345
15346 if (gpu_temp_retain_set == 0)
15347 {
15348 gpu_temp_retain = gpu_temp_retain_target;
15349 gpu_temp_retain_set = 1;
15350 }
15351 else
15352 {
15353 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15354 }
15355
15356 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15357 }
15358 }
15359
15360 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15361
15362 temp_retain_fanspeed_value[device_id] = fan_speed;
15363
15364 if (fan_speed == -1)
15365 {
15366 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15367
15368 temp_retain_fanspeed_value[device_id] = 0;
15369 }
15370 }
15371
15372 hc_thread_mutex_unlock (mux_adl);
15373 }
15374 }
15375
15376 /**
15377 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15378 */
15379
15380 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15381 {
15382 hc_thread_mutex_lock (mux_adl);
15383
15384 if (data.hm_device[device_id].od_version == 6)
15385 {
15386 int ADL_rc;
15387
15388 // check powertune capabilities first, if not available then skip device
15389
15390 int powertune_supported = 0;
15391
15392 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15393 {
15394 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15395
15396 return (-1);
15397 }
15398
15399 if (powertune_supported != 0)
15400 {
15401 // powercontrol settings
15402
15403 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15404
15405 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15406 {
15407 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15408 }
15409
15410 if (ADL_rc != ADL_OK)
15411 {
15412 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15413
15414 return (-1);
15415 }
15416
15417 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15418 {
15419 log_error ("ERROR: Failed to set new ADL PowerControl values");
15420
15421 return (-1);
15422 }
15423
15424 // clocks
15425
15426 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15427
15428 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15429
15430 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)
15431 {
15432 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15433
15434 return (-1);
15435 }
15436
15437 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15438
15439 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15440
15441 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15442 {
15443 log_error ("ERROR: Failed to get ADL device capabilities");
15444
15445 return (-1);
15446 }
15447
15448 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15449 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15450
15451 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15452 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15453
15454 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15455 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15456
15457 // warning if profile has too low max values
15458
15459 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15460 {
15461 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15462 }
15463
15464 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15465 {
15466 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15467 }
15468
15469 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15470
15471 performance_state->iNumberOfPerformanceLevels = 2;
15472
15473 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15474 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15475 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15476 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15477
15478 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)
15479 {
15480 log_info ("ERROR: Failed to set ADL performance state");
15481
15482 return (-1);
15483 }
15484
15485 local_free (performance_state);
15486 }
15487 }
15488
15489 hc_thread_mutex_unlock (mux_adl);
15490 }
15491 #endif // HAVE_HWMON && HAVE_ADL
15492 }
15493
15494 data.kernel_power_all = kernel_power_all;
15495
15496 if (data.quiet == 0) log_info_nn ("");
15497
15498 /**
15499 * In benchmark-mode, inform user which algorithm is checked
15500 */
15501
15502 if (benchmark == 1)
15503 {
15504 if (status_automat == 0)
15505 {
15506 quiet = 0;
15507
15508 data.quiet = quiet;
15509
15510 char *hash_type = strhashtype (data.hash_mode); // not a bug
15511
15512 log_info ("Hashtype: %s", hash_type);
15513 log_info ("");
15514 }
15515 }
15516
15517 /**
15518 * keep track of the progress
15519 */
15520
15521 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15522 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15523 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15524
15525 /**
15526 * open filehandles
15527 */
15528
15529 #if _WIN
15530 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15531 {
15532 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15533
15534 return (-1);
15535 }
15536
15537 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15538 {
15539 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15540
15541 return (-1);
15542 }
15543
15544 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15545 {
15546 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15547
15548 return (-1);
15549 }
15550 #endif
15551
15552 /**
15553 * dictionary pad
15554 */
15555
15556 segment_size *= (1024 * 1024);
15557
15558 data.segment_size = segment_size;
15559
15560 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15561
15562 wl_data->buf = (char *) mymalloc (segment_size);
15563 wl_data->avail = segment_size;
15564 wl_data->incr = segment_size;
15565 wl_data->cnt = 0;
15566 wl_data->pos = 0;
15567
15568 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15569
15570 data.wordlist_mode = wordlist_mode;
15571
15572 cs_t *css_buf = NULL;
15573 uint css_cnt = 0;
15574 uint dictcnt = 0;
15575 uint maskcnt = 1;
15576 char **masks = NULL;
15577 char **dictfiles = NULL;
15578
15579 uint mask_from_file = 0;
15580
15581 if (attack_mode == ATTACK_MODE_STRAIGHT)
15582 {
15583 if (wordlist_mode == WL_MODE_FILE)
15584 {
15585 int wls_left = myargc - (optind + 1);
15586
15587 for (int i = 0; i < wls_left; i++)
15588 {
15589 char *l0_filename = myargv[optind + 1 + i];
15590
15591 struct stat l0_stat;
15592
15593 if (stat (l0_filename, &l0_stat) == -1)
15594 {
15595 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15596
15597 return (-1);
15598 }
15599
15600 uint is_dir = S_ISDIR (l0_stat.st_mode);
15601
15602 if (is_dir == 0)
15603 {
15604 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15605
15606 dictcnt++;
15607
15608 dictfiles[dictcnt - 1] = l0_filename;
15609 }
15610 else
15611 {
15612 // do not allow --keyspace w/ a directory
15613
15614 if (keyspace == 1)
15615 {
15616 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15617
15618 return (-1);
15619 }
15620
15621 char **dictionary_files = NULL;
15622
15623 dictionary_files = scan_directory (l0_filename);
15624
15625 if (dictionary_files != NULL)
15626 {
15627 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15628
15629 for (int d = 0; dictionary_files[d] != NULL; d++)
15630 {
15631 char *l1_filename = dictionary_files[d];
15632
15633 struct stat l1_stat;
15634
15635 if (stat (l1_filename, &l1_stat) == -1)
15636 {
15637 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15638
15639 return (-1);
15640 }
15641
15642 if (S_ISREG (l1_stat.st_mode))
15643 {
15644 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15645
15646 dictcnt++;
15647
15648 dictfiles[dictcnt - 1] = strdup (l1_filename);
15649 }
15650 }
15651 }
15652
15653 local_free (dictionary_files);
15654 }
15655 }
15656
15657 if (dictcnt < 1)
15658 {
15659 log_error ("ERROR: No usable dictionary file found.");
15660
15661 return (-1);
15662 }
15663 }
15664 else if (wordlist_mode == WL_MODE_STDIN)
15665 {
15666 dictcnt = 1;
15667 }
15668 }
15669 else if (attack_mode == ATTACK_MODE_COMBI)
15670 {
15671 // display
15672
15673 char *dictfile1 = myargv[optind + 1 + 0];
15674 char *dictfile2 = myargv[optind + 1 + 1];
15675
15676 // find the bigger dictionary and use as base
15677
15678 FILE *fp1 = NULL;
15679 FILE *fp2 = NULL;
15680
15681 struct stat tmp_stat;
15682
15683 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15684 {
15685 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15686
15687 return (-1);
15688 }
15689
15690 if (stat (dictfile1, &tmp_stat) == -1)
15691 {
15692 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15693
15694 fclose (fp1);
15695
15696 return (-1);
15697 }
15698
15699 if (S_ISDIR (tmp_stat.st_mode))
15700 {
15701 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15702
15703 fclose (fp1);
15704
15705 return (-1);
15706 }
15707
15708 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15709 {
15710 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15711
15712 fclose (fp1);
15713
15714 return (-1);
15715 }
15716
15717 if (stat (dictfile2, &tmp_stat) == -1)
15718 {
15719 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15720
15721 fclose (fp1);
15722 fclose (fp2);
15723
15724 return (-1);
15725 }
15726
15727 if (S_ISDIR (tmp_stat.st_mode))
15728 {
15729 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15730
15731 fclose (fp1);
15732 fclose (fp2);
15733
15734 return (-1);
15735 }
15736
15737 data.combs_cnt = 1;
15738
15739 data.quiet = 1;
15740
15741 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15742
15743 data.quiet = quiet;
15744
15745 if (words1_cnt == 0)
15746 {
15747 log_error ("ERROR: %s: empty file", dictfile1);
15748
15749 fclose (fp1);
15750 fclose (fp2);
15751
15752 return (-1);
15753 }
15754
15755 data.combs_cnt = 1;
15756
15757 data.quiet = 1;
15758
15759 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15760
15761 data.quiet = quiet;
15762
15763 if (words2_cnt == 0)
15764 {
15765 log_error ("ERROR: %s: empty file", dictfile2);
15766
15767 fclose (fp1);
15768 fclose (fp2);
15769
15770 return (-1);
15771 }
15772
15773 fclose (fp1);
15774 fclose (fp2);
15775
15776 data.dictfile = dictfile1;
15777 data.dictfile2 = dictfile2;
15778
15779 if (words1_cnt >= words2_cnt)
15780 {
15781 data.combs_cnt = words2_cnt;
15782 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15783
15784 dictfiles = &data.dictfile;
15785
15786 dictcnt = 1;
15787 }
15788 else
15789 {
15790 data.combs_cnt = words1_cnt;
15791 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15792
15793 dictfiles = &data.dictfile2;
15794
15795 dictcnt = 1;
15796
15797 // we also have to switch wordlist related rules!
15798
15799 char *tmpc = data.rule_buf_l;
15800
15801 data.rule_buf_l = data.rule_buf_r;
15802 data.rule_buf_r = tmpc;
15803
15804 int tmpi = data.rule_len_l;
15805
15806 data.rule_len_l = data.rule_len_r;
15807 data.rule_len_r = tmpi;
15808 }
15809 }
15810 else if (attack_mode == ATTACK_MODE_BF)
15811 {
15812 char *mask = NULL;
15813
15814 maskcnt = 0;
15815
15816 if (benchmark == 0)
15817 {
15818 mask = myargv[optind + 1];
15819
15820 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15821
15822 if ((optind + 2) <= myargc)
15823 {
15824 struct stat file_stat;
15825
15826 if (stat (mask, &file_stat) == -1)
15827 {
15828 maskcnt = 1;
15829
15830 masks[maskcnt - 1] = mystrdup (mask);
15831 }
15832 else
15833 {
15834 int wls_left = myargc - (optind + 1);
15835
15836 uint masks_avail = INCR_MASKS;
15837
15838 for (int i = 0; i < wls_left; i++)
15839 {
15840 if (i != 0)
15841 {
15842 mask = myargv[optind + 1 + i];
15843
15844 if (stat (mask, &file_stat) == -1)
15845 {
15846 log_error ("ERROR: %s: %s", mask, strerror (errno));
15847
15848 return (-1);
15849 }
15850 }
15851
15852 uint is_file = S_ISREG (file_stat.st_mode);
15853
15854 if (is_file == 1)
15855 {
15856 FILE *mask_fp;
15857
15858 if ((mask_fp = fopen (mask, "r")) == NULL)
15859 {
15860 log_error ("ERROR: %s: %s", mask, strerror (errno));
15861
15862 return (-1);
15863 }
15864
15865 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15866
15867 while (!feof (mask_fp))
15868 {
15869 memset (line_buf, 0, HCBUFSIZ);
15870
15871 int line_len = fgetl (mask_fp, line_buf);
15872
15873 if (line_len == 0) continue;
15874
15875 if (line_buf[0] == '#') continue;
15876
15877 if (masks_avail == maskcnt)
15878 {
15879 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15880
15881 masks_avail += INCR_MASKS;
15882 }
15883
15884 masks[maskcnt] = mystrdup (line_buf);
15885
15886 maskcnt++;
15887 }
15888
15889 myfree (line_buf);
15890
15891 fclose (mask_fp);
15892 }
15893 else
15894 {
15895 log_error ("ERROR: %s: unsupported file-type", mask);
15896
15897 return (-1);
15898 }
15899 }
15900
15901 mask_from_file = 1;
15902 }
15903 }
15904 else
15905 {
15906 custom_charset_1 = (char *) "?l?d?u";
15907 custom_charset_2 = (char *) "?l?d";
15908 custom_charset_3 = (char *) "?l?d*!$@_";
15909
15910 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15911 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15912 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15913
15914 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15915
15916 wordlist_mode = WL_MODE_MASK;
15917
15918 data.wordlist_mode = wordlist_mode;
15919
15920 increment = 1;
15921
15922 maskcnt = 1;
15923 }
15924 }
15925 else
15926 {
15927 /**
15928 * generate full masks and charsets
15929 */
15930
15931 masks = (char **) mymalloc (sizeof (char *));
15932
15933 switch (hash_mode)
15934 {
15935 case 1731: pw_min = 5;
15936 pw_max = 5;
15937 mask = mystrdup ("?b?b?b?b?b");
15938 break;
15939 case 12500: pw_min = 5;
15940 pw_max = 5;
15941 mask = mystrdup ("?b?b?b?b?b");
15942 break;
15943 default: pw_min = 7;
15944 pw_max = 7;
15945 mask = mystrdup ("?b?b?b?b?b?b?b");
15946 break;
15947 }
15948
15949 maskcnt = 1;
15950
15951 masks[maskcnt - 1] = mystrdup (mask);
15952
15953 wordlist_mode = WL_MODE_MASK;
15954
15955 data.wordlist_mode = wordlist_mode;
15956
15957 increment = 1;
15958 }
15959
15960 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15961
15962 if (increment)
15963 {
15964 if (increment_min > pw_min) pw_min = increment_min;
15965
15966 if (increment_max < pw_max) pw_max = increment_max;
15967 }
15968 }
15969 else if (attack_mode == ATTACK_MODE_HYBRID1)
15970 {
15971 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15972
15973 // display
15974
15975 char *mask = myargv[myargc - 1];
15976
15977 maskcnt = 0;
15978
15979 masks = (char **) mymalloc (1 * sizeof (char *));
15980
15981 // mod
15982
15983 struct stat file_stat;
15984
15985 if (stat (mask, &file_stat) == -1)
15986 {
15987 maskcnt = 1;
15988
15989 masks[maskcnt - 1] = mystrdup (mask);
15990 }
15991 else
15992 {
15993 uint is_file = S_ISREG (file_stat.st_mode);
15994
15995 if (is_file == 1)
15996 {
15997 FILE *mask_fp;
15998
15999 if ((mask_fp = fopen (mask, "r")) == NULL)
16000 {
16001 log_error ("ERROR: %s: %s", mask, strerror (errno));
16002
16003 return (-1);
16004 }
16005
16006 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16007
16008 uint masks_avail = 1;
16009
16010 while (!feof (mask_fp))
16011 {
16012 memset (line_buf, 0, HCBUFSIZ);
16013
16014 int line_len = fgetl (mask_fp, line_buf);
16015
16016 if (line_len == 0) continue;
16017
16018 if (line_buf[0] == '#') continue;
16019
16020 if (masks_avail == maskcnt)
16021 {
16022 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16023
16024 masks_avail += INCR_MASKS;
16025 }
16026
16027 masks[maskcnt] = mystrdup (line_buf);
16028
16029 maskcnt++;
16030 }
16031
16032 myfree (line_buf);
16033
16034 fclose (mask_fp);
16035
16036 mask_from_file = 1;
16037 }
16038 else
16039 {
16040 maskcnt = 1;
16041
16042 masks[maskcnt - 1] = mystrdup (mask);
16043 }
16044 }
16045
16046 // base
16047
16048 int wls_left = myargc - (optind + 2);
16049
16050 for (int i = 0; i < wls_left; i++)
16051 {
16052 char *filename = myargv[optind + 1 + i];
16053
16054 struct stat file_stat;
16055
16056 if (stat (filename, &file_stat) == -1)
16057 {
16058 log_error ("ERROR: %s: %s", filename, strerror (errno));
16059
16060 return (-1);
16061 }
16062
16063 uint is_dir = S_ISDIR (file_stat.st_mode);
16064
16065 if (is_dir == 0)
16066 {
16067 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16068
16069 dictcnt++;
16070
16071 dictfiles[dictcnt - 1] = filename;
16072 }
16073 else
16074 {
16075 // do not allow --keyspace w/ a directory
16076
16077 if (keyspace == 1)
16078 {
16079 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16080
16081 return (-1);
16082 }
16083
16084 char **dictionary_files = NULL;
16085
16086 dictionary_files = scan_directory (filename);
16087
16088 if (dictionary_files != NULL)
16089 {
16090 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16091
16092 for (int d = 0; dictionary_files[d] != NULL; d++)
16093 {
16094 char *l1_filename = dictionary_files[d];
16095
16096 struct stat l1_stat;
16097
16098 if (stat (l1_filename, &l1_stat) == -1)
16099 {
16100 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16101
16102 return (-1);
16103 }
16104
16105 if (S_ISREG (l1_stat.st_mode))
16106 {
16107 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16108
16109 dictcnt++;
16110
16111 dictfiles[dictcnt - 1] = strdup (l1_filename);
16112 }
16113 }
16114 }
16115
16116 local_free (dictionary_files);
16117 }
16118 }
16119
16120 if (dictcnt < 1)
16121 {
16122 log_error ("ERROR: No usable dictionary file found.");
16123
16124 return (-1);
16125 }
16126
16127 if (increment)
16128 {
16129 maskcnt = 0;
16130
16131 uint mask_min = increment_min; // we can't reject smaller masks here
16132 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16133
16134 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16135 {
16136 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16137
16138 if (cur_mask == NULL) break;
16139
16140 masks[maskcnt] = cur_mask;
16141
16142 maskcnt++;
16143
16144 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16145 }
16146 }
16147 }
16148 else if (attack_mode == ATTACK_MODE_HYBRID2)
16149 {
16150 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16151
16152 // display
16153
16154 char *mask = myargv[optind + 1 + 0];
16155
16156 maskcnt = 0;
16157
16158 masks = (char **) mymalloc (1 * sizeof (char *));
16159
16160 // mod
16161
16162 struct stat file_stat;
16163
16164 if (stat (mask, &file_stat) == -1)
16165 {
16166 maskcnt = 1;
16167
16168 masks[maskcnt - 1] = mystrdup (mask);
16169 }
16170 else
16171 {
16172 uint is_file = S_ISREG (file_stat.st_mode);
16173
16174 if (is_file == 1)
16175 {
16176 FILE *mask_fp;
16177
16178 if ((mask_fp = fopen (mask, "r")) == NULL)
16179 {
16180 log_error ("ERROR: %s: %s", mask, strerror (errno));
16181
16182 return (-1);
16183 }
16184
16185 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16186
16187 uint masks_avail = 1;
16188
16189 while (!feof (mask_fp))
16190 {
16191 memset (line_buf, 0, HCBUFSIZ);
16192
16193 int line_len = fgetl (mask_fp, line_buf);
16194
16195 if (line_len == 0) continue;
16196
16197 if (line_buf[0] == '#') continue;
16198
16199 if (masks_avail == maskcnt)
16200 {
16201 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16202
16203 masks_avail += INCR_MASKS;
16204 }
16205
16206 masks[maskcnt] = mystrdup (line_buf);
16207
16208 maskcnt++;
16209 }
16210
16211 myfree (line_buf);
16212
16213 fclose (mask_fp);
16214
16215 mask_from_file = 1;
16216 }
16217 else
16218 {
16219 maskcnt = 1;
16220
16221 masks[maskcnt - 1] = mystrdup (mask);
16222 }
16223 }
16224
16225 // base
16226
16227 int wls_left = myargc - (optind + 2);
16228
16229 for (int i = 0; i < wls_left; i++)
16230 {
16231 char *filename = myargv[optind + 2 + i];
16232
16233 struct stat file_stat;
16234
16235 if (stat (filename, &file_stat) == -1)
16236 {
16237 log_error ("ERROR: %s: %s", filename, strerror (errno));
16238
16239 return (-1);
16240 }
16241
16242 uint is_dir = S_ISDIR (file_stat.st_mode);
16243
16244 if (is_dir == 0)
16245 {
16246 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16247
16248 dictcnt++;
16249
16250 dictfiles[dictcnt - 1] = filename;
16251 }
16252 else
16253 {
16254 // do not allow --keyspace w/ a directory
16255
16256 if (keyspace == 1)
16257 {
16258 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16259
16260 return (-1);
16261 }
16262
16263 char **dictionary_files = NULL;
16264
16265 dictionary_files = scan_directory (filename);
16266
16267 if (dictionary_files != NULL)
16268 {
16269 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16270
16271 for (int d = 0; dictionary_files[d] != NULL; d++)
16272 {
16273 char *l1_filename = dictionary_files[d];
16274
16275 struct stat l1_stat;
16276
16277 if (stat (l1_filename, &l1_stat) == -1)
16278 {
16279 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16280
16281 return (-1);
16282 }
16283
16284 if (S_ISREG (l1_stat.st_mode))
16285 {
16286 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16287
16288 dictcnt++;
16289
16290 dictfiles[dictcnt - 1] = strdup (l1_filename);
16291 }
16292 }
16293 }
16294
16295 local_free (dictionary_files);
16296 }
16297 }
16298
16299 if (dictcnt < 1)
16300 {
16301 log_error ("ERROR: No usable dictionary file found.");
16302
16303 return (-1);
16304 }
16305
16306 if (increment)
16307 {
16308 maskcnt = 0;
16309
16310 uint mask_min = increment_min; // we can't reject smaller masks here
16311 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16312
16313 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16314 {
16315 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16316
16317 if (cur_mask == NULL) break;
16318
16319 masks[maskcnt] = cur_mask;
16320
16321 maskcnt++;
16322
16323 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16324 }
16325 }
16326 }
16327
16328 data.pw_min = pw_min;
16329 data.pw_max = pw_max;
16330
16331 /**
16332 * weak hash check
16333 */
16334
16335 if (weak_hash_threshold >= salts_cnt)
16336 {
16337 hc_device_param_t *device_param = NULL;
16338
16339 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16340 {
16341 device_param = &data.devices_param[device_id];
16342
16343 if (device_param->skipped) continue;
16344
16345 break;
16346 }
16347
16348 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16349
16350 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16351 {
16352 weak_hash_check (device_param, salt_pos);
16353 }
16354
16355 // Display hack, guarantee that there is at least one \r before real start
16356
16357 //if (data.quiet == 0) log_info ("");
16358 }
16359
16360 /**
16361 * status and monitor threads
16362 */
16363
16364 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16365
16366 hc_thread_t i_thread = 0;
16367
16368 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16369 {
16370 hc_thread_create (i_thread, thread_keypress, &benchmark);
16371 }
16372
16373 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16374
16375 uint ni_threads_cnt = 0;
16376
16377 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16378
16379 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16380
16381 ni_threads_cnt++;
16382
16383 /**
16384 * Outfile remove
16385 */
16386
16387 if (keyspace == 0)
16388 {
16389 if (outfile_check_timer != 0)
16390 {
16391 if (data.outfile_check_directory != NULL)
16392 {
16393 if ((hash_mode != 5200) &&
16394 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16395 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16396 (hash_mode != 9000))
16397 {
16398 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16399
16400 ni_threads_cnt++;
16401 }
16402 else
16403 {
16404 outfile_check_timer = 0;
16405 }
16406 }
16407 else
16408 {
16409 outfile_check_timer = 0;
16410 }
16411 }
16412 }
16413
16414 /**
16415 * Inform the user if we got some hashes remove because of the pot file remove feature
16416 */
16417
16418 if (data.quiet == 0)
16419 {
16420 if (potfile_remove_cracks > 0)
16421 {
16422 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16423 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16424 }
16425 }
16426
16427 data.outfile_check_timer = outfile_check_timer;
16428
16429 /**
16430 * main loop
16431 */
16432
16433 char **induction_dictionaries = NULL;
16434
16435 int induction_dictionaries_cnt = 0;
16436
16437 hcstat_table_t *root_table_buf = NULL;
16438 hcstat_table_t *markov_table_buf = NULL;
16439
16440 uint initial_restore_done = 0;
16441
16442 data.maskcnt = maskcnt;
16443
16444 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16445 {
16446 if (data.devices_status == STATUS_CRACKED) break;
16447
16448 data.devices_status = STATUS_INIT;
16449
16450 if (maskpos > rd->maskpos)
16451 {
16452 rd->dictpos = 0;
16453 }
16454
16455 rd->maskpos = maskpos;
16456 data.maskpos = maskpos;
16457
16458 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16459 {
16460 char *mask = masks[maskpos];
16461
16462 if (mask_from_file == 1)
16463 {
16464 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16465
16466 char *str_ptr;
16467 uint str_pos;
16468
16469 uint mask_offset = 0;
16470
16471 uint separator_cnt;
16472
16473 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16474 {
16475 str_ptr = strstr (mask + mask_offset, ",");
16476
16477 if (str_ptr == NULL) break;
16478
16479 str_pos = str_ptr - mask;
16480
16481 // escaped separator, i.e. "\,"
16482
16483 if (str_pos > 0)
16484 {
16485 if (mask[str_pos - 1] == '\\')
16486 {
16487 separator_cnt --;
16488
16489 mask_offset = str_pos + 1;
16490
16491 continue;
16492 }
16493 }
16494
16495 // reset the offset
16496
16497 mask_offset = 0;
16498
16499 mask[str_pos] = '\0';
16500
16501 switch (separator_cnt)
16502 {
16503 case 0:
16504 mp_reset_usr (mp_usr, 0);
16505
16506 custom_charset_1 = mask;
16507 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16508 break;
16509
16510 case 1:
16511 mp_reset_usr (mp_usr, 1);
16512
16513 custom_charset_2 = mask;
16514 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16515 break;
16516
16517 case 2:
16518 mp_reset_usr (mp_usr, 2);
16519
16520 custom_charset_3 = mask;
16521 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16522 break;
16523
16524 case 3:
16525 mp_reset_usr (mp_usr, 3);
16526
16527 custom_charset_4 = mask;
16528 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16529 break;
16530 }
16531
16532 mask = mask + str_pos + 1;
16533 }
16534 }
16535
16536 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16537 {
16538 if (maskpos > 0)
16539 {
16540 local_free (css_buf);
16541 local_free (data.root_css_buf);
16542 local_free (data.markov_css_buf);
16543
16544 local_free (masks[maskpos - 1]);
16545 }
16546
16547 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16548
16549 data.mask = mask;
16550 data.css_cnt = css_cnt;
16551 data.css_buf = css_buf;
16552
16553 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16554
16555 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16556
16557 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16558 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16559
16560 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16561
16562 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16563
16564 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16565 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16566
16567 data.root_css_buf = root_css_buf;
16568 data.markov_css_buf = markov_css_buf;
16569
16570 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16571
16572 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16573
16574 local_free (root_table_buf);
16575 local_free (markov_table_buf);
16576
16577 // args
16578
16579 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16580 {
16581 hc_device_param_t *device_param = &data.devices_param[device_id];
16582
16583 if (device_param->skipped) continue;
16584
16585 device_param->kernel_params_mp[0] = &device_param->d_combs;
16586 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16587 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16588
16589 device_param->kernel_params_mp_buf64[3] = 0;
16590 device_param->kernel_params_mp_buf32[4] = css_cnt;
16591 device_param->kernel_params_mp_buf32[5] = 0;
16592 device_param->kernel_params_mp_buf32[6] = 0;
16593 device_param->kernel_params_mp_buf32[7] = 0;
16594
16595 if (attack_mode == ATTACK_MODE_HYBRID1)
16596 {
16597 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16598 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16599 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16600 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16601 }
16602 else if (attack_mode == ATTACK_MODE_HYBRID2)
16603 {
16604 device_param->kernel_params_mp_buf32[5] = 0;
16605 device_param->kernel_params_mp_buf32[6] = 0;
16606 device_param->kernel_params_mp_buf32[7] = 0;
16607 }
16608
16609 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]);
16610 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]);
16611 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]);
16612
16613 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);
16614 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);
16615 }
16616 }
16617 else if (attack_mode == ATTACK_MODE_BF)
16618 {
16619 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16620
16621 if (increment)
16622 {
16623 for (uint i = 0; i < dictcnt; i++)
16624 {
16625 local_free (dictfiles[i]);
16626 }
16627
16628 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16629 {
16630 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16631
16632 if (l1_filename == NULL) break;
16633
16634 dictcnt++;
16635
16636 dictfiles[dictcnt - 1] = l1_filename;
16637 }
16638 }
16639 else
16640 {
16641 dictcnt++;
16642
16643 dictfiles[dictcnt - 1] = mask;
16644 }
16645
16646 if (dictcnt == 0)
16647 {
16648 log_error ("ERROR: Mask is too small");
16649
16650 return (-1);
16651 }
16652 }
16653 }
16654
16655 free (induction_dictionaries);
16656
16657 // induction_dictionaries_cnt = 0; // implied
16658
16659 if (attack_mode != ATTACK_MODE_BF)
16660 {
16661 if (keyspace == 0)
16662 {
16663 induction_dictionaries = scan_directory (induction_directory);
16664
16665 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16666 }
16667 }
16668
16669 if (induction_dictionaries_cnt)
16670 {
16671 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16672 }
16673
16674 /**
16675 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16676 */
16677 if (keyspace == 1)
16678 {
16679 if ((maskcnt > 1) || (dictcnt > 1))
16680 {
16681 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16682
16683 return (-1);
16684 }
16685 }
16686
16687 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16688 {
16689 char *subid = logfile_generate_subid ();
16690
16691 data.subid = subid;
16692
16693 logfile_sub_msg ("START");
16694
16695 data.devices_status = STATUS_INIT;
16696
16697 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16698 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16699 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16700
16701 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16702
16703 data.cpt_pos = 0;
16704
16705 data.cpt_start = time (NULL);
16706
16707 data.cpt_total = 0;
16708
16709 if (data.restore == 0)
16710 {
16711 rd->words_cur = skip;
16712
16713 skip = 0;
16714
16715 data.skip = 0;
16716 }
16717
16718 data.ms_paused = 0;
16719
16720 data.words_cur = rd->words_cur;
16721
16722 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16723 {
16724 hc_device_param_t *device_param = &data.devices_param[device_id];
16725
16726 if (device_param->skipped) continue;
16727
16728 device_param->speed_pos = 0;
16729
16730 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16731 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16732
16733 device_param->exec_pos = 0;
16734
16735 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16736
16737 device_param->kernel_power = device_param->kernel_power_user;
16738
16739 device_param->outerloop_pos = 0;
16740 device_param->outerloop_left = 0;
16741 device_param->innerloop_pos = 0;
16742 device_param->innerloop_left = 0;
16743
16744 // some more resets:
16745
16746 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16747
16748 device_param->pws_cnt = 0;
16749
16750 device_param->words_off = 0;
16751 device_param->words_done = 0;
16752 }
16753
16754 data.kernel_power_div = 0;
16755
16756 // figure out some workload
16757
16758 if (attack_mode == ATTACK_MODE_STRAIGHT)
16759 {
16760 if (data.wordlist_mode == WL_MODE_FILE)
16761 {
16762 char *dictfile = NULL;
16763
16764 if (induction_dictionaries_cnt)
16765 {
16766 dictfile = induction_dictionaries[0];
16767 }
16768 else
16769 {
16770 dictfile = dictfiles[dictpos];
16771 }
16772
16773 data.dictfile = dictfile;
16774
16775 logfile_sub_string (dictfile);
16776
16777 for (uint i = 0; i < rp_files_cnt; i++)
16778 {
16779 logfile_sub_var_string ("rulefile", rp_files[i]);
16780 }
16781
16782 FILE *fd2 = fopen (dictfile, "rb");
16783
16784 if (fd2 == NULL)
16785 {
16786 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16787
16788 return (-1);
16789 }
16790
16791 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16792
16793 fclose (fd2);
16794
16795 if (data.words_cnt == 0)
16796 {
16797 if (data.devices_status == STATUS_CRACKED) break;
16798 if (data.devices_status == STATUS_ABORTED) break;
16799
16800 dictpos++;
16801
16802 continue;
16803 }
16804 }
16805 }
16806 else if (attack_mode == ATTACK_MODE_COMBI)
16807 {
16808 char *dictfile = data.dictfile;
16809 char *dictfile2 = data.dictfile2;
16810
16811 logfile_sub_string (dictfile);
16812 logfile_sub_string (dictfile2);
16813
16814 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16815 {
16816 FILE *fd2 = fopen (dictfile, "rb");
16817
16818 if (fd2 == NULL)
16819 {
16820 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16821
16822 return (-1);
16823 }
16824
16825 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16826
16827 fclose (fd2);
16828 }
16829 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16830 {
16831 FILE *fd2 = fopen (dictfile2, "rb");
16832
16833 if (fd2 == NULL)
16834 {
16835 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16836
16837 return (-1);
16838 }
16839
16840 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16841
16842 fclose (fd2);
16843 }
16844
16845 if (data.words_cnt == 0)
16846 {
16847 if (data.devices_status == STATUS_CRACKED) break;
16848 if (data.devices_status == STATUS_ABORTED) break;
16849
16850 dictpos++;
16851
16852 continue;
16853 }
16854 }
16855 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16856 {
16857 char *dictfile = NULL;
16858
16859 if (induction_dictionaries_cnt)
16860 {
16861 dictfile = induction_dictionaries[0];
16862 }
16863 else
16864 {
16865 dictfile = dictfiles[dictpos];
16866 }
16867
16868 data.dictfile = dictfile;
16869
16870 char *mask = data.mask;
16871
16872 logfile_sub_string (dictfile);
16873 logfile_sub_string (mask);
16874
16875 FILE *fd2 = fopen (dictfile, "rb");
16876
16877 if (fd2 == NULL)
16878 {
16879 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16880
16881 return (-1);
16882 }
16883
16884 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16885
16886 fclose (fd2);
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_BF)
16899 {
16900 local_free (css_buf);
16901 local_free (data.root_css_buf);
16902 local_free (data.markov_css_buf);
16903
16904 char *mask = dictfiles[dictpos];
16905
16906 logfile_sub_string (mask);
16907
16908 // base
16909
16910 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16911
16912 if (opts_type & OPTS_TYPE_PT_UNICODE)
16913 {
16914 uint css_cnt_unicode = css_cnt * 2;
16915
16916 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16917
16918 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16919 {
16920 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16921
16922 css_buf_unicode[j + 1].cs_buf[0] = 0;
16923 css_buf_unicode[j + 1].cs_len = 1;
16924 }
16925
16926 free (css_buf);
16927
16928 css_buf = css_buf_unicode;
16929 css_cnt = css_cnt_unicode;
16930 }
16931
16932 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16933
16934 uint mask_min = pw_min;
16935 uint mask_max = pw_max;
16936
16937 if (opts_type & OPTS_TYPE_PT_UNICODE)
16938 {
16939 mask_min *= 2;
16940 mask_max *= 2;
16941 }
16942
16943 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16944 {
16945 if (css_cnt < mask_min)
16946 {
16947 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16948 }
16949
16950 if (css_cnt > mask_max)
16951 {
16952 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16953 }
16954
16955 // skip to next mask
16956
16957 dictpos++;
16958
16959 rd->dictpos = dictpos;
16960
16961 logfile_sub_msg ("STOP");
16962
16963 continue;
16964 }
16965
16966 uint save_css_cnt = css_cnt;
16967
16968 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16969 {
16970 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16971 {
16972 uint salt_len = (uint) data.salts_buf[0].salt_len;
16973 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16974
16975 uint css_cnt_salt = css_cnt + salt_len;
16976
16977 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16978
16979 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16980
16981 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16982 {
16983 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16984 css_buf_salt[j].cs_len = 1;
16985 }
16986
16987 free (css_buf);
16988
16989 css_buf = css_buf_salt;
16990 css_cnt = css_cnt_salt;
16991 }
16992 }
16993
16994 data.mask = mask;
16995 data.css_cnt = css_cnt;
16996 data.css_buf = css_buf;
16997
16998 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16999
17000 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17001
17002 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17003
17004 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17005 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17006
17007 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17008
17009 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17010
17011 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17012 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17013
17014 data.root_css_buf = root_css_buf;
17015 data.markov_css_buf = markov_css_buf;
17016
17017 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17018
17019 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17020
17021 local_free (root_table_buf);
17022 local_free (markov_table_buf);
17023
17024 // copy + args
17025
17026 uint css_cnt_l = css_cnt;
17027 uint css_cnt_r;
17028
17029 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17030 {
17031 if (save_css_cnt < 6)
17032 {
17033 css_cnt_r = 1;
17034 }
17035 else if (save_css_cnt == 6)
17036 {
17037 css_cnt_r = 2;
17038 }
17039 else
17040 {
17041 if (opts_type & OPTS_TYPE_PT_UNICODE)
17042 {
17043 if (save_css_cnt == 8 || save_css_cnt == 10)
17044 {
17045 css_cnt_r = 2;
17046 }
17047 else
17048 {
17049 css_cnt_r = 4;
17050 }
17051 }
17052 else
17053 {
17054 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17055 {
17056 css_cnt_r = 3;
17057 }
17058 else
17059 {
17060 css_cnt_r = 4;
17061 }
17062 }
17063 }
17064 }
17065 else
17066 {
17067 css_cnt_r = 1;
17068
17069 /* unfinished code?
17070 int sum = css_buf[css_cnt_r - 1].cs_len;
17071
17072 for (uint i = 1; i < 4 && i < css_cnt; i++)
17073 {
17074 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17075
17076 css_cnt_r++;
17077
17078 sum *= css_buf[css_cnt_r - 1].cs_len;
17079 }
17080 */
17081 }
17082
17083 css_cnt_l -= css_cnt_r;
17084
17085 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17086
17087 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17088 {
17089 hc_device_param_t *device_param = &data.devices_param[device_id];
17090
17091 if (device_param->skipped) continue;
17092
17093 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17094 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17095 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17096
17097 device_param->kernel_params_mp_l_buf64[3] = 0;
17098 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17099 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17100 device_param->kernel_params_mp_l_buf32[6] = 0;
17101 device_param->kernel_params_mp_l_buf32[7] = 0;
17102 device_param->kernel_params_mp_l_buf32[8] = 0;
17103
17104 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17105 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17106 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17107 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17108
17109 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17110 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17111 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17112
17113 device_param->kernel_params_mp_r_buf64[3] = 0;
17114 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17115 device_param->kernel_params_mp_r_buf32[5] = 0;
17116 device_param->kernel_params_mp_r_buf32[6] = 0;
17117 device_param->kernel_params_mp_r_buf32[7] = 0;
17118
17119 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]);
17120 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]);
17121 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]);
17122
17123 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]);
17124 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]);
17125 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]);
17126
17127 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);
17128 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);
17129 }
17130 }
17131
17132 u64 words_base = data.words_cnt;
17133
17134 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17135 {
17136 if (data.kernel_rules_cnt)
17137 {
17138 words_base /= data.kernel_rules_cnt;
17139 }
17140 }
17141 else if (data.attack_kern == ATTACK_KERN_COMBI)
17142 {
17143 if (data.combs_cnt)
17144 {
17145 words_base /= data.combs_cnt;
17146 }
17147 }
17148 else if (data.attack_kern == ATTACK_KERN_BF)
17149 {
17150 if (data.bfs_cnt)
17151 {
17152 words_base /= data.bfs_cnt;
17153 }
17154 }
17155
17156 data.words_base = words_base;
17157
17158 if (keyspace == 1)
17159 {
17160 log_info ("%llu", (unsigned long long int) words_base);
17161
17162 return (0);
17163 }
17164
17165 if (data.words_cur > data.words_base)
17166 {
17167 log_error ("ERROR: restore value greater keyspace");
17168
17169 return (-1);
17170 }
17171
17172 if (data.words_cur)
17173 {
17174 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17175 {
17176 for (uint i = 0; i < data.salts_cnt; i++)
17177 {
17178 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17179 }
17180 }
17181 else if (data.attack_kern == ATTACK_KERN_COMBI)
17182 {
17183 for (uint i = 0; i < data.salts_cnt; i++)
17184 {
17185 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17186 }
17187 }
17188 else if (data.attack_kern == ATTACK_KERN_BF)
17189 {
17190 for (uint i = 0; i < data.salts_cnt; i++)
17191 {
17192 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17193 }
17194 }
17195 }
17196
17197 /*
17198 * Inform user about possible slow speeds
17199 */
17200
17201 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17202 {
17203 if (data.words_base < kernel_power_all)
17204 {
17205 if (quiet == 0)
17206 {
17207 log_info ("ATTENTION!");
17208 log_info (" The wordlist or mask you are using is too small.");
17209 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17210 log_info (" The cracking speed will drop.");
17211 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17212 log_info ("");
17213 }
17214 }
17215 }
17216
17217 /*
17218 * Update loopback file
17219 */
17220
17221 if (loopback == 1)
17222 {
17223 time_t now;
17224
17225 time (&now);
17226
17227 uint random_num = get_random_num (0, 9999);
17228
17229 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17230
17231 data.loopback_file = loopback_file;
17232 }
17233
17234 /*
17235 * Update dictionary statistic
17236 */
17237
17238 if (keyspace == 0)
17239 {
17240 dictstat_fp = fopen (dictstat, "wb");
17241
17242 if (dictstat_fp)
17243 {
17244 lock_file (dictstat_fp);
17245
17246 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17247
17248 fclose (dictstat_fp);
17249 }
17250 }
17251
17252 data.devices_status = STATUS_RUNNING;
17253
17254 if (initial_restore_done == 0)
17255 {
17256 if (data.restore_disable == 0) cycle_restore ();
17257
17258 initial_restore_done = 1;
17259 }
17260
17261 hc_timer_set (&data.timer_running);
17262
17263 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17264 {
17265 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17266 {
17267 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17268 if (quiet == 0) fflush (stdout);
17269 }
17270 }
17271 else if (wordlist_mode == WL_MODE_STDIN)
17272 {
17273 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17274 if (data.quiet == 0) log_info ("");
17275 }
17276
17277 time_t runtime_start;
17278
17279 time (&runtime_start);
17280
17281 data.runtime_start = runtime_start;
17282
17283 /**
17284 * create cracker threads
17285 */
17286
17287 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17288
17289 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17290 {
17291 hc_device_param_t *device_param = &devices_param[device_id];
17292
17293 if (wordlist_mode == WL_MODE_STDIN)
17294 {
17295 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17296 }
17297 else
17298 {
17299 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17300 }
17301 }
17302
17303 // wait for crack threads to exit
17304
17305 hc_thread_wait (data.devices_cnt, c_threads);
17306
17307 local_free (c_threads);
17308
17309 data.restore = 0;
17310
17311 // finalize task
17312
17313 logfile_sub_var_uint ("status-after-work", data.devices_status);
17314
17315 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17316
17317 if (data.devices_status == STATUS_CRACKED) break;
17318 if (data.devices_status == STATUS_ABORTED) break;
17319
17320 if (data.devices_status == STATUS_BYPASS)
17321 {
17322 data.devices_status = STATUS_RUNNING;
17323 }
17324
17325 if (induction_dictionaries_cnt)
17326 {
17327 unlink (induction_dictionaries[0]);
17328 }
17329
17330 free (induction_dictionaries);
17331
17332 if (attack_mode != ATTACK_MODE_BF)
17333 {
17334 induction_dictionaries = scan_directory (induction_directory);
17335
17336 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17337 }
17338
17339 if (benchmark == 0)
17340 {
17341 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17342 {
17343 if (quiet == 0) clear_prompt ();
17344
17345 if (quiet == 0) log_info ("");
17346
17347 if (status == 1)
17348 {
17349 status_display ();
17350 }
17351 else
17352 {
17353 if (quiet == 0) status_display ();
17354 }
17355
17356 if (quiet == 0) log_info ("");
17357 }
17358 }
17359
17360 if (attack_mode == ATTACK_MODE_BF)
17361 {
17362 dictpos++;
17363
17364 rd->dictpos = dictpos;
17365 }
17366 else
17367 {
17368 if (induction_dictionaries_cnt)
17369 {
17370 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17371 }
17372 else
17373 {
17374 dictpos++;
17375
17376 rd->dictpos = dictpos;
17377 }
17378 }
17379
17380 time_t runtime_stop;
17381
17382 time (&runtime_stop);
17383
17384 data.runtime_stop = runtime_stop;
17385
17386 logfile_sub_uint (runtime_start);
17387 logfile_sub_uint (runtime_stop);
17388
17389 logfile_sub_msg ("STOP");
17390
17391 global_free (subid);
17392 }
17393
17394 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17395
17396 if (data.devices_status == STATUS_CRACKED) break;
17397 if (data.devices_status == STATUS_ABORTED) break;
17398 if (data.devices_status == STATUS_QUIT) break;
17399
17400 if (data.devices_status == STATUS_BYPASS)
17401 {
17402 data.devices_status = STATUS_RUNNING;
17403 }
17404 }
17405
17406 // 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
17407
17408 if (attack_mode == ATTACK_MODE_STRAIGHT)
17409 {
17410 if (data.wordlist_mode == WL_MODE_FILE)
17411 {
17412 if (data.dictfile == NULL)
17413 {
17414 if (dictfiles != NULL)
17415 {
17416 data.dictfile = dictfiles[0];
17417
17418 hc_timer_set (&data.timer_running);
17419 }
17420 }
17421 }
17422 }
17423 // NOTE: combi is okay because it is already set beforehand
17424 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17425 {
17426 if (data.dictfile == NULL)
17427 {
17428 if (dictfiles != NULL)
17429 {
17430 hc_timer_set (&data.timer_running);
17431
17432 data.dictfile = dictfiles[0];
17433 }
17434 }
17435 }
17436 else if (attack_mode == ATTACK_MODE_BF)
17437 {
17438 if (data.mask == NULL)
17439 {
17440 hc_timer_set (&data.timer_running);
17441
17442 data.mask = masks[0];
17443 }
17444 }
17445
17446 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17447 {
17448 data.devices_status = STATUS_EXHAUSTED;
17449 }
17450
17451 // if cracked / aborted remove last induction dictionary
17452
17453 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17454 {
17455 struct stat induct_stat;
17456
17457 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17458 {
17459 unlink (induction_dictionaries[file_pos]);
17460 }
17461 }
17462
17463 // wait for non-interactive threads
17464
17465 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17466 {
17467 hc_thread_wait (1, &ni_threads[thread_idx]);
17468 }
17469
17470 local_free (ni_threads);
17471
17472 // wait for interactive threads
17473
17474 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17475 {
17476 hc_thread_wait (1, &i_thread);
17477 }
17478
17479 // we dont need restore file anymore
17480 if (data.restore_disable == 0)
17481 {
17482 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17483 {
17484 unlink (eff_restore_file);
17485 unlink (new_restore_file);
17486 }
17487 else
17488 {
17489 cycle_restore ();
17490 }
17491 }
17492
17493 // finally save left hashes
17494
17495 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17496 {
17497 save_hash ();
17498 }
17499
17500 /**
17501 * Clean up
17502 */
17503
17504 if (benchmark == 1)
17505 {
17506 status_benchmark ();
17507
17508 if (status_automat == 0)
17509 {
17510 log_info ("");
17511 }
17512 }
17513 else
17514 {
17515 if (quiet == 0) clear_prompt ();
17516
17517 if (quiet == 0) log_info ("");
17518
17519 if (status == 1)
17520 {
17521 status_display ();
17522 }
17523 else
17524 {
17525 if (quiet == 0) status_display ();
17526 }
17527
17528 if (quiet == 0) log_info ("");
17529 }
17530
17531 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17532 {
17533 hc_device_param_t *device_param = &data.devices_param[device_id];
17534
17535 if (device_param->skipped) continue;
17536
17537 local_free (device_param->combs_buf);
17538
17539 local_free (device_param->hooks_buf);
17540
17541 local_free (device_param->device_name);
17542
17543 local_free (device_param->device_name_chksum);
17544
17545 local_free (device_param->device_version);
17546
17547 local_free (device_param->driver_version);
17548
17549 if (device_param->pws_buf) myfree (device_param->pws_buf);
17550 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17551 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17552 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17553 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17554 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17555 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17556 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17557 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17558 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17559 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17560 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17561 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17562 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17563 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17564 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17565 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17566 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17567 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17568 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17569 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17570 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17571 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17572 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17573 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17574 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17575 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17576 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17577 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17578
17579 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17580 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17581 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17582 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17583 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17584 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17585 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17586 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17587 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17588 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17589
17590 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17591 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17592 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17593
17594 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17595 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17596 }
17597
17598 // reset default fan speed
17599
17600 #ifdef HAVE_HWMON
17601 if (gpu_temp_disable == 0)
17602 {
17603 #ifdef HAVE_ADL
17604 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17605 {
17606 hc_thread_mutex_lock (mux_adl);
17607
17608 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17609 {
17610 hc_device_param_t *device_param = &data.devices_param[device_id];
17611
17612 if (device_param->skipped) continue;
17613
17614 if (data.hm_device[device_id].fan_supported == 1)
17615 {
17616 int fanspeed = temp_retain_fanspeed_value[device_id];
17617
17618 if (fanspeed == -1) continue;
17619
17620 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17621
17622 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17623 }
17624 }
17625
17626 hc_thread_mutex_unlock (mux_adl);
17627 }
17628 #endif // HAVE_ADL
17629 }
17630
17631 #ifdef HAVE_ADL
17632 // reset power tuning
17633
17634 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17635 {
17636 hc_thread_mutex_lock (mux_adl);
17637
17638 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17639 {
17640 hc_device_param_t *device_param = &data.devices_param[device_id];
17641
17642 if (device_param->skipped) continue;
17643
17644 if (data.hm_device[device_id].od_version == 6)
17645 {
17646 // check powertune capabilities first, if not available then skip device
17647
17648 int powertune_supported = 0;
17649
17650 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17651 {
17652 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17653
17654 return (-1);
17655 }
17656
17657 if (powertune_supported != 0)
17658 {
17659 // powercontrol settings
17660
17661 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)
17662 {
17663 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17664
17665 return (-1);
17666 }
17667
17668 // clocks
17669
17670 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17671
17672 performance_state->iNumberOfPerformanceLevels = 2;
17673
17674 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17675 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17676 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17677 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17678
17679 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)
17680 {
17681 log_info ("ERROR: Failed to restore ADL performance state");
17682
17683 return (-1);
17684 }
17685
17686 local_free (performance_state);
17687 }
17688 }
17689 }
17690
17691 hc_thread_mutex_unlock (mux_adl);
17692 }
17693 #endif // HAVE_ADL
17694
17695 if (gpu_temp_disable == 0)
17696 {
17697 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17698 if (data.hm_nv)
17699 {
17700 #if defined(LINUX) && defined(HAVE_NVML)
17701
17702 hm_NVML_nvmlShutdown (data.hm_nv);
17703
17704 nvml_close (data.hm_nv);
17705
17706 #elif defined(WIN) && (HAVE_NVAPI)
17707
17708 hm_NvAPI_Unload (data.hm_nv);
17709
17710 nvapi_close (data.hm_nv);
17711
17712 #endif
17713
17714 data.hm_nv = NULL;
17715 }
17716 #endif
17717
17718 #ifdef HAVE_ADL
17719 if (data.hm_amd)
17720 {
17721 hm_ADL_Main_Control_Destroy (data.hm_amd);
17722
17723 adl_close (data.hm_amd);
17724 data.hm_amd = NULL;
17725 }
17726 #endif
17727 }
17728 #endif // HAVE_HWMON
17729
17730 // free memory
17731
17732 local_free (masks);
17733
17734 local_free (dictstat_base);
17735
17736 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17737 {
17738 pot_t *pot_ptr = &pot[pot_pos];
17739
17740 hash_t *hash = &pot_ptr->hash;
17741
17742 local_free (hash->digest);
17743
17744 if (isSalted)
17745 {
17746 local_free (hash->salt);
17747 }
17748 }
17749
17750 local_free (pot);
17751
17752 local_free (all_kernel_rules_cnt);
17753 local_free (all_kernel_rules_buf);
17754
17755 local_free (wl_data->buf);
17756 local_free (wl_data);
17757
17758 local_free (bitmap_s1_a);
17759 local_free (bitmap_s1_b);
17760 local_free (bitmap_s1_c);
17761 local_free (bitmap_s1_d);
17762 local_free (bitmap_s2_a);
17763 local_free (bitmap_s2_b);
17764 local_free (bitmap_s2_c);
17765 local_free (bitmap_s2_d);
17766
17767 #ifdef HAVE_HWMON
17768 local_free (temp_retain_fanspeed_value);
17769 #ifdef HAVE_ADL
17770 local_free (od_clock_mem_status);
17771 local_free (od_power_control_status);
17772 #endif // ADL
17773 #endif
17774
17775 global_free (devices_param);
17776
17777 global_free (kernel_rules_buf);
17778
17779 global_free (root_css_buf);
17780 global_free (markov_css_buf);
17781
17782 global_free (digests_buf);
17783 global_free (digests_shown);
17784 global_free (digests_shown_tmp);
17785
17786 global_free (salts_buf);
17787 global_free (salts_shown);
17788
17789 global_free (esalts_buf);
17790
17791 global_free (words_progress_done);
17792 global_free (words_progress_rejected);
17793 global_free (words_progress_restored);
17794
17795 if (pot_fp) fclose (pot_fp);
17796
17797 if (data.devices_status == STATUS_QUIT) break;
17798 }
17799
17800 // destroy others mutex
17801
17802 hc_thread_mutex_delete (mux_dispatcher);
17803 hc_thread_mutex_delete (mux_counter);
17804 hc_thread_mutex_delete (mux_display);
17805 hc_thread_mutex_delete (mux_adl);
17806
17807 // free memory
17808
17809 local_free (eff_restore_file);
17810 local_free (new_restore_file);
17811
17812 local_free (rd);
17813
17814 // tuning db
17815
17816 tuning_db_destroy (tuning_db);
17817
17818 // loopback
17819
17820 local_free (loopback_file);
17821
17822 if (loopback == 1) unlink (loopback_file);
17823
17824 // induction directory
17825
17826 if (induction_dir == NULL)
17827 {
17828 if (attack_mode != ATTACK_MODE_BF)
17829 {
17830 if (rmdir (induction_directory) == -1)
17831 {
17832 if (errno == ENOENT)
17833 {
17834 // good, we can ignore
17835 }
17836 else if (errno == ENOTEMPTY)
17837 {
17838 // good, we can ignore
17839 }
17840 else
17841 {
17842 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17843
17844 return (-1);
17845 }
17846 }
17847
17848 local_free (induction_directory);
17849 }
17850 }
17851
17852 // outfile-check directory
17853
17854 if (outfile_check_dir == NULL)
17855 {
17856 if (rmdir (outfile_check_directory) == -1)
17857 {
17858 if (errno == ENOENT)
17859 {
17860 // good, we can ignore
17861 }
17862 else if (errno == ENOTEMPTY)
17863 {
17864 // good, we can ignore
17865 }
17866 else
17867 {
17868 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17869
17870 return (-1);
17871 }
17872 }
17873
17874 local_free (outfile_check_directory);
17875 }
17876
17877 time_t proc_stop;
17878
17879 time (&proc_stop);
17880
17881 logfile_top_uint (proc_start);
17882 logfile_top_uint (proc_stop);
17883
17884 logfile_top_msg ("STOP");
17885
17886 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17887 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17888
17889 if (data.ocl) ocl_close (data.ocl);
17890
17891 if (data.devices_status == STATUS_ABORTED) return 2;
17892 if (data.devices_status == STATUS_QUIT) return 2;
17893 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17894 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17895 if (data.devices_status == STATUS_CRACKED) return 0;
17896
17897 return -1;
17898 }
Hashcat additions to support pwdhash