projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix changes
[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] = { 8, 16, 96, 512 };
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 " Short- | Long- | Parameter- | Description | Example",
357 " Option | Option | Type | |",
358 "--------+---------------------------+------------+------------------------------------------------------+---------------------",
359 " -m | --hash-type | Number | Hash-type, see references below | -m 1000",
360 " -a | --attack-mode | Number | Attack-mode, see references below | -a 3",
361 " -V | --version | | Print version | --version",
362 " -h | --help | | Print help | --help",
363 " | --quiet | | Suppress output | --quiet",
364 " | --hex-charset | | Assume charset is given in hex | --hex-charset",
365 " | --hex-salt | | Assume salt is given in hex | --hex-salt",
366 " | --hex-wordlist | | Assume words in wordlist is given in hex | --hex-wordlist",
367 " | --force | | Ignore warnings | --force",
368 " | --status | | Enable automatic update of the status-screen | --status",
369 " | --status-timer | Number | Sets seconds between status-screen update to X | --status-timer=1",
370 " | --status-automat | | Display the status view in a machine readable format | --status-automat",
371 " | --loopback | | Add new plains to induct directory | --loopback",
372 " | --weak-hash-threshold | Number | Threshold X when to stop checking for weak hashes | --weak-hash-threshold=0",
373 " | --markov-hcstat | File | Specify hcstat file to use, default is hashcat.hcstat| --markiv-hcstat=my.hcstat",
374 " | --markov-disable | | Disables markov-chains, emulates classic brute-force | --markov-disable",
375 " | --markov-classic | | Enables classic markov-chains, no per-position | --markov-classic",
376 " -t | --markov-threshold | Number | Threshold X when to stop accepting new markov-chains | -t 50",
377 " | --runtime | Number | Abort session after X seconds of runtime | --runtime=10",
378 " | --session | String | Define specific session name | --session=mysession",
379 " | --restore | | Restore session from --session | --restore",
380 " | --restore-disable | | Do not write restore file | --restore-disable",
381 " -o | --outfile | File | Define outfile for recovered hash | -o outfile.txt",
382 " | --outfile-format | Number | Define outfile-format X for recovered hash | --outfile-format=7",
383 " | --outfile-autohex-disable | | Disable the use of $HEX[] in output plains | --outfile-autohex-disable",
384 " | --outfile-check-timer | Number | Sets seconds between outfile checks to X | --outfile-check-timer=30",
385 " -p | --separator | Char | Separator char for hashlists and outfile | -p :",
386 " | --show | | Show cracked passwords only | --show",
387 " | --left | | Show un-cracked passwords only | --left",
388 " | --username | | Enable ignoring of usernames in hashfile | --username",
389 " | --remove | | Enable remove of hash once it is cracked | --remove",
390 " | --remove-timer | Number | Update input hash file each X seconds | --remove-timer=30",
391 " | --potfile-disable | | Do not write potfile | --potfile-disable",
392 " | --potfile-path | | Specific path to potfile | --potfile-path=hashcat.pot",
393 " | --debug-mode | Number | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
394 " | --debug-file | File | Output file for debugging rules | --debug-file=goodrules.log",
395 " | --induction-dir | Folder | Specify the induction directory to use for loopback | --induction-dir=inducts",
396 " | --outfile-check-dir | Folder | Specify the outfile directory to monitor for plains | --outfile-check-dir=ext",
397 " | --logfile-disable | | Disable the logfile | --logfile-disable",
398 " | --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-keyfiles=xx.png",
399 " | --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-keyfiles=xx.png",
400 " | --veracrypt-pim | Number | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
401 " -b | --benchmark | | Run benchmark | -b",
402 " -c | --segment-size | Number | Sets size in MB to cache from the wordfile to X | -c 32",
403 " | --bitmap-min | Number | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
404 " | --bitmap-max | Number | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
405 " | --cpu-affinity | String | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3,4",
406 " | --opencl-platforms | String | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
407 " -d | --opencl-devices | String | OpenCL devices to use, separate with comma | -d 1",
408 " | --opencl-device-types | String | OpenCL device-types to use, separate with comma | --opencl-device-types=1,2",
409 " | --opencl-vector-width | Number | Manual override OpenCL vector-width to X | --opencl-vector-width=4",
410 " -w | --workload-profile | Number | Enable a specific workload profile, see pool below | -w 3",
411 " -n | --kernel-accel | Number | Manual workload tuning, set outerloop step size to X | -n 64",
412 " -u | --kernel-loops | Number | Manual workload tuning, set innerloop step size to X | -u 256",
413 " | --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers | --gpu-temp-disable",
414 #ifdef HAVE_HWMON
415 " | --gpu-temp-abort | Number | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
416 " | --gpu-temp-retain | Number | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
417 #ifdef HAVE_ADL
418 " | --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) | --powertune-enable",
419 #endif
420 #endif
421 " | --scrypt-tmto | Number | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
422 " -s | --skip | Number | Skip X words from the start | -s 1000000",
423 " -l | --limit | Number | Limit X words from the start + skipped words | -l 1000000",
424 " | --keyspace | | Show keyspace base:mod values and quit | --keyspace",
425 " -j | --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
426 " -k | --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
427 " -r | --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
428 " -g | --generate-rules | | Enable generate random rules | -g 10000",
429 " | --generate-rules-func-min | Number | Force min X funcs per rule |",
430 " | --generate-rules-func-max | Number | Force max X funcs per rule |",
431 " | --generate-rules-seed | Number | Force RNG seed set to X |",
432 " -1 | --custom-charset1 | Charset | User-defined charset ?1 | -1 ?l?d?u",
433 " -2 | --custom-charset2 | Charset | User-defined charset ?2 | -2 ?l?d?s",
434 " -3 | --custom-charset3 | Charset | User-defined charset ?3 |",
435 " -4 | --custom-charset4 | Charset | User-defined charset ?4 |",
436 " -i | --increment | | Enable mask increment mode | --increment",
437 " | --increment-min | Number | Start mask incrementing at X | --increment-min=4",
438 " | --increment-max | Number | Stop mask incrementing at X | --increment-max=8",
439 "",
440 "################",
441 "## Hash modes ##",
442 "################",
443 "",
444 " # | Name | Category",
445 " ------+--------------------------------------------------+--------------------------------------",
446 " 900 | MD4 | Raw Hash",
447 " 0 | MD5 | Raw Hash",
448 " 5100 | Half MD5 | Raw Hash",
449 " 100 | SHA1 | Raw Hash",
450 " 10800 | SHA-384 | Raw Hash",
451 " 1400 | SHA-256 | Raw Hash",
452 " 1700 | SHA-512 | Raw Hash",
453 " 5000 | SHA-3(Keccak) | Raw Hash",
454 " 10100 | SipHash | Raw Hash",
455 " 6000 | RipeMD160 | Raw Hash",
456 " 6100 | Whirlpool | Raw Hash",
457 " 6900 | GOST R 34.11-94 | Raw Hash",
458 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
459 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
460 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
461 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
462 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
463 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
464 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
466 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
467 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
468 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
469 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
470 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
471 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
472 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
473 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
474 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
475 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
477 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
478 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
479 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
480 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
481 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
482 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
483 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
484 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
485 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
486 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
487 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
488 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
489 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
490 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
491 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
492 " 400 | phpass | Generic KDF",
493 " 8900 | scrypt | Generic KDF",
494 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
495 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
496 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
497 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
498 " 23 | Skype | Network protocols",
499 " 2500 | WPA/WPA2 | Network protocols",
500 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
501 " 5300 | IKE-PSK MD5 | Network protocols",
502 " 5400 | IKE-PSK SHA1 | Network protocols",
503 " 5500 | NetNTLMv1 | Network protocols",
504 " 5500 | NetNTLMv1 + ESS | Network protocols",
505 " 5600 | NetNTLMv2 | Network protocols",
506 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
507 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
508 " 8300 | DNSSEC (NSEC3) | Network protocols",
509 " 10200 | Cram MD5 | Network protocols",
510 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
511 " 11200 | MySQL CRAM (SHA1) | Network protocols",
512 " 11400 | SIP digest authentication (MD5) | Network protocols",
513 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
514 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
515 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
516 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
517 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
518 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
519 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
520 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
521 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
522 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
523 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
524 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
525 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
526 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
527 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
528 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
529 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
530 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
531 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
532 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
533 " 12 | PostgreSQL | Database Server",
534 " 131 | MSSQL(2000) | Database Server",
535 " 132 | MSSQL(2005) | Database Server",
536 " 1731 | MSSQL(2012) | Database Server",
537 " 1731 | MSSQL(2014) | Database Server",
538 " 200 | MySQL323 | Database Server",
539 " 300 | MySQL4.1/MySQL5 | Database Server",
540 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
541 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
542 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
543 " 8000 | Sybase ASE | Database Server",
544 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
545 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
546 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
547 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
548 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
549 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
550 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
551 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
552 " 11500 | CRC32 | Checksums",
553 " 3000 | LM | Operating-Systems",
554 " 1000 | NTLM | Operating-Systems",
555 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
556 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
557 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
558 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
559 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
560 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
561 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
562 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
563 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
564 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
565 " 1722 | OSX v10.7 | Operating-Systems",
566 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
567 " 6300 | AIX {smd5} | Operating-Systems",
568 " 6700 | AIX {ssha1} | Operating-Systems",
569 " 6400 | AIX {ssha256} | Operating-Systems",
570 " 6500 | AIX {ssha512} | Operating-Systems",
571 " 2400 | Cisco-PIX | Operating-Systems",
572 " 2410 | Cisco-ASA | Operating-Systems",
573 " 500 | Cisco-IOS $1$ | Operating-Systems",
574 " 5700 | Cisco-IOS $4$ | Operating-Systems",
575 " 9200 | Cisco-IOS $8$ | Operating-Systems",
576 " 9300 | Cisco-IOS $9$ | Operating-Systems",
577 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
578 " 501 | Juniper IVE | Operating-Systems",
579 " 5800 | Android PIN | Operating-Systems",
580 " 8100 | Citrix Netscaler | Operating-Systems",
581 " 8500 | RACF | Operating-Systems",
582 " 7200 | GRUB 2 | Operating-Systems",
583 " 9900 | Radmin2 | Operating-Systems",
584 " 125 | ArubaOS | Operating-Systems",
585 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
586 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
587 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
588 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
589 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
590 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
591 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
592 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
593 " 11600 | 7-Zip | Archives",
594 " 12500 | RAR3-hp | Archives",
595 " 13000 | RAR5 | Archives",
596 " 13200 | AxCrypt | Archives",
597 " 13300 | AxCrypt in memory SHA1 | Archives",
598 " 13600 | WinZip | Archives",
599 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
600 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
601 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
602 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
603 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
604 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
605 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
606 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
608 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
609 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
610 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
611 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
612 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
613 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
614 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
615 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
616 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
617 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
618 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
619 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
620 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
621 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
622 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
623 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
624 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
625 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
626 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
628 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
629 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
630 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
631 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
632 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
633 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
634 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
635 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
636 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
637 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
638 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
639 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
640 " 9400 | MS Office 2007 | Documents",
641 " 9500 | MS Office 2010 | Documents",
642 " 9600 | MS Office 2013 | Documents",
643 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
644 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
645 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
646 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
647 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
648 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
649 " 9000 | Password Safe v2 | Password Managers",
650 " 5200 | Password Safe v3 | Password Managers",
651 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
652 " 6600 | 1Password, agilekeychain | Password Managers",
653 " 8200 | 1Password, cloudkeychain | Password Managers",
654 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
655 " 12700 | Blockchain, My Wallet | Password Managers",
656 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
657 "",
658 "#####################",
659 "## Outfile Formats ##",
660 "#####################",
661 "",
662 " # | Format",
663 " ---+--------",
664 " 1 | hash[:salt]",
665 " 2 | plain",
666 " 3 | hash[:salt]:plain",
667 " 4 | hex_plain",
668 " 5 | hash[:salt]:hex_plain",
669 " 6 | plain:hex_plain",
670 " 7 | hash[:salt]:plain:hex_plain",
671 " 8 | crackpos",
672 " 9 | hash[:salt]:crack_pos",
673 " 10 | plain:crack_pos",
674 " 11 | hash[:salt]:plain:crack_pos",
675 " 12 | hex_plain:crack_pos",
676 " 13 | hash[:salt]:hex_plain:crack_pos",
677 " 14 | plain:hex_plain:crack_pos",
678 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
679 "",
680 "##########################",
681 "## Rule Debugging Modes ##",
682 "##########################",
683 "",
684 " # | Format",
685 " ---+--------",
686 " 1 | Finding-Rule",
687 " 2 | Original-Word",
688 " 3 | Original-Word:Finding-Rule",
689 " 4 | Original-Word:Finding-Rule:Processed-Word",
690 "",
691 "##################",
692 "## Attack Modes ##",
693 "##################",
694 "",
695 " # | Mode",
696 " ---+------",
697 " 0 | Straight",
698 " 1 | Combination",
699 " 3 | Brute-force",
700 " 6 | Hybrid Wordlist + Mask",
701 " 7 | Hybrid Mask + Wordlist",
702 "",
703 "#######################",
704 "## Built-in Charsets ##",
705 "#######################",
706 "",
707 " ? | Charset",
708 " ---+---------",
709 " l | abcdefghijklmnopqrstuvwxyz",
710 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
711 " d | 0123456789",
712 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
713 " a | ?l?u?d?s",
714 " b | 0x00 - 0xff",
715 "",
716 "#########################",
717 "## OpenCL Device Types ##",
718 "#########################",
719 "",
720 " # | Device Type",
721 " ---+-------------",
722 " 1 | CPU",
723 " 2 | GPU",
724 " 3 | FPGA, DSP, Co-Processor",
725 "",
726 "#######################",
727 "## Workload Profiles ##",
728 "#######################",
729 "",
730 " # | Performance | Runtime | Power Consumption | Desktop Impact",
731 " ---+-------------+---------+-------------------+----------------",
732 " 1 | Low | 8 ms | Low | Minimal",
733 " 2 | Default | 16 ms | Economic | Noticeable",
734 " 3 | High | 96 ms | High | Unresponsive",
735 " 4 | Nightmare | 512 ms | Insane | Headless",
736 "",
737 "If you have no idea what just happend, please visit the following pages:",
738 "",
739 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
740 "* https://hashcat.net/wiki/#frequently_asked_questions",
741 "",
742 NULL
743 };
744
745 /**
746 * hashcat specific functions
747 */
748
749 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
750 {
751 int exec_pos = (int) device_param->exec_pos - last_num_entries;
752
753 if (exec_pos < 0) exec_pos += EXEC_CACHE;
754
755 double exec_ms_sum = 0;
756
757 int exec_ms_cnt = 0;
758
759 for (int i = 0; i < last_num_entries; i++)
760 {
761 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
762
763 if (exec_ms)
764 {
765 exec_ms_sum += exec_ms;
766
767 exec_ms_cnt++;
768 }
769 }
770
771 if (exec_ms_cnt == 0) return 0;
772
773 return exec_ms_sum / exec_ms_cnt;
774 }
775
776 void status_display_automat ()
777 {
778 FILE *out = stdout;
779
780 fprintf (out, "STATUS\t%u\t", data.devices_status);
781
782 /**
783 * speed new
784 */
785
786 fprintf (out, "SPEED\t");
787
788 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
789 {
790 hc_device_param_t *device_param = &data.devices_param[device_id];
791
792 if (device_param->skipped) continue;
793
794 u64 speed_cnt = 0;
795 double speed_ms = 0;
796
797 for (int i = 0; i < SPEED_CACHE; i++)
798 {
799 speed_cnt += device_param->speed_cnt[i];
800 speed_ms += device_param->speed_ms[i];
801 }
802
803 speed_cnt /= SPEED_CACHE;
804 speed_ms /= SPEED_CACHE;
805
806 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
807 }
808
809 /**
810 * exec time
811 */
812
813 fprintf (out, "EXEC_RUNTIME\t");
814
815 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
816 {
817 hc_device_param_t *device_param = &data.devices_param[device_id];
818
819 if (device_param->skipped) continue;
820
821 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
822
823 fprintf (out, "%f\t", exec_ms_avg);
824 }
825
826 /**
827 * words_cur
828 */
829
830 u64 words_cur = get_lowest_words_done ();
831
832 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
833
834 /**
835 * counter
836 */
837
838 u64 progress_total = data.words_cnt * data.salts_cnt;
839
840 u64 all_done = 0;
841 u64 all_rejected = 0;
842 u64 all_restored = 0;
843
844 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
845 {
846 all_done += data.words_progress_done[salt_pos];
847 all_rejected += data.words_progress_rejected[salt_pos];
848 all_restored += data.words_progress_restored[salt_pos];
849 }
850
851 u64 progress_cur = all_restored + all_done + all_rejected;
852 u64 progress_end = progress_total;
853
854 u64 progress_skip = 0;
855
856 if (data.skip)
857 {
858 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
859
860 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
861 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
862 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
863 }
864
865 if (data.limit)
866 {
867 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
868
869 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
870 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
871 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
872 }
873
874 u64 progress_cur_relative_skip = progress_cur - progress_skip;
875 u64 progress_end_relative_skip = progress_end - progress_skip;
876
877 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
878
879 /**
880 * cracks
881 */
882
883 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
884 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
885
886 /**
887 * temperature
888 */
889
890 #ifdef HAVE_HWMON
891 if (data.gpu_temp_disable == 0)
892 {
893 fprintf (out, "TEMP\t");
894
895 hc_thread_mutex_lock (mux_adl);
896
897 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
898 {
899 hc_device_param_t *device_param = &data.devices_param[device_id];
900
901 if (device_param->skipped) continue;
902
903 int temp = hm_get_temperature_with_device_id (device_id);
904
905 fprintf (out, "%d\t", temp);
906 }
907
908 hc_thread_mutex_unlock (mux_adl);
909 }
910 #endif // HAVE_HWMON
911
912 /**
913 * flush
914 */
915
916 #ifdef _WIN
917 fputc ('\r', out);
918 fputc ('\n', out);
919 #endif
920
921 #ifdef _POSIX
922 fputc ('\n', out);
923 #endif
924
925 fflush (out);
926 }
927
928 void status_display ()
929 {
930 if (data.devices_status == STATUS_INIT) return;
931 if (data.devices_status == STATUS_STARTING) return;
932 if (data.devices_status == STATUS_BYPASS) return;
933
934 if (data.status_automat == 1)
935 {
936 status_display_automat ();
937
938 return;
939 }
940
941 char tmp_buf[1000] = { 0 };
942
943 uint tmp_len = 0;
944
945 log_info ("Session.Name...: %s", data.session);
946
947 char *status_type = strstatus (data.devices_status);
948
949 uint hash_mode = data.hash_mode;
950
951 char *hash_type = strhashtype (hash_mode); // not a bug
952
953 log_info ("Status.........: %s", status_type);
954
955 /**
956 * show rules
957 */
958
959 if (data.rp_files_cnt)
960 {
961 uint i;
962
963 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
964 {
965 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
966 }
967
968 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
969
970 log_info ("Rules.Type.....: %s", tmp_buf);
971
972 tmp_len = 0;
973 }
974
975 if (data.rp_gen)
976 {
977 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
978
979 if (data.rp_gen_seed)
980 {
981 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
982 }
983 }
984
985 /**
986 * show input
987 */
988
989 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
990 {
991 if (data.wordlist_mode == WL_MODE_FILE)
992 {
993 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
994 }
995 else if (data.wordlist_mode == WL_MODE_STDIN)
996 {
997 log_info ("Input.Mode.....: Pipe");
998 }
999 }
1000 else if (data.attack_mode == ATTACK_MODE_COMBI)
1001 {
1002 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1003 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
1004 }
1005 else if (data.attack_mode == ATTACK_MODE_BF)
1006 {
1007 char *mask = data.mask;
1008
1009 if (mask != NULL)
1010 {
1011 uint mask_len = data.css_cnt;
1012
1013 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
1014
1015 if (mask_len > 0)
1016 {
1017 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1018 {
1019 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1020 {
1021 mask_len -= data.salts_buf[0].salt_len;
1022 }
1023 }
1024
1025 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1026
1027 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1028 }
1029
1030 if (data.maskcnt > 1)
1031 {
1032 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1033
1034 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1035 }
1036
1037 log_info ("Input.Mode.....: %s", tmp_buf);
1038 }
1039
1040 tmp_len = 0;
1041 }
1042 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1043 {
1044 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1045 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1046 }
1047 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1048 {
1049 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1050 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1051 }
1052
1053 if (data.digests_cnt == 1)
1054 {
1055 if (data.hash_mode == 2500)
1056 {
1057 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1058
1059 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1060 (char *) data.salts_buf[0].salt_buf,
1061 wpa->orig_mac1[0],
1062 wpa->orig_mac1[1],
1063 wpa->orig_mac1[2],
1064 wpa->orig_mac1[3],
1065 wpa->orig_mac1[4],
1066 wpa->orig_mac1[5],
1067 wpa->orig_mac2[0],
1068 wpa->orig_mac2[1],
1069 wpa->orig_mac2[2],
1070 wpa->orig_mac2[3],
1071 wpa->orig_mac2[4],
1072 wpa->orig_mac2[5]);
1073 }
1074 else if (data.hash_mode == 5200)
1075 {
1076 log_info ("Hash.Target....: File (%s)", data.hashfile);
1077 }
1078 else if (data.hash_mode == 9000)
1079 {
1080 log_info ("Hash.Target....: File (%s)", data.hashfile);
1081 }
1082 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1083 {
1084 log_info ("Hash.Target....: File (%s)", data.hashfile);
1085 }
1086 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1087 {
1088 log_info ("Hash.Target....: File (%s)", data.hashfile);
1089 }
1090 else
1091 {
1092 char out_buf[HCBUFSIZ] = { 0 };
1093
1094 ascii_digest (out_buf, 0, 0);
1095
1096 // limit length
1097 if (strlen (out_buf) > 40)
1098 {
1099 out_buf[41] = '.';
1100 out_buf[42] = '.';
1101 out_buf[43] = '.';
1102 out_buf[44] = 0;
1103 }
1104
1105 log_info ("Hash.Target....: %s", out_buf);
1106 }
1107 }
1108 else
1109 {
1110 if (data.hash_mode == 3000)
1111 {
1112 char out_buf1[32] = { 0 };
1113 char out_buf2[32] = { 0 };
1114
1115 ascii_digest (out_buf1, 0, 0);
1116 ascii_digest (out_buf2, 0, 1);
1117
1118 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1119 }
1120 else
1121 {
1122 log_info ("Hash.Target....: File (%s)", data.hashfile);
1123 }
1124 }
1125
1126 log_info ("Hash.Type......: %s", hash_type);
1127
1128 /**
1129 * speed new
1130 */
1131
1132 u64 speed_cnt[DEVICES_MAX] = { 0 };
1133 double speed_ms[DEVICES_MAX] = { 0 };
1134
1135 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1136 {
1137 hc_device_param_t *device_param = &data.devices_param[device_id];
1138
1139 if (device_param->skipped) continue;
1140
1141 speed_cnt[device_id] = 0;
1142 speed_ms[device_id] = 0;
1143
1144 for (int i = 0; i < SPEED_CACHE; i++)
1145 {
1146 speed_cnt[device_id] += device_param->speed_cnt[i];
1147 speed_ms[device_id] += device_param->speed_ms[i];
1148 }
1149
1150 speed_cnt[device_id] /= SPEED_CACHE;
1151 speed_ms[device_id] /= SPEED_CACHE;
1152 }
1153
1154 double hashes_all_ms = 0;
1155
1156 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1157
1158 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1159 {
1160 hc_device_param_t *device_param = &data.devices_param[device_id];
1161
1162 if (device_param->skipped) continue;
1163
1164 hashes_dev_ms[device_id] = 0;
1165
1166 if (speed_ms[device_id])
1167 {
1168 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1169
1170 hashes_all_ms += hashes_dev_ms[device_id];
1171 }
1172 }
1173
1174 /**
1175 * exec time
1176 */
1177
1178 double exec_all_ms[DEVICES_MAX] = { 0 };
1179
1180 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1181 {
1182 hc_device_param_t *device_param = &data.devices_param[device_id];
1183
1184 if (device_param->skipped) continue;
1185
1186 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1187
1188 exec_all_ms[device_id] = exec_ms_avg;
1189 }
1190
1191 /**
1192 * timers
1193 */
1194
1195 double ms_running = 0;
1196
1197 hc_timer_get (data.timer_running, ms_running);
1198
1199 double ms_paused = data.ms_paused;
1200
1201 if (data.devices_status == STATUS_PAUSED)
1202 {
1203 double ms_paused_tmp = 0;
1204
1205 hc_timer_get (data.timer_paused, ms_paused_tmp);
1206
1207 ms_paused += ms_paused_tmp;
1208 }
1209
1210 #ifdef WIN
1211
1212 __time64_t sec_run = ms_running / 1000;
1213
1214 #else
1215
1216 time_t sec_run = ms_running / 1000;
1217
1218 #endif
1219
1220 if (sec_run)
1221 {
1222 char display_run[32] = { 0 };
1223
1224 struct tm tm_run;
1225
1226 struct tm *tmp = NULL;
1227
1228 #ifdef WIN
1229
1230 tmp = _gmtime64 (&sec_run);
1231
1232 #else
1233
1234 tmp = gmtime (&sec_run);
1235
1236 #endif
1237
1238 if (tmp != NULL)
1239 {
1240 memset (&tm_run, 0, sizeof (tm_run));
1241
1242 memcpy (&tm_run, tmp, sizeof (tm_run));
1243
1244 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1245
1246 char *start = ctime (&data.proc_start);
1247
1248 size_t start_len = strlen (start);
1249
1250 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1251 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1252
1253 log_info ("Time.Started...: %s (%s)", start, display_run);
1254 }
1255 }
1256 else
1257 {
1258 log_info ("Time.Started...: 0 secs");
1259 }
1260
1261 /**
1262 * counters
1263 */
1264
1265 u64 progress_total = data.words_cnt * data.salts_cnt;
1266
1267 u64 all_done = 0;
1268 u64 all_rejected = 0;
1269 u64 all_restored = 0;
1270
1271 u64 progress_noneed = 0;
1272
1273 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1274 {
1275 all_done += data.words_progress_done[salt_pos];
1276 all_rejected += data.words_progress_rejected[salt_pos];
1277 all_restored += data.words_progress_restored[salt_pos];
1278
1279 // Important for ETA only
1280
1281 if (data.salts_shown[salt_pos] == 1)
1282 {
1283 const u64 all = data.words_progress_done[salt_pos]
1284 + data.words_progress_rejected[salt_pos]
1285 + data.words_progress_restored[salt_pos];
1286
1287 const u64 left = data.words_cnt - all;
1288
1289 progress_noneed += left;
1290 }
1291 }
1292
1293 u64 progress_cur = all_restored + all_done + all_rejected;
1294 u64 progress_end = progress_total;
1295
1296 u64 progress_skip = 0;
1297
1298 if (data.skip)
1299 {
1300 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1301
1302 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1303 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1304 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1305 }
1306
1307 if (data.limit)
1308 {
1309 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1310
1311 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1312 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1313 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1314 }
1315
1316 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1317 u64 progress_end_relative_skip = progress_end - progress_skip;
1318
1319 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1320 {
1321 if (data.devices_status != STATUS_CRACKED)
1322 {
1323 #ifdef WIN
1324 __time64_t sec_etc = 0;
1325 #else
1326 time_t sec_etc = 0;
1327 #endif
1328
1329 if (hashes_all_ms)
1330 {
1331 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1332
1333 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1334
1335 sec_etc = ms_left / 1000;
1336 }
1337
1338 if (sec_etc == 0)
1339 {
1340 //log_info ("Time.Estimated.: 0 secs");
1341 }
1342 else if ((u64) sec_etc > ETC_MAX)
1343 {
1344 log_info ("Time.Estimated.: > 10 Years");
1345 }
1346 else
1347 {
1348 char display_etc[32] = { 0 };
1349
1350 struct tm tm_etc;
1351
1352 struct tm *tmp = NULL;
1353
1354 #ifdef WIN
1355
1356 tmp = _gmtime64 (&sec_etc);
1357
1358 #else
1359
1360 tmp = gmtime (&sec_etc);
1361
1362 #endif
1363
1364 if (tmp != NULL)
1365 {
1366 memset (&tm_etc, 0, sizeof (tm_etc));
1367
1368 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1369
1370 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1371
1372 time_t now;
1373
1374 time (&now);
1375
1376 now += sec_etc;
1377
1378 char *etc = ctime (&now);
1379
1380 size_t etc_len = strlen (etc);
1381
1382 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1383 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1384
1385 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1386 }
1387 }
1388 }
1389 }
1390
1391 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1392 {
1393 hc_device_param_t *device_param = &data.devices_param[device_id];
1394
1395 if (device_param->skipped) continue;
1396
1397 char display_dev_cur[16] = { 0 };
1398
1399 strncpy (display_dev_cur, "0.00", 4);
1400
1401 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1402
1403 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1404 }
1405
1406 char display_all_cur[16] = { 0 };
1407
1408 strncpy (display_all_cur, "0.00", 4);
1409
1410 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1411
1412 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1413
1414 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1415 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1416
1417 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);
1418
1419 // crack-per-time
1420
1421 if (data.digests_cnt > 100)
1422 {
1423 time_t now = time (NULL);
1424
1425 int cpt_cur_min = 0;
1426 int cpt_cur_hour = 0;
1427 int cpt_cur_day = 0;
1428
1429 for (int i = 0; i < CPT_BUF; i++)
1430 {
1431 const uint cracked = data.cpt_buf[i].cracked;
1432 const time_t timestamp = data.cpt_buf[i].timestamp;
1433
1434 if ((timestamp + 60) > now)
1435 {
1436 cpt_cur_min += cracked;
1437 }
1438
1439 if ((timestamp + 3600) > now)
1440 {
1441 cpt_cur_hour += cracked;
1442 }
1443
1444 if ((timestamp + 86400) > now)
1445 {
1446 cpt_cur_day += cracked;
1447 }
1448 }
1449
1450 double ms_real = ms_running - ms_paused;
1451
1452 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1453 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1454 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1455
1456 if ((data.cpt_start + 86400) < now)
1457 {
1458 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1459 cpt_cur_min,
1460 cpt_cur_hour,
1461 cpt_cur_day,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else if ((data.cpt_start + 3600) < now)
1467 {
1468 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_cur_min,
1470 cpt_cur_hour,
1471 cpt_avg_min,
1472 cpt_avg_hour,
1473 cpt_avg_day);
1474 }
1475 else if ((data.cpt_start + 60) < now)
1476 {
1477 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1478 cpt_cur_min,
1479 cpt_avg_min,
1480 cpt_avg_hour,
1481 cpt_avg_day);
1482 }
1483 else
1484 {
1485 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1486 cpt_avg_min,
1487 cpt_avg_hour,
1488 cpt_avg_day);
1489 }
1490 }
1491
1492 // Restore point
1493
1494 u64 restore_point = get_lowest_words_done ();
1495
1496 u64 restore_total = data.words_base;
1497
1498 float percent_restore = 0;
1499
1500 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1501
1502 if (progress_end_relative_skip)
1503 {
1504 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1505 {
1506 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1507 float percent_rejected = 0.0;
1508
1509 if (progress_cur)
1510 {
1511 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1512 }
1513
1514 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);
1515 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1516
1517 if (data.restore_disable == 0)
1518 {
1519 if (percent_finished != 1)
1520 {
1521 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1522 }
1523 }
1524 }
1525 }
1526 else
1527 {
1528 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1529 {
1530 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1531 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1532
1533 if (data.restore_disable == 0)
1534 {
1535 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1536 }
1537 }
1538 else
1539 {
1540 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1541 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1542
1543 // --restore not allowed if stdin is used -- really? why?
1544
1545 //if (data.restore_disable == 0)
1546 //{
1547 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1548 //}
1549 }
1550 }
1551
1552 #ifdef HAVE_HWMON
1553 if (data.gpu_temp_disable == 0)
1554 {
1555 hc_thread_mutex_lock (mux_adl);
1556
1557 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1558 {
1559 hc_device_param_t *device_param = &data.devices_param[device_id];
1560
1561 if (device_param->skipped) continue;
1562
1563 #define HM_STR_BUF_SIZE 255
1564
1565 if (data.hm_device[device_id].fan_supported == 1)
1566 {
1567 char utilization[HM_STR_BUF_SIZE] = { 0 };
1568 char temperature[HM_STR_BUF_SIZE] = { 0 };
1569 char fanspeed[HM_STR_BUF_SIZE] = { 0 };
1570
1571 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1572 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1573
1574 if (device_param->vendor_id == VENDOR_ID_AMD)
1575 {
1576 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1577 }
1578 else if (device_param->vendor_id == VENDOR_ID_NV)
1579 {
1580 hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id));
1581 }
1582
1583 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed);
1584 }
1585 else
1586 {
1587 char utilization[HM_STR_BUF_SIZE] = { 0 };
1588 char temperature[HM_STR_BUF_SIZE] = { 0 };
1589
1590 hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id));
1591 hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id));
1592
1593 log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature);
1594 }
1595 }
1596
1597 hc_thread_mutex_unlock (mux_adl);
1598 }
1599 #endif // HAVE_HWMON
1600 }
1601
1602 static void status_benchmark_automat ()
1603 {
1604 u64 speed_cnt[DEVICES_MAX] = { 0 };
1605 double speed_ms[DEVICES_MAX] = { 0 };
1606
1607 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1608 {
1609 hc_device_param_t *device_param = &data.devices_param[device_id];
1610
1611 if (device_param->skipped) continue;
1612
1613 speed_cnt[device_id] = device_param->speed_cnt[0];
1614 speed_ms[device_id] = device_param->speed_ms[0];
1615 }
1616
1617 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1618
1619 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1620 {
1621 hc_device_param_t *device_param = &data.devices_param[device_id];
1622
1623 if (device_param->skipped) continue;
1624
1625 hashes_dev_ms[device_id] = 0;
1626
1627 if (speed_ms[device_id])
1628 {
1629 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1630 }
1631 }
1632
1633 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1634 {
1635 hc_device_param_t *device_param = &data.devices_param[device_id];
1636
1637 if (device_param->skipped) continue;
1638
1639 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1640 }
1641 }
1642
1643 static void status_benchmark ()
1644 {
1645 if (data.devices_status == STATUS_INIT) return;
1646 if (data.devices_status == STATUS_STARTING) return;
1647 if (data.devices_status == STATUS_BYPASS) return;
1648
1649 if (data.status_automat == 1)
1650 {
1651 status_benchmark_automat ();
1652
1653 return;
1654 }
1655
1656 u64 speed_cnt[DEVICES_MAX] = { 0 };
1657 double speed_ms[DEVICES_MAX] = { 0 };
1658
1659 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1660 {
1661 hc_device_param_t *device_param = &data.devices_param[device_id];
1662
1663 if (device_param->skipped) continue;
1664
1665 speed_cnt[device_id] = device_param->speed_cnt[0];
1666 speed_ms[device_id] = device_param->speed_ms[0];
1667 }
1668
1669 double hashes_all_ms = 0;
1670
1671 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1672
1673 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1674 {
1675 hc_device_param_t *device_param = &data.devices_param[device_id];
1676
1677 if (device_param->skipped) continue;
1678
1679 hashes_dev_ms[device_id] = 0;
1680
1681 if (speed_ms[device_id])
1682 {
1683 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1684
1685 hashes_all_ms += hashes_dev_ms[device_id];
1686 }
1687 }
1688
1689 /**
1690 * exec time
1691 */
1692
1693 double exec_all_ms[DEVICES_MAX] = { 0 };
1694
1695 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1696 {
1697 hc_device_param_t *device_param = &data.devices_param[device_id];
1698
1699 if (device_param->skipped) continue;
1700
1701 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1702
1703 exec_all_ms[device_id] = exec_ms_avg;
1704 }
1705
1706 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1707 {
1708 hc_device_param_t *device_param = &data.devices_param[device_id];
1709
1710 if (device_param->skipped) continue;
1711
1712 char display_dev_cur[16] = { 0 };
1713
1714 strncpy (display_dev_cur, "0.00", 4);
1715
1716 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1717
1718 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1719 }
1720
1721 char display_all_cur[16] = { 0 };
1722
1723 strncpy (display_all_cur, "0.00", 4);
1724
1725 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1726
1727 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1728 }
1729
1730 /**
1731 * hashcat -only- functions
1732 */
1733
1734 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1735 {
1736 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1737 {
1738 if (attack_kern == ATTACK_KERN_STRAIGHT)
1739 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1740 else if (attack_kern == ATTACK_KERN_COMBI)
1741 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1742 else if (attack_kern == ATTACK_KERN_BF)
1743 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1744 }
1745 else
1746 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1747 }
1748
1749 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)
1750 {
1751 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1752 {
1753 if (attack_kern == ATTACK_KERN_STRAIGHT)
1754 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1755 else if (attack_kern == ATTACK_KERN_COMBI)
1756 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1757 else if (attack_kern == ATTACK_KERN_BF)
1758 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1759 }
1760 else
1761 {
1762 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1763 }
1764 }
1765
1766 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1767 {
1768 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1769 {
1770 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1771 }
1772 else
1773 {
1774 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1775 }
1776 }
1777
1778 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)
1779 {
1780 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1781 {
1782 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1783 }
1784 else
1785 {
1786 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1787 }
1788 }
1789
1790 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1791 {
1792 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1793 }
1794
1795 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1796 {
1797 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1798 }
1799
1800 static uint convert_from_hex (char *line_buf, const uint line_len)
1801 {
1802 if (line_len & 1) return (line_len); // not in hex
1803
1804 if (data.hex_wordlist == 1)
1805 {
1806 uint i;
1807 uint j;
1808
1809 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1810 {
1811 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1812 }
1813
1814 memset (line_buf + i, 0, line_len - i);
1815
1816 return (i);
1817 }
1818 else if (line_len >= 6) // $HEX[] = 6
1819 {
1820 if (line_buf[0] != '$') return (line_len);
1821 if (line_buf[1] != 'H') return (line_len);
1822 if (line_buf[2] != 'E') return (line_len);
1823 if (line_buf[3] != 'X') return (line_len);
1824 if (line_buf[4] != '[') return (line_len);
1825 if (line_buf[line_len - 1] != ']') return (line_len);
1826
1827 uint i;
1828 uint j;
1829
1830 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1831 {
1832 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1833 }
1834
1835 memset (line_buf + i, 0, line_len - i);
1836
1837 return (i);
1838 }
1839
1840 return (line_len);
1841 }
1842
1843 static void clear_prompt ()
1844 {
1845 fputc ('\r', stdout);
1846
1847 for (size_t i = 0; i < strlen (PROMPT); i++)
1848 {
1849 fputc (' ', stdout);
1850 }
1851
1852 fputc ('\r', stdout);
1853
1854 fflush (stdout);
1855 }
1856
1857 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1858 {
1859 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);
1860 }
1861
1862 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1863 {
1864 char *outfile = data.outfile;
1865 uint quiet = data.quiet;
1866 FILE *pot_fp = data.pot_fp;
1867 uint loopback = data.loopback;
1868 uint debug_mode = data.debug_mode;
1869 char *debug_file = data.debug_file;
1870
1871 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1872 int debug_rule_len = 0; // -1 error
1873 uint debug_plain_len = 0;
1874
1875 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1876
1877 // hash
1878
1879 char out_buf[HCBUFSIZ] = { 0 };
1880
1881 const u32 salt_pos = plain->salt_pos;
1882 const u32 digest_pos = plain->digest_pos; // relative
1883 const u32 gidvid = plain->gidvid;
1884 const u32 il_pos = plain->il_pos;
1885
1886 ascii_digest (out_buf, salt_pos, digest_pos);
1887
1888 // plain
1889
1890 u64 crackpos = device_param->words_off;
1891
1892 uint plain_buf[16] = { 0 };
1893
1894 u8 *plain_ptr = (u8 *) plain_buf;
1895
1896 unsigned int plain_len = 0;
1897
1898 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1899 {
1900 pw_t pw;
1901
1902 gidd_to_pw_t (device_param, gidvid, &pw);
1903
1904 for (int i = 0; i < 16; i++)
1905 {
1906 plain_buf[i] = pw.i[i];
1907 }
1908
1909 plain_len = pw.pw_len;
1910
1911 const uint off = device_param->innerloop_pos + il_pos;
1912
1913 if (debug_mode > 0)
1914 {
1915 debug_rule_len = 0;
1916
1917 // save rule
1918 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1919 {
1920 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1921
1922 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1923 }
1924
1925 // save plain
1926 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1927 {
1928 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1929
1930 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1931
1932 debug_plain_len = plain_len;
1933 }
1934 }
1935
1936 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1937
1938 crackpos += gidvid;
1939 crackpos *= data.kernel_rules_cnt;
1940 crackpos += device_param->innerloop_pos + il_pos;
1941
1942 if (plain_len > data.pw_max) plain_len = data.pw_max;
1943 }
1944 else if (data.attack_mode == ATTACK_MODE_COMBI)
1945 {
1946 pw_t pw;
1947
1948 gidd_to_pw_t (device_param, gidvid, &pw);
1949
1950 for (int i = 0; i < 16; i++)
1951 {
1952 plain_buf[i] = pw.i[i];
1953 }
1954
1955 plain_len = pw.pw_len;
1956
1957 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1958 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1959
1960 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1961 {
1962 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1963 }
1964 else
1965 {
1966 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1967
1968 memcpy (plain_ptr, comb_buf, comb_len);
1969 }
1970
1971 plain_len += comb_len;
1972
1973 crackpos += gidvid;
1974 crackpos *= data.combs_cnt;
1975 crackpos += device_param->innerloop_pos + il_pos;
1976
1977 if (data.pw_max != PW_DICTMAX1)
1978 {
1979 if (plain_len > data.pw_max) plain_len = data.pw_max;
1980 }
1981 }
1982 else if (data.attack_mode == ATTACK_MODE_BF)
1983 {
1984 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
1985 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
1986
1987 uint l_start = device_param->kernel_params_mp_l_buf32[5];
1988 uint r_start = device_param->kernel_params_mp_r_buf32[5];
1989
1990 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
1991 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
1992
1993 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
1994 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
1995
1996 plain_len = data.css_cnt;
1997
1998 crackpos += gidvid;
1999 crackpos *= data.bfs_cnt;
2000 crackpos += device_param->innerloop_pos + il_pos;
2001 }
2002 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2003 {
2004 pw_t pw;
2005
2006 gidd_to_pw_t (device_param, gidvid, &pw);
2007
2008 for (int i = 0; i < 16; i++)
2009 {
2010 plain_buf[i] = pw.i[i];
2011 }
2012
2013 plain_len = pw.pw_len;
2014
2015 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2016
2017 uint start = 0;
2018 uint stop = device_param->kernel_params_mp_buf32[4];
2019
2020 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2021
2022 plain_len += start + stop;
2023
2024 crackpos += gidvid;
2025 crackpos *= data.combs_cnt;
2026 crackpos += device_param->innerloop_pos + il_pos;
2027
2028 if (data.pw_max != PW_DICTMAX1)
2029 {
2030 if (plain_len > data.pw_max) plain_len = data.pw_max;
2031 }
2032 }
2033 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2034 {
2035 pw_t pw;
2036
2037 gidd_to_pw_t (device_param, gidvid, &pw);
2038
2039 for (int i = 0; i < 16; i++)
2040 {
2041 plain_buf[i] = pw.i[i];
2042 }
2043
2044 plain_len = pw.pw_len;
2045
2046 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2047
2048 uint start = 0;
2049 uint stop = device_param->kernel_params_mp_buf32[4];
2050
2051 memmove (plain_ptr + stop, plain_ptr, plain_len);
2052
2053 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2054
2055 plain_len += start + stop;
2056
2057 crackpos += gidvid;
2058 crackpos *= data.combs_cnt;
2059 crackpos += device_param->innerloop_pos + il_pos;
2060
2061 if (data.pw_max != PW_DICTMAX1)
2062 {
2063 if (plain_len > data.pw_max) plain_len = data.pw_max;
2064 }
2065 }
2066
2067 if (data.attack_mode == ATTACK_MODE_BF)
2068 {
2069 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2070 {
2071 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2072 {
2073 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2074 {
2075 plain_len = plain_len - data.salts_buf[0].salt_len;
2076 }
2077 }
2078
2079 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2080 {
2081 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2082 {
2083 plain_ptr[j] = plain_ptr[i];
2084 }
2085
2086 plain_len = plain_len / 2;
2087 }
2088 }
2089 }
2090
2091 // if enabled, update also the potfile
2092
2093 if (pot_fp)
2094 {
2095 lock_file (pot_fp);
2096
2097 fprintf (pot_fp, "%s:", out_buf);
2098
2099 format_plain (pot_fp, plain_ptr, plain_len, 1);
2100
2101 fputc ('\n', pot_fp);
2102
2103 fflush (pot_fp);
2104
2105 unlock_file (pot_fp);
2106 }
2107
2108 // outfile
2109
2110 FILE *out_fp = NULL;
2111
2112 if (outfile != NULL)
2113 {
2114 if ((out_fp = fopen (outfile, "ab")) == NULL)
2115 {
2116 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2117
2118 out_fp = stdout;
2119 }
2120 lock_file (out_fp);
2121 }
2122 else
2123 {
2124 out_fp = stdout;
2125
2126 if (quiet == 0) clear_prompt ();
2127 }
2128
2129 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2130
2131 if (outfile != NULL)
2132 {
2133 if (out_fp != stdout)
2134 {
2135 fclose (out_fp);
2136 }
2137 }
2138 else
2139 {
2140 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2141 {
2142 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2143 {
2144 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2145 if (quiet == 0) fflush (stdout);
2146 }
2147 }
2148 }
2149
2150 // loopback
2151
2152 if (loopback)
2153 {
2154 char *loopback_file = data.loopback_file;
2155
2156 FILE *fb_fp = NULL;
2157
2158 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2159 {
2160 lock_file (fb_fp);
2161
2162 format_plain (fb_fp, plain_ptr, plain_len, 1);
2163
2164 fputc ('\n', fb_fp);
2165
2166 fclose (fb_fp);
2167 }
2168 }
2169
2170 // (rule) debug mode
2171
2172 // the next check implies that:
2173 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2174 // - debug_mode > 0
2175
2176 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2177 {
2178 if (debug_rule_len < 0) debug_rule_len = 0;
2179
2180 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2181
2182 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2183
2184 if ((quiet == 0) && (debug_file == NULL))
2185 {
2186 fprintf (stdout, "%s", PROMPT);
2187
2188 fflush (stdout);
2189 }
2190 }
2191 }
2192
2193 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2194 {
2195 salt_t *salt_buf = &data.salts_buf[salt_pos];
2196
2197 u32 num_cracked;
2198
2199 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2200
2201 if (num_cracked)
2202 {
2203 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2204
2205 log_info_nn ("");
2206
2207 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2208
2209 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);
2210
2211 uint cpt_cracked = 0;
2212
2213 for (uint i = 0; i < num_cracked; i++)
2214 {
2215 const uint hash_pos = cracked[i].hash_pos;
2216
2217 if (data.digests_shown[hash_pos] == 1) continue;
2218
2219 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2220 {
2221 data.digests_shown[hash_pos] = 1;
2222
2223 data.digests_done++;
2224
2225 cpt_cracked++;
2226
2227 salt_buf->digests_done++;
2228
2229 if (salt_buf->digests_done == salt_buf->digests_cnt)
2230 {
2231 data.salts_shown[salt_pos] = 1;
2232
2233 data.salts_done++;
2234 }
2235 }
2236
2237 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2238
2239 check_hash (device_param, &cracked[i]);
2240 }
2241
2242 myfree (cracked);
2243
2244 if (cpt_cracked > 0)
2245 {
2246 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2247 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2248
2249 data.cpt_pos++;
2250
2251 data.cpt_total += cpt_cracked;
2252
2253 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2254 }
2255
2256 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2257 {
2258 // we need to reset cracked state on the device
2259 // otherwise host thinks again and again the hash was cracked
2260 // and returns invalid password each time
2261
2262 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2263
2264 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);
2265 }
2266
2267 num_cracked = 0;
2268
2269 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2270 }
2271 }
2272
2273 static void save_hash ()
2274 {
2275 char *hashfile = data.hashfile;
2276
2277 char new_hashfile[256] = { 0 };
2278 char old_hashfile[256] = { 0 };
2279
2280 snprintf (new_hashfile, 255, "%s.new", hashfile);
2281 snprintf (old_hashfile, 255, "%s.old", hashfile);
2282
2283 unlink (new_hashfile);
2284
2285 char separator = data.separator;
2286
2287 FILE *fp = fopen (new_hashfile, "wb");
2288
2289 if (fp == NULL)
2290 {
2291 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2292
2293 exit (-1);
2294 }
2295
2296 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2297 {
2298 if (data.salts_shown[salt_pos] == 1) continue;
2299
2300 salt_t *salt_buf = &data.salts_buf[salt_pos];
2301
2302 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2303 {
2304 uint idx = salt_buf->digests_offset + digest_pos;
2305
2306 if (data.digests_shown[idx] == 1) continue;
2307
2308 if (data.hash_mode != 2500)
2309 {
2310 char out_buf[HCBUFSIZ] = { 0 };
2311
2312 if (data.username == 1)
2313 {
2314 user_t *user = data.hash_info[idx]->user;
2315
2316 uint i;
2317
2318 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2319
2320 fputc (separator, fp);
2321 }
2322
2323 ascii_digest (out_buf, salt_pos, digest_pos);
2324
2325 fputs (out_buf, fp);
2326
2327 log_out (fp, "");
2328 }
2329 else
2330 {
2331 hccap_t hccap;
2332
2333 to_hccap_t (&hccap, salt_pos, digest_pos);
2334
2335 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2336 }
2337 }
2338 }
2339
2340 fflush (fp);
2341
2342 fclose (fp);
2343
2344 unlink (old_hashfile);
2345
2346 if (rename (hashfile, old_hashfile) != 0)
2347 {
2348 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2349
2350 exit (-1);
2351 }
2352
2353 unlink (hashfile);
2354
2355 if (rename (new_hashfile, hashfile) != 0)
2356 {
2357 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2358
2359 exit (-1);
2360 }
2361
2362 unlink (old_hashfile);
2363 }
2364
2365 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2366 {
2367 // function called only in case kernel_power_all > words_left
2368
2369 float kernel_power_div = (float) (total_left) / kernel_power_all;
2370
2371 kernel_power_div += kernel_power_div / 100;
2372
2373 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2374
2375 while (kernel_power_new < total_left)
2376 {
2377 kernel_power_div += kernel_power_div / 100;
2378
2379 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2380 }
2381
2382 if (data.quiet == 0)
2383 {
2384 clear_prompt ();
2385
2386 //log_info ("");
2387
2388 log_info ("INFO: approaching final keyspace, workload adjusted");
2389 log_info ("");
2390
2391 fprintf (stdout, "%s", PROMPT);
2392
2393 fflush (stdout);
2394 }
2395
2396 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2397
2398 return kernel_power_div;
2399 }
2400
2401 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2402 {
2403 uint num_elements = num;
2404
2405 device_param->kernel_params_buf32[30] = data.combs_mode;
2406 device_param->kernel_params_buf32[31] = num;
2407
2408 uint kernel_threads = device_param->kernel_threads;
2409
2410 while (num_elements % kernel_threads) num_elements++;
2411
2412 cl_kernel kernel = NULL;
2413
2414 switch (kern_run)
2415 {
2416 case KERN_RUN_1: kernel = device_param->kernel1; break;
2417 case KERN_RUN_12: kernel = device_param->kernel12; break;
2418 case KERN_RUN_2: kernel = device_param->kernel2; break;
2419 case KERN_RUN_23: kernel = device_param->kernel23; break;
2420 case KERN_RUN_3: kernel = device_param->kernel3; break;
2421 }
2422
2423 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2424 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2425 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2426 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2427 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2428 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2429 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2430 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2431 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2432 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2433 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2434
2435 cl_event event;
2436
2437 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2438 {
2439 const size_t global_work_size[3] = { num_elements, 32, 1 };
2440 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2441
2442 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2443 }
2444 else
2445 {
2446 if (kern_run == KERN_RUN_2)
2447 {
2448 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2449 {
2450 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2451 }
2452 }
2453
2454 while (num_elements % kernel_threads) num_elements++;
2455
2456 const size_t global_work_size[3] = { num_elements, 1, 1 };
2457 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2458
2459 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2460 }
2461
2462 hc_clFlush (data.ocl, device_param->command_queue);
2463
2464 hc_clWaitForEvents (data.ocl, 1, &event);
2465
2466 if (event_update)
2467 {
2468 cl_ulong time_start;
2469 cl_ulong time_end;
2470
2471 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2472 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2473
2474 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2475
2476 uint exec_pos = device_param->exec_pos;
2477
2478 device_param->exec_ms[exec_pos] = exec_time;
2479
2480 exec_pos++;
2481
2482 if (exec_pos == EXEC_CACHE)
2483 {
2484 exec_pos = 0;
2485 }
2486
2487 device_param->exec_pos = exec_pos;
2488 }
2489
2490 hc_clReleaseEvent (data.ocl, event);
2491
2492 hc_clFinish (data.ocl, device_param->command_queue);
2493 }
2494
2495 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2496 {
2497 uint num_elements = num;
2498
2499 switch (kern_run)
2500 {
2501 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2502 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2503 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2504 }
2505
2506 // causes problems with special threads like in bcrypt
2507 // const uint kernel_threads = device_param->kernel_threads;
2508
2509 uint kernel_threads = device_param->kernel_threads;
2510
2511 while (num_elements % kernel_threads) num_elements++;
2512
2513 cl_kernel kernel = NULL;
2514
2515 switch (kern_run)
2516 {
2517 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2518 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2519 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2520 }
2521
2522 switch (kern_run)
2523 {
2524 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2525 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2526 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2527 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2528 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2529 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2530 break;
2531 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2532 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2533 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2534 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2535 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2536 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2537 break;
2538 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2539 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2540 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2541 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2542 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2543 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2544 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2545 break;
2546 }
2547
2548 const size_t global_work_size[3] = { num_elements, 1, 1 };
2549 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2550
2551 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2552
2553 hc_clFlush (data.ocl, device_param->command_queue);
2554
2555 hc_clFinish (data.ocl, device_param->command_queue);
2556 }
2557
2558 static void run_kernel_tm (hc_device_param_t *device_param)
2559 {
2560 const uint num_elements = 1024; // fixed
2561
2562 uint kernel_threads = 32;
2563
2564 cl_kernel kernel = device_param->kernel_tm;
2565
2566 const size_t global_work_size[3] = { num_elements, 1, 1 };
2567 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2568
2569 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2570
2571 hc_clFlush (data.ocl, device_param->command_queue);
2572
2573 hc_clFinish (data.ocl, device_param->command_queue);
2574 }
2575
2576 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2577 {
2578 uint num_elements = num;
2579
2580 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2581 device_param->kernel_params_amp_buf32[6] = num_elements;
2582
2583 // causes problems with special threads like in bcrypt
2584 // const uint kernel_threads = device_param->kernel_threads;
2585
2586 uint kernel_threads = device_param->kernel_threads;
2587
2588 while (num_elements % kernel_threads) num_elements++;
2589
2590 cl_kernel kernel = device_param->kernel_amp;
2591
2592 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2593 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2594
2595 const size_t global_work_size[3] = { num_elements, 1, 1 };
2596 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2597
2598 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2599
2600 hc_clFlush (data.ocl, device_param->command_queue);
2601
2602 hc_clFinish (data.ocl, device_param->command_queue);
2603 }
2604
2605 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2606 {
2607 int rc = -1;
2608
2609 if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD)
2610 {
2611 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2612
2613 const cl_uchar zero = 0;
2614
2615 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2616 }
2617
2618 if (rc != 0)
2619 {
2620 // NOTE: clEnqueueFillBuffer () always fails with -59
2621 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2622 // How's that possible, OpenCL 1.2 support is advertised??
2623 // We need to workaround...
2624
2625 #define FILLSZ 0x100000
2626
2627 char *tmp = (char *) mymalloc (FILLSZ);
2628
2629 for (size_t i = 0; i < size; i += FILLSZ)
2630 {
2631 const size_t left = size - i;
2632
2633 const size_t fillsz = MIN (FILLSZ, left);
2634
2635 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2636 }
2637
2638 myfree (tmp);
2639 }
2640 }
2641
2642 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)
2643 {
2644 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2645 {
2646 if (attack_mode == ATTACK_MODE_BF)
2647 {
2648 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2649 {
2650 const uint size_tm = 32 * sizeof (bs_word_t);
2651
2652 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2653
2654 run_kernel_tm (device_param);
2655
2656 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);
2657 }
2658 }
2659
2660 if (highest_pw_len < 16)
2661 {
2662 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2663 }
2664 else if (highest_pw_len < 32)
2665 {
2666 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2667 }
2668 else
2669 {
2670 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2671 }
2672 }
2673 else
2674 {
2675 run_kernel_amp (device_param, pws_cnt);
2676
2677 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2678
2679 if (opts_type & OPTS_TYPE_HOOK12)
2680 {
2681 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2682 }
2683
2684 uint iter = salt_buf->salt_iter;
2685
2686 uint loop_step = device_param->kernel_loops;
2687
2688 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2689 {
2690 uint loop_left = iter - loop_pos;
2691
2692 loop_left = MIN (loop_left, loop_step);
2693
2694 device_param->kernel_params_buf32[25] = loop_pos;
2695 device_param->kernel_params_buf32[26] = loop_left;
2696
2697 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2698
2699 if (data.devices_status == STATUS_CRACKED) break;
2700 if (data.devices_status == STATUS_ABORTED) break;
2701 if (data.devices_status == STATUS_QUIT) break;
2702
2703 /**
2704 * speed
2705 */
2706
2707 const float iter_part = (float) (loop_pos + loop_left) / iter;
2708
2709 const u64 perf_sum_all = pws_cnt * iter_part;
2710
2711 double speed_ms;
2712
2713 hc_timer_get (device_param->timer_speed, speed_ms);
2714
2715 const u32 speed_pos = device_param->speed_pos;
2716
2717 device_param->speed_cnt[speed_pos] = perf_sum_all;
2718
2719 device_param->speed_ms[speed_pos] = speed_ms;
2720
2721 if (data.benchmark == 1)
2722 {
2723 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2724 }
2725 }
2726
2727 if (opts_type & OPTS_TYPE_HOOK23)
2728 {
2729 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2730
2731 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);
2732
2733 // do something with data
2734
2735 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);
2736 }
2737
2738 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2739 }
2740 }
2741
2742 static int run_rule_engine (const int rule_len, const char *rule_buf)
2743 {
2744 if (rule_len == 0)
2745 {
2746 return 0;
2747 }
2748 else if (rule_len == 1)
2749 {
2750 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2751 }
2752
2753 return 1;
2754 }
2755
2756 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2757 {
2758 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2759 {
2760 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);
2761 }
2762 else if (data.attack_kern == ATTACK_KERN_COMBI)
2763 {
2764 if (data.attack_mode == ATTACK_MODE_HYBRID2)
2765 {
2766 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2767 {
2768 for (u32 i = 0; i < pws_cnt; i++)
2769 {
2770 const u32 pw_len = device_param->pws_buf[i].pw_len;
2771
2772 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2773
2774 ptr[pw_len] = 0x01;
2775 }
2776 }
2777 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2778 {
2779 for (u32 i = 0; i < pws_cnt; i++)
2780 {
2781 const u32 pw_len = device_param->pws_buf[i].pw_len;
2782
2783 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2784
2785 ptr[pw_len] = 0x80;
2786 }
2787 }
2788 }
2789
2790 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);
2791 }
2792 else if (data.attack_kern == ATTACK_KERN_BF)
2793 {
2794 const u64 off = device_param->words_off;
2795
2796 device_param->kernel_params_mp_l_buf64[3] = off;
2797
2798 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2799 }
2800 }
2801
2802 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2803 {
2804 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2805
2806 device_param->kernel_params_buf32[25] = 0;
2807 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2808 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2809
2810 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2811 {
2812 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2813 }
2814 else
2815 {
2816 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2817 }
2818
2819 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2820
2821 return exec_ms_prev;
2822 }
2823
2824 static void autotune (hc_device_param_t *device_param)
2825 {
2826 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2827
2828 const u32 kernel_accel_min = device_param->kernel_accel_min;
2829 const u32 kernel_accel_max = device_param->kernel_accel_max;
2830
2831 const u32 kernel_loops_min = device_param->kernel_loops_min;
2832 const u32 kernel_loops_max = device_param->kernel_loops_max;
2833
2834 u32 kernel_accel = kernel_accel_min;
2835 u32 kernel_loops = kernel_loops_min;
2836
2837 // in this case the user specified a fixed -u and -n on the commandline
2838 // no way to tune anything
2839 // but we need to run a few caching rounds
2840
2841 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2842 {
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 try_run (device_param, kernel_accel, kernel_loops);
2847
2848 return;
2849 }
2850
2851 // from here it's clear we are allowed to autotune
2852 // so let's init some fake words
2853
2854 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2855
2856 for (u32 i = 0; i < kernel_power_max; i++)
2857 {
2858 device_param->pws_buf[i].i[0] = i;
2859 device_param->pws_buf[i].i[1] = 0x01234567;
2860 device_param->pws_buf[i].pw_len = 7;
2861 }
2862
2863 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);
2864
2865 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2866 {
2867 run_kernel_amp (device_param, kernel_power_max);
2868 }
2869
2870 #define VERIFIER_CNT 1
2871
2872 // first find out highest kernel-loops that stays below target_ms
2873
2874 if (kernel_loops_min < kernel_loops_max)
2875 {
2876 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
2877 {
2878 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
2879
2880 for (int i = 0; i < VERIFIER_CNT; i++)
2881 {
2882 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
2883
2884 exec_ms = MIN (exec_ms, exec_ms_v);
2885 }
2886
2887 if (exec_ms < target_ms) break;
2888 }
2889 }
2890
2891 // now the same for kernel-accel but with the new kernel-loops from previous loop set
2892
2893 #define STEPS_CNT 10
2894
2895 if (kernel_accel_min < kernel_accel_max)
2896 {
2897 for (int i = 0; i < STEPS_CNT; i++)
2898 {
2899 const u32 kernel_accel_try = 1 << i;
2900
2901 if (kernel_accel_try < kernel_accel_min) continue;
2902 if (kernel_accel_try > kernel_accel_max) break;
2903
2904 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
2905
2906 for (int i = 0; i < VERIFIER_CNT; i++)
2907 {
2908 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
2909
2910 exec_ms = MIN (exec_ms, exec_ms_v);
2911 }
2912
2913 if (exec_ms > target_ms) break;
2914
2915 kernel_accel = kernel_accel_try;
2916 }
2917 }
2918
2919 // at this point we want to know the actual runtime for the following reason:
2920 // we need a reference for the balancing loop following up, and this
2921 // the balancing loop can have an effect that the creates a new opportunity, for example:
2922 // if the target is 95 ms and the current runtime is 48ms the above loop
2923 // stopped the execution because the previous exec_ms was > 95ms
2924 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
2925 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
2926
2927 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
2928
2929 for (int i = 0; i < VERIFIER_CNT; i++)
2930 {
2931 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
2932
2933 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
2934 }
2935
2936 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
2937 {
2938 for (u32 f = 2; f < 1024; f++)
2939 {
2940 const u32 kernel_accel_try = kernel_accel * f;
2941 const u32 kernel_loops_try = kernel_loops / f;
2942
2943 if (kernel_accel_try > kernel_accel_max) break;
2944 if (kernel_loops_try < kernel_loops_min) break;
2945
2946 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
2947
2948 for (int i = 0; i < VERIFIER_CNT; i++)
2949 {
2950 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
2951
2952 exec_ms = MIN (exec_ms, exec_ms_v);
2953 }
2954
2955 if (exec_ms < exec_ms_pre_final)
2956 {
2957 exec_ms_pre_final = exec_ms;
2958
2959 kernel_accel = kernel_accel_try;
2960 kernel_loops = kernel_loops_try;
2961 }
2962 }
2963 }
2964
2965 const double exec_left = target_ms / exec_ms_pre_final;
2966
2967 const double accel_left = kernel_accel_max / kernel_accel;
2968
2969 const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
2970
2971 if (exec_accel_min >= 2)
2972 {
2973 // this is safe to not overflow kernel_accel_max because of accel_left
2974
2975 kernel_accel *= exec_accel_min;
2976 }
2977
2978 // reset them fake words
2979
2980 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
2981
2982 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);
2983 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);
2984
2985 // reset timer
2986
2987 device_param->exec_pos = 0;
2988
2989 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
2990
2991 // store
2992
2993 device_param->kernel_accel = kernel_accel;
2994 device_param->kernel_loops = kernel_loops;
2995
2996 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2997
2998 device_param->kernel_power = kernel_power;
2999
3000 #ifdef DEBUG
3001
3002 if (data.quiet == 0)
3003 {
3004 clear_prompt ();
3005
3006 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3007 "Device #%u: autotuned kernel-loops to %u\n",
3008 device_param->device_id + 1, kernel_accel,
3009 device_param->device_id + 1, kernel_loops);
3010
3011 fprintf (stdout, "%s", PROMPT);
3012
3013 fflush (stdout);
3014 }
3015
3016 #endif
3017 }
3018
3019 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3020 {
3021 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3022
3023 // init speed timer
3024
3025 uint speed_pos = device_param->speed_pos;
3026
3027 #ifdef _POSIX
3028 if (device_param->timer_speed.tv_sec == 0)
3029 {
3030 hc_timer_set (&device_param->timer_speed);
3031 }
3032 #endif
3033
3034 #ifdef _WIN
3035 if (device_param->timer_speed.QuadPart == 0)
3036 {
3037 hc_timer_set (&device_param->timer_speed);
3038 }
3039 #endif
3040
3041 // find higest password length, this is for optimization stuff
3042
3043 uint highest_pw_len = 0;
3044
3045 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3046 {
3047 }
3048 else if (data.attack_kern == ATTACK_KERN_COMBI)
3049 {
3050 }
3051 else if (data.attack_kern == ATTACK_KERN_BF)
3052 {
3053 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3054 + device_param->kernel_params_mp_l_buf32[5];
3055 }
3056
3057 // iteration type
3058
3059 uint innerloop_step = 0;
3060 uint innerloop_cnt = 0;
3061
3062 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3063 else innerloop_step = 1;
3064
3065 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3066 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3067 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3068
3069 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3070
3071 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3072 {
3073 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3074
3075 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3076
3077 if (data.devices_status == STATUS_CRACKED) break;
3078 if (data.devices_status == STATUS_ABORTED) break;
3079 if (data.devices_status == STATUS_QUIT) break;
3080 if (data.devices_status == STATUS_BYPASS) break;
3081
3082 salt_t *salt_buf = &data.salts_buf[salt_pos];
3083
3084 device_param->kernel_params_buf32[24] = salt_pos;
3085 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3086 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3087
3088 FILE *combs_fp = device_param->combs_fp;
3089
3090 if (data.attack_mode == ATTACK_MODE_COMBI)
3091 {
3092 rewind (combs_fp);
3093 }
3094
3095 // innerloops
3096
3097 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3098 {
3099 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3100
3101 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3102
3103 if (data.devices_status == STATUS_CRACKED) break;
3104 if (data.devices_status == STATUS_ABORTED) break;
3105 if (data.devices_status == STATUS_QUIT) break;
3106 if (data.devices_status == STATUS_BYPASS) break;
3107
3108 uint innerloop_left = innerloop_cnt - innerloop_pos;
3109
3110 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3111
3112 device_param->innerloop_pos = innerloop_pos;
3113 device_param->innerloop_left = innerloop_left;
3114
3115 device_param->kernel_params_buf32[27] = innerloop_left;
3116
3117 // i think we can get rid of this
3118 if (innerloop_left == 0)
3119 {
3120 puts ("bug, how should this happen????\n");
3121
3122 continue;
3123 }
3124
3125 if (data.salts_shown[salt_pos] == 1)
3126 {
3127 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3128
3129 continue;
3130 }
3131
3132 // initialize amplifiers
3133
3134 if (data.attack_mode == ATTACK_MODE_COMBI)
3135 {
3136 uint i = 0;
3137
3138 while (i < innerloop_left)
3139 {
3140 if (feof (combs_fp)) break;
3141
3142 int line_len = fgetl (combs_fp, line_buf);
3143
3144 if (line_len >= PW_MAX1) continue;
3145
3146 line_len = convert_from_hex (line_buf, line_len);
3147
3148 char *line_buf_new = line_buf;
3149
3150 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3151 {
3152 char rule_buf_out[BLOCK_SIZE] = { 0 };
3153
3154 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3155
3156 if (rule_len_out < 0)
3157 {
3158 data.words_progress_rejected[salt_pos] += pws_cnt;
3159
3160 continue;
3161 }
3162
3163 line_len = rule_len_out;
3164
3165 line_buf_new = rule_buf_out;
3166 }
3167
3168 line_len = MIN (line_len, PW_DICTMAX);
3169
3170 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3171
3172 memcpy (ptr, line_buf_new, line_len);
3173
3174 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3175
3176 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3177 {
3178 uppercase (ptr, line_len);
3179 }
3180
3181 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3182 {
3183 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3184 {
3185 ptr[line_len] = 0x80;
3186 }
3187
3188 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3189 {
3190 ptr[line_len] = 0x01;
3191 }
3192 }
3193
3194 device_param->combs_buf[i].pw_len = line_len;
3195
3196 i++;
3197 }
3198
3199 for (uint j = i; j < innerloop_left; j++)
3200 {
3201 device_param->combs_buf[j].i[0] = 0;
3202 device_param->combs_buf[j].i[1] = 0;
3203 device_param->combs_buf[j].i[2] = 0;
3204 device_param->combs_buf[j].i[3] = 0;
3205 device_param->combs_buf[j].i[4] = 0;
3206 device_param->combs_buf[j].i[5] = 0;
3207 device_param->combs_buf[j].i[6] = 0;
3208 device_param->combs_buf[j].i[7] = 0;
3209
3210 device_param->combs_buf[j].pw_len = 0;
3211 }
3212
3213 innerloop_left = i;
3214 }
3215 else if (data.attack_mode == ATTACK_MODE_BF)
3216 {
3217 u64 off = innerloop_pos;
3218
3219 device_param->kernel_params_mp_r_buf64[3] = off;
3220
3221 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3222 }
3223 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3224 {
3225 u64 off = innerloop_pos;
3226
3227 device_param->kernel_params_mp_buf64[3] = off;
3228
3229 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3230 }
3231 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3232 {
3233 u64 off = innerloop_pos;
3234
3235 device_param->kernel_params_mp_buf64[3] = off;
3236
3237 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3238 }
3239
3240 // copy amplifiers
3241
3242 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3243 {
3244 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);
3245 }
3246 else if (data.attack_mode == ATTACK_MODE_COMBI)
3247 {
3248 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);
3249 }
3250 else if (data.attack_mode == ATTACK_MODE_BF)
3251 {
3252 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);
3253 }
3254 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3255 {
3256 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);
3257 }
3258 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3259 {
3260 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);
3261 }
3262
3263 if (data.benchmark == 1)
3264 {
3265 hc_timer_set (&device_param->timer_speed);
3266 }
3267
3268 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3269
3270 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3271
3272 if (data.devices_status == STATUS_CRACKED) break;
3273 if (data.devices_status == STATUS_ABORTED) break;
3274 if (data.devices_status == STATUS_QUIT) break;
3275
3276 /**
3277 * result
3278 */
3279
3280 hc_thread_mutex_lock (mux_display);
3281
3282 check_cracked (device_param, salt_pos);
3283
3284 hc_thread_mutex_unlock (mux_display);
3285
3286 /**
3287 * progress
3288 */
3289
3290 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3291
3292 hc_thread_mutex_lock (mux_counter);
3293
3294 data.words_progress_done[salt_pos] += perf_sum_all;
3295
3296 hc_thread_mutex_unlock (mux_counter);
3297
3298 /**
3299 * speed
3300 */
3301
3302 double speed_ms;
3303
3304 hc_timer_get (device_param->timer_speed, speed_ms);
3305
3306 hc_timer_set (&device_param->timer_speed);
3307
3308 hc_thread_mutex_lock (mux_display);
3309
3310 // current speed
3311
3312 device_param->speed_cnt[speed_pos] = perf_sum_all;
3313
3314 device_param->speed_ms[speed_pos] = speed_ms;
3315
3316 hc_thread_mutex_unlock (mux_display);
3317
3318 speed_pos++;
3319
3320 if (speed_pos == SPEED_CACHE)
3321 {
3322 speed_pos = 0;
3323 }
3324
3325 /**
3326 * benchmark
3327 */
3328
3329 if (data.benchmark == 1) break;
3330 }
3331 }
3332
3333 device_param->speed_pos = speed_pos;
3334
3335 myfree (line_buf);
3336 }
3337
3338 static void load_segment (wl_data_t *wl_data, FILE *fd)
3339 {
3340 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3341
3342 wl_data->pos = 0;
3343
3344 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3345
3346 wl_data->buf[wl_data->cnt] = 0;
3347
3348 if (wl_data->cnt == 0) return;
3349
3350 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3351
3352 while (!feof (fd))
3353 {
3354 if (wl_data->cnt == wl_data->avail)
3355 {
3356 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3357
3358 wl_data->avail += wl_data->incr;
3359 }
3360
3361 const int c = fgetc (fd);
3362
3363 if (c == EOF) break;
3364
3365 wl_data->buf[wl_data->cnt] = (char) c;
3366
3367 wl_data->cnt++;
3368
3369 if (c == '\n') break;
3370 }
3371
3372 // ensure stream ends with a newline
3373
3374 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3375 {
3376 wl_data->cnt++;
3377
3378 wl_data->buf[wl_data->cnt - 1] = '\n';
3379 }
3380
3381 return;
3382 }
3383
3384 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3385 {
3386 char *ptr = buf;
3387
3388 for (u32 i = 0; i < sz; i++, ptr++)
3389 {
3390 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3391
3392 if (i == 7)
3393 {
3394 *off = i;
3395 *len = i;
3396
3397 return;
3398 }
3399
3400 if (*ptr != '\n') continue;
3401
3402 *off = i + 1;
3403
3404 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3405
3406 *len = i;
3407
3408 return;
3409 }
3410
3411 *off = sz;
3412 *len = sz;
3413 }
3414
3415 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3416 {
3417 char *ptr = buf;
3418
3419 for (u32 i = 0; i < sz; i++, ptr++)
3420 {
3421 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3422
3423 if (*ptr != '\n') continue;
3424
3425 *off = i + 1;
3426
3427 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3428
3429 *len = i;
3430
3431 return;
3432 }
3433
3434 *off = sz;
3435 *len = sz;
3436 }
3437
3438 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3439 {
3440 char *ptr = buf;
3441
3442 for (u32 i = 0; i < sz; i++, ptr++)
3443 {
3444 if (*ptr != '\n') continue;
3445
3446 *off = i + 1;
3447
3448 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3449
3450 *len = i;
3451
3452 return;
3453 }
3454
3455 *off = sz;
3456 *len = sz;
3457 }
3458
3459 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3460 {
3461 while (wl_data->pos < wl_data->cnt)
3462 {
3463 uint off;
3464 uint len;
3465
3466 char *ptr = wl_data->buf + wl_data->pos;
3467
3468 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3469
3470 wl_data->pos += off;
3471
3472 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3473 {
3474 char rule_buf_out[BLOCK_SIZE] = { 0 };
3475
3476 int rule_len_out = -1;
3477
3478 if (len < BLOCK_SIZE)
3479 {
3480 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3481 }
3482
3483 if (rule_len_out < 0)
3484 {
3485 continue;
3486 }
3487
3488 if (rule_len_out > PW_MAX)
3489 {
3490 continue;
3491 }
3492 }
3493 else
3494 {
3495 if (len > PW_MAX)
3496 {
3497 continue;
3498 }
3499 }
3500
3501 *out_buf = ptr;
3502 *out_len = len;
3503
3504 return;
3505 }
3506
3507 if (feof (fd))
3508 {
3509 fprintf (stderr, "BUG feof()!!\n");
3510
3511 return;
3512 }
3513
3514 load_segment (wl_data, fd);
3515
3516 get_next_word (wl_data, fd, out_buf, out_len);
3517 }
3518
3519 #ifdef _POSIX
3520 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3521 #endif
3522
3523 #ifdef _WIN
3524 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3525 #endif
3526 {
3527 hc_signal (NULL);
3528
3529 dictstat_t d;
3530
3531 d.cnt = 0;
3532
3533 #ifdef _POSIX
3534 fstat (fileno (fd), &d.stat);
3535 #endif
3536
3537 #ifdef _WIN
3538 _fstat64 (fileno (fd), &d.stat);
3539 #endif
3540
3541 d.stat.st_mode = 0;
3542 d.stat.st_nlink = 0;
3543 d.stat.st_uid = 0;
3544 d.stat.st_gid = 0;
3545 d.stat.st_rdev = 0;
3546 d.stat.st_atime = 0;
3547
3548 #ifdef _POSIX
3549 d.stat.st_blksize = 0;
3550 d.stat.st_blocks = 0;
3551 #endif
3552
3553 if (d.stat.st_size == 0) return 0;
3554
3555 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3556
3557 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3558 {
3559 if (d_cache)
3560 {
3561 u64 cnt = d_cache->cnt;
3562
3563 u64 keyspace = cnt;
3564
3565 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3566 {
3567 keyspace *= data.kernel_rules_cnt;
3568 }
3569 else if (data.attack_kern == ATTACK_KERN_COMBI)
3570 {
3571 keyspace *= data.combs_cnt;
3572 }
3573
3574 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);
3575 if (data.quiet == 0) log_info ("");
3576
3577 hc_signal (sigHandler_default);
3578
3579 return (keyspace);
3580 }
3581 }
3582
3583 time_t now = 0;
3584 time_t prev = 0;
3585
3586 u64 comp = 0;
3587 u64 cnt = 0;
3588 u64 cnt2 = 0;
3589
3590 while (!feof (fd))
3591 {
3592 load_segment (wl_data, fd);
3593
3594 comp += wl_data->cnt;
3595
3596 u32 i = 0;
3597
3598 while (i < wl_data->cnt)
3599 {
3600 u32 len;
3601 u32 off;
3602
3603 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3604
3605 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3606 {
3607 char rule_buf_out[BLOCK_SIZE] = { 0 };
3608
3609 int rule_len_out = -1;
3610
3611 if (len < BLOCK_SIZE)
3612 {
3613 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3614 }
3615
3616 if (rule_len_out < 0)
3617 {
3618 len = PW_MAX1;
3619 }
3620 else
3621 {
3622 len = rule_len_out;
3623 }
3624 }
3625
3626 if (len < PW_MAX1)
3627 {
3628 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3629 {
3630 cnt += data.kernel_rules_cnt;
3631 }
3632 else if (data.attack_kern == ATTACK_KERN_COMBI)
3633 {
3634 cnt += data.combs_cnt;
3635 }
3636
3637 d.cnt++;
3638 }
3639
3640 i += off;
3641
3642 cnt2++;
3643 }
3644
3645 time (&now);
3646
3647 if ((now - prev) == 0) continue;
3648
3649 float percent = (float) comp / (float) d.stat.st_size;
3650
3651 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);
3652
3653 time (&prev);
3654 }
3655
3656 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);
3657 if (data.quiet == 0) log_info ("");
3658
3659 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3660
3661 hc_signal (sigHandler_default);
3662
3663 return (cnt);
3664 }
3665
3666 static void *thread_monitor (void *p)
3667 {
3668 uint runtime_check = 0;
3669 uint remove_check = 0;
3670 uint status_check = 0;
3671 uint restore_check = 0;
3672
3673 uint restore_left = data.restore_timer;
3674 uint remove_left = data.remove_timer;
3675 uint status_left = data.status_timer;
3676
3677 #ifdef HAVE_HWMON
3678 uint hwmon_check = 0;
3679
3680 // these variables are mainly used for fan control (AMD only)
3681
3682 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3683
3684 // temperature controller "loopback" values
3685
3686 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3687 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3688
3689 #ifdef HAVE_ADL
3690 int temp_threshold = 1; // degrees celcius
3691
3692 int fan_speed_min = 15; // in percentage
3693 int fan_speed_max = 100;
3694 #endif // HAVE_ADL
3695
3696 time_t last_temp_check_time;
3697 #endif // HAVE_HWMON
3698
3699 uint sleep_time = 1;
3700
3701 if (data.runtime)
3702 {
3703 runtime_check = 1;
3704 }
3705
3706 if (data.restore_timer)
3707 {
3708 restore_check = 1;
3709 }
3710
3711 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3712 {
3713 remove_check = 1;
3714 }
3715
3716 if (data.status == 1)
3717 {
3718 status_check = 1;
3719 }
3720
3721 #ifdef HAVE_HWMON
3722 if (data.gpu_temp_disable == 0)
3723 {
3724 time (&last_temp_check_time);
3725
3726 hwmon_check = 1;
3727 }
3728 #endif
3729
3730 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3731 {
3732 #ifdef HAVE_HWMON
3733 if (hwmon_check == 0)
3734 #endif
3735 return (p);
3736 }
3737
3738 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3739 {
3740 hc_sleep (sleep_time);
3741
3742 if (data.devices_status != STATUS_RUNNING) continue;
3743
3744 #ifdef HAVE_HWMON
3745 if (hwmon_check == 1)
3746 {
3747 hc_thread_mutex_lock (mux_adl);
3748
3749 time_t temp_check_time;
3750
3751 time (&temp_check_time);
3752
3753 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3754
3755 if (Ta == 0) Ta = 1;
3756
3757 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3758 {
3759 hc_device_param_t *device_param = &data.devices_param[device_id];
3760
3761 if (device_param->skipped) continue;
3762
3763 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3764
3765 const int temperature = hm_get_temperature_with_device_id (device_id);
3766
3767 if (temperature > (int) data.gpu_temp_abort)
3768 {
3769 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3770
3771 if (data.devices_status != STATUS_QUIT) myabort ();
3772
3773 break;
3774 }
3775
3776 #ifdef HAVE_ADL
3777 const int gpu_temp_retain = data.gpu_temp_retain;
3778
3779 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3780 {
3781 if (data.hm_device[device_id].fan_supported == 1)
3782 {
3783 int temp_cur = temperature;
3784
3785 int temp_diff_new = gpu_temp_retain - temp_cur;
3786
3787 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3788
3789 // calculate Ta value (time difference in seconds between the last check and this check)
3790
3791 last_temp_check_time = temp_check_time;
3792
3793 float Kp = 1.8;
3794 float Ki = 0.005;
3795 float Kd = 6;
3796
3797 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3798
3799 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);
3800
3801 if (abs (fan_diff_required) >= temp_threshold)
3802 {
3803 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3804
3805 int fan_speed_level = fan_speed_cur;
3806
3807 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3808
3809 int fan_speed_new = fan_speed_level - fan_diff_required;
3810
3811 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
3812 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
3813
3814 if (fan_speed_new != fan_speed_cur)
3815 {
3816 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
3817 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
3818
3819 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
3820 {
3821 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
3822
3823 fan_speed_chgd[device_id] = 1;
3824 }
3825
3826 temp_diff_old[device_id] = temp_diff_new;
3827 }
3828 }
3829 }
3830 }
3831 #endif // HAVE_ADL
3832 }
3833
3834 hc_thread_mutex_unlock (mux_adl);
3835 }
3836 #endif // HAVE_HWMON
3837
3838 if (restore_check == 1)
3839 {
3840 restore_left--;
3841
3842 if (restore_left == 0)
3843 {
3844 if (data.restore_disable == 0) cycle_restore ();
3845
3846 restore_left = data.restore_timer;
3847 }
3848 }
3849
3850 if ((runtime_check == 1) && (data.runtime_start > 0))
3851 {
3852 time_t runtime_cur;
3853
3854 time (&runtime_cur);
3855
3856 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
3857
3858 if (runtime_left <= 0)
3859 {
3860 if (data.benchmark == 0)
3861 {
3862 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
3863 }
3864
3865 if (data.devices_status != STATUS_QUIT) myabort ();
3866 }
3867 }
3868
3869 if (remove_check == 1)
3870 {
3871 remove_left--;
3872
3873 if (remove_left == 0)
3874 {
3875 if (data.digests_saved != data.digests_done)
3876 {
3877 data.digests_saved = data.digests_done;
3878
3879 save_hash ();
3880 }
3881
3882 remove_left = data.remove_timer;
3883 }
3884 }
3885
3886 if (status_check == 1)
3887 {
3888 status_left--;
3889
3890 if (status_left == 0)
3891 {
3892 hc_thread_mutex_lock (mux_display);
3893
3894 if (data.quiet == 0) clear_prompt ();
3895
3896 if (data.quiet == 0) log_info ("");
3897
3898 status_display ();
3899
3900 if (data.quiet == 0) log_info ("");
3901
3902 hc_thread_mutex_unlock (mux_display);
3903
3904 status_left = data.status_timer;
3905 }
3906 }
3907 }
3908
3909 #ifdef HAVE_HWMON
3910 myfree (fan_speed_chgd);
3911
3912 myfree (temp_diff_old);
3913 myfree (temp_diff_sum);
3914 #endif
3915
3916 p = NULL;
3917
3918 return (p);
3919 }
3920
3921 static void *thread_outfile_remove (void *p)
3922 {
3923 // some hash-dependent constants
3924 char *outfile_dir = data.outfile_check_directory;
3925 uint dgst_size = data.dgst_size;
3926 uint isSalted = data.isSalted;
3927 uint esalt_size = data.esalt_size;
3928 uint hash_mode = data.hash_mode;
3929
3930 uint outfile_check_timer = data.outfile_check_timer;
3931
3932 char separator = data.separator;
3933
3934 // some hash-dependent functions
3935 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
3936 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
3937
3938 // buffers
3939 hash_t hash_buf = { 0, 0, 0, 0, 0 };
3940
3941 hash_buf.digest = mymalloc (dgst_size);
3942
3943 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
3944
3945 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
3946
3947 uint digest_buf[64] = { 0 };
3948
3949 outfile_data_t *out_info = NULL;
3950
3951 char **out_files = NULL;
3952
3953 time_t folder_mtime = 0;
3954
3955 int out_cnt = 0;
3956
3957 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
3958
3959 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3960 {
3961 hc_sleep (1);
3962
3963 if (data.devices_status != STATUS_RUNNING) continue;
3964
3965 check_left--;
3966
3967 if (check_left == 0)
3968 {
3969 struct stat outfile_check_stat;
3970
3971 if (stat (outfile_dir, &outfile_check_stat) == 0)
3972 {
3973 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
3974
3975 if (is_dir == 1)
3976 {
3977 if (outfile_check_stat.st_mtime > folder_mtime)
3978 {
3979 char **out_files_new = scan_directory (outfile_dir);
3980
3981 int out_cnt_new = count_dictionaries (out_files_new);
3982
3983 outfile_data_t *out_info_new = NULL;
3984
3985 if (out_cnt_new > 0)
3986 {
3987 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
3988
3989 for (int i = 0; i < out_cnt_new; i++)
3990 {
3991 out_info_new[i].file_name = out_files_new[i];
3992
3993 // check if there are files that we have seen/checked before (and not changed)
3994
3995 for (int j = 0; j < out_cnt; j++)
3996 {
3997 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
3998 {
3999 struct stat outfile_stat;
4000
4001 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4002 {
4003 if (outfile_stat.st_ctime == out_info[j].ctime)
4004 {
4005 out_info_new[i].ctime = out_info[j].ctime;
4006 out_info_new[i].seek = out_info[j].seek;
4007 }
4008 }
4009 }
4010 }
4011 }
4012 }
4013
4014 local_free (out_info);
4015 local_free (out_files);
4016
4017 out_files = out_files_new;
4018 out_cnt = out_cnt_new;
4019 out_info = out_info_new;
4020
4021 folder_mtime = outfile_check_stat.st_mtime;
4022 }
4023
4024 for (int j = 0; j < out_cnt; j++)
4025 {
4026 FILE *fp = fopen (out_info[j].file_name, "rb");
4027
4028 if (fp != NULL)
4029 {
4030 //hc_thread_mutex_lock (mux_display);
4031
4032 #ifdef _POSIX
4033 struct stat outfile_stat;
4034
4035 fstat (fileno (fp), &outfile_stat);
4036 #endif
4037
4038 #ifdef _WIN
4039 struct stat64 outfile_stat;
4040
4041 _fstat64 (fileno (fp), &outfile_stat);
4042 #endif
4043
4044 if (outfile_stat.st_ctime > out_info[j].ctime)
4045 {
4046 out_info[j].ctime = outfile_stat.st_ctime;
4047 out_info[j].seek = 0;
4048 }
4049
4050 fseek (fp, out_info[j].seek, SEEK_SET);
4051
4052 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4053
4054 while (!feof (fp))
4055 {
4056 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4057
4058 if (ptr == NULL) break;
4059
4060 int line_len = strlen (line_buf);
4061
4062 if (line_len <= 0) continue;
4063
4064 int iter = MAX_CUT_TRIES;
4065
4066 for (uint i = line_len - 1; i && iter; i--, line_len--)
4067 {
4068 if (line_buf[i] != separator) continue;
4069
4070 int parser_status = PARSER_OK;
4071
4072 if ((hash_mode != 2500) && (hash_mode != 6800))
4073 {
4074 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4075 }
4076
4077 uint found = 0;
4078
4079 if (parser_status == PARSER_OK)
4080 {
4081 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4082 {
4083 if (data.salts_shown[salt_pos] == 1) continue;
4084
4085 salt_t *salt_buf = &data.salts_buf[salt_pos];
4086
4087 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4088 {
4089 uint idx = salt_buf->digests_offset + digest_pos;
4090
4091 if (data.digests_shown[idx] == 1) continue;
4092
4093 uint cracked = 0;
4094
4095 if (hash_mode == 6800)
4096 {
4097 if (i == salt_buf->salt_len)
4098 {
4099 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4100 }
4101 }
4102 else if (hash_mode == 2500)
4103 {
4104 // BSSID : MAC1 : MAC2 (:plain)
4105 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4106 {
4107 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4108
4109 if (!cracked) continue;
4110
4111 // now compare MAC1 and MAC2 too, since we have this additional info
4112 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4113 char *mac2_pos = mac1_pos + 12 + 1;
4114
4115 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4116 wpa_t *wpa = &wpas[salt_pos];
4117
4118 // compare hex string(s) vs binary MAC address(es)
4119
4120 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4121 {
4122 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4123 {
4124 cracked = 0;
4125
4126 break;
4127 }
4128 }
4129
4130 // early skip ;)
4131 if (!cracked) continue;
4132
4133 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4134 {
4135 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4136 {
4137 cracked = 0;
4138
4139 break;
4140 }
4141 }
4142 }
4143 }
4144 else
4145 {
4146 char *digests_buf_ptr = (char *) data.digests_buf;
4147
4148 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4149
4150 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4151 }
4152
4153 if (cracked == 1)
4154 {
4155 found = 1;
4156
4157 data.digests_shown[idx] = 1;
4158
4159 data.digests_done++;
4160
4161 salt_buf->digests_done++;
4162
4163 if (salt_buf->digests_done == salt_buf->digests_cnt)
4164 {
4165 data.salts_shown[salt_pos] = 1;
4166
4167 data.salts_done++;
4168
4169 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4170 }
4171 }
4172 }
4173
4174 if (data.devices_status == STATUS_CRACKED) break;
4175 }
4176 }
4177
4178 if (found) break;
4179
4180 if (data.devices_status == STATUS_CRACKED) break;
4181
4182 iter--;
4183 }
4184
4185 if (data.devices_status == STATUS_CRACKED) break;
4186 }
4187
4188 myfree (line_buf);
4189
4190 out_info[j].seek = ftell (fp);
4191
4192 //hc_thread_mutex_unlock (mux_display);
4193
4194 fclose (fp);
4195 }
4196 }
4197 }
4198 }
4199
4200 check_left = outfile_check_timer;
4201 }
4202 }
4203
4204 if (esalt_size) local_free (hash_buf.esalt);
4205
4206 if (isSalted) local_free (hash_buf.salt);
4207
4208 local_free (hash_buf.digest);
4209
4210 local_free (out_info);
4211
4212 local_free (out_files);
4213
4214 p = NULL;
4215
4216 return (p);
4217 }
4218
4219 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4220 {
4221 if (device_param->pws_cnt < device_param->kernel_power)
4222 {
4223 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4224
4225 u8 *ptr = (u8 *) pw->i;
4226
4227 memcpy (ptr, pw_buf, pw_len);
4228
4229 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4230
4231 pw->pw_len = pw_len;
4232
4233 device_param->pws_cnt++;
4234 }
4235 else
4236 {
4237 fprintf (stderr, "BUG pw_add()!!\n");
4238
4239 return;
4240 }
4241 }
4242
4243 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4244 {
4245 hc_thread_mutex_lock (mux_dispatcher);
4246
4247 const u64 words_cur = data.words_cur;
4248 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4249
4250 device_param->words_off = words_cur;
4251
4252 const u64 words_left = words_base - words_cur;
4253
4254 if (allow_div)
4255 {
4256 if (data.kernel_power_all > words_left)
4257 {
4258 if (data.kernel_power_div == 0)
4259 {
4260 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4261 }
4262 }
4263
4264 if (data.kernel_power_div)
4265 {
4266 if (device_param->kernel_power == device_param->kernel_power_user)
4267 {
4268 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4269
4270 if (kernel_power_new < device_param->kernel_power)
4271 {
4272 device_param->kernel_power = kernel_power_new;
4273 }
4274 }
4275 }
4276 }
4277
4278 const uint kernel_power = device_param->kernel_power;
4279
4280 uint work = MIN (words_left, kernel_power);
4281
4282 work = MIN (work, max);
4283
4284 data.words_cur += work;
4285
4286 hc_thread_mutex_unlock (mux_dispatcher);
4287
4288 return work;
4289 }
4290
4291 static void *thread_calc_stdin (void *p)
4292 {
4293 hc_device_param_t *device_param = (hc_device_param_t *) p;
4294
4295 if (device_param->skipped) return NULL;
4296
4297 autotune (device_param);
4298
4299 char *buf = (char *) mymalloc (HCBUFSIZ);
4300
4301 const uint attack_kern = data.attack_kern;
4302
4303 const uint kernel_power = device_param->kernel_power;
4304
4305 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4306 {
4307 hc_thread_mutex_lock (mux_dispatcher);
4308
4309 if (feof (stdin) != 0)
4310 {
4311 hc_thread_mutex_unlock (mux_dispatcher);
4312
4313 break;
4314 }
4315
4316 uint words_cur = 0;
4317
4318 while (words_cur < kernel_power)
4319 {
4320 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4321
4322 if (line_buf == NULL) break;
4323
4324 uint line_len = in_superchop (line_buf);
4325
4326 line_len = convert_from_hex (line_buf, line_len);
4327
4328 // post-process rule engine
4329
4330 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4331 {
4332 char rule_buf_out[BLOCK_SIZE] = { 0 };
4333
4334 int rule_len_out = -1;
4335
4336 if (line_len < BLOCK_SIZE)
4337 {
4338 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4339 }
4340
4341 if (rule_len_out < 0) continue;
4342
4343 line_buf = rule_buf_out;
4344 line_len = rule_len_out;
4345 }
4346
4347 if (line_len > PW_MAX)
4348 {
4349 continue;
4350 }
4351
4352 if (attack_kern == ATTACK_KERN_STRAIGHT)
4353 {
4354 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4355 {
4356 hc_thread_mutex_lock (mux_counter);
4357
4358 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4359 {
4360 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4361 }
4362
4363 hc_thread_mutex_unlock (mux_counter);
4364
4365 continue;
4366 }
4367 }
4368 else if (attack_kern == ATTACK_KERN_COMBI)
4369 {
4370 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4371 // since we still need to combine the plains
4372
4373 if (line_len > data.pw_max)
4374 {
4375 hc_thread_mutex_lock (mux_counter);
4376
4377 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4378 {
4379 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4380 }
4381
4382 hc_thread_mutex_unlock (mux_counter);
4383
4384 continue;
4385 }
4386 }
4387
4388 pw_add (device_param, (u8 *) line_buf, line_len);
4389
4390 words_cur++;
4391
4392 if (data.devices_status == STATUS_CRACKED) break;
4393 if (data.devices_status == STATUS_ABORTED) break;
4394 if (data.devices_status == STATUS_QUIT) break;
4395 if (data.devices_status == STATUS_BYPASS) break;
4396 }
4397
4398 hc_thread_mutex_unlock (mux_dispatcher);
4399
4400 if (data.devices_status == STATUS_CRACKED) break;
4401 if (data.devices_status == STATUS_ABORTED) break;
4402 if (data.devices_status == STATUS_QUIT) break;
4403 if (data.devices_status == STATUS_BYPASS) break;
4404
4405 // flush
4406
4407 const uint pws_cnt = device_param->pws_cnt;
4408
4409 if (pws_cnt)
4410 {
4411 run_copy (device_param, pws_cnt);
4412
4413 run_cracker (device_param, pws_cnt);
4414
4415 device_param->pws_cnt = 0;
4416
4417 /*
4418 still required?
4419 if (attack_kern == ATTACK_KERN_STRAIGHT)
4420 {
4421 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4422 }
4423 else if (attack_kern == ATTACK_KERN_COMBI)
4424 {
4425 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4426 }
4427 */
4428 }
4429 }
4430
4431 device_param->kernel_accel = 0;
4432 device_param->kernel_loops = 0;
4433
4434 myfree (buf);
4435
4436 return NULL;
4437 }
4438
4439 static void *thread_calc (void *p)
4440 {
4441 hc_device_param_t *device_param = (hc_device_param_t *) p;
4442
4443 if (device_param->skipped) return NULL;
4444
4445 autotune (device_param);
4446
4447 const uint attack_mode = data.attack_mode;
4448 const uint attack_kern = data.attack_kern;
4449
4450 if (attack_mode == ATTACK_MODE_BF)
4451 {
4452 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4453 {
4454 const uint work = get_work (device_param, -1, true);
4455
4456 if (work == 0) break;
4457
4458 const u64 words_off = device_param->words_off;
4459 const u64 words_fin = words_off + work;
4460
4461 const uint pws_cnt = work;
4462
4463 device_param->pws_cnt = pws_cnt;
4464
4465 if (pws_cnt)
4466 {
4467 run_copy (device_param, pws_cnt);
4468
4469 run_cracker (device_param, pws_cnt);
4470
4471 device_param->pws_cnt = 0;
4472
4473 /*
4474 still required?
4475 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4476 */
4477 }
4478
4479 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4480
4481 if (data.devices_status == STATUS_CRACKED) break;
4482 if (data.devices_status == STATUS_ABORTED) break;
4483 if (data.devices_status == STATUS_QUIT) break;
4484 if (data.devices_status == STATUS_BYPASS) break;
4485
4486 if (data.benchmark == 1) break;
4487
4488 device_param->words_done = words_fin;
4489 }
4490 }
4491 else
4492 {
4493 const uint segment_size = data.segment_size;
4494
4495 char *dictfile = data.dictfile;
4496
4497 if (attack_mode == ATTACK_MODE_COMBI)
4498 {
4499 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4500 {
4501 dictfile = data.dictfile2;
4502 }
4503 }
4504
4505 FILE *fd = fopen (dictfile, "rb");
4506
4507 if (fd == NULL)
4508 {
4509 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4510
4511 return NULL;
4512 }
4513
4514 if (attack_mode == ATTACK_MODE_COMBI)
4515 {
4516 const uint combs_mode = data.combs_mode;
4517
4518 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4519 {
4520 const char *dictfilec = data.dictfile2;
4521
4522 FILE *combs_fp = fopen (dictfilec, "rb");
4523
4524 if (combs_fp == NULL)
4525 {
4526 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4527
4528 fclose (fd);
4529
4530 return NULL;
4531 }
4532
4533 device_param->combs_fp = combs_fp;
4534 }
4535 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4536 {
4537 const char *dictfilec = data.dictfile;
4538
4539 FILE *combs_fp = fopen (dictfilec, "rb");
4540
4541 if (combs_fp == NULL)
4542 {
4543 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4544
4545 fclose (fd);
4546
4547 return NULL;
4548 }
4549
4550 device_param->combs_fp = combs_fp;
4551 }
4552 }
4553
4554 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4555
4556 wl_data->buf = (char *) mymalloc (segment_size);
4557 wl_data->avail = segment_size;
4558 wl_data->incr = segment_size;
4559 wl_data->cnt = 0;
4560 wl_data->pos = 0;
4561
4562 u64 words_cur = 0;
4563
4564 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4565 {
4566 u64 words_off = 0;
4567 u64 words_fin = 0;
4568
4569 bool allow_div = true;
4570
4571 u64 max = -1;
4572
4573 while (max)
4574 {
4575 const uint work = get_work (device_param, max, allow_div);
4576
4577 allow_div = false;
4578
4579 if (work == 0) break;
4580
4581 words_off = device_param->words_off;
4582 words_fin = words_off + work;
4583
4584 char *line_buf;
4585 uint line_len;
4586
4587 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4588
4589 max = 0;
4590
4591 for ( ; words_cur < words_fin; words_cur++)
4592 {
4593 get_next_word (wl_data, fd, &line_buf, &line_len);
4594
4595 line_len = convert_from_hex (line_buf, line_len);
4596
4597 // post-process rule engine
4598
4599 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4600 {
4601 char rule_buf_out[BLOCK_SIZE] = { 0 };
4602
4603 int rule_len_out = -1;
4604
4605 if (line_len < BLOCK_SIZE)
4606 {
4607 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4608 }
4609
4610 if (rule_len_out < 0) continue;
4611
4612 line_buf = rule_buf_out;
4613 line_len = rule_len_out;
4614 }
4615
4616 if (attack_kern == ATTACK_KERN_STRAIGHT)
4617 {
4618 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4619 {
4620 max++;
4621
4622 hc_thread_mutex_lock (mux_counter);
4623
4624 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4625 {
4626 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4627 }
4628
4629 hc_thread_mutex_unlock (mux_counter);
4630
4631 continue;
4632 }
4633 }
4634 else if (attack_kern == ATTACK_KERN_COMBI)
4635 {
4636 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4637 // since we still need to combine the plains
4638
4639 if (line_len > data.pw_max)
4640 {
4641 max++;
4642
4643 hc_thread_mutex_lock (mux_counter);
4644
4645 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4646 {
4647 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4648 }
4649
4650 hc_thread_mutex_unlock (mux_counter);
4651
4652 continue;
4653 }
4654 }
4655
4656 pw_add (device_param, (u8 *) line_buf, line_len);
4657
4658 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4659
4660 if (data.devices_status == STATUS_CRACKED) break;
4661 if (data.devices_status == STATUS_ABORTED) break;
4662 if (data.devices_status == STATUS_QUIT) break;
4663 if (data.devices_status == STATUS_BYPASS) break;
4664 }
4665
4666 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4667
4668 if (data.devices_status == STATUS_CRACKED) break;
4669 if (data.devices_status == STATUS_ABORTED) break;
4670 if (data.devices_status == STATUS_QUIT) break;
4671 if (data.devices_status == STATUS_BYPASS) break;
4672 }
4673
4674 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4675
4676 if (data.devices_status == STATUS_CRACKED) break;
4677 if (data.devices_status == STATUS_ABORTED) break;
4678 if (data.devices_status == STATUS_QUIT) break;
4679 if (data.devices_status == STATUS_BYPASS) break;
4680
4681 //
4682 // flush
4683 //
4684
4685 const uint pws_cnt = device_param->pws_cnt;
4686
4687 if (pws_cnt)
4688 {
4689 run_copy (device_param, pws_cnt);
4690
4691 run_cracker (device_param, pws_cnt);
4692
4693 device_param->pws_cnt = 0;
4694
4695 /*
4696 still required?
4697 if (attack_kern == ATTACK_KERN_STRAIGHT)
4698 {
4699 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4700 }
4701 else if (attack_kern == ATTACK_KERN_COMBI)
4702 {
4703 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4704 }
4705 */
4706 }
4707
4708 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4709
4710 if (data.devices_status == STATUS_CRACKED) break;
4711 if (data.devices_status == STATUS_ABORTED) break;
4712 if (data.devices_status == STATUS_QUIT) break;
4713 if (data.devices_status == STATUS_BYPASS) break;
4714
4715 if (words_fin == 0) break;
4716
4717 device_param->words_done = words_fin;
4718 }
4719
4720 if (attack_mode == ATTACK_MODE_COMBI)
4721 {
4722 fclose (device_param->combs_fp);
4723 }
4724
4725 free (wl_data->buf);
4726 free (wl_data);
4727
4728 fclose (fd);
4729 }
4730
4731 device_param->kernel_accel = 0;
4732 device_param->kernel_loops = 0;
4733
4734 return NULL;
4735 }
4736
4737 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4738 {
4739 if (!device_param)
4740 {
4741 log_error ("ERROR: %s : Invalid argument", __func__);
4742
4743 exit (-1);
4744 }
4745
4746 salt_t *salt_buf = &data.salts_buf[salt_pos];
4747
4748 device_param->kernel_params_buf32[24] = salt_pos;
4749 device_param->kernel_params_buf32[27] = 1;
4750 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4751 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4752 device_param->kernel_params_buf32[30] = 0;
4753 device_param->kernel_params_buf32[31] = 1;
4754
4755 char *dictfile_old = data.dictfile;
4756
4757 const char *weak_hash_check = "weak-hash-check";
4758
4759 data.dictfile = (char *) weak_hash_check;
4760
4761 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4762
4763 data.kernel_rules_buf[0].cmds[0] = 0;
4764
4765 /**
4766 * run the kernel
4767 */
4768
4769 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4770 {
4771 run_kernel (KERN_RUN_1, device_param, 1, false);
4772 }
4773 else
4774 {
4775 run_kernel (KERN_RUN_1, device_param, 1, false);
4776
4777 uint loop_step = 16;
4778
4779 const uint iter = salt_buf->salt_iter;
4780
4781 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4782 {
4783 uint loop_left = iter - loop_pos;
4784
4785 loop_left = MIN (loop_left, loop_step);
4786
4787 device_param->kernel_params_buf32[25] = loop_pos;
4788 device_param->kernel_params_buf32[26] = loop_left;
4789
4790 run_kernel (KERN_RUN_2, device_param, 1, false);
4791 }
4792
4793 run_kernel (KERN_RUN_3, device_param, 1, false);
4794 }
4795
4796 /**
4797 * result
4798 */
4799
4800 check_cracked (device_param, salt_pos);
4801
4802 /**
4803 * cleanup
4804 */
4805
4806 device_param->kernel_params_buf32[24] = 0;
4807 device_param->kernel_params_buf32[25] = 0;
4808 device_param->kernel_params_buf32[26] = 0;
4809 device_param->kernel_params_buf32[27] = 0;
4810 device_param->kernel_params_buf32[28] = 0;
4811 device_param->kernel_params_buf32[29] = 0;
4812 device_param->kernel_params_buf32[30] = 0;
4813 device_param->kernel_params_buf32[31] = 0;
4814
4815 data.dictfile = dictfile_old;
4816
4817 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
4818 }
4819
4820 // hlfmt hashcat
4821
4822 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4823 {
4824 if (data.username == 0)
4825 {
4826 *hashbuf_pos = line_buf;
4827 *hashbuf_len = line_len;
4828 }
4829 else
4830 {
4831 char *pos = line_buf;
4832 int len = line_len;
4833
4834 for (int i = 0; i < line_len; i++, pos++, len--)
4835 {
4836 if (line_buf[i] == data.separator)
4837 {
4838 pos++;
4839
4840 len--;
4841
4842 break;
4843 }
4844 }
4845
4846 *hashbuf_pos = pos;
4847 *hashbuf_len = len;
4848 }
4849 }
4850
4851 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4852 {
4853 char *pos = NULL;
4854 int len = 0;
4855
4856 int sep_cnt = 0;
4857
4858 for (int i = 0; i < line_len; i++)
4859 {
4860 if (line_buf[i] == data.separator)
4861 {
4862 sep_cnt++;
4863
4864 continue;
4865 }
4866
4867 if (sep_cnt == 0)
4868 {
4869 if (pos == NULL) pos = line_buf + i;
4870
4871 len++;
4872 }
4873 }
4874
4875 *userbuf_pos = pos;
4876 *userbuf_len = len;
4877 }
4878
4879 // hlfmt pwdump
4880
4881 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
4882 {
4883 int sep_cnt = 0;
4884
4885 int sep2_len = 0;
4886 int sep3_len = 0;
4887
4888 for (int i = 0; i < line_len; i++)
4889 {
4890 if (line_buf[i] == ':')
4891 {
4892 sep_cnt++;
4893
4894 continue;
4895 }
4896
4897 if (sep_cnt == 2) sep2_len++;
4898 if (sep_cnt == 3) sep3_len++;
4899 }
4900
4901 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
4902
4903 return 0;
4904 }
4905
4906 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
4907 {
4908 char *pos = NULL;
4909 int len = 0;
4910
4911 int sep_cnt = 0;
4912
4913 for (int i = 0; i < line_len; i++)
4914 {
4915 if (line_buf[i] == ':')
4916 {
4917 sep_cnt++;
4918
4919 continue;
4920 }
4921
4922 if (data.hash_mode == 1000)
4923 {
4924 if (sep_cnt == 3)
4925 {
4926 if (pos == NULL) pos = line_buf + i;
4927
4928 len++;
4929 }
4930 }
4931 else if (data.hash_mode == 3000)
4932 {
4933 if (sep_cnt == 2)
4934 {
4935 if (pos == NULL) pos = line_buf + i;
4936
4937 len++;
4938 }
4939 }
4940 }
4941
4942 *hashbuf_pos = pos;
4943 *hashbuf_len = len;
4944 }
4945
4946 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
4947 {
4948 char *pos = NULL;
4949 int len = 0;
4950
4951 int sep_cnt = 0;
4952
4953 for (int i = 0; i < line_len; i++)
4954 {
4955 if (line_buf[i] == ':')
4956 {
4957 sep_cnt++;
4958
4959 continue;
4960 }
4961
4962 if (sep_cnt == 0)
4963 {
4964 if (pos == NULL) pos = line_buf + i;
4965
4966 len++;
4967 }
4968 }
4969
4970 *userbuf_pos = pos;
4971 *userbuf_len = len;
4972 }
4973
4974 // hlfmt passwd
4975
4976 static int hlfmt_detect_passwd (char *line_buf, int line_len)
4977 {
4978 int sep_cnt = 0;
4979
4980 char sep5_first = 0;
4981 char sep6_first = 0;
4982
4983 for (int i = 0; i < line_len; i++)
4984 {
4985 if (line_buf[i] == ':')
4986 {
4987 sep_cnt++;
4988
4989 continue;
4990 }
4991
4992 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
4993 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
4994 }
4995
4996 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
4997
4998 return 0;
4999 }
5000
5001 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5002 {
5003 char *pos = NULL;
5004 int len = 0;
5005
5006 int sep_cnt = 0;
5007
5008 for (int i = 0; i < line_len; i++)
5009 {
5010 if (line_buf[i] == ':')
5011 {
5012 sep_cnt++;
5013
5014 continue;
5015 }
5016
5017 if (sep_cnt == 1)
5018 {
5019 if (pos == NULL) pos = line_buf + i;
5020
5021 len++;
5022 }
5023 }
5024
5025 *hashbuf_pos = pos;
5026 *hashbuf_len = len;
5027 }
5028
5029 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5030 {
5031 char *pos = NULL;
5032 int len = 0;
5033
5034 int sep_cnt = 0;
5035
5036 for (int i = 0; i < line_len; i++)
5037 {
5038 if (line_buf[i] == ':')
5039 {
5040 sep_cnt++;
5041
5042 continue;
5043 }
5044
5045 if (sep_cnt == 0)
5046 {
5047 if (pos == NULL) pos = line_buf + i;
5048
5049 len++;
5050 }
5051 }
5052
5053 *userbuf_pos = pos;
5054 *userbuf_len = len;
5055 }
5056
5057 // hlfmt shadow
5058
5059 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5060 {
5061 int sep_cnt = 0;
5062
5063 for (int i = 0; i < line_len; i++)
5064 {
5065 if (line_buf[i] == ':') sep_cnt++;
5066 }
5067
5068 if (sep_cnt == 8) return 1;
5069
5070 return 0;
5071 }
5072
5073 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5074 {
5075 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5076 }
5077
5078 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5079 {
5080 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5081 }
5082
5083 // hlfmt main
5084
5085 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5086 {
5087 switch (hashfile_format)
5088 {
5089 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5090 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5091 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5092 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5093 }
5094 }
5095
5096 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5097 {
5098 switch (hashfile_format)
5099 {
5100 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5101 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5102 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5103 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5104 }
5105 }
5106
5107 char *strhlfmt (const uint hashfile_format)
5108 {
5109 switch (hashfile_format)
5110 {
5111 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5112 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5113 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5114 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5115 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5116 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5117 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5118 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5119 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5120 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5121 }
5122
5123 return ((char *) "Unknown");
5124 }
5125
5126 static uint hlfmt_detect (FILE *fp, uint max_check)
5127 {
5128 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5129
5130 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5131 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5132
5133 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5134
5135 uint num_check = 0;
5136
5137 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5138
5139 while (!feof (fp))
5140 {
5141 int line_len = fgetl (fp, line_buf);
5142
5143 if (line_len == 0) continue;
5144
5145 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5146 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5147 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5148
5149 if (num_check == max_check) break;
5150
5151 num_check++;
5152 }
5153
5154 myfree (line_buf);
5155
5156 uint hashlist_format = HLFMT_HASHCAT;
5157
5158 for (int i = 1; i < HLFMTS_CNT; i++)
5159 {
5160 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5161
5162 hashlist_format = i;
5163 }
5164
5165 free (formats_cnt);
5166
5167 return hashlist_format;
5168 }
5169
5170 /**
5171 * some further helper function
5172 */
5173
5174 // wrapper around mymalloc for ADL
5175
5176 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5177 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5178 {
5179 return mymalloc (iSize);
5180 }
5181 #endif
5182
5183 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)
5184 {
5185 u64 collisions = 0;
5186
5187 const uint dgst_pos0 = data.dgst_pos0;
5188 const uint dgst_pos1 = data.dgst_pos1;
5189 const uint dgst_pos2 = data.dgst_pos2;
5190 const uint dgst_pos3 = data.dgst_pos3;
5191
5192 memset (bitmap_a, 0, bitmap_size);
5193 memset (bitmap_b, 0, bitmap_size);
5194 memset (bitmap_c, 0, bitmap_size);
5195 memset (bitmap_d, 0, bitmap_size);
5196
5197 for (uint i = 0; i < digests_cnt; i++)
5198 {
5199 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5200
5201 uint *digest_ptr = (uint *) digests_buf_ptr;
5202
5203 digests_buf_ptr += dgst_size;
5204
5205 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5206 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5207 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5208 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5209
5210 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5211 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5212 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5213 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5214
5215 if (bitmap_a[idx0] & val0) collisions++;
5216 if (bitmap_b[idx1] & val1) collisions++;
5217 if (bitmap_c[idx2] & val2) collisions++;
5218 if (bitmap_d[idx3] & val3) collisions++;
5219
5220 bitmap_a[idx0] |= val0;
5221 bitmap_b[idx1] |= val1;
5222 bitmap_c[idx2] |= val2;
5223 bitmap_d[idx3] |= val3;
5224
5225 if (collisions >= collisions_max) return 0x7fffffff;
5226 }
5227
5228 return collisions;
5229 }
5230
5231 /**
5232 * main
5233 */
5234
5235 int main (int argc, char **argv)
5236 {
5237 /**
5238 * To help users a bit
5239 */
5240
5241 char *compute = getenv ("COMPUTE");
5242
5243 if (compute)
5244 {
5245 static char display[100];
5246
5247 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5248
5249 putenv (display);
5250 }
5251 else
5252 {
5253 if (getenv ("DISPLAY") == NULL)
5254 putenv ((char *) "DISPLAY=:0");
5255 }
5256
5257 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5258 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5259
5260 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5261 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5262
5263 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5264 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5265
5266 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5267 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5268
5269 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5270 putenv ((char *) "POCL_KERNEL_CACHE=0");
5271
5272 umask (077);
5273
5274 /**
5275 * Real init
5276 */
5277
5278 memset (&data, 0, sizeof (hc_global_data_t));
5279
5280 time_t proc_start;
5281
5282 time (&proc_start);
5283
5284 data.proc_start = proc_start;
5285
5286 int myargc = argc;
5287 char **myargv = argv;
5288
5289 hc_thread_mutex_init (mux_dispatcher);
5290 hc_thread_mutex_init (mux_counter);
5291 hc_thread_mutex_init (mux_display);
5292 hc_thread_mutex_init (mux_adl);
5293
5294 /**
5295 * commandline parameters
5296 */
5297
5298 uint usage = USAGE;
5299 uint version = VERSION;
5300 uint quiet = QUIET;
5301 uint benchmark = BENCHMARK;
5302 uint show = SHOW;
5303 uint left = LEFT;
5304 uint username = USERNAME;
5305 uint remove = REMOVE;
5306 uint remove_timer = REMOVE_TIMER;
5307 u64 skip = SKIP;
5308 u64 limit = LIMIT;
5309 uint keyspace = KEYSPACE;
5310 uint potfile_disable = POTFILE_DISABLE;
5311 char *potfile_path = NULL;
5312 uint debug_mode = DEBUG_MODE;
5313 char *debug_file = NULL;
5314 char *induction_dir = NULL;
5315 char *outfile_check_dir = NULL;
5316 uint force = FORCE;
5317 uint runtime = RUNTIME;
5318 uint hash_mode = HASH_MODE;
5319 uint attack_mode = ATTACK_MODE;
5320 uint markov_disable = MARKOV_DISABLE;
5321 uint markov_classic = MARKOV_CLASSIC;
5322 uint markov_threshold = MARKOV_THRESHOLD;
5323 char *markov_hcstat = NULL;
5324 char *outfile = NULL;
5325 uint outfile_format = OUTFILE_FORMAT;
5326 uint outfile_autohex = OUTFILE_AUTOHEX;
5327 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5328 uint restore = RESTORE;
5329 uint restore_timer = RESTORE_TIMER;
5330 uint restore_disable = RESTORE_DISABLE;
5331 uint status = STATUS;
5332 uint status_timer = STATUS_TIMER;
5333 uint status_automat = STATUS_AUTOMAT;
5334 uint loopback = LOOPBACK;
5335 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5336 char *session = NULL;
5337 uint hex_charset = HEX_CHARSET;
5338 uint hex_salt = HEX_SALT;
5339 uint hex_wordlist = HEX_WORDLIST;
5340 uint rp_gen = RP_GEN;
5341 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5342 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5343 uint rp_gen_seed = RP_GEN_SEED;
5344 char *rule_buf_l = (char *) RULE_BUF_L;
5345 char *rule_buf_r = (char *) RULE_BUF_R;
5346 uint increment = INCREMENT;
5347 uint increment_min = INCREMENT_MIN;
5348 uint increment_max = INCREMENT_MAX;
5349 char *cpu_affinity = NULL;
5350 OCL_PTR *ocl = NULL;
5351 char *opencl_devices = NULL;
5352 char *opencl_platforms = NULL;
5353 char *opencl_device_types = NULL;
5354 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5355 char *truecrypt_keyfiles = NULL;
5356 char *veracrypt_keyfiles = NULL;
5357 uint veracrypt_pim = 0;
5358 uint workload_profile = WORKLOAD_PROFILE;
5359 uint kernel_accel = KERNEL_ACCEL;
5360 uint kernel_loops = KERNEL_LOOPS;
5361 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5362 #ifdef HAVE_HWMON
5363 uint gpu_temp_abort = GPU_TEMP_ABORT;
5364 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5365 #ifdef HAVE_ADL
5366 uint powertune_enable = POWERTUNE_ENABLE;
5367 #endif
5368 #endif
5369 uint logfile_disable = LOGFILE_DISABLE;
5370 uint segment_size = SEGMENT_SIZE;
5371 uint scrypt_tmto = SCRYPT_TMTO;
5372 char separator = SEPARATOR;
5373 uint bitmap_min = BITMAP_MIN;
5374 uint bitmap_max = BITMAP_MAX;
5375 char *custom_charset_1 = NULL;
5376 char *custom_charset_2 = NULL;
5377 char *custom_charset_3 = NULL;
5378 char *custom_charset_4 = NULL;
5379
5380 #define IDX_HELP 'h'
5381 #define IDX_VERSION 'V'
5382 #define IDX_VERSION_LOWER 'v'
5383 #define IDX_QUIET 0xff02
5384 #define IDX_SHOW 0xff03
5385 #define IDX_LEFT 0xff04
5386 #define IDX_REMOVE 0xff05
5387 #define IDX_REMOVE_TIMER 0xff37
5388 #define IDX_SKIP 's'
5389 #define IDX_LIMIT 'l'
5390 #define IDX_KEYSPACE 0xff35
5391 #define IDX_POTFILE_DISABLE 0xff06
5392 #define IDX_POTFILE_PATH 0xffe0
5393 #define IDX_DEBUG_MODE 0xff43
5394 #define IDX_DEBUG_FILE 0xff44
5395 #define IDX_INDUCTION_DIR 0xff46
5396 #define IDX_OUTFILE_CHECK_DIR 0xff47
5397 #define IDX_USERNAME 0xff07
5398 #define IDX_FORCE 0xff08
5399 #define IDX_RUNTIME 0xff09
5400 #define IDX_BENCHMARK 'b'
5401 #define IDX_HASH_MODE 'm'
5402 #define IDX_ATTACK_MODE 'a'
5403 #define IDX_RP_FILE 'r'
5404 #define IDX_RP_GEN 'g'
5405 #define IDX_RP_GEN_FUNC_MIN 0xff10
5406 #define IDX_RP_GEN_FUNC_MAX 0xff11
5407 #define IDX_RP_GEN_SEED 0xff34
5408 #define IDX_RULE_BUF_L 'j'
5409 #define IDX_RULE_BUF_R 'k'
5410 #define IDX_INCREMENT 'i'
5411 #define IDX_INCREMENT_MIN 0xff12
5412 #define IDX_INCREMENT_MAX 0xff13
5413 #define IDX_OUTFILE 'o'
5414 #define IDX_OUTFILE_FORMAT 0xff14
5415 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5416 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5417 #define IDX_RESTORE 0xff15
5418 #define IDX_RESTORE_DISABLE 0xff27
5419 #define IDX_STATUS 0xff17
5420 #define IDX_STATUS_TIMER 0xff18
5421 #define IDX_STATUS_AUTOMAT 0xff50
5422 #define IDX_LOOPBACK 0xff38
5423 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5424 #define IDX_SESSION 0xff19
5425 #define IDX_HEX_CHARSET 0xff20
5426 #define IDX_HEX_SALT 0xff21
5427 #define IDX_HEX_WORDLIST 0xff40
5428 #define IDX_MARKOV_DISABLE 0xff22
5429 #define IDX_MARKOV_CLASSIC 0xff23
5430 #define IDX_MARKOV_THRESHOLD 't'
5431 #define IDX_MARKOV_HCSTAT 0xff24
5432 #define IDX_CPU_AFFINITY 0xff25
5433 #define IDX_OPENCL_DEVICES 'd'
5434 #define IDX_OPENCL_PLATFORMS 0xff72
5435 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5436 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5437 #define IDX_WORKLOAD_PROFILE 'w'
5438 #define IDX_KERNEL_ACCEL 'n'
5439 #define IDX_KERNEL_LOOPS 'u'
5440 #define IDX_GPU_TEMP_DISABLE 0xff29
5441 #define IDX_GPU_TEMP_ABORT 0xff30
5442 #define IDX_GPU_TEMP_RETAIN 0xff31
5443 #define IDX_POWERTUNE_ENABLE 0xff41
5444 #define IDX_LOGFILE_DISABLE 0xff51
5445 #define IDX_TRUECRYPT_KEYFILES 0xff52
5446 #define IDX_VERACRYPT_KEYFILES 0xff53
5447 #define IDX_VERACRYPT_PIM 0xff54
5448 #define IDX_SCRYPT_TMTO 0xff61
5449 #define IDX_SEGMENT_SIZE 'c'
5450 #define IDX_SEPARATOR 'p'
5451 #define IDX_BITMAP_MIN 0xff70
5452 #define IDX_BITMAP_MAX 0xff71
5453 #define IDX_CUSTOM_CHARSET_1 '1'
5454 #define IDX_CUSTOM_CHARSET_2 '2'
5455 #define IDX_CUSTOM_CHARSET_3 '3'
5456 #define IDX_CUSTOM_CHARSET_4 '4'
5457
5458 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5459
5460 struct option long_options[] =
5461 {
5462 {"help", no_argument, 0, IDX_HELP},
5463 {"version", no_argument, 0, IDX_VERSION},
5464 {"quiet", no_argument, 0, IDX_QUIET},
5465 {"show", no_argument, 0, IDX_SHOW},
5466 {"left", no_argument, 0, IDX_LEFT},
5467 {"username", no_argument, 0, IDX_USERNAME},
5468 {"remove", no_argument, 0, IDX_REMOVE},
5469 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5470 {"skip", required_argument, 0, IDX_SKIP},
5471 {"limit", required_argument, 0, IDX_LIMIT},
5472 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5473 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5474 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5475 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5476 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5477 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5478 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5479 {"force", no_argument, 0, IDX_FORCE},
5480 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5481 {"restore", no_argument, 0, IDX_RESTORE},
5482 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5483 {"status", no_argument, 0, IDX_STATUS},
5484 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5485 {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT},
5486 {"loopback", no_argument, 0, IDX_LOOPBACK},
5487 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5488 {"session", required_argument, 0, IDX_SESSION},
5489 {"runtime", required_argument, 0, IDX_RUNTIME},
5490 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5491 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5492 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5493 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5494 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5495 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5496 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5497 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5498 {"rules-file", required_argument, 0, IDX_RP_FILE},
5499 {"outfile", required_argument, 0, IDX_OUTFILE},
5500 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5501 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5502 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5503 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5504 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5505 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5506 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5507 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5508 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5509 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5510 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5511 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5512 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5513 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5514 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5515 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5516 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5517 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5518 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5519 #ifdef HAVE_HWMON
5520 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5521 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5522 #ifdef HAVE_ADL
5523 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5524 #endif
5525 #endif // HAVE_HWMON
5526 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5527 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5528 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5529 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5530 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5531 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5532 {"seperator", required_argument, 0, IDX_SEPARATOR},
5533 {"separator", required_argument, 0, IDX_SEPARATOR},
5534 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5535 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5536 {"increment", no_argument, 0, IDX_INCREMENT},
5537 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5538 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5539 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5540 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5541 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5542 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5543 {0, 0, 0, 0}
5544 };
5545
5546 uint rp_files_cnt = 0;
5547
5548 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5549
5550 int option_index = 0;
5551 int c = -1;
5552
5553 optind = 1;
5554 optopt = 0;
5555
5556 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5557 {
5558 switch (c)
5559 {
5560 case IDX_HELP: usage = 1; break;
5561 case IDX_VERSION:
5562 case IDX_VERSION_LOWER: version = 1; break;
5563 case IDX_RESTORE: restore = 1; break;
5564 case IDX_SESSION: session = optarg; break;
5565 case IDX_SHOW: show = 1; break;
5566 case IDX_LEFT: left = 1; break;
5567 case '?': return (-1);
5568 }
5569 }
5570
5571 if (optopt != 0)
5572 {
5573 log_error ("ERROR: Invalid argument specified");
5574
5575 return (-1);
5576 }
5577
5578 /**
5579 * exit functions
5580 */
5581
5582 if (version)
5583 {
5584 log_info ("%s", VERSION_TAG);
5585
5586 return (0);
5587 }
5588
5589 if (usage)
5590 {
5591 usage_big_print (PROGNAME);
5592
5593 return (0);
5594 }
5595
5596 /**
5597 * session needs to be set, always!
5598 */
5599
5600 if (session == NULL) session = (char *) PROGNAME;
5601
5602 /**
5603 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5604 */
5605
5606 char *exec_path = get_exec_path ();
5607
5608 #ifdef LINUX
5609
5610 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5611 char *resolved_exec_path = realpath (exec_path, NULL);
5612
5613 char *install_dir = get_install_dir (resolved_exec_path);
5614 char *profile_dir = NULL;
5615 char *session_dir = NULL;
5616 char *shared_dir = NULL;
5617
5618 if (strcmp (install_dir, resolved_install_folder) == 0)
5619 {
5620 struct passwd *pw = getpwuid (getuid ());
5621
5622 const char *homedir = pw->pw_dir;
5623
5624 profile_dir = get_profile_dir (homedir);
5625 session_dir = get_session_dir (profile_dir);
5626 shared_dir = strdup (SHARED_FOLDER);
5627
5628 mkdir (profile_dir, 0700);
5629 mkdir (session_dir, 0700);
5630 }
5631 else
5632 {
5633 profile_dir = install_dir;
5634 session_dir = install_dir;
5635 shared_dir = install_dir;
5636 }
5637
5638 myfree (resolved_install_folder);
5639 myfree (resolved_exec_path);
5640
5641 #else
5642
5643 char *install_dir = get_install_dir (exec_path);
5644 char *profile_dir = install_dir;
5645 char *session_dir = install_dir;
5646 char *shared_dir = install_dir;
5647
5648 #endif
5649
5650 data.install_dir = install_dir;
5651 data.profile_dir = profile_dir;
5652 data.session_dir = session_dir;
5653 data.shared_dir = shared_dir;
5654
5655 myfree (exec_path);
5656
5657 /**
5658 * kernel cache, we need to make sure folder exist
5659 */
5660
5661 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5662
5663 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5664
5665 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5666
5667 mkdir (kernels_folder, 0700);
5668
5669 myfree (kernels_folder);
5670
5671 /**
5672 * session
5673 */
5674
5675 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5676
5677 data.session = session;
5678
5679 char *eff_restore_file = (char *) mymalloc (session_size);
5680 char *new_restore_file = (char *) mymalloc (session_size);
5681
5682 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5683 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5684
5685 data.eff_restore_file = eff_restore_file;
5686 data.new_restore_file = new_restore_file;
5687
5688 if (((show == 1) || (left == 1)) && (restore == 1))
5689 {
5690 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5691 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5692
5693 return (-1);
5694 }
5695
5696 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5697 if ((show == 1) || (left == 1))
5698 {
5699 restore_disable = 1;
5700
5701 restore = 0;
5702 }
5703
5704 data.restore_disable = restore_disable;
5705
5706 restore_data_t *rd = init_restore (argc, argv);
5707
5708 data.rd = rd;
5709
5710 /**
5711 * restore file
5712 */
5713
5714 if (restore == 1)
5715 {
5716 read_restore (eff_restore_file, rd);
5717
5718 if (rd->version_bin < RESTORE_MIN)
5719 {
5720 log_error ("ERROR: Incompatible restore-file version");
5721
5722 return (-1);
5723 }
5724
5725 myargc = rd->argc;
5726 myargv = rd->argv;
5727
5728 #ifdef _POSIX
5729 rd->pid = getpid ();
5730 #elif _WIN
5731 rd->pid = GetCurrentProcessId ();
5732 #endif
5733 }
5734
5735 uint hash_mode_chgd = 0;
5736 uint runtime_chgd = 0;
5737 uint kernel_loops_chgd = 0;
5738 uint kernel_accel_chgd = 0;
5739 uint attack_mode_chgd = 0;
5740 uint outfile_format_chgd = 0;
5741 uint rp_gen_seed_chgd = 0;
5742 uint remove_timer_chgd = 0;
5743 uint increment_min_chgd = 0;
5744 uint increment_max_chgd = 0;
5745 uint workload_profile_chgd = 0;
5746 uint opencl_vector_width_chgd = 0;
5747
5748 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5749 uint gpu_temp_retain_chgd = 0;
5750 uint gpu_temp_abort_chgd = 0;
5751 #endif
5752
5753 optind = 1;
5754 optopt = 0;
5755 option_index = 0;
5756
5757 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5758 {
5759 switch (c)
5760 {
5761 //case IDX_HELP: usage = 1; break;
5762 //case IDX_VERSION: version = 1; break;
5763 //case IDX_RESTORE: restore = 1; break;
5764 case IDX_QUIET: quiet = 1; break;
5765 //case IDX_SHOW: show = 1; break;
5766 case IDX_SHOW: break;
5767 //case IDX_LEFT: left = 1; break;
5768 case IDX_LEFT: break;
5769 case IDX_USERNAME: username = 1; break;
5770 case IDX_REMOVE: remove = 1; break;
5771 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5772 remove_timer_chgd = 1; break;
5773 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5774 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5775 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5776 case IDX_DEBUG_FILE: debug_file = optarg; break;
5777 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5778 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5779 case IDX_FORCE: force = 1; break;
5780 case IDX_SKIP: skip = atoll (optarg); break;
5781 case IDX_LIMIT: limit = atoll (optarg); break;
5782 case IDX_KEYSPACE: keyspace = 1; break;
5783 case IDX_BENCHMARK: benchmark = 1; break;
5784 case IDX_RESTORE: break;
5785 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
5786 case IDX_STATUS: status = 1; break;
5787 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
5788 case IDX_STATUS_AUTOMAT: status_automat = 1; break;
5789 case IDX_LOOPBACK: loopback = 1; break;
5790 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
5791 //case IDX_SESSION: session = optarg; break;
5792 case IDX_SESSION: break;
5793 case IDX_HASH_MODE: hash_mode = atoi (optarg);
5794 hash_mode_chgd = 1; break;
5795 case IDX_RUNTIME: runtime = atoi (optarg);
5796 runtime_chgd = 1; break;
5797 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
5798 attack_mode_chgd = 1; break;
5799 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
5800 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
5801 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
5802 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
5803 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
5804 rp_gen_seed_chgd = 1; break;
5805 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
5806 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
5807 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
5808 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
5809 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
5810 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
5811 case IDX_OUTFILE: outfile = optarg; break;
5812 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
5813 outfile_format_chgd = 1; break;
5814 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
5815 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
5816 case IDX_HEX_CHARSET: hex_charset = 1; break;
5817 case IDX_HEX_SALT: hex_salt = 1; break;
5818 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
5819 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
5820 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
5821 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
5822 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
5823 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
5824 opencl_vector_width_chgd = 1; break;
5825 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
5826 workload_profile_chgd = 1; break;
5827 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
5828 kernel_accel_chgd = 1; break;
5829 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
5830 kernel_loops_chgd = 1; break;
5831 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
5832 #ifdef HAVE_HWMON
5833 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
5834 #ifdef HAVE_ADL
5835 gpu_temp_abort_chgd = 1;
5836 #endif
5837 break;
5838 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
5839 #ifdef HAVE_ADL
5840 gpu_temp_retain_chgd = 1;
5841 #endif
5842 break;
5843 #ifdef HAVE_ADL
5844 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
5845 #endif
5846 #endif // HAVE_HWMON
5847 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
5848 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
5849 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
5850 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
5851 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
5852 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
5853 case IDX_SEPARATOR: separator = optarg[0]; break;
5854 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
5855 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
5856 case IDX_INCREMENT: increment = 1; break;
5857 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
5858 increment_min_chgd = 1; break;
5859 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
5860 increment_max_chgd = 1; break;
5861 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
5862 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
5863 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
5864 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
5865
5866 default:
5867 log_error ("ERROR: Invalid argument specified");
5868 return (-1);
5869 }
5870 }
5871
5872 if (optopt != 0)
5873 {
5874 log_error ("ERROR: Invalid argument specified");
5875
5876 return (-1);
5877 }
5878
5879 /**
5880 * Inform user things getting started,
5881 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
5882 * - we do not need to check algorithm_pos
5883 */
5884
5885 if (quiet == 0)
5886 {
5887 if (benchmark == 1)
5888 {
5889 if (status_automat == 0)
5890 {
5891 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
5892 log_info ("");
5893 }
5894 else
5895 {
5896 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
5897 }
5898 }
5899 else if (restore == 1)
5900 {
5901 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
5902 log_info ("");
5903 }
5904 else
5905 {
5906 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
5907 log_info ("");
5908 }
5909 }
5910
5911 /**
5912 * sanity check
5913 */
5914
5915 if (attack_mode > 7)
5916 {
5917 log_error ("ERROR: Invalid attack-mode specified");
5918
5919 return (-1);
5920 }
5921
5922 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
5923 {
5924 log_error ("ERROR: Invalid runtime specified");
5925
5926 return (-1);
5927 }
5928
5929 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
5930 {
5931 log_error ("ERROR: Invalid hash-type specified");
5932
5933 return (-1);
5934 }
5935
5936 // renamed hash modes
5937
5938 if (hash_mode_chgd)
5939 {
5940 int n = -1;
5941
5942 switch (hash_mode)
5943 {
5944 case 123: n = 124;
5945 break;
5946 }
5947
5948 if (n >= 0)
5949 {
5950 log_error ("Old -m specified, use -m %d instead", n);
5951
5952 return (-1);
5953 }
5954 }
5955
5956 if (username == 1)
5957 {
5958 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
5959 {
5960 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
5961
5962 return (-1);
5963 }
5964 }
5965
5966 if (outfile_format > 16)
5967 {
5968 log_error ("ERROR: Invalid outfile-format specified");
5969
5970 return (-1);
5971 }
5972
5973 if (left == 1)
5974 {
5975 if (outfile_format_chgd == 1)
5976 {
5977 if (outfile_format > 1)
5978 {
5979 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
5980
5981 return (-1);
5982 }
5983 }
5984 else
5985 {
5986 outfile_format = OUTFILE_FMT_HASH;
5987 }
5988 }
5989
5990 if (show == 1)
5991 {
5992 if (outfile_format_chgd == 1)
5993 {
5994 if ((outfile_format > 7) && (outfile_format < 16))
5995 {
5996 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
5997
5998 return (-1);
5999 }
6000 }
6001 }
6002
6003 if (increment_min < INCREMENT_MIN)
6004 {
6005 log_error ("ERROR: Invalid increment-min specified");
6006
6007 return (-1);
6008 }
6009
6010 if (increment_max > INCREMENT_MAX)
6011 {
6012 log_error ("ERROR: Invalid increment-max specified");
6013
6014 return (-1);
6015 }
6016
6017 if (increment_min > increment_max)
6018 {
6019 log_error ("ERROR: Invalid increment-min specified");
6020
6021 return (-1);
6022 }
6023
6024 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6025 {
6026 log_error ("ERROR: increment is not allowed in attack-mode 0");
6027
6028 return (-1);
6029 }
6030
6031 if ((increment == 0) && (increment_min_chgd == 1))
6032 {
6033 log_error ("ERROR: increment-min is only supported together with increment switch");
6034
6035 return (-1);
6036 }
6037
6038 if ((increment == 0) && (increment_max_chgd == 1))
6039 {
6040 log_error ("ERROR: increment-max is only supported together with increment switch");
6041
6042 return (-1);
6043 }
6044
6045 if (rp_files_cnt && rp_gen)
6046 {
6047 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6048
6049 return (-1);
6050 }
6051
6052 if (rp_files_cnt || rp_gen)
6053 {
6054 if (attack_mode != ATTACK_MODE_STRAIGHT)
6055 {
6056 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6057
6058 return (-1);
6059 }
6060 }
6061
6062 if (rp_gen_func_min > rp_gen_func_max)
6063 {
6064 log_error ("ERROR: Invalid rp-gen-func-min specified");
6065
6066 return (-1);
6067 }
6068
6069 if (kernel_accel_chgd == 1)
6070 {
6071 if (force == 0)
6072 {
6073 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6074 log_info ("Please consider using the option -w instead");
6075 log_info ("You can use --force to override this but do not post error reports if you do so");
6076 log_info ("");
6077
6078 return (-1);
6079 }
6080
6081 if (kernel_accel < 1)
6082 {
6083 log_error ("ERROR: Invalid kernel-accel specified");
6084
6085 return (-1);
6086 }
6087
6088 if (kernel_accel > 1024)
6089 {
6090 log_error ("ERROR: Invalid kernel-accel specified");
6091
6092 return (-1);
6093 }
6094 }
6095
6096 if (kernel_loops_chgd == 1)
6097 {
6098 if (force == 0)
6099 {
6100 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6101 log_info ("Please consider using the option -w instead");
6102 log_info ("You can use --force to override this but do not post error reports if you do so");
6103 log_info ("");
6104
6105 return (-1);
6106 }
6107
6108 if (kernel_loops < 1)
6109 {
6110 log_error ("ERROR: Invalid kernel-loops specified");
6111
6112 return (-1);
6113 }
6114
6115 if (kernel_loops > 1024)
6116 {
6117 log_error ("ERROR: Invalid kernel-loops specified");
6118
6119 return (-1);
6120 }
6121 }
6122
6123 if ((workload_profile < 1) || (workload_profile > 4))
6124 {
6125 log_error ("ERROR: workload-profile %i not available", workload_profile);
6126
6127 return (-1);
6128 }
6129
6130 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6131 {
6132 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6133
6134 return (-1);
6135 }
6136
6137 if (show == 1 || left == 1)
6138 {
6139 attack_mode = ATTACK_MODE_NONE;
6140
6141 if (remove == 1)
6142 {
6143 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6144
6145 return (-1);
6146 }
6147
6148 if (potfile_disable == 1)
6149 {
6150 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6151
6152 return (-1);
6153 }
6154 }
6155
6156 uint attack_kern = ATTACK_KERN_NONE;
6157
6158 switch (attack_mode)
6159 {
6160 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6161 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6162 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6163 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6164 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6165 }
6166
6167 if (benchmark == 0)
6168 {
6169 if (keyspace == 1)
6170 {
6171 int num_additional_params = 1;
6172
6173 if (attack_kern == ATTACK_KERN_COMBI)
6174 {
6175 num_additional_params = 2;
6176 }
6177
6178 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6179
6180 if (keyspace_wordlist_specified == 0) optind--;
6181 }
6182
6183 if (attack_kern == ATTACK_KERN_NONE)
6184 {
6185 if ((optind + 1) != myargc)
6186 {
6187 usage_mini_print (myargv[0]);
6188
6189 return (-1);
6190 }
6191 }
6192 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6193 {
6194 if ((optind + 1) > myargc)
6195 {
6196 usage_mini_print (myargv[0]);
6197
6198 return (-1);
6199 }
6200 }
6201 else if (attack_kern == ATTACK_KERN_COMBI)
6202 {
6203 if ((optind + 3) != myargc)
6204 {
6205 usage_mini_print (myargv[0]);
6206
6207 return (-1);
6208 }
6209 }
6210 else if (attack_kern == ATTACK_KERN_BF)
6211 {
6212 if ((optind + 1) > myargc)
6213 {
6214 usage_mini_print (myargv[0]);
6215
6216 return (-1);
6217 }
6218 }
6219 else
6220 {
6221 usage_mini_print (myargv[0]);
6222
6223 return (-1);
6224 }
6225 }
6226 else
6227 {
6228 if (myargv[optind] != 0)
6229 {
6230 log_error ("ERROR: Invalid argument for benchmark mode specified");
6231
6232 return (-1);
6233 }
6234
6235 if (attack_mode_chgd == 1)
6236 {
6237 if (attack_mode != ATTACK_MODE_BF)
6238 {
6239 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6240
6241 return (-1);
6242 }
6243 }
6244 }
6245
6246 if (skip != 0 && limit != 0)
6247 {
6248 limit += skip;
6249 }
6250
6251 if (keyspace == 1)
6252 {
6253 if (show == 1)
6254 {
6255 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6256
6257 return (-1);
6258 }
6259 else if (left == 1)
6260 {
6261 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6262
6263 return (-1);
6264 }
6265
6266 potfile_disable = 1;
6267
6268 restore_disable = 1;
6269
6270 restore = 0;
6271
6272 weak_hash_threshold = 0;
6273
6274 quiet = 1;
6275 }
6276
6277 if (remove_timer_chgd == 1)
6278 {
6279 if (remove == 0)
6280 {
6281 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6282
6283 return (-1);
6284 }
6285
6286 if (remove_timer < 1)
6287 {
6288 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6289
6290 return (-1);
6291 }
6292 }
6293
6294 if (loopback == 1)
6295 {
6296 if (attack_mode == ATTACK_MODE_STRAIGHT)
6297 {
6298 if ((rp_files_cnt == 0) && (rp_gen == 0))
6299 {
6300 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6301
6302 return (-1);
6303 }
6304 }
6305 else
6306 {
6307 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6308
6309 return (-1);
6310 }
6311 }
6312
6313 if (debug_mode > 0)
6314 {
6315 if (attack_mode != ATTACK_MODE_STRAIGHT)
6316 {
6317 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6318
6319 return (-1);
6320 }
6321
6322 if ((rp_files_cnt == 0) && (rp_gen == 0))
6323 {
6324 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6325
6326 return (-1);
6327 }
6328 }
6329
6330 if (debug_mode > 4)
6331 {
6332 log_error ("ERROR: Invalid debug-mode specified");
6333
6334 return (-1);
6335 }
6336
6337 if (debug_file != NULL)
6338 {
6339 if (debug_mode < 1)
6340 {
6341 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6342
6343 return (-1);
6344 }
6345 }
6346
6347 if (induction_dir != NULL)
6348 {
6349 if (attack_mode == ATTACK_MODE_BF)
6350 {
6351 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6352
6353 return (-1);
6354 }
6355 }
6356
6357 if (attack_mode != ATTACK_MODE_STRAIGHT)
6358 {
6359 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6360 {
6361 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6362
6363 return (-1);
6364 }
6365
6366 weak_hash_threshold = 0;
6367 }
6368
6369 /**
6370 * induction directory
6371 */
6372
6373 char *induction_directory = NULL;
6374
6375 if (attack_mode != ATTACK_MODE_BF)
6376 {
6377 if (induction_dir == NULL)
6378 {
6379 induction_directory = (char *) mymalloc (session_size);
6380
6381 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6382
6383 // create induction folder if it does not already exist
6384
6385 if (keyspace == 0)
6386 {
6387 if (rmdir (induction_directory) == -1)
6388 {
6389 if (errno == ENOENT)
6390 {
6391 // good, we can ignore
6392 }
6393 else if (errno == ENOTEMPTY)
6394 {
6395 char *induction_directory_mv = (char *) mymalloc (session_size);
6396
6397 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6398
6399 if (rename (induction_directory, induction_directory_mv) != 0)
6400 {
6401 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6402
6403 return (-1);
6404 }
6405 }
6406 else
6407 {
6408 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6409
6410 return (-1);
6411 }
6412 }
6413
6414 if (mkdir (induction_directory, 0700) == -1)
6415 {
6416 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6417
6418 return (-1);
6419 }
6420 }
6421 }
6422 else
6423 {
6424 induction_directory = induction_dir;
6425 }
6426 }
6427
6428 data.induction_directory = induction_directory;
6429
6430 /**
6431 * loopback
6432 */
6433
6434 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6435
6436 char *loopback_file = (char *) mymalloc (loopback_size);
6437
6438 /**
6439 * tuning db
6440 */
6441
6442 char tuning_db_file[256] = { 0 };
6443
6444 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6445
6446 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6447
6448 /**
6449 * outfile-check directory
6450 */
6451
6452 char *outfile_check_directory = NULL;
6453
6454 if (outfile_check_dir == NULL)
6455 {
6456 outfile_check_directory = (char *) mymalloc (session_size);
6457
6458 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6459 }
6460 else
6461 {
6462 outfile_check_directory = outfile_check_dir;
6463 }
6464
6465 data.outfile_check_directory = outfile_check_directory;
6466
6467 if (keyspace == 0)
6468 {
6469 struct stat outfile_check_stat;
6470
6471 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6472 {
6473 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6474
6475 if (is_dir == 0)
6476 {
6477 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6478
6479 return (-1);
6480 }
6481 }
6482 else if (outfile_check_dir == NULL)
6483 {
6484 if (mkdir (outfile_check_directory, 0700) == -1)
6485 {
6486 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6487
6488 return (-1);
6489 }
6490 }
6491 }
6492
6493 /**
6494 * special other stuff
6495 */
6496
6497 if (hash_mode == 9710)
6498 {
6499 outfile_format = 5;
6500 outfile_format_chgd = 1;
6501 }
6502
6503 if (hash_mode == 9810)
6504 {
6505 outfile_format = 5;
6506 outfile_format_chgd = 1;
6507 }
6508
6509 if (hash_mode == 10410)
6510 {
6511 outfile_format = 5;
6512 outfile_format_chgd = 1;
6513 }
6514
6515 /**
6516 * store stuff
6517 */
6518
6519 data.hash_mode = hash_mode;
6520 data.restore = restore;
6521 data.restore_timer = restore_timer;
6522 data.restore_disable = restore_disable;
6523 data.status = status;
6524 data.status_timer = status_timer;
6525 data.status_automat = status_automat;
6526 data.loopback = loopback;
6527 data.runtime = runtime;
6528 data.remove = remove;
6529 data.remove_timer = remove_timer;
6530 data.debug_mode = debug_mode;
6531 data.debug_file = debug_file;
6532 data.username = username;
6533 data.quiet = quiet;
6534 data.outfile = outfile;
6535 data.outfile_format = outfile_format;
6536 data.outfile_autohex = outfile_autohex;
6537 data.hex_charset = hex_charset;
6538 data.hex_salt = hex_salt;
6539 data.hex_wordlist = hex_wordlist;
6540 data.separator = separator;
6541 data.rp_files = rp_files;
6542 data.rp_files_cnt = rp_files_cnt;
6543 data.rp_gen = rp_gen;
6544 data.rp_gen_seed = rp_gen_seed;
6545 data.force = force;
6546 data.benchmark = benchmark;
6547 data.skip = skip;
6548 data.limit = limit;
6549 #ifdef HAVE_HWMON
6550 #ifdef HAVE_ADL
6551 data.powertune_enable = powertune_enable;
6552 #endif
6553 #endif
6554 data.logfile_disable = logfile_disable;
6555 data.truecrypt_keyfiles = truecrypt_keyfiles;
6556 data.veracrypt_keyfiles = veracrypt_keyfiles;
6557 data.veracrypt_pim = veracrypt_pim;
6558 data.scrypt_tmto = scrypt_tmto;
6559 data.workload_profile = workload_profile;
6560
6561 /**
6562 * cpu affinity
6563 */
6564
6565 if (cpu_affinity)
6566 {
6567 set_cpu_affinity (cpu_affinity);
6568 }
6569
6570 if (rp_gen_seed_chgd == 0)
6571 {
6572 srand (proc_start);
6573 }
6574 else
6575 {
6576 srand (rp_gen_seed);
6577 }
6578
6579 /**
6580 * logfile init
6581 */
6582
6583 if (logfile_disable == 0)
6584 {
6585 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6586
6587 char *logfile = (char *) mymalloc (logfile_size);
6588
6589 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6590
6591 data.logfile = logfile;
6592
6593 char *topid = logfile_generate_topid ();
6594
6595 data.topid = topid;
6596 }
6597
6598 // logfile_append() checks for logfile_disable internally to make it easier from here
6599
6600 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6601 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6602 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6603 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6604 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6605 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6606 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6607 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6608 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6609 #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));
6610
6611 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6612 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6613 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6614 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6615 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6616 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6617 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6618 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6619
6620 logfile_top_msg ("START");
6621
6622 logfile_top_uint (attack_mode);
6623 logfile_top_uint (attack_kern);
6624 logfile_top_uint (benchmark);
6625 logfile_top_uint (bitmap_min);
6626 logfile_top_uint (bitmap_max);
6627 logfile_top_uint (debug_mode);
6628 logfile_top_uint (force);
6629 logfile_top_uint (kernel_accel);
6630 logfile_top_uint (kernel_loops);
6631 logfile_top_uint (gpu_temp_disable);
6632 #ifdef HAVE_HWMON
6633 logfile_top_uint (gpu_temp_abort);
6634 logfile_top_uint (gpu_temp_retain);
6635 #endif
6636 logfile_top_uint (hash_mode);
6637 logfile_top_uint (hex_charset);
6638 logfile_top_uint (hex_salt);
6639 logfile_top_uint (hex_wordlist);
6640 logfile_top_uint (increment);
6641 logfile_top_uint (increment_max);
6642 logfile_top_uint (increment_min);
6643 logfile_top_uint (keyspace);
6644 logfile_top_uint (left);
6645 logfile_top_uint (logfile_disable);
6646 logfile_top_uint (loopback);
6647 logfile_top_uint (markov_classic);
6648 logfile_top_uint (markov_disable);
6649 logfile_top_uint (markov_threshold);
6650 logfile_top_uint (outfile_autohex);
6651 logfile_top_uint (outfile_check_timer);
6652 logfile_top_uint (outfile_format);
6653 logfile_top_uint (potfile_disable);
6654 logfile_top_string (potfile_path);
6655 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6656 logfile_top_uint (powertune_enable);
6657 #endif
6658 logfile_top_uint (scrypt_tmto);
6659 logfile_top_uint (quiet);
6660 logfile_top_uint (remove);
6661 logfile_top_uint (remove_timer);
6662 logfile_top_uint (restore);
6663 logfile_top_uint (restore_disable);
6664 logfile_top_uint (restore_timer);
6665 logfile_top_uint (rp_gen);
6666 logfile_top_uint (rp_gen_func_max);
6667 logfile_top_uint (rp_gen_func_min);
6668 logfile_top_uint (rp_gen_seed);
6669 logfile_top_uint (runtime);
6670 logfile_top_uint (segment_size);
6671 logfile_top_uint (show);
6672 logfile_top_uint (status);
6673 logfile_top_uint (status_automat);
6674 logfile_top_uint (status_timer);
6675 logfile_top_uint (usage);
6676 logfile_top_uint (username);
6677 logfile_top_uint (version);
6678 logfile_top_uint (weak_hash_threshold);
6679 logfile_top_uint (workload_profile);
6680 logfile_top_uint64 (limit);
6681 logfile_top_uint64 (skip);
6682 logfile_top_char (separator);
6683 logfile_top_string (cpu_affinity);
6684 logfile_top_string (custom_charset_1);
6685 logfile_top_string (custom_charset_2);
6686 logfile_top_string (custom_charset_3);
6687 logfile_top_string (custom_charset_4);
6688 logfile_top_string (debug_file);
6689 logfile_top_string (opencl_devices);
6690 logfile_top_string (opencl_platforms);
6691 logfile_top_string (opencl_device_types);
6692 logfile_top_uint (opencl_vector_width);
6693 logfile_top_string (induction_dir);
6694 logfile_top_string (markov_hcstat);
6695 logfile_top_string (outfile);
6696 logfile_top_string (outfile_check_dir);
6697 logfile_top_string (rule_buf_l);
6698 logfile_top_string (rule_buf_r);
6699 logfile_top_string (session);
6700 logfile_top_string (truecrypt_keyfiles);
6701 logfile_top_string (veracrypt_keyfiles);
6702 logfile_top_uint (veracrypt_pim);
6703
6704 /**
6705 * Init OpenCL library loader
6706 */
6707
6708 if (keyspace == 0)
6709 {
6710 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6711
6712 ocl_init (ocl);
6713
6714 data.ocl = ocl;
6715 }
6716
6717 /**
6718 * OpenCL platform selection
6719 */
6720
6721 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6722
6723 /**
6724 * OpenCL device selection
6725 */
6726
6727 u32 devices_filter = setup_devices_filter (opencl_devices);
6728
6729 /**
6730 * OpenCL device type selection
6731 */
6732
6733 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6734
6735 /**
6736 * benchmark
6737 */
6738
6739 if (benchmark == 1)
6740 {
6741 /**
6742 * disable useless stuff for benchmark
6743 */
6744
6745 status_timer = 0;
6746 restore_timer = 0;
6747 restore_disable = 1;
6748 potfile_disable = 1;
6749 weak_hash_threshold = 0;
6750 gpu_temp_disable = 1;
6751
6752 data.status_timer = status_timer;
6753 data.restore_timer = restore_timer;
6754 data.restore_disable = restore_disable;
6755
6756 /**
6757 * force attack mode to be bruteforce
6758 */
6759
6760 attack_mode = ATTACK_MODE_BF;
6761 attack_kern = ATTACK_KERN_BF;
6762
6763 if (workload_profile_chgd == 0)
6764 {
6765 workload_profile = 3;
6766
6767 data.workload_profile = workload_profile;
6768 }
6769 }
6770
6771 /**
6772 * config
6773 */
6774
6775 uint hash_type = 0;
6776 uint salt_type = 0;
6777 uint attack_exec = 0;
6778 uint opts_type = 0;
6779 uint kern_type = 0;
6780 uint dgst_size = 0;
6781 uint esalt_size = 0;
6782 uint opti_type = 0;
6783 uint dgst_pos0 = -1;
6784 uint dgst_pos1 = -1;
6785 uint dgst_pos2 = -1;
6786 uint dgst_pos3 = -1;
6787
6788 int (*parse_func) (char *, uint, hash_t *);
6789 int (*sort_by_digest) (const void *, const void *);
6790
6791 uint algorithm_pos = 0;
6792 uint algorithm_max = 1;
6793
6794 uint *algorithms = default_benchmark_algorithms;
6795
6796 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
6797
6798 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
6799 {
6800 /*
6801 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
6802 * the following algos are skipped entirely
6803 */
6804
6805 if (algorithm_pos > 0)
6806 {
6807 local_free (rd);
6808
6809 rd = init_restore (argc, argv);
6810
6811 data.rd = rd;
6812 }
6813
6814 /**
6815 * update hash_mode in case of multihash benchmark
6816 */
6817
6818 if (benchmark == 1)
6819 {
6820 if (hash_mode_chgd == 0)
6821 {
6822 hash_mode = algorithms[algorithm_pos];
6823
6824 data.hash_mode = hash_mode;
6825 }
6826
6827 quiet = 1;
6828
6829 data.quiet = quiet;
6830 }
6831
6832 switch (hash_mode)
6833 {
6834 case 0: hash_type = HASH_TYPE_MD5;
6835 salt_type = SALT_TYPE_NONE;
6836 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6837 opts_type = OPTS_TYPE_PT_GENERATE_LE
6838 | OPTS_TYPE_PT_ADD80
6839 | OPTS_TYPE_PT_ADDBITS14;
6840 kern_type = KERN_TYPE_MD5;
6841 dgst_size = DGST_SIZE_4_4;
6842 parse_func = md5_parse_hash;
6843 sort_by_digest = sort_by_digest_4_4;
6844 opti_type = OPTI_TYPE_ZERO_BYTE
6845 | OPTI_TYPE_PRECOMPUTE_INIT
6846 | OPTI_TYPE_PRECOMPUTE_MERKLE
6847 | OPTI_TYPE_MEET_IN_MIDDLE
6848 | OPTI_TYPE_EARLY_SKIP
6849 | OPTI_TYPE_NOT_ITERATED
6850 | OPTI_TYPE_NOT_SALTED
6851 | OPTI_TYPE_RAW_HASH;
6852 dgst_pos0 = 0;
6853 dgst_pos1 = 3;
6854 dgst_pos2 = 2;
6855 dgst_pos3 = 1;
6856 break;
6857
6858 case 10: hash_type = HASH_TYPE_MD5;
6859 salt_type = SALT_TYPE_INTERN;
6860 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6861 opts_type = OPTS_TYPE_PT_GENERATE_LE
6862 | OPTS_TYPE_ST_ADD80
6863 | OPTS_TYPE_ST_ADDBITS14;
6864 kern_type = KERN_TYPE_MD5_PWSLT;
6865 dgst_size = DGST_SIZE_4_4;
6866 parse_func = md5s_parse_hash;
6867 sort_by_digest = sort_by_digest_4_4;
6868 opti_type = OPTI_TYPE_ZERO_BYTE
6869 | OPTI_TYPE_PRECOMPUTE_INIT
6870 | OPTI_TYPE_PRECOMPUTE_MERKLE
6871 | OPTI_TYPE_MEET_IN_MIDDLE
6872 | OPTI_TYPE_EARLY_SKIP
6873 | OPTI_TYPE_NOT_ITERATED
6874 | OPTI_TYPE_APPENDED_SALT
6875 | OPTI_TYPE_RAW_HASH;
6876 dgst_pos0 = 0;
6877 dgst_pos1 = 3;
6878 dgst_pos2 = 2;
6879 dgst_pos3 = 1;
6880 break;
6881
6882 case 11: hash_type = HASH_TYPE_MD5;
6883 salt_type = SALT_TYPE_INTERN;
6884 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6885 opts_type = OPTS_TYPE_PT_GENERATE_LE
6886 | OPTS_TYPE_ST_ADD80
6887 | OPTS_TYPE_ST_ADDBITS14;
6888 kern_type = KERN_TYPE_MD5_PWSLT;
6889 dgst_size = DGST_SIZE_4_4;
6890 parse_func = joomla_parse_hash;
6891 sort_by_digest = sort_by_digest_4_4;
6892 opti_type = OPTI_TYPE_ZERO_BYTE
6893 | OPTI_TYPE_PRECOMPUTE_INIT
6894 | OPTI_TYPE_PRECOMPUTE_MERKLE
6895 | OPTI_TYPE_MEET_IN_MIDDLE
6896 | OPTI_TYPE_EARLY_SKIP
6897 | OPTI_TYPE_NOT_ITERATED
6898 | OPTI_TYPE_APPENDED_SALT
6899 | OPTI_TYPE_RAW_HASH;
6900 dgst_pos0 = 0;
6901 dgst_pos1 = 3;
6902 dgst_pos2 = 2;
6903 dgst_pos3 = 1;
6904 break;
6905
6906 case 12: hash_type = HASH_TYPE_MD5;
6907 salt_type = SALT_TYPE_INTERN;
6908 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6909 opts_type = OPTS_TYPE_PT_GENERATE_LE
6910 | OPTS_TYPE_ST_ADD80
6911 | OPTS_TYPE_ST_ADDBITS14;
6912 kern_type = KERN_TYPE_MD5_PWSLT;
6913 dgst_size = DGST_SIZE_4_4;
6914 parse_func = postgresql_parse_hash;
6915 sort_by_digest = sort_by_digest_4_4;
6916 opti_type = OPTI_TYPE_ZERO_BYTE
6917 | OPTI_TYPE_PRECOMPUTE_INIT
6918 | OPTI_TYPE_PRECOMPUTE_MERKLE
6919 | OPTI_TYPE_MEET_IN_MIDDLE
6920 | OPTI_TYPE_EARLY_SKIP
6921 | OPTI_TYPE_NOT_ITERATED
6922 | OPTI_TYPE_APPENDED_SALT
6923 | OPTI_TYPE_RAW_HASH;
6924 dgst_pos0 = 0;
6925 dgst_pos1 = 3;
6926 dgst_pos2 = 2;
6927 dgst_pos3 = 1;
6928 break;
6929
6930 case 20: hash_type = HASH_TYPE_MD5;
6931 salt_type = SALT_TYPE_INTERN;
6932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6933 opts_type = OPTS_TYPE_PT_GENERATE_LE
6934 | OPTS_TYPE_PT_ADD80
6935 | OPTS_TYPE_PT_ADDBITS14;
6936 kern_type = KERN_TYPE_MD5_SLTPW;
6937 dgst_size = DGST_SIZE_4_4;
6938 parse_func = md5s_parse_hash;
6939 sort_by_digest = sort_by_digest_4_4;
6940 opti_type = OPTI_TYPE_ZERO_BYTE
6941 | OPTI_TYPE_PRECOMPUTE_INIT
6942 | OPTI_TYPE_PRECOMPUTE_MERKLE
6943 | OPTI_TYPE_EARLY_SKIP
6944 | OPTI_TYPE_NOT_ITERATED
6945 | OPTI_TYPE_PREPENDED_SALT
6946 | OPTI_TYPE_RAW_HASH;
6947 dgst_pos0 = 0;
6948 dgst_pos1 = 3;
6949 dgst_pos2 = 2;
6950 dgst_pos3 = 1;
6951 break;
6952
6953 case 21: hash_type = HASH_TYPE_MD5;
6954 salt_type = SALT_TYPE_INTERN;
6955 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6956 opts_type = OPTS_TYPE_PT_GENERATE_LE
6957 | OPTS_TYPE_PT_ADD80
6958 | OPTS_TYPE_PT_ADDBITS14;
6959 kern_type = KERN_TYPE_MD5_SLTPW;
6960 dgst_size = DGST_SIZE_4_4;
6961 parse_func = osc_parse_hash;
6962 sort_by_digest = sort_by_digest_4_4;
6963 opti_type = OPTI_TYPE_ZERO_BYTE
6964 | OPTI_TYPE_PRECOMPUTE_INIT
6965 | OPTI_TYPE_PRECOMPUTE_MERKLE
6966 | OPTI_TYPE_EARLY_SKIP
6967 | OPTI_TYPE_NOT_ITERATED
6968 | OPTI_TYPE_PREPENDED_SALT
6969 | OPTI_TYPE_RAW_HASH;
6970 dgst_pos0 = 0;
6971 dgst_pos1 = 3;
6972 dgst_pos2 = 2;
6973 dgst_pos3 = 1;
6974 break;
6975
6976 case 22: hash_type = HASH_TYPE_MD5;
6977 salt_type = SALT_TYPE_EMBEDDED;
6978 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
6979 opts_type = OPTS_TYPE_PT_GENERATE_LE
6980 | OPTS_TYPE_PT_ADD80
6981 | OPTS_TYPE_PT_ADDBITS14;
6982 kern_type = KERN_TYPE_MD5_SLTPW;
6983 dgst_size = DGST_SIZE_4_4;
6984 parse_func = netscreen_parse_hash;
6985 sort_by_digest = sort_by_digest_4_4;
6986 opti_type = OPTI_TYPE_ZERO_BYTE
6987 | OPTI_TYPE_PRECOMPUTE_INIT
6988 | OPTI_TYPE_PRECOMPUTE_MERKLE
6989 | OPTI_TYPE_EARLY_SKIP
6990 | OPTI_TYPE_NOT_ITERATED
6991 | OPTI_TYPE_PREPENDED_SALT
6992 | OPTI_TYPE_RAW_HASH;
6993 dgst_pos0 = 0;
6994 dgst_pos1 = 3;
6995 dgst_pos2 = 2;
6996 dgst_pos3 = 1;
6997 break;
6998
6999 case 23: hash_type = HASH_TYPE_MD5;
7000 salt_type = SALT_TYPE_EMBEDDED;
7001 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7002 opts_type = OPTS_TYPE_PT_GENERATE_LE
7003 | OPTS_TYPE_PT_ADD80
7004 | OPTS_TYPE_PT_ADDBITS14;
7005 kern_type = KERN_TYPE_MD5_SLTPW;
7006 dgst_size = DGST_SIZE_4_4;
7007 parse_func = skype_parse_hash;
7008 sort_by_digest = sort_by_digest_4_4;
7009 opti_type = OPTI_TYPE_ZERO_BYTE
7010 | OPTI_TYPE_PRECOMPUTE_INIT
7011 | OPTI_TYPE_PRECOMPUTE_MERKLE
7012 | OPTI_TYPE_EARLY_SKIP
7013 | OPTI_TYPE_NOT_ITERATED
7014 | OPTI_TYPE_PREPENDED_SALT
7015 | OPTI_TYPE_RAW_HASH;
7016 dgst_pos0 = 0;
7017 dgst_pos1 = 3;
7018 dgst_pos2 = 2;
7019 dgst_pos3 = 1;
7020 break;
7021
7022 case 30: hash_type = HASH_TYPE_MD5;
7023 salt_type = SALT_TYPE_INTERN;
7024 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7025 opts_type = OPTS_TYPE_PT_GENERATE_LE
7026 | OPTS_TYPE_PT_UNICODE
7027 | OPTS_TYPE_ST_ADD80
7028 | OPTS_TYPE_ST_ADDBITS14;
7029 kern_type = KERN_TYPE_MD5_PWUSLT;
7030 dgst_size = DGST_SIZE_4_4;
7031 parse_func = md5s_parse_hash;
7032 sort_by_digest = sort_by_digest_4_4;
7033 opti_type = OPTI_TYPE_ZERO_BYTE
7034 | OPTI_TYPE_PRECOMPUTE_INIT
7035 | OPTI_TYPE_PRECOMPUTE_MERKLE
7036 | OPTI_TYPE_MEET_IN_MIDDLE
7037 | OPTI_TYPE_EARLY_SKIP
7038 | OPTI_TYPE_NOT_ITERATED
7039 | OPTI_TYPE_APPENDED_SALT
7040 | OPTI_TYPE_RAW_HASH;
7041 dgst_pos0 = 0;
7042 dgst_pos1 = 3;
7043 dgst_pos2 = 2;
7044 dgst_pos3 = 1;
7045 break;
7046
7047 case 40: hash_type = HASH_TYPE_MD5;
7048 salt_type = SALT_TYPE_INTERN;
7049 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7050 opts_type = OPTS_TYPE_PT_GENERATE_LE
7051 | OPTS_TYPE_PT_ADD80
7052 | OPTS_TYPE_PT_ADDBITS14
7053 | OPTS_TYPE_PT_UNICODE;
7054 kern_type = KERN_TYPE_MD5_SLTPWU;
7055 dgst_size = DGST_SIZE_4_4;
7056 parse_func = md5s_parse_hash;
7057 sort_by_digest = sort_by_digest_4_4;
7058 opti_type = OPTI_TYPE_ZERO_BYTE
7059 | OPTI_TYPE_PRECOMPUTE_INIT
7060 | OPTI_TYPE_PRECOMPUTE_MERKLE
7061 | OPTI_TYPE_EARLY_SKIP
7062 | OPTI_TYPE_NOT_ITERATED
7063 | OPTI_TYPE_PREPENDED_SALT
7064 | OPTI_TYPE_RAW_HASH;
7065 dgst_pos0 = 0;
7066 dgst_pos1 = 3;
7067 dgst_pos2 = 2;
7068 dgst_pos3 = 1;
7069 break;
7070
7071 case 50: hash_type = HASH_TYPE_MD5;
7072 salt_type = SALT_TYPE_INTERN;
7073 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7074 opts_type = OPTS_TYPE_PT_GENERATE_LE
7075 | OPTS_TYPE_ST_ADD80
7076 | OPTS_TYPE_ST_ADDBITS14;
7077 kern_type = KERN_TYPE_HMACMD5_PW;
7078 dgst_size = DGST_SIZE_4_4;
7079 parse_func = hmacmd5_parse_hash;
7080 sort_by_digest = sort_by_digest_4_4;
7081 opti_type = OPTI_TYPE_ZERO_BYTE
7082 | OPTI_TYPE_NOT_ITERATED;
7083 dgst_pos0 = 0;
7084 dgst_pos1 = 3;
7085 dgst_pos2 = 2;
7086 dgst_pos3 = 1;
7087 break;
7088
7089 case 60: hash_type = HASH_TYPE_MD5;
7090 salt_type = SALT_TYPE_INTERN;
7091 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7092 opts_type = OPTS_TYPE_PT_GENERATE_LE
7093 | OPTS_TYPE_PT_ADD80
7094 | OPTS_TYPE_PT_ADDBITS14;
7095 kern_type = KERN_TYPE_HMACMD5_SLT;
7096 dgst_size = DGST_SIZE_4_4;
7097 parse_func = hmacmd5_parse_hash;
7098 sort_by_digest = sort_by_digest_4_4;
7099 opti_type = OPTI_TYPE_ZERO_BYTE
7100 | OPTI_TYPE_NOT_ITERATED;
7101 dgst_pos0 = 0;
7102 dgst_pos1 = 3;
7103 dgst_pos2 = 2;
7104 dgst_pos3 = 1;
7105 break;
7106
7107 case 100: hash_type = HASH_TYPE_SHA1;
7108 salt_type = SALT_TYPE_NONE;
7109 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7110 opts_type = OPTS_TYPE_PT_GENERATE_BE
7111 | OPTS_TYPE_PT_ADD80
7112 | OPTS_TYPE_PT_ADDBITS15;
7113 kern_type = KERN_TYPE_SHA1;
7114 dgst_size = DGST_SIZE_4_5;
7115 parse_func = sha1_parse_hash;
7116 sort_by_digest = sort_by_digest_4_5;
7117 opti_type = OPTI_TYPE_ZERO_BYTE
7118 | OPTI_TYPE_PRECOMPUTE_INIT
7119 | OPTI_TYPE_PRECOMPUTE_MERKLE
7120 | OPTI_TYPE_EARLY_SKIP
7121 | OPTI_TYPE_NOT_ITERATED
7122 | OPTI_TYPE_NOT_SALTED
7123 | OPTI_TYPE_RAW_HASH;
7124 dgst_pos0 = 3;
7125 dgst_pos1 = 4;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 101: hash_type = HASH_TYPE_SHA1;
7131 salt_type = SALT_TYPE_NONE;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_BE
7134 | OPTS_TYPE_PT_ADD80
7135 | OPTS_TYPE_PT_ADDBITS15;
7136 kern_type = KERN_TYPE_SHA1;
7137 dgst_size = DGST_SIZE_4_5;
7138 parse_func = sha1b64_parse_hash;
7139 sort_by_digest = sort_by_digest_4_5;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_PRECOMPUTE_INIT
7142 | OPTI_TYPE_PRECOMPUTE_MERKLE
7143 | OPTI_TYPE_EARLY_SKIP
7144 | OPTI_TYPE_NOT_ITERATED
7145 | OPTI_TYPE_NOT_SALTED
7146 | OPTI_TYPE_RAW_HASH;
7147 dgst_pos0 = 3;
7148 dgst_pos1 = 4;
7149 dgst_pos2 = 2;
7150 dgst_pos3 = 1;
7151 break;
7152
7153 case 110: hash_type = HASH_TYPE_SHA1;
7154 salt_type = SALT_TYPE_INTERN;
7155 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7156 opts_type = OPTS_TYPE_PT_GENERATE_BE
7157 | OPTS_TYPE_ST_ADD80
7158 | OPTS_TYPE_ST_ADDBITS15;
7159 kern_type = KERN_TYPE_SHA1_PWSLT;
7160 dgst_size = DGST_SIZE_4_5;
7161 parse_func = sha1s_parse_hash;
7162 sort_by_digest = sort_by_digest_4_5;
7163 opti_type = OPTI_TYPE_ZERO_BYTE
7164 | OPTI_TYPE_PRECOMPUTE_INIT
7165 | OPTI_TYPE_PRECOMPUTE_MERKLE
7166 | OPTI_TYPE_EARLY_SKIP
7167 | OPTI_TYPE_NOT_ITERATED
7168 | OPTI_TYPE_APPENDED_SALT
7169 | OPTI_TYPE_RAW_HASH;
7170 dgst_pos0 = 3;
7171 dgst_pos1 = 4;
7172 dgst_pos2 = 2;
7173 dgst_pos3 = 1;
7174 break;
7175
7176 case 111: hash_type = HASH_TYPE_SHA1;
7177 salt_type = SALT_TYPE_EMBEDDED;
7178 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7179 opts_type = OPTS_TYPE_PT_GENERATE_BE
7180 | OPTS_TYPE_ST_ADD80
7181 | OPTS_TYPE_ST_ADDBITS15;
7182 kern_type = KERN_TYPE_SHA1_PWSLT;
7183 dgst_size = DGST_SIZE_4_5;
7184 parse_func = sha1b64s_parse_hash;
7185 sort_by_digest = sort_by_digest_4_5;
7186 opti_type = OPTI_TYPE_ZERO_BYTE
7187 | OPTI_TYPE_PRECOMPUTE_INIT
7188 | OPTI_TYPE_PRECOMPUTE_MERKLE
7189 | OPTI_TYPE_EARLY_SKIP
7190 | OPTI_TYPE_NOT_ITERATED
7191 | OPTI_TYPE_APPENDED_SALT
7192 | OPTI_TYPE_RAW_HASH;
7193 dgst_pos0 = 3;
7194 dgst_pos1 = 4;
7195 dgst_pos2 = 2;
7196 dgst_pos3 = 1;
7197 break;
7198
7199 case 112: hash_type = HASH_TYPE_SHA1;
7200 salt_type = SALT_TYPE_INTERN;
7201 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7202 opts_type = OPTS_TYPE_PT_GENERATE_BE
7203 | OPTS_TYPE_ST_ADD80
7204 | OPTS_TYPE_ST_ADDBITS15
7205 | OPTS_TYPE_ST_HEX;
7206 kern_type = KERN_TYPE_SHA1_PWSLT;
7207 dgst_size = DGST_SIZE_4_5;
7208 parse_func = oracles_parse_hash;
7209 sort_by_digest = sort_by_digest_4_5;
7210 opti_type = OPTI_TYPE_ZERO_BYTE
7211 | OPTI_TYPE_PRECOMPUTE_INIT
7212 | OPTI_TYPE_PRECOMPUTE_MERKLE
7213 | OPTI_TYPE_EARLY_SKIP
7214 | OPTI_TYPE_NOT_ITERATED
7215 | OPTI_TYPE_APPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 3;
7218 dgst_pos1 = 4;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 120: hash_type = HASH_TYPE_SHA1;
7224 salt_type = SALT_TYPE_INTERN;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_BE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS15;
7229 kern_type = KERN_TYPE_SHA1_SLTPW;
7230 dgst_size = DGST_SIZE_4_5;
7231 parse_func = sha1s_parse_hash;
7232 sort_by_digest = sort_by_digest_4_5;
7233 opti_type = OPTI_TYPE_ZERO_BYTE
7234 | OPTI_TYPE_PRECOMPUTE_INIT
7235 | OPTI_TYPE_PRECOMPUTE_MERKLE
7236 | OPTI_TYPE_EARLY_SKIP
7237 | OPTI_TYPE_NOT_ITERATED
7238 | OPTI_TYPE_PREPENDED_SALT
7239 | OPTI_TYPE_RAW_HASH;
7240 dgst_pos0 = 3;
7241 dgst_pos1 = 4;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 121: hash_type = HASH_TYPE_SHA1;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_BE
7250 | OPTS_TYPE_PT_ADD80
7251 | OPTS_TYPE_PT_ADDBITS15
7252 | OPTS_TYPE_ST_LOWER;
7253 kern_type = KERN_TYPE_SHA1_SLTPW;
7254 dgst_size = DGST_SIZE_4_5;
7255 parse_func = smf_parse_hash;
7256 sort_by_digest = sort_by_digest_4_5;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_EARLY_SKIP
7261 | OPTI_TYPE_NOT_ITERATED
7262 | OPTI_TYPE_PREPENDED_SALT
7263 | OPTI_TYPE_RAW_HASH;
7264 dgst_pos0 = 3;
7265 dgst_pos1 = 4;
7266 dgst_pos2 = 2;
7267 dgst_pos3 = 1;
7268 break;
7269
7270 case 122: hash_type = HASH_TYPE_SHA1;
7271 salt_type = SALT_TYPE_EMBEDDED;
7272 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7273 opts_type = OPTS_TYPE_PT_GENERATE_BE
7274 | OPTS_TYPE_PT_ADD80
7275 | OPTS_TYPE_PT_ADDBITS15
7276 | OPTS_TYPE_ST_HEX;
7277 kern_type = KERN_TYPE_SHA1_SLTPW;
7278 dgst_size = DGST_SIZE_4_5;
7279 parse_func = osx1_parse_hash;
7280 sort_by_digest = sort_by_digest_4_5;
7281 opti_type = OPTI_TYPE_ZERO_BYTE
7282 | OPTI_TYPE_PRECOMPUTE_INIT
7283 | OPTI_TYPE_PRECOMPUTE_MERKLE
7284 | OPTI_TYPE_EARLY_SKIP
7285 | OPTI_TYPE_NOT_ITERATED
7286 | OPTI_TYPE_PREPENDED_SALT
7287 | OPTI_TYPE_RAW_HASH;
7288 dgst_pos0 = 3;
7289 dgst_pos1 = 4;
7290 dgst_pos2 = 2;
7291 dgst_pos3 = 1;
7292 break;
7293
7294 case 124: hash_type = HASH_TYPE_SHA1;
7295 salt_type = SALT_TYPE_EMBEDDED;
7296 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7297 opts_type = OPTS_TYPE_PT_GENERATE_BE
7298 | OPTS_TYPE_PT_ADD80
7299 | OPTS_TYPE_PT_ADDBITS15;
7300 kern_type = KERN_TYPE_SHA1_SLTPW;
7301 dgst_size = DGST_SIZE_4_5;
7302 parse_func = djangosha1_parse_hash;
7303 sort_by_digest = sort_by_digest_4_5;
7304 opti_type = OPTI_TYPE_ZERO_BYTE
7305 | OPTI_TYPE_PRECOMPUTE_INIT
7306 | OPTI_TYPE_PRECOMPUTE_MERKLE
7307 | OPTI_TYPE_EARLY_SKIP
7308 | OPTI_TYPE_NOT_ITERATED
7309 | OPTI_TYPE_PREPENDED_SALT
7310 | OPTI_TYPE_RAW_HASH;
7311 dgst_pos0 = 3;
7312 dgst_pos1 = 4;
7313 dgst_pos2 = 2;
7314 dgst_pos3 = 1;
7315 break;
7316
7317 case 125: hash_type = HASH_TYPE_SHA1;
7318 salt_type = SALT_TYPE_EMBEDDED;
7319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7320 opts_type = OPTS_TYPE_PT_GENERATE_BE
7321 | OPTS_TYPE_PT_ADD80
7322 | OPTS_TYPE_PT_ADDBITS15
7323 | OPTS_TYPE_ST_HEX;
7324 kern_type = KERN_TYPE_SHA1_SLTPW;
7325 dgst_size = DGST_SIZE_4_5;
7326 parse_func = arubaos_parse_hash;
7327 sort_by_digest = sort_by_digest_4_5;
7328 opti_type = OPTI_TYPE_ZERO_BYTE
7329 | OPTI_TYPE_PRECOMPUTE_INIT
7330 | OPTI_TYPE_PRECOMPUTE_MERKLE
7331 | OPTI_TYPE_EARLY_SKIP
7332 | OPTI_TYPE_NOT_ITERATED
7333 | OPTI_TYPE_PREPENDED_SALT
7334 | OPTI_TYPE_RAW_HASH;
7335 dgst_pos0 = 3;
7336 dgst_pos1 = 4;
7337 dgst_pos2 = 2;
7338 dgst_pos3 = 1;
7339 break;
7340
7341 case 130: hash_type = HASH_TYPE_SHA1;
7342 salt_type = SALT_TYPE_INTERN;
7343 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7344 opts_type = OPTS_TYPE_PT_GENERATE_BE
7345 | OPTS_TYPE_PT_UNICODE
7346 | OPTS_TYPE_ST_ADD80
7347 | OPTS_TYPE_ST_ADDBITS15;
7348 kern_type = KERN_TYPE_SHA1_PWUSLT;
7349 dgst_size = DGST_SIZE_4_5;
7350 parse_func = sha1s_parse_hash;
7351 sort_by_digest = sort_by_digest_4_5;
7352 opti_type = OPTI_TYPE_ZERO_BYTE
7353 | OPTI_TYPE_PRECOMPUTE_INIT
7354 | OPTI_TYPE_PRECOMPUTE_MERKLE
7355 | OPTI_TYPE_EARLY_SKIP
7356 | OPTI_TYPE_NOT_ITERATED
7357 | OPTI_TYPE_APPENDED_SALT
7358 | OPTI_TYPE_RAW_HASH;
7359 dgst_pos0 = 3;
7360 dgst_pos1 = 4;
7361 dgst_pos2 = 2;
7362 dgst_pos3 = 1;
7363 break;
7364
7365 case 131: hash_type = HASH_TYPE_SHA1;
7366 salt_type = SALT_TYPE_EMBEDDED;
7367 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7368 opts_type = OPTS_TYPE_PT_GENERATE_BE
7369 | OPTS_TYPE_PT_UNICODE
7370 | OPTS_TYPE_PT_UPPER
7371 | OPTS_TYPE_ST_ADD80
7372 | OPTS_TYPE_ST_ADDBITS15
7373 | OPTS_TYPE_ST_HEX;
7374 kern_type = KERN_TYPE_SHA1_PWUSLT;
7375 dgst_size = DGST_SIZE_4_5;
7376 parse_func = mssql2000_parse_hash;
7377 sort_by_digest = sort_by_digest_4_5;
7378 opti_type = OPTI_TYPE_ZERO_BYTE
7379 | OPTI_TYPE_PRECOMPUTE_INIT
7380 | OPTI_TYPE_PRECOMPUTE_MERKLE
7381 | OPTI_TYPE_EARLY_SKIP
7382 | OPTI_TYPE_NOT_ITERATED
7383 | OPTI_TYPE_APPENDED_SALT
7384 | OPTI_TYPE_RAW_HASH;
7385 dgst_pos0 = 3;
7386 dgst_pos1 = 4;
7387 dgst_pos2 = 2;
7388 dgst_pos3 = 1;
7389 break;
7390
7391 case 132: hash_type = HASH_TYPE_SHA1;
7392 salt_type = SALT_TYPE_EMBEDDED;
7393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7394 opts_type = OPTS_TYPE_PT_GENERATE_BE
7395 | OPTS_TYPE_PT_UNICODE
7396 | OPTS_TYPE_ST_ADD80
7397 | OPTS_TYPE_ST_ADDBITS15
7398 | OPTS_TYPE_ST_HEX;
7399 kern_type = KERN_TYPE_SHA1_PWUSLT;
7400 dgst_size = DGST_SIZE_4_5;
7401 parse_func = mssql2005_parse_hash;
7402 sort_by_digest = sort_by_digest_4_5;
7403 opti_type = OPTI_TYPE_ZERO_BYTE
7404 | OPTI_TYPE_PRECOMPUTE_INIT
7405 | OPTI_TYPE_PRECOMPUTE_MERKLE
7406 | OPTI_TYPE_EARLY_SKIP
7407 | OPTI_TYPE_NOT_ITERATED
7408 | OPTI_TYPE_APPENDED_SALT
7409 | OPTI_TYPE_RAW_HASH;
7410 dgst_pos0 = 3;
7411 dgst_pos1 = 4;
7412 dgst_pos2 = 2;
7413 dgst_pos3 = 1;
7414 break;
7415
7416 case 133: hash_type = HASH_TYPE_SHA1;
7417 salt_type = SALT_TYPE_EMBEDDED;
7418 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7419 opts_type = OPTS_TYPE_PT_GENERATE_BE
7420 | OPTS_TYPE_PT_UNICODE
7421 | OPTS_TYPE_ST_ADD80
7422 | OPTS_TYPE_ST_ADDBITS15;
7423 kern_type = KERN_TYPE_SHA1_PWUSLT;
7424 dgst_size = DGST_SIZE_4_5;
7425 parse_func = peoplesoft_parse_hash;
7426 sort_by_digest = sort_by_digest_4_5;
7427 opti_type = OPTI_TYPE_ZERO_BYTE
7428 | OPTI_TYPE_PRECOMPUTE_INIT
7429 | OPTI_TYPE_PRECOMPUTE_MERKLE
7430 | OPTI_TYPE_EARLY_SKIP
7431 | OPTI_TYPE_NOT_ITERATED
7432 | OPTI_TYPE_APPENDED_SALT
7433 | OPTI_TYPE_RAW_HASH;
7434 dgst_pos0 = 3;
7435 dgst_pos1 = 4;
7436 dgst_pos2 = 2;
7437 dgst_pos3 = 1;
7438 break;
7439
7440 case 140: hash_type = HASH_TYPE_SHA1;
7441 salt_type = SALT_TYPE_INTERN;
7442 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7443 opts_type = OPTS_TYPE_PT_GENERATE_BE
7444 | OPTS_TYPE_PT_ADD80
7445 | OPTS_TYPE_PT_ADDBITS15
7446 | OPTS_TYPE_PT_UNICODE;
7447 kern_type = KERN_TYPE_SHA1_SLTPWU;
7448 dgst_size = DGST_SIZE_4_5;
7449 parse_func = sha1s_parse_hash;
7450 sort_by_digest = sort_by_digest_4_5;
7451 opti_type = OPTI_TYPE_ZERO_BYTE
7452 | OPTI_TYPE_PRECOMPUTE_INIT
7453 | OPTI_TYPE_PRECOMPUTE_MERKLE
7454 | OPTI_TYPE_EARLY_SKIP
7455 | OPTI_TYPE_NOT_ITERATED
7456 | OPTI_TYPE_PREPENDED_SALT
7457 | OPTI_TYPE_RAW_HASH;
7458 dgst_pos0 = 3;
7459 dgst_pos1 = 4;
7460 dgst_pos2 = 2;
7461 dgst_pos3 = 1;
7462 break;
7463
7464 case 141: hash_type = HASH_TYPE_SHA1;
7465 salt_type = SALT_TYPE_EMBEDDED;
7466 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7467 opts_type = OPTS_TYPE_PT_GENERATE_BE
7468 | OPTS_TYPE_PT_ADD80
7469 | OPTS_TYPE_PT_ADDBITS15
7470 | OPTS_TYPE_PT_UNICODE
7471 | OPTS_TYPE_ST_BASE64;
7472 kern_type = KERN_TYPE_SHA1_SLTPWU;
7473 dgst_size = DGST_SIZE_4_5;
7474 parse_func = episerver_parse_hash;
7475 sort_by_digest = sort_by_digest_4_5;
7476 opti_type = OPTI_TYPE_ZERO_BYTE
7477 | OPTI_TYPE_PRECOMPUTE_INIT
7478 | OPTI_TYPE_PRECOMPUTE_MERKLE
7479 | OPTI_TYPE_EARLY_SKIP
7480 | OPTI_TYPE_NOT_ITERATED
7481 | OPTI_TYPE_PREPENDED_SALT
7482 | OPTI_TYPE_RAW_HASH;
7483 dgst_pos0 = 3;
7484 dgst_pos1 = 4;
7485 dgst_pos2 = 2;
7486 dgst_pos3 = 1;
7487 break;
7488
7489 case 150: hash_type = HASH_TYPE_SHA1;
7490 salt_type = SALT_TYPE_INTERN;
7491 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7492 opts_type = OPTS_TYPE_PT_GENERATE_BE
7493 | OPTS_TYPE_ST_ADD80
7494 | OPTS_TYPE_ST_ADDBITS15;
7495 kern_type = KERN_TYPE_HMACSHA1_PW;
7496 dgst_size = DGST_SIZE_4_5;
7497 parse_func = hmacsha1_parse_hash;
7498 sort_by_digest = sort_by_digest_4_5;
7499 opti_type = OPTI_TYPE_ZERO_BYTE
7500 | OPTI_TYPE_NOT_ITERATED;
7501 dgst_pos0 = 3;
7502 dgst_pos1 = 4;
7503 dgst_pos2 = 2;
7504 dgst_pos3 = 1;
7505 break;
7506
7507 case 160: hash_type = HASH_TYPE_SHA1;
7508 salt_type = SALT_TYPE_INTERN;
7509 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7510 opts_type = OPTS_TYPE_PT_GENERATE_BE
7511 | OPTS_TYPE_PT_ADD80
7512 | OPTS_TYPE_PT_ADDBITS15;
7513 kern_type = KERN_TYPE_HMACSHA1_SLT;
7514 dgst_size = DGST_SIZE_4_5;
7515 parse_func = hmacsha1_parse_hash;
7516 sort_by_digest = sort_by_digest_4_5;
7517 opti_type = OPTI_TYPE_ZERO_BYTE
7518 | OPTI_TYPE_NOT_ITERATED;
7519 dgst_pos0 = 3;
7520 dgst_pos1 = 4;
7521 dgst_pos2 = 2;
7522 dgst_pos3 = 1;
7523 break;
7524
7525 case 190: hash_type = HASH_TYPE_SHA1;
7526 salt_type = SALT_TYPE_NONE;
7527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7528 opts_type = OPTS_TYPE_PT_GENERATE_BE
7529 | OPTS_TYPE_PT_ADD80
7530 | OPTS_TYPE_PT_ADDBITS15;
7531 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7532 dgst_size = DGST_SIZE_4_5;
7533 parse_func = sha1linkedin_parse_hash;
7534 sort_by_digest = sort_by_digest_4_5;
7535 opti_type = OPTI_TYPE_ZERO_BYTE
7536 | OPTI_TYPE_PRECOMPUTE_INIT
7537 | OPTI_TYPE_EARLY_SKIP
7538 | OPTI_TYPE_NOT_ITERATED
7539 | OPTI_TYPE_NOT_SALTED;
7540 dgst_pos0 = 0;
7541 dgst_pos1 = 4;
7542 dgst_pos2 = 3;
7543 dgst_pos3 = 2;
7544 break;
7545
7546 case 200: hash_type = HASH_TYPE_MYSQL;
7547 salt_type = SALT_TYPE_NONE;
7548 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7549 opts_type = 0;
7550 kern_type = KERN_TYPE_MYSQL;
7551 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7552 parse_func = mysql323_parse_hash;
7553 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7554 opti_type = OPTI_TYPE_ZERO_BYTE;
7555 dgst_pos0 = 0;
7556 dgst_pos1 = 1;
7557 dgst_pos2 = 2;
7558 dgst_pos3 = 3;
7559 break;
7560
7561 case 300: hash_type = HASH_TYPE_SHA1;
7562 salt_type = SALT_TYPE_NONE;
7563 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7564 opts_type = OPTS_TYPE_PT_GENERATE_BE
7565 | OPTS_TYPE_PT_ADD80
7566 | OPTS_TYPE_PT_ADDBITS15;
7567 kern_type = KERN_TYPE_MYSQL41;
7568 dgst_size = DGST_SIZE_4_5;
7569 parse_func = sha1_parse_hash;
7570 sort_by_digest = sort_by_digest_4_5;
7571 opti_type = OPTI_TYPE_ZERO_BYTE
7572 | OPTI_TYPE_PRECOMPUTE_INIT
7573 | OPTI_TYPE_PRECOMPUTE_MERKLE
7574 | OPTI_TYPE_EARLY_SKIP
7575 | OPTI_TYPE_NOT_ITERATED
7576 | OPTI_TYPE_NOT_SALTED;
7577 dgst_pos0 = 3;
7578 dgst_pos1 = 4;
7579 dgst_pos2 = 2;
7580 dgst_pos3 = 1;
7581 break;
7582
7583 case 400: hash_type = HASH_TYPE_MD5;
7584 salt_type = SALT_TYPE_EMBEDDED;
7585 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7586 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7587 kern_type = KERN_TYPE_PHPASS;
7588 dgst_size = DGST_SIZE_4_4;
7589 parse_func = phpass_parse_hash;
7590 sort_by_digest = sort_by_digest_4_4;
7591 opti_type = OPTI_TYPE_ZERO_BYTE
7592 | OPTI_TYPE_SLOW_HASH_SIMD;
7593 dgst_pos0 = 0;
7594 dgst_pos1 = 1;
7595 dgst_pos2 = 2;
7596 dgst_pos3 = 3;
7597 break;
7598
7599 case 500: hash_type = HASH_TYPE_MD5;
7600 salt_type = SALT_TYPE_EMBEDDED;
7601 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7602 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7603 kern_type = KERN_TYPE_MD5CRYPT;
7604 dgst_size = DGST_SIZE_4_4;
7605 parse_func = md5crypt_parse_hash;
7606 sort_by_digest = sort_by_digest_4_4;
7607 opti_type = OPTI_TYPE_ZERO_BYTE;
7608 dgst_pos0 = 0;
7609 dgst_pos1 = 1;
7610 dgst_pos2 = 2;
7611 dgst_pos3 = 3;
7612 break;
7613
7614 case 501: hash_type = HASH_TYPE_MD5;
7615 salt_type = SALT_TYPE_EMBEDDED;
7616 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7617 opts_type = OPTS_TYPE_PT_GENERATE_LE
7618 | OPTS_TYPE_HASH_COPY;
7619 kern_type = KERN_TYPE_MD5CRYPT;
7620 dgst_size = DGST_SIZE_4_4;
7621 parse_func = juniper_parse_hash;
7622 sort_by_digest = sort_by_digest_4_4;
7623 opti_type = OPTI_TYPE_ZERO_BYTE;
7624 dgst_pos0 = 0;
7625 dgst_pos1 = 1;
7626 dgst_pos2 = 2;
7627 dgst_pos3 = 3;
7628 break;
7629
7630 case 900: hash_type = HASH_TYPE_MD4;
7631 salt_type = SALT_TYPE_NONE;
7632 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7633 opts_type = OPTS_TYPE_PT_GENERATE_LE
7634 | OPTS_TYPE_PT_ADD80
7635 | OPTS_TYPE_PT_ADDBITS14;
7636 kern_type = KERN_TYPE_MD4;
7637 dgst_size = DGST_SIZE_4_4;
7638 parse_func = md4_parse_hash;
7639 sort_by_digest = sort_by_digest_4_4;
7640 opti_type = OPTI_TYPE_ZERO_BYTE
7641 | OPTI_TYPE_PRECOMPUTE_INIT
7642 | OPTI_TYPE_PRECOMPUTE_MERKLE
7643 | OPTI_TYPE_MEET_IN_MIDDLE
7644 | OPTI_TYPE_EARLY_SKIP
7645 | OPTI_TYPE_NOT_ITERATED
7646 | OPTI_TYPE_NOT_SALTED
7647 | OPTI_TYPE_RAW_HASH;
7648 dgst_pos0 = 0;
7649 dgst_pos1 = 3;
7650 dgst_pos2 = 2;
7651 dgst_pos3 = 1;
7652 break;
7653
7654 case 1000: hash_type = HASH_TYPE_MD4;
7655 salt_type = SALT_TYPE_NONE;
7656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7657 opts_type = OPTS_TYPE_PT_GENERATE_LE
7658 | OPTS_TYPE_PT_ADD80
7659 | OPTS_TYPE_PT_ADDBITS14
7660 | OPTS_TYPE_PT_UNICODE;
7661 kern_type = KERN_TYPE_MD4_PWU;
7662 dgst_size = DGST_SIZE_4_4;
7663 parse_func = md4_parse_hash;
7664 sort_by_digest = sort_by_digest_4_4;
7665 opti_type = OPTI_TYPE_ZERO_BYTE
7666 | OPTI_TYPE_PRECOMPUTE_INIT
7667 | OPTI_TYPE_PRECOMPUTE_MERKLE
7668 | OPTI_TYPE_MEET_IN_MIDDLE
7669 | OPTI_TYPE_EARLY_SKIP
7670 | OPTI_TYPE_NOT_ITERATED
7671 | OPTI_TYPE_NOT_SALTED
7672 | OPTI_TYPE_RAW_HASH;
7673 dgst_pos0 = 0;
7674 dgst_pos1 = 3;
7675 dgst_pos2 = 2;
7676 dgst_pos3 = 1;
7677 break;
7678
7679 case 1100: hash_type = HASH_TYPE_MD4;
7680 salt_type = SALT_TYPE_INTERN;
7681 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7682 opts_type = OPTS_TYPE_PT_GENERATE_LE
7683 | OPTS_TYPE_PT_ADD80
7684 | OPTS_TYPE_PT_ADDBITS14
7685 | OPTS_TYPE_PT_UNICODE
7686 | OPTS_TYPE_ST_ADD80
7687 | OPTS_TYPE_ST_UNICODE
7688 | OPTS_TYPE_ST_LOWER;
7689 kern_type = KERN_TYPE_MD44_PWUSLT;
7690 dgst_size = DGST_SIZE_4_4;
7691 parse_func = dcc_parse_hash;
7692 sort_by_digest = sort_by_digest_4_4;
7693 opti_type = OPTI_TYPE_ZERO_BYTE
7694 | OPTI_TYPE_PRECOMPUTE_INIT
7695 | OPTI_TYPE_PRECOMPUTE_MERKLE
7696 | OPTI_TYPE_EARLY_SKIP
7697 | OPTI_TYPE_NOT_ITERATED;
7698 dgst_pos0 = 0;
7699 dgst_pos1 = 3;
7700 dgst_pos2 = 2;
7701 dgst_pos3 = 1;
7702 break;
7703
7704 case 1400: hash_type = HASH_TYPE_SHA256;
7705 salt_type = SALT_TYPE_NONE;
7706 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7707 opts_type = OPTS_TYPE_PT_GENERATE_BE
7708 | OPTS_TYPE_PT_ADD80
7709 | OPTS_TYPE_PT_ADDBITS15;
7710 kern_type = KERN_TYPE_SHA256;
7711 dgst_size = DGST_SIZE_4_8;
7712 parse_func = sha256_parse_hash;
7713 sort_by_digest = sort_by_digest_4_8;
7714 opti_type = OPTI_TYPE_ZERO_BYTE
7715 | OPTI_TYPE_PRECOMPUTE_INIT
7716 | OPTI_TYPE_PRECOMPUTE_MERKLE
7717 | OPTI_TYPE_EARLY_SKIP
7718 | OPTI_TYPE_NOT_ITERATED
7719 | OPTI_TYPE_NOT_SALTED
7720 | OPTI_TYPE_RAW_HASH;
7721 dgst_pos0 = 3;
7722 dgst_pos1 = 7;
7723 dgst_pos2 = 2;
7724 dgst_pos3 = 6;
7725 break;
7726
7727 case 1410: hash_type = HASH_TYPE_SHA256;
7728 salt_type = SALT_TYPE_INTERN;
7729 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7730 opts_type = OPTS_TYPE_PT_GENERATE_BE
7731 | OPTS_TYPE_ST_ADD80
7732 | OPTS_TYPE_ST_ADDBITS15;
7733 kern_type = KERN_TYPE_SHA256_PWSLT;
7734 dgst_size = DGST_SIZE_4_8;
7735 parse_func = sha256s_parse_hash;
7736 sort_by_digest = sort_by_digest_4_8;
7737 opti_type = OPTI_TYPE_ZERO_BYTE
7738 | OPTI_TYPE_PRECOMPUTE_INIT
7739 | OPTI_TYPE_PRECOMPUTE_MERKLE
7740 | OPTI_TYPE_EARLY_SKIP
7741 | OPTI_TYPE_NOT_ITERATED
7742 | OPTI_TYPE_APPENDED_SALT
7743 | OPTI_TYPE_RAW_HASH;
7744 dgst_pos0 = 3;
7745 dgst_pos1 = 7;
7746 dgst_pos2 = 2;
7747 dgst_pos3 = 6;
7748 break;
7749
7750 case 1420: hash_type = HASH_TYPE_SHA256;
7751 salt_type = SALT_TYPE_INTERN;
7752 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7753 opts_type = OPTS_TYPE_PT_GENERATE_BE
7754 | OPTS_TYPE_PT_ADD80
7755 | OPTS_TYPE_PT_ADDBITS15;
7756 kern_type = KERN_TYPE_SHA256_SLTPW;
7757 dgst_size = DGST_SIZE_4_8;
7758 parse_func = sha256s_parse_hash;
7759 sort_by_digest = sort_by_digest_4_8;
7760 opti_type = OPTI_TYPE_ZERO_BYTE
7761 | OPTI_TYPE_PRECOMPUTE_INIT
7762 | OPTI_TYPE_PRECOMPUTE_MERKLE
7763 | OPTI_TYPE_EARLY_SKIP
7764 | OPTI_TYPE_NOT_ITERATED
7765 | OPTI_TYPE_PREPENDED_SALT
7766 | OPTI_TYPE_RAW_HASH;
7767 dgst_pos0 = 3;
7768 dgst_pos1 = 7;
7769 dgst_pos2 = 2;
7770 dgst_pos3 = 6;
7771 break;
7772
7773 case 1421: hash_type = HASH_TYPE_SHA256;
7774 salt_type = SALT_TYPE_EMBEDDED;
7775 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7776 opts_type = OPTS_TYPE_PT_GENERATE_BE
7777 | OPTS_TYPE_PT_ADD80
7778 | OPTS_TYPE_PT_ADDBITS15;
7779 kern_type = KERN_TYPE_SHA256_SLTPW;
7780 dgst_size = DGST_SIZE_4_8;
7781 parse_func = hmailserver_parse_hash;
7782 sort_by_digest = sort_by_digest_4_8;
7783 opti_type = OPTI_TYPE_ZERO_BYTE
7784 | OPTI_TYPE_PRECOMPUTE_INIT
7785 | OPTI_TYPE_PRECOMPUTE_MERKLE
7786 | OPTI_TYPE_EARLY_SKIP
7787 | OPTI_TYPE_NOT_ITERATED
7788 | OPTI_TYPE_PREPENDED_SALT
7789 | OPTI_TYPE_RAW_HASH;
7790 dgst_pos0 = 3;
7791 dgst_pos1 = 7;
7792 dgst_pos2 = 2;
7793 dgst_pos3 = 6;
7794 break;
7795
7796 case 1430: hash_type = HASH_TYPE_SHA256;
7797 salt_type = SALT_TYPE_INTERN;
7798 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7799 opts_type = OPTS_TYPE_PT_GENERATE_BE
7800 | OPTS_TYPE_PT_UNICODE
7801 | OPTS_TYPE_ST_ADD80
7802 | OPTS_TYPE_ST_ADDBITS15;
7803 kern_type = KERN_TYPE_SHA256_PWUSLT;
7804 dgst_size = DGST_SIZE_4_8;
7805 parse_func = sha256s_parse_hash;
7806 sort_by_digest = sort_by_digest_4_8;
7807 opti_type = OPTI_TYPE_ZERO_BYTE
7808 | OPTI_TYPE_PRECOMPUTE_INIT
7809 | OPTI_TYPE_PRECOMPUTE_MERKLE
7810 | OPTI_TYPE_EARLY_SKIP
7811 | OPTI_TYPE_NOT_ITERATED
7812 | OPTI_TYPE_APPENDED_SALT
7813 | OPTI_TYPE_RAW_HASH;
7814 dgst_pos0 = 3;
7815 dgst_pos1 = 7;
7816 dgst_pos2 = 2;
7817 dgst_pos3 = 6;
7818 break;
7819
7820 case 1440: hash_type = HASH_TYPE_SHA256;
7821 salt_type = SALT_TYPE_INTERN;
7822 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7823 opts_type = OPTS_TYPE_PT_GENERATE_BE
7824 | OPTS_TYPE_PT_ADD80
7825 | OPTS_TYPE_PT_ADDBITS15
7826 | OPTS_TYPE_PT_UNICODE;
7827 kern_type = KERN_TYPE_SHA256_SLTPWU;
7828 dgst_size = DGST_SIZE_4_8;
7829 parse_func = sha256s_parse_hash;
7830 sort_by_digest = sort_by_digest_4_8;
7831 opti_type = OPTI_TYPE_ZERO_BYTE
7832 | OPTI_TYPE_PRECOMPUTE_INIT
7833 | OPTI_TYPE_PRECOMPUTE_MERKLE
7834 | OPTI_TYPE_EARLY_SKIP
7835 | OPTI_TYPE_NOT_ITERATED
7836 | OPTI_TYPE_PREPENDED_SALT
7837 | OPTI_TYPE_RAW_HASH;
7838 dgst_pos0 = 3;
7839 dgst_pos1 = 7;
7840 dgst_pos2 = 2;
7841 dgst_pos3 = 6;
7842 break;
7843
7844 case 1441: hash_type = HASH_TYPE_SHA256;
7845 salt_type = SALT_TYPE_EMBEDDED;
7846 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7847 opts_type = OPTS_TYPE_PT_GENERATE_BE
7848 | OPTS_TYPE_PT_ADD80
7849 | OPTS_TYPE_PT_ADDBITS15
7850 | OPTS_TYPE_PT_UNICODE
7851 | OPTS_TYPE_ST_BASE64;
7852 kern_type = KERN_TYPE_SHA256_SLTPWU;
7853 dgst_size = DGST_SIZE_4_8;
7854 parse_func = episerver4_parse_hash;
7855 sort_by_digest = sort_by_digest_4_8;
7856 opti_type = OPTI_TYPE_ZERO_BYTE
7857 | OPTI_TYPE_PRECOMPUTE_INIT
7858 | OPTI_TYPE_PRECOMPUTE_MERKLE
7859 | OPTI_TYPE_EARLY_SKIP
7860 | OPTI_TYPE_NOT_ITERATED
7861 | OPTI_TYPE_PREPENDED_SALT
7862 | OPTI_TYPE_RAW_HASH;
7863 dgst_pos0 = 3;
7864 dgst_pos1 = 7;
7865 dgst_pos2 = 2;
7866 dgst_pos3 = 6;
7867 break;
7868
7869 case 1450: hash_type = HASH_TYPE_SHA256;
7870 salt_type = SALT_TYPE_INTERN;
7871 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7872 opts_type = OPTS_TYPE_PT_GENERATE_BE
7873 | OPTS_TYPE_ST_ADD80;
7874 kern_type = KERN_TYPE_HMACSHA256_PW;
7875 dgst_size = DGST_SIZE_4_8;
7876 parse_func = hmacsha256_parse_hash;
7877 sort_by_digest = sort_by_digest_4_8;
7878 opti_type = OPTI_TYPE_ZERO_BYTE
7879 | OPTI_TYPE_NOT_ITERATED;
7880 dgst_pos0 = 3;
7881 dgst_pos1 = 7;
7882 dgst_pos2 = 2;
7883 dgst_pos3 = 6;
7884 break;
7885
7886 case 1460: hash_type = HASH_TYPE_SHA256;
7887 salt_type = SALT_TYPE_INTERN;
7888 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7889 opts_type = OPTS_TYPE_PT_GENERATE_BE
7890 | OPTS_TYPE_PT_ADD80
7891 | OPTS_TYPE_PT_ADDBITS15;
7892 kern_type = KERN_TYPE_HMACSHA256_SLT;
7893 dgst_size = DGST_SIZE_4_8;
7894 parse_func = hmacsha256_parse_hash;
7895 sort_by_digest = sort_by_digest_4_8;
7896 opti_type = OPTI_TYPE_ZERO_BYTE
7897 | OPTI_TYPE_NOT_ITERATED;
7898 dgst_pos0 = 3;
7899 dgst_pos1 = 7;
7900 dgst_pos2 = 2;
7901 dgst_pos3 = 6;
7902 break;
7903
7904 case 1500: hash_type = HASH_TYPE_DESCRYPT;
7905 salt_type = SALT_TYPE_EMBEDDED;
7906 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7907 opts_type = OPTS_TYPE_PT_GENERATE_LE
7908 | OPTS_TYPE_PT_BITSLICE;
7909 kern_type = KERN_TYPE_DESCRYPT;
7910 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7911 parse_func = descrypt_parse_hash;
7912 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7913 opti_type = OPTI_TYPE_ZERO_BYTE
7914 | OPTI_TYPE_PRECOMPUTE_PERMUT;
7915 dgst_pos0 = 0;
7916 dgst_pos1 = 1;
7917 dgst_pos2 = 2;
7918 dgst_pos3 = 3;
7919 break;
7920
7921 case 1600: hash_type = HASH_TYPE_MD5;
7922 salt_type = SALT_TYPE_EMBEDDED;
7923 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7924 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7925 kern_type = KERN_TYPE_APR1CRYPT;
7926 dgst_size = DGST_SIZE_4_4;
7927 parse_func = md5apr1_parse_hash;
7928 sort_by_digest = sort_by_digest_4_4;
7929 opti_type = OPTI_TYPE_ZERO_BYTE;
7930 dgst_pos0 = 0;
7931 dgst_pos1 = 1;
7932 dgst_pos2 = 2;
7933 dgst_pos3 = 3;
7934 break;
7935
7936 case 1700: hash_type = HASH_TYPE_SHA512;
7937 salt_type = SALT_TYPE_NONE;
7938 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7939 opts_type = OPTS_TYPE_PT_GENERATE_BE
7940 | OPTS_TYPE_PT_ADD80
7941 | OPTS_TYPE_PT_ADDBITS15;
7942 kern_type = KERN_TYPE_SHA512;
7943 dgst_size = DGST_SIZE_8_8;
7944 parse_func = sha512_parse_hash;
7945 sort_by_digest = sort_by_digest_8_8;
7946 opti_type = OPTI_TYPE_ZERO_BYTE
7947 | OPTI_TYPE_PRECOMPUTE_INIT
7948 | OPTI_TYPE_PRECOMPUTE_MERKLE
7949 | OPTI_TYPE_EARLY_SKIP
7950 | OPTI_TYPE_NOT_ITERATED
7951 | OPTI_TYPE_NOT_SALTED
7952 | OPTI_TYPE_USES_BITS_64
7953 | OPTI_TYPE_RAW_HASH;
7954 dgst_pos0 = 14;
7955 dgst_pos1 = 15;
7956 dgst_pos2 = 6;
7957 dgst_pos3 = 7;
7958 break;
7959
7960 case 1710: hash_type = HASH_TYPE_SHA512;
7961 salt_type = SALT_TYPE_INTERN;
7962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7963 opts_type = OPTS_TYPE_PT_GENERATE_BE
7964 | OPTS_TYPE_ST_ADD80
7965 | OPTS_TYPE_ST_ADDBITS15;
7966 kern_type = KERN_TYPE_SHA512_PWSLT;
7967 dgst_size = DGST_SIZE_8_8;
7968 parse_func = sha512s_parse_hash;
7969 sort_by_digest = sort_by_digest_8_8;
7970 opti_type = OPTI_TYPE_ZERO_BYTE
7971 | OPTI_TYPE_PRECOMPUTE_INIT
7972 | OPTI_TYPE_PRECOMPUTE_MERKLE
7973 | OPTI_TYPE_EARLY_SKIP
7974 | OPTI_TYPE_NOT_ITERATED
7975 | OPTI_TYPE_APPENDED_SALT
7976 | OPTI_TYPE_USES_BITS_64
7977 | OPTI_TYPE_RAW_HASH;
7978 dgst_pos0 = 14;
7979 dgst_pos1 = 15;
7980 dgst_pos2 = 6;
7981 dgst_pos3 = 7;
7982 break;
7983
7984 case 1711: hash_type = HASH_TYPE_SHA512;
7985 salt_type = SALT_TYPE_EMBEDDED;
7986 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7987 opts_type = OPTS_TYPE_PT_GENERATE_BE
7988 | OPTS_TYPE_ST_ADD80
7989 | OPTS_TYPE_ST_ADDBITS15;
7990 kern_type = KERN_TYPE_SHA512_PWSLT;
7991 dgst_size = DGST_SIZE_8_8;
7992 parse_func = sha512b64s_parse_hash;
7993 sort_by_digest = sort_by_digest_8_8;
7994 opti_type = OPTI_TYPE_ZERO_BYTE
7995 | OPTI_TYPE_PRECOMPUTE_INIT
7996 | OPTI_TYPE_PRECOMPUTE_MERKLE
7997 | OPTI_TYPE_EARLY_SKIP
7998 | OPTI_TYPE_NOT_ITERATED
7999 | OPTI_TYPE_APPENDED_SALT
8000 | OPTI_TYPE_USES_BITS_64
8001 | OPTI_TYPE_RAW_HASH;
8002 dgst_pos0 = 14;
8003 dgst_pos1 = 15;
8004 dgst_pos2 = 6;
8005 dgst_pos3 = 7;
8006 break;
8007
8008 case 1720: hash_type = HASH_TYPE_SHA512;
8009 salt_type = SALT_TYPE_INTERN;
8010 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8011 opts_type = OPTS_TYPE_PT_GENERATE_BE
8012 | OPTS_TYPE_PT_ADD80
8013 | OPTS_TYPE_PT_ADDBITS15;
8014 kern_type = KERN_TYPE_SHA512_SLTPW;
8015 dgst_size = DGST_SIZE_8_8;
8016 parse_func = sha512s_parse_hash;
8017 sort_by_digest = sort_by_digest_8_8;
8018 opti_type = OPTI_TYPE_ZERO_BYTE
8019 | OPTI_TYPE_PRECOMPUTE_INIT
8020 | OPTI_TYPE_PRECOMPUTE_MERKLE
8021 | OPTI_TYPE_EARLY_SKIP
8022 | OPTI_TYPE_NOT_ITERATED
8023 | OPTI_TYPE_PREPENDED_SALT
8024 | OPTI_TYPE_USES_BITS_64
8025 | OPTI_TYPE_RAW_HASH;
8026 dgst_pos0 = 14;
8027 dgst_pos1 = 15;
8028 dgst_pos2 = 6;
8029 dgst_pos3 = 7;
8030 break;
8031
8032 case 1722: hash_type = HASH_TYPE_SHA512;
8033 salt_type = SALT_TYPE_EMBEDDED;
8034 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8035 opts_type = OPTS_TYPE_PT_GENERATE_BE
8036 | OPTS_TYPE_PT_ADD80
8037 | OPTS_TYPE_PT_ADDBITS15
8038 | OPTS_TYPE_ST_HEX;
8039 kern_type = KERN_TYPE_SHA512_SLTPW;
8040 dgst_size = DGST_SIZE_8_8;
8041 parse_func = osx512_parse_hash;
8042 sort_by_digest = sort_by_digest_8_8;
8043 opti_type = OPTI_TYPE_ZERO_BYTE
8044 | OPTI_TYPE_PRECOMPUTE_INIT
8045 | OPTI_TYPE_PRECOMPUTE_MERKLE
8046 | OPTI_TYPE_EARLY_SKIP
8047 | OPTI_TYPE_NOT_ITERATED
8048 | OPTI_TYPE_PREPENDED_SALT
8049 | OPTI_TYPE_USES_BITS_64
8050 | OPTI_TYPE_RAW_HASH;
8051 dgst_pos0 = 14;
8052 dgst_pos1 = 15;
8053 dgst_pos2 = 6;
8054 dgst_pos3 = 7;
8055 break;
8056
8057 case 1730: hash_type = HASH_TYPE_SHA512;
8058 salt_type = SALT_TYPE_INTERN;
8059 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8060 opts_type = OPTS_TYPE_PT_GENERATE_BE
8061 | OPTS_TYPE_PT_UNICODE
8062 | OPTS_TYPE_ST_ADD80
8063 | OPTS_TYPE_ST_ADDBITS15;
8064 kern_type = KERN_TYPE_SHA512_PWSLTU;
8065 dgst_size = DGST_SIZE_8_8;
8066 parse_func = sha512s_parse_hash;
8067 sort_by_digest = sort_by_digest_8_8;
8068 opti_type = OPTI_TYPE_ZERO_BYTE
8069 | OPTI_TYPE_PRECOMPUTE_INIT
8070 | OPTI_TYPE_PRECOMPUTE_MERKLE
8071 | OPTI_TYPE_EARLY_SKIP
8072 | OPTI_TYPE_NOT_ITERATED
8073 | OPTI_TYPE_APPENDED_SALT
8074 | OPTI_TYPE_USES_BITS_64
8075 | OPTI_TYPE_RAW_HASH;
8076 dgst_pos0 = 14;
8077 dgst_pos1 = 15;
8078 dgst_pos2 = 6;
8079 dgst_pos3 = 7;
8080 break;
8081
8082 case 1731: hash_type = HASH_TYPE_SHA512;
8083 salt_type = SALT_TYPE_EMBEDDED;
8084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8085 opts_type = OPTS_TYPE_PT_GENERATE_BE
8086 | OPTS_TYPE_PT_UNICODE
8087 | OPTS_TYPE_ST_ADD80
8088 | OPTS_TYPE_ST_ADDBITS15
8089 | OPTS_TYPE_ST_HEX;
8090 kern_type = KERN_TYPE_SHA512_PWSLTU;
8091 dgst_size = DGST_SIZE_8_8;
8092 parse_func = mssql2012_parse_hash;
8093 sort_by_digest = sort_by_digest_8_8;
8094 opti_type = OPTI_TYPE_ZERO_BYTE
8095 | OPTI_TYPE_PRECOMPUTE_INIT
8096 | OPTI_TYPE_PRECOMPUTE_MERKLE
8097 | OPTI_TYPE_EARLY_SKIP
8098 | OPTI_TYPE_NOT_ITERATED
8099 | OPTI_TYPE_APPENDED_SALT
8100 | OPTI_TYPE_USES_BITS_64
8101 | OPTI_TYPE_RAW_HASH;
8102 dgst_pos0 = 14;
8103 dgst_pos1 = 15;
8104 dgst_pos2 = 6;
8105 dgst_pos3 = 7;
8106 break;
8107
8108 case 1740: hash_type = HASH_TYPE_SHA512;
8109 salt_type = SALT_TYPE_INTERN;
8110 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8111 opts_type = OPTS_TYPE_PT_GENERATE_BE
8112 | OPTS_TYPE_PT_ADD80
8113 | OPTS_TYPE_PT_ADDBITS15
8114 | OPTS_TYPE_PT_UNICODE;
8115 kern_type = KERN_TYPE_SHA512_SLTPWU;
8116 dgst_size = DGST_SIZE_8_8;
8117 parse_func = sha512s_parse_hash;
8118 sort_by_digest = sort_by_digest_8_8;
8119 opti_type = OPTI_TYPE_ZERO_BYTE
8120 | OPTI_TYPE_PRECOMPUTE_INIT
8121 | OPTI_TYPE_PRECOMPUTE_MERKLE
8122 | OPTI_TYPE_EARLY_SKIP
8123 | OPTI_TYPE_NOT_ITERATED
8124 | OPTI_TYPE_PREPENDED_SALT
8125 | OPTI_TYPE_USES_BITS_64
8126 | OPTI_TYPE_RAW_HASH;
8127 dgst_pos0 = 14;
8128 dgst_pos1 = 15;
8129 dgst_pos2 = 6;
8130 dgst_pos3 = 7;
8131 break;
8132
8133 case 1750: hash_type = HASH_TYPE_SHA512;
8134 salt_type = SALT_TYPE_INTERN;
8135 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8136 opts_type = OPTS_TYPE_PT_GENERATE_BE
8137 | OPTS_TYPE_ST_ADD80;
8138 kern_type = KERN_TYPE_HMACSHA512_PW;
8139 dgst_size = DGST_SIZE_8_8;
8140 parse_func = hmacsha512_parse_hash;
8141 sort_by_digest = sort_by_digest_8_8;
8142 opti_type = OPTI_TYPE_ZERO_BYTE
8143 | OPTI_TYPE_USES_BITS_64
8144 | OPTI_TYPE_NOT_ITERATED;
8145 dgst_pos0 = 14;
8146 dgst_pos1 = 15;
8147 dgst_pos2 = 6;
8148 dgst_pos3 = 7;
8149 break;
8150
8151 case 1760: hash_type = HASH_TYPE_SHA512;
8152 salt_type = SALT_TYPE_INTERN;
8153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8154 opts_type = OPTS_TYPE_PT_GENERATE_BE
8155 | OPTS_TYPE_PT_ADD80
8156 | OPTS_TYPE_PT_ADDBITS15;
8157 kern_type = KERN_TYPE_HMACSHA512_SLT;
8158 dgst_size = DGST_SIZE_8_8;
8159 parse_func = hmacsha512_parse_hash;
8160 sort_by_digest = sort_by_digest_8_8;
8161 opti_type = OPTI_TYPE_ZERO_BYTE
8162 | OPTI_TYPE_USES_BITS_64
8163 | OPTI_TYPE_NOT_ITERATED;
8164 dgst_pos0 = 14;
8165 dgst_pos1 = 15;
8166 dgst_pos2 = 6;
8167 dgst_pos3 = 7;
8168 break;
8169
8170 case 1800: hash_type = HASH_TYPE_SHA512;
8171 salt_type = SALT_TYPE_EMBEDDED;
8172 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8173 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8174 kern_type = KERN_TYPE_SHA512CRYPT;
8175 dgst_size = DGST_SIZE_8_8;
8176 parse_func = sha512crypt_parse_hash;
8177 sort_by_digest = sort_by_digest_8_8;
8178 opti_type = OPTI_TYPE_ZERO_BYTE
8179 | OPTI_TYPE_USES_BITS_64;
8180 dgst_pos0 = 0;
8181 dgst_pos1 = 1;
8182 dgst_pos2 = 2;
8183 dgst_pos3 = 3;
8184 break;
8185
8186 case 2100: hash_type = HASH_TYPE_DCC2;
8187 salt_type = SALT_TYPE_EMBEDDED;
8188 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8189 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8190 | OPTS_TYPE_ST_LOWER
8191 | OPTS_TYPE_ST_UNICODE;
8192 kern_type = KERN_TYPE_DCC2;
8193 dgst_size = DGST_SIZE_4_4;
8194 parse_func = dcc2_parse_hash;
8195 sort_by_digest = sort_by_digest_4_4;
8196 opti_type = OPTI_TYPE_ZERO_BYTE
8197 | OPTI_TYPE_SLOW_HASH_SIMD;
8198 dgst_pos0 = 0;
8199 dgst_pos1 = 1;
8200 dgst_pos2 = 2;
8201 dgst_pos3 = 3;
8202 break;
8203
8204 case 2400: hash_type = HASH_TYPE_MD5;
8205 salt_type = SALT_TYPE_NONE;
8206 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8207 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8208 kern_type = KERN_TYPE_MD5PIX;
8209 dgst_size = DGST_SIZE_4_4;
8210 parse_func = md5pix_parse_hash;
8211 sort_by_digest = sort_by_digest_4_4;
8212 opti_type = OPTI_TYPE_ZERO_BYTE
8213 | OPTI_TYPE_PRECOMPUTE_INIT
8214 | OPTI_TYPE_PRECOMPUTE_MERKLE
8215 | OPTI_TYPE_EARLY_SKIP
8216 | OPTI_TYPE_NOT_ITERATED
8217 | OPTI_TYPE_NOT_SALTED;
8218 dgst_pos0 = 0;
8219 dgst_pos1 = 3;
8220 dgst_pos2 = 2;
8221 dgst_pos3 = 1;
8222 break;
8223
8224 case 2410: hash_type = HASH_TYPE_MD5;
8225 salt_type = SALT_TYPE_INTERN;
8226 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8227 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8228 kern_type = KERN_TYPE_MD5ASA;
8229 dgst_size = DGST_SIZE_4_4;
8230 parse_func = md5asa_parse_hash;
8231 sort_by_digest = sort_by_digest_4_4;
8232 opti_type = OPTI_TYPE_ZERO_BYTE
8233 | OPTI_TYPE_PRECOMPUTE_INIT
8234 | OPTI_TYPE_PRECOMPUTE_MERKLE
8235 | OPTI_TYPE_EARLY_SKIP
8236 | OPTI_TYPE_NOT_ITERATED;
8237 dgst_pos0 = 0;
8238 dgst_pos1 = 3;
8239 dgst_pos2 = 2;
8240 dgst_pos3 = 1;
8241 break;
8242
8243 case 2500: hash_type = HASH_TYPE_WPA;
8244 salt_type = SALT_TYPE_EMBEDDED;
8245 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8246 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8247 kern_type = KERN_TYPE_WPA;
8248 dgst_size = DGST_SIZE_4_4;
8249 parse_func = wpa_parse_hash;
8250 sort_by_digest = sort_by_digest_4_4;
8251 opti_type = OPTI_TYPE_ZERO_BYTE
8252 | OPTI_TYPE_SLOW_HASH_SIMD;
8253 dgst_pos0 = 0;
8254 dgst_pos1 = 1;
8255 dgst_pos2 = 2;
8256 dgst_pos3 = 3;
8257 break;
8258
8259 case 2600: hash_type = HASH_TYPE_MD5;
8260 salt_type = SALT_TYPE_VIRTUAL;
8261 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8262 opts_type = OPTS_TYPE_PT_GENERATE_LE
8263 | OPTS_TYPE_PT_ADD80
8264 | OPTS_TYPE_PT_ADDBITS14
8265 | OPTS_TYPE_ST_ADD80;
8266 kern_type = KERN_TYPE_MD55_PWSLT1;
8267 dgst_size = DGST_SIZE_4_4;
8268 parse_func = md5md5_parse_hash;
8269 sort_by_digest = sort_by_digest_4_4;
8270 opti_type = OPTI_TYPE_ZERO_BYTE
8271 | OPTI_TYPE_PRECOMPUTE_INIT
8272 | OPTI_TYPE_PRECOMPUTE_MERKLE
8273 | OPTI_TYPE_EARLY_SKIP;
8274 dgst_pos0 = 0;
8275 dgst_pos1 = 3;
8276 dgst_pos2 = 2;
8277 dgst_pos3 = 1;
8278 break;
8279
8280 case 2611: hash_type = HASH_TYPE_MD5;
8281 salt_type = SALT_TYPE_INTERN;
8282 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8283 opts_type = OPTS_TYPE_PT_GENERATE_LE
8284 | OPTS_TYPE_PT_ADD80
8285 | OPTS_TYPE_PT_ADDBITS14
8286 | OPTS_TYPE_ST_ADD80;
8287 kern_type = KERN_TYPE_MD55_PWSLT1;
8288 dgst_size = DGST_SIZE_4_4;
8289 parse_func = vb3_parse_hash;
8290 sort_by_digest = sort_by_digest_4_4;
8291 opti_type = OPTI_TYPE_ZERO_BYTE
8292 | OPTI_TYPE_PRECOMPUTE_INIT
8293 | OPTI_TYPE_PRECOMPUTE_MERKLE
8294 | OPTI_TYPE_EARLY_SKIP;
8295 dgst_pos0 = 0;
8296 dgst_pos1 = 3;
8297 dgst_pos2 = 2;
8298 dgst_pos3 = 1;
8299 break;
8300
8301 case 2612: hash_type = HASH_TYPE_MD5;
8302 salt_type = SALT_TYPE_EMBEDDED;
8303 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8304 opts_type = OPTS_TYPE_PT_GENERATE_LE
8305 | OPTS_TYPE_PT_ADD80
8306 | OPTS_TYPE_PT_ADDBITS14
8307 | OPTS_TYPE_ST_ADD80
8308 | OPTS_TYPE_ST_HEX;
8309 kern_type = KERN_TYPE_MD55_PWSLT1;
8310 dgst_size = DGST_SIZE_4_4;
8311 parse_func = phps_parse_hash;
8312 sort_by_digest = sort_by_digest_4_4;
8313 opti_type = OPTI_TYPE_ZERO_BYTE
8314 | OPTI_TYPE_PRECOMPUTE_INIT
8315 | OPTI_TYPE_PRECOMPUTE_MERKLE
8316 | OPTI_TYPE_EARLY_SKIP;
8317 dgst_pos0 = 0;
8318 dgst_pos1 = 3;
8319 dgst_pos2 = 2;
8320 dgst_pos3 = 1;
8321 break;
8322
8323 case 2711: hash_type = HASH_TYPE_MD5;
8324 salt_type = SALT_TYPE_INTERN;
8325 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8326 opts_type = OPTS_TYPE_PT_GENERATE_LE
8327 | OPTS_TYPE_PT_ADD80
8328 | OPTS_TYPE_PT_ADDBITS14
8329 | OPTS_TYPE_ST_ADD80;
8330 kern_type = KERN_TYPE_MD55_PWSLT2;
8331 dgst_size = DGST_SIZE_4_4;
8332 parse_func = vb30_parse_hash;
8333 sort_by_digest = sort_by_digest_4_4;
8334 opti_type = OPTI_TYPE_ZERO_BYTE
8335 | OPTI_TYPE_PRECOMPUTE_INIT
8336 | OPTI_TYPE_EARLY_SKIP;
8337 dgst_pos0 = 0;
8338 dgst_pos1 = 3;
8339 dgst_pos2 = 2;
8340 dgst_pos3 = 1;
8341 break;
8342
8343 case 2811: hash_type = HASH_TYPE_MD5;
8344 salt_type = SALT_TYPE_INTERN;
8345 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8346 opts_type = OPTS_TYPE_PT_GENERATE_LE
8347 | OPTS_TYPE_PT_ADD80
8348 | OPTS_TYPE_PT_ADDBITS14;
8349 kern_type = KERN_TYPE_MD55_SLTPW;
8350 dgst_size = DGST_SIZE_4_4;
8351 parse_func = ipb2_parse_hash;
8352 sort_by_digest = sort_by_digest_4_4;
8353 opti_type = OPTI_TYPE_ZERO_BYTE
8354 | OPTI_TYPE_PRECOMPUTE_INIT
8355 | OPTI_TYPE_EARLY_SKIP;
8356 dgst_pos0 = 0;
8357 dgst_pos1 = 3;
8358 dgst_pos2 = 2;
8359 dgst_pos3 = 1;
8360 break;
8361
8362 case 3000: hash_type = HASH_TYPE_LM;
8363 salt_type = SALT_TYPE_NONE;
8364 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8365 opts_type = OPTS_TYPE_PT_GENERATE_LE
8366 | OPTS_TYPE_PT_UPPER
8367 | OPTS_TYPE_PT_BITSLICE;
8368 kern_type = KERN_TYPE_LM;
8369 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8370 parse_func = lm_parse_hash;
8371 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8372 opti_type = OPTI_TYPE_ZERO_BYTE
8373 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8374 dgst_pos0 = 0;
8375 dgst_pos1 = 1;
8376 dgst_pos2 = 2;
8377 dgst_pos3 = 3;
8378 break;
8379
8380 case 3100: hash_type = HASH_TYPE_ORACLEH;
8381 salt_type = SALT_TYPE_INTERN;
8382 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8383 opts_type = OPTS_TYPE_PT_GENERATE_LE
8384 | OPTS_TYPE_PT_UPPER
8385 | OPTS_TYPE_ST_UPPER;
8386 kern_type = KERN_TYPE_ORACLEH;
8387 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8388 parse_func = oracleh_parse_hash;
8389 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8390 opti_type = OPTI_TYPE_ZERO_BYTE;
8391 dgst_pos0 = 0;
8392 dgst_pos1 = 1;
8393 dgst_pos2 = 2;
8394 dgst_pos3 = 3;
8395 break;
8396
8397 case 3200: hash_type = HASH_TYPE_BCRYPT;
8398 salt_type = SALT_TYPE_EMBEDDED;
8399 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8400 opts_type = OPTS_TYPE_PT_GENERATE_LE
8401 | OPTS_TYPE_ST_GENERATE_LE;
8402 kern_type = KERN_TYPE_BCRYPT;
8403 dgst_size = DGST_SIZE_4_6;
8404 parse_func = bcrypt_parse_hash;
8405 sort_by_digest = sort_by_digest_4_6;
8406 opti_type = OPTI_TYPE_ZERO_BYTE;
8407 dgst_pos0 = 0;
8408 dgst_pos1 = 1;
8409 dgst_pos2 = 2;
8410 dgst_pos3 = 3;
8411 break;
8412
8413 case 3710: hash_type = HASH_TYPE_MD5;
8414 salt_type = SALT_TYPE_INTERN;
8415 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8416 opts_type = OPTS_TYPE_PT_GENERATE_LE
8417 | OPTS_TYPE_PT_ADD80
8418 | OPTS_TYPE_PT_ADDBITS14;
8419 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8420 dgst_size = DGST_SIZE_4_4;
8421 parse_func = md5s_parse_hash;
8422 sort_by_digest = sort_by_digest_4_4;
8423 opti_type = OPTI_TYPE_ZERO_BYTE
8424 | OPTI_TYPE_PRECOMPUTE_INIT
8425 | OPTI_TYPE_PRECOMPUTE_MERKLE
8426 | OPTI_TYPE_EARLY_SKIP;
8427 dgst_pos0 = 0;
8428 dgst_pos1 = 3;
8429 dgst_pos2 = 2;
8430 dgst_pos3 = 1;
8431 break;
8432
8433 case 3711: hash_type = HASH_TYPE_MD5;
8434 salt_type = SALT_TYPE_EMBEDDED;
8435 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8436 opts_type = OPTS_TYPE_PT_GENERATE_LE
8437 | OPTS_TYPE_PT_ADD80
8438 | OPTS_TYPE_PT_ADDBITS14;
8439 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8440 dgst_size = DGST_SIZE_4_4;
8441 parse_func = mediawiki_b_parse_hash;
8442 sort_by_digest = sort_by_digest_4_4;
8443 opti_type = OPTI_TYPE_ZERO_BYTE
8444 | OPTI_TYPE_PRECOMPUTE_INIT
8445 | OPTI_TYPE_PRECOMPUTE_MERKLE
8446 | OPTI_TYPE_EARLY_SKIP;
8447 dgst_pos0 = 0;
8448 dgst_pos1 = 3;
8449 dgst_pos2 = 2;
8450 dgst_pos3 = 1;
8451 break;
8452
8453 case 3800: hash_type = HASH_TYPE_MD5;
8454 salt_type = SALT_TYPE_INTERN;
8455 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8456 opts_type = OPTS_TYPE_PT_GENERATE_LE
8457 | OPTS_TYPE_ST_ADDBITS14;
8458 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8459 dgst_size = DGST_SIZE_4_4;
8460 parse_func = md5s_parse_hash;
8461 sort_by_digest = sort_by_digest_4_4;
8462 opti_type = OPTI_TYPE_ZERO_BYTE
8463 | OPTI_TYPE_PRECOMPUTE_INIT
8464 | OPTI_TYPE_PRECOMPUTE_MERKLE
8465 | OPTI_TYPE_EARLY_SKIP
8466 | OPTI_TYPE_NOT_ITERATED
8467 | OPTI_TYPE_RAW_HASH;
8468 dgst_pos0 = 0;
8469 dgst_pos1 = 3;
8470 dgst_pos2 = 2;
8471 dgst_pos3 = 1;
8472 break;
8473
8474 case 4300: hash_type = HASH_TYPE_MD5;
8475 salt_type = SALT_TYPE_VIRTUAL;
8476 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8477 opts_type = OPTS_TYPE_PT_GENERATE_LE
8478 | OPTS_TYPE_PT_ADD80
8479 | OPTS_TYPE_PT_ADDBITS14
8480 | OPTS_TYPE_ST_ADD80;
8481 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8482 dgst_size = DGST_SIZE_4_4;
8483 parse_func = md5md5_parse_hash;
8484 sort_by_digest = sort_by_digest_4_4;
8485 opti_type = OPTI_TYPE_ZERO_BYTE
8486 | OPTI_TYPE_PRECOMPUTE_INIT
8487 | OPTI_TYPE_PRECOMPUTE_MERKLE
8488 | OPTI_TYPE_EARLY_SKIP;
8489 dgst_pos0 = 0;
8490 dgst_pos1 = 3;
8491 dgst_pos2 = 2;
8492 dgst_pos3 = 1;
8493 break;
8494
8495
8496 case 4400: hash_type = HASH_TYPE_MD5;
8497 salt_type = SALT_TYPE_NONE;
8498 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8499 opts_type = OPTS_TYPE_PT_GENERATE_BE
8500 | OPTS_TYPE_PT_ADD80
8501 | OPTS_TYPE_PT_ADDBITS15;
8502 kern_type = KERN_TYPE_MD5_SHA1;
8503 dgst_size = DGST_SIZE_4_4;
8504 parse_func = md5_parse_hash;
8505 sort_by_digest = sort_by_digest_4_4;
8506 opti_type = OPTI_TYPE_ZERO_BYTE
8507 | OPTI_TYPE_PRECOMPUTE_INIT
8508 | OPTI_TYPE_PRECOMPUTE_MERKLE
8509 | OPTI_TYPE_EARLY_SKIP
8510 | OPTI_TYPE_NOT_ITERATED
8511 | OPTI_TYPE_NOT_SALTED
8512 | OPTI_TYPE_RAW_HASH;
8513 dgst_pos0 = 0;
8514 dgst_pos1 = 3;
8515 dgst_pos2 = 2;
8516 dgst_pos3 = 1;
8517 break;
8518
8519 case 4500: hash_type = HASH_TYPE_SHA1;
8520 salt_type = SALT_TYPE_NONE;
8521 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8522 opts_type = OPTS_TYPE_PT_GENERATE_BE
8523 | OPTS_TYPE_PT_ADD80
8524 | OPTS_TYPE_PT_ADDBITS15;
8525 kern_type = KERN_TYPE_SHA11;
8526 dgst_size = DGST_SIZE_4_5;
8527 parse_func = sha1_parse_hash;
8528 sort_by_digest = sort_by_digest_4_5;
8529 opti_type = OPTI_TYPE_ZERO_BYTE
8530 | OPTI_TYPE_PRECOMPUTE_INIT
8531 | OPTI_TYPE_PRECOMPUTE_MERKLE
8532 | OPTI_TYPE_EARLY_SKIP
8533 | OPTI_TYPE_NOT_SALTED;
8534 dgst_pos0 = 3;
8535 dgst_pos1 = 4;
8536 dgst_pos2 = 2;
8537 dgst_pos3 = 1;
8538 break;
8539
8540 case 4700: hash_type = HASH_TYPE_SHA1;
8541 salt_type = SALT_TYPE_NONE;
8542 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8543 opts_type = OPTS_TYPE_PT_GENERATE_LE
8544 | OPTS_TYPE_PT_ADD80
8545 | OPTS_TYPE_PT_ADDBITS14;
8546 kern_type = KERN_TYPE_SHA1_MD5;
8547 dgst_size = DGST_SIZE_4_5;
8548 parse_func = sha1_parse_hash;
8549 sort_by_digest = sort_by_digest_4_5;
8550 opti_type = OPTI_TYPE_ZERO_BYTE
8551 | OPTI_TYPE_PRECOMPUTE_INIT
8552 | OPTI_TYPE_PRECOMPUTE_MERKLE
8553 | OPTI_TYPE_EARLY_SKIP
8554 | OPTI_TYPE_NOT_ITERATED
8555 | OPTI_TYPE_NOT_SALTED
8556 | OPTI_TYPE_RAW_HASH;
8557 dgst_pos0 = 3;
8558 dgst_pos1 = 4;
8559 dgst_pos2 = 2;
8560 dgst_pos3 = 1;
8561 break;
8562
8563 case 4800: hash_type = HASH_TYPE_MD5;
8564 salt_type = SALT_TYPE_EMBEDDED;
8565 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8566 opts_type = OPTS_TYPE_PT_GENERATE_LE
8567 | OPTS_TYPE_PT_ADDBITS14;
8568 kern_type = KERN_TYPE_MD5_CHAP;
8569 dgst_size = DGST_SIZE_4_4;
8570 parse_func = chap_parse_hash;
8571 sort_by_digest = sort_by_digest_4_4;
8572 opti_type = OPTI_TYPE_ZERO_BYTE
8573 | OPTI_TYPE_PRECOMPUTE_INIT
8574 | OPTI_TYPE_PRECOMPUTE_MERKLE
8575 | OPTI_TYPE_MEET_IN_MIDDLE
8576 | OPTI_TYPE_EARLY_SKIP
8577 | OPTI_TYPE_NOT_ITERATED
8578 | OPTI_TYPE_RAW_HASH;
8579 dgst_pos0 = 0;
8580 dgst_pos1 = 3;
8581 dgst_pos2 = 2;
8582 dgst_pos3 = 1;
8583 break;
8584
8585 case 4900: hash_type = HASH_TYPE_SHA1;
8586 salt_type = SALT_TYPE_INTERN;
8587 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8588 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8589 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8590 dgst_size = DGST_SIZE_4_5;
8591 parse_func = sha1s_parse_hash;
8592 sort_by_digest = sort_by_digest_4_5;
8593 opti_type = OPTI_TYPE_ZERO_BYTE
8594 | OPTI_TYPE_PRECOMPUTE_INIT
8595 | OPTI_TYPE_PRECOMPUTE_MERKLE
8596 | OPTI_TYPE_EARLY_SKIP;
8597 dgst_pos0 = 3;
8598 dgst_pos1 = 4;
8599 dgst_pos2 = 2;
8600 dgst_pos3 = 1;
8601 break;
8602
8603 case 5000: hash_type = HASH_TYPE_KECCAK;
8604 salt_type = SALT_TYPE_EMBEDDED;
8605 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8606 opts_type = OPTS_TYPE_PT_GENERATE_LE
8607 | OPTS_TYPE_PT_ADD01;
8608 kern_type = KERN_TYPE_KECCAK;
8609 dgst_size = DGST_SIZE_8_25;
8610 parse_func = keccak_parse_hash;
8611 sort_by_digest = sort_by_digest_8_25;
8612 opti_type = OPTI_TYPE_ZERO_BYTE
8613 | OPTI_TYPE_USES_BITS_64
8614 | OPTI_TYPE_RAW_HASH;
8615 dgst_pos0 = 2;
8616 dgst_pos1 = 3;
8617 dgst_pos2 = 4;
8618 dgst_pos3 = 5;
8619 break;
8620
8621 case 5100: hash_type = HASH_TYPE_MD5H;
8622 salt_type = SALT_TYPE_NONE;
8623 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_PT_ADD80
8626 | OPTS_TYPE_PT_ADDBITS14;
8627 kern_type = KERN_TYPE_MD5H;
8628 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8629 parse_func = md5half_parse_hash;
8630 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8631 opti_type = OPTI_TYPE_ZERO_BYTE
8632 | OPTI_TYPE_RAW_HASH;
8633 dgst_pos0 = 0;
8634 dgst_pos1 = 1;
8635 dgst_pos2 = 2;
8636 dgst_pos3 = 3;
8637 break;
8638
8639 case 5200: hash_type = HASH_TYPE_SHA256;
8640 salt_type = SALT_TYPE_EMBEDDED;
8641 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8642 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8643 kern_type = KERN_TYPE_PSAFE3;
8644 dgst_size = DGST_SIZE_4_8;
8645 parse_func = psafe3_parse_hash;
8646 sort_by_digest = sort_by_digest_4_8;
8647 opti_type = OPTI_TYPE_ZERO_BYTE;
8648 dgst_pos0 = 0;
8649 dgst_pos1 = 1;
8650 dgst_pos2 = 2;
8651 dgst_pos3 = 3;
8652 break;
8653
8654 case 5300: hash_type = HASH_TYPE_MD5;
8655 salt_type = SALT_TYPE_EMBEDDED;
8656 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8657 opts_type = OPTS_TYPE_PT_GENERATE_LE
8658 | OPTS_TYPE_ST_ADD80;
8659 kern_type = KERN_TYPE_IKEPSK_MD5;
8660 dgst_size = DGST_SIZE_4_4;
8661 parse_func = ikepsk_md5_parse_hash;
8662 sort_by_digest = sort_by_digest_4_4;
8663 opti_type = OPTI_TYPE_ZERO_BYTE;
8664 dgst_pos0 = 0;
8665 dgst_pos1 = 3;
8666 dgst_pos2 = 2;
8667 dgst_pos3 = 1;
8668 break;
8669
8670 case 5400: hash_type = HASH_TYPE_SHA1;
8671 salt_type = SALT_TYPE_EMBEDDED;
8672 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8673 opts_type = OPTS_TYPE_PT_GENERATE_BE
8674 | OPTS_TYPE_ST_ADD80;
8675 kern_type = KERN_TYPE_IKEPSK_SHA1;
8676 dgst_size = DGST_SIZE_4_5;
8677 parse_func = ikepsk_sha1_parse_hash;
8678 sort_by_digest = sort_by_digest_4_5;
8679 opti_type = OPTI_TYPE_ZERO_BYTE;
8680 dgst_pos0 = 3;
8681 dgst_pos1 = 4;
8682 dgst_pos2 = 2;
8683 dgst_pos3 = 1;
8684 break;
8685
8686 case 5500: hash_type = HASH_TYPE_NETNTLM;
8687 salt_type = SALT_TYPE_EMBEDDED;
8688 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8689 opts_type = OPTS_TYPE_PT_GENERATE_LE
8690 | OPTS_TYPE_PT_ADD80
8691 | OPTS_TYPE_PT_ADDBITS14
8692 | OPTS_TYPE_PT_UNICODE
8693 | OPTS_TYPE_ST_HEX;
8694 kern_type = KERN_TYPE_NETNTLMv1;
8695 dgst_size = DGST_SIZE_4_4;
8696 parse_func = netntlmv1_parse_hash;
8697 sort_by_digest = sort_by_digest_4_4;
8698 opti_type = OPTI_TYPE_ZERO_BYTE
8699 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8700 dgst_pos0 = 0;
8701 dgst_pos1 = 1;
8702 dgst_pos2 = 2;
8703 dgst_pos3 = 3;
8704 break;
8705
8706 case 5600: hash_type = HASH_TYPE_MD5;
8707 salt_type = SALT_TYPE_EMBEDDED;
8708 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8709 opts_type = OPTS_TYPE_PT_GENERATE_LE
8710 | OPTS_TYPE_PT_ADD80
8711 | OPTS_TYPE_PT_ADDBITS14
8712 | OPTS_TYPE_PT_UNICODE;
8713 kern_type = KERN_TYPE_NETNTLMv2;
8714 dgst_size = DGST_SIZE_4_4;
8715 parse_func = netntlmv2_parse_hash;
8716 sort_by_digest = sort_by_digest_4_4;
8717 opti_type = OPTI_TYPE_ZERO_BYTE;
8718 dgst_pos0 = 0;
8719 dgst_pos1 = 3;
8720 dgst_pos2 = 2;
8721 dgst_pos3 = 1;
8722 break;
8723
8724 case 5700: hash_type = HASH_TYPE_SHA256;
8725 salt_type = SALT_TYPE_NONE;
8726 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8727 opts_type = OPTS_TYPE_PT_GENERATE_BE
8728 | OPTS_TYPE_PT_ADD80
8729 | OPTS_TYPE_PT_ADDBITS15;
8730 kern_type = KERN_TYPE_SHA256;
8731 dgst_size = DGST_SIZE_4_8;
8732 parse_func = cisco4_parse_hash;
8733 sort_by_digest = sort_by_digest_4_8;
8734 opti_type = OPTI_TYPE_ZERO_BYTE
8735 | OPTI_TYPE_PRECOMPUTE_INIT
8736 | OPTI_TYPE_PRECOMPUTE_MERKLE
8737 | OPTI_TYPE_EARLY_SKIP
8738 | OPTI_TYPE_NOT_ITERATED
8739 | OPTI_TYPE_NOT_SALTED
8740 | OPTI_TYPE_RAW_HASH;
8741 dgst_pos0 = 3;
8742 dgst_pos1 = 7;
8743 dgst_pos2 = 2;
8744 dgst_pos3 = 6;
8745 break;
8746
8747 case 5800: hash_type = HASH_TYPE_SHA1;
8748 salt_type = SALT_TYPE_INTERN;
8749 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8750 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8751 | OPTS_TYPE_ST_ADD80;
8752 kern_type = KERN_TYPE_ANDROIDPIN;
8753 dgst_size = DGST_SIZE_4_5;
8754 parse_func = androidpin_parse_hash;
8755 sort_by_digest = sort_by_digest_4_5;
8756 opti_type = OPTI_TYPE_ZERO_BYTE;
8757 dgst_pos0 = 0;
8758 dgst_pos1 = 1;
8759 dgst_pos2 = 2;
8760 dgst_pos3 = 3;
8761 break;
8762
8763 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8764 salt_type = SALT_TYPE_NONE;
8765 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8766 opts_type = OPTS_TYPE_PT_GENERATE_LE
8767 | OPTS_TYPE_PT_ADD80;
8768 kern_type = KERN_TYPE_RIPEMD160;
8769 dgst_size = DGST_SIZE_4_5;
8770 parse_func = ripemd160_parse_hash;
8771 sort_by_digest = sort_by_digest_4_5;
8772 opti_type = OPTI_TYPE_ZERO_BYTE;
8773 dgst_pos0 = 0;
8774 dgst_pos1 = 1;
8775 dgst_pos2 = 2;
8776 dgst_pos3 = 3;
8777 break;
8778
8779 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
8780 salt_type = SALT_TYPE_NONE;
8781 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8782 opts_type = OPTS_TYPE_PT_GENERATE_BE
8783 | OPTS_TYPE_PT_ADD80;
8784 kern_type = KERN_TYPE_WHIRLPOOL;
8785 dgst_size = DGST_SIZE_4_16;
8786 parse_func = whirlpool_parse_hash;
8787 sort_by_digest = sort_by_digest_4_16;
8788 opti_type = OPTI_TYPE_ZERO_BYTE;
8789 dgst_pos0 = 0;
8790 dgst_pos1 = 1;
8791 dgst_pos2 = 2;
8792 dgst_pos3 = 3;
8793 break;
8794
8795 case 6211: hash_type = HASH_TYPE_RIPEMD160;
8796 salt_type = SALT_TYPE_EMBEDDED;
8797 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8798 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8799 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8800 dgst_size = DGST_SIZE_4_5;
8801 parse_func = truecrypt_parse_hash_2k;
8802 sort_by_digest = sort_by_digest_4_5;
8803 opti_type = OPTI_TYPE_ZERO_BYTE;
8804 dgst_pos0 = 0;
8805 dgst_pos1 = 1;
8806 dgst_pos2 = 2;
8807 dgst_pos3 = 3;
8808 break;
8809
8810 case 6212: hash_type = HASH_TYPE_RIPEMD160;
8811 salt_type = SALT_TYPE_EMBEDDED;
8812 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8813 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8814 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8815 dgst_size = DGST_SIZE_4_5;
8816 parse_func = truecrypt_parse_hash_2k;
8817 sort_by_digest = sort_by_digest_4_5;
8818 opti_type = OPTI_TYPE_ZERO_BYTE;
8819 dgst_pos0 = 0;
8820 dgst_pos1 = 1;
8821 dgst_pos2 = 2;
8822 dgst_pos3 = 3;
8823 break;
8824
8825 case 6213: hash_type = HASH_TYPE_RIPEMD160;
8826 salt_type = SALT_TYPE_EMBEDDED;
8827 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8829 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8830 dgst_size = DGST_SIZE_4_5;
8831 parse_func = truecrypt_parse_hash_2k;
8832 sort_by_digest = sort_by_digest_4_5;
8833 opti_type = OPTI_TYPE_ZERO_BYTE;
8834 dgst_pos0 = 0;
8835 dgst_pos1 = 1;
8836 dgst_pos2 = 2;
8837 dgst_pos3 = 3;
8838 break;
8839
8840 case 6221: hash_type = HASH_TYPE_SHA512;
8841 salt_type = SALT_TYPE_EMBEDDED;
8842 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8843 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8844 kern_type = KERN_TYPE_TCSHA512_XTS512;
8845 dgst_size = DGST_SIZE_8_8;
8846 parse_func = truecrypt_parse_hash_1k;
8847 sort_by_digest = sort_by_digest_8_8;
8848 opti_type = OPTI_TYPE_ZERO_BYTE
8849 | OPTI_TYPE_USES_BITS_64;
8850 dgst_pos0 = 0;
8851 dgst_pos1 = 1;
8852 dgst_pos2 = 2;
8853 dgst_pos3 = 3;
8854 break;
8855
8856 case 6222: hash_type = HASH_TYPE_SHA512;
8857 salt_type = SALT_TYPE_EMBEDDED;
8858 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8859 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8860 kern_type = KERN_TYPE_TCSHA512_XTS1024;
8861 dgst_size = DGST_SIZE_8_8;
8862 parse_func = truecrypt_parse_hash_1k;
8863 sort_by_digest = sort_by_digest_8_8;
8864 opti_type = OPTI_TYPE_ZERO_BYTE
8865 | OPTI_TYPE_USES_BITS_64;
8866 dgst_pos0 = 0;
8867 dgst_pos1 = 1;
8868 dgst_pos2 = 2;
8869 dgst_pos3 = 3;
8870 break;
8871
8872 case 6223: hash_type = HASH_TYPE_SHA512;
8873 salt_type = SALT_TYPE_EMBEDDED;
8874 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8875 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8876 kern_type = KERN_TYPE_TCSHA512_XTS1536;
8877 dgst_size = DGST_SIZE_8_8;
8878 parse_func = truecrypt_parse_hash_1k;
8879 sort_by_digest = sort_by_digest_8_8;
8880 opti_type = OPTI_TYPE_ZERO_BYTE
8881 | OPTI_TYPE_USES_BITS_64;
8882 dgst_pos0 = 0;
8883 dgst_pos1 = 1;
8884 dgst_pos2 = 2;
8885 dgst_pos3 = 3;
8886 break;
8887
8888 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
8889 salt_type = SALT_TYPE_EMBEDDED;
8890 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8891 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8892 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
8893 dgst_size = DGST_SIZE_4_8;
8894 parse_func = truecrypt_parse_hash_1k;
8895 sort_by_digest = sort_by_digest_4_8;
8896 opti_type = OPTI_TYPE_ZERO_BYTE;
8897 dgst_pos0 = 0;
8898 dgst_pos1 = 1;
8899 dgst_pos2 = 2;
8900 dgst_pos3 = 3;
8901 break;
8902
8903 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
8904 salt_type = SALT_TYPE_EMBEDDED;
8905 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8906 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8907 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
8908 dgst_size = DGST_SIZE_4_8;
8909 parse_func = truecrypt_parse_hash_1k;
8910 sort_by_digest = sort_by_digest_4_8;
8911 opti_type = OPTI_TYPE_ZERO_BYTE;
8912 dgst_pos0 = 0;
8913 dgst_pos1 = 1;
8914 dgst_pos2 = 2;
8915 dgst_pos3 = 3;
8916 break;
8917
8918 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
8919 salt_type = SALT_TYPE_EMBEDDED;
8920 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8921 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8922 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
8923 dgst_size = DGST_SIZE_4_8;
8924 parse_func = truecrypt_parse_hash_1k;
8925 sort_by_digest = sort_by_digest_4_8;
8926 opti_type = OPTI_TYPE_ZERO_BYTE;
8927 dgst_pos0 = 0;
8928 dgst_pos1 = 1;
8929 dgst_pos2 = 2;
8930 dgst_pos3 = 3;
8931 break;
8932
8933 case 6241: hash_type = HASH_TYPE_RIPEMD160;
8934 salt_type = SALT_TYPE_EMBEDDED;
8935 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8936 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8937 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
8938 dgst_size = DGST_SIZE_4_5;
8939 parse_func = truecrypt_parse_hash_1k;
8940 sort_by_digest = sort_by_digest_4_5;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 1;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 3;
8946 break;
8947
8948 case 6242: hash_type = HASH_TYPE_RIPEMD160;
8949 salt_type = SALT_TYPE_EMBEDDED;
8950 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8952 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
8953 dgst_size = DGST_SIZE_4_5;
8954 parse_func = truecrypt_parse_hash_1k;
8955 sort_by_digest = sort_by_digest_4_5;
8956 opti_type = OPTI_TYPE_ZERO_BYTE;
8957 dgst_pos0 = 0;
8958 dgst_pos1 = 1;
8959 dgst_pos2 = 2;
8960 dgst_pos3 = 3;
8961 break;
8962
8963 case 6243: hash_type = HASH_TYPE_RIPEMD160;
8964 salt_type = SALT_TYPE_EMBEDDED;
8965 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8967 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
8968 dgst_size = DGST_SIZE_4_5;
8969 parse_func = truecrypt_parse_hash_1k;
8970 sort_by_digest = sort_by_digest_4_5;
8971 opti_type = OPTI_TYPE_ZERO_BYTE;
8972 dgst_pos0 = 0;
8973 dgst_pos1 = 1;
8974 dgst_pos2 = 2;
8975 dgst_pos3 = 3;
8976 break;
8977
8978 case 6300: hash_type = HASH_TYPE_MD5;
8979 salt_type = SALT_TYPE_EMBEDDED;
8980 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8981 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8982 kern_type = KERN_TYPE_MD5AIX;
8983 dgst_size = DGST_SIZE_4_4;
8984 parse_func = md5aix_parse_hash;
8985 sort_by_digest = sort_by_digest_4_4;
8986 opti_type = OPTI_TYPE_ZERO_BYTE;
8987 dgst_pos0 = 0;
8988 dgst_pos1 = 1;
8989 dgst_pos2 = 2;
8990 dgst_pos3 = 3;
8991 break;
8992
8993 case 6400: hash_type = HASH_TYPE_SHA256;
8994 salt_type = SALT_TYPE_EMBEDDED;
8995 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8996 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8997 kern_type = KERN_TYPE_SHA256AIX;
8998 dgst_size = DGST_SIZE_4_8;
8999 parse_func = sha256aix_parse_hash;
9000 sort_by_digest = sort_by_digest_4_8;
9001 opti_type = OPTI_TYPE_ZERO_BYTE;
9002 dgst_pos0 = 0;
9003 dgst_pos1 = 1;
9004 dgst_pos2 = 2;
9005 dgst_pos3 = 3;
9006 break;
9007
9008 case 6500: hash_type = HASH_TYPE_SHA512;
9009 salt_type = SALT_TYPE_EMBEDDED;
9010 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9011 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9012 kern_type = KERN_TYPE_SHA512AIX;
9013 dgst_size = DGST_SIZE_8_8;
9014 parse_func = sha512aix_parse_hash;
9015 sort_by_digest = sort_by_digest_8_8;
9016 opti_type = OPTI_TYPE_ZERO_BYTE
9017 | OPTI_TYPE_USES_BITS_64;
9018 dgst_pos0 = 0;
9019 dgst_pos1 = 1;
9020 dgst_pos2 = 2;
9021 dgst_pos3 = 3;
9022 break;
9023
9024 case 6600: hash_type = HASH_TYPE_AES;
9025 salt_type = SALT_TYPE_EMBEDDED;
9026 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9027 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9028 kern_type = KERN_TYPE_AGILEKEY;
9029 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9030 parse_func = agilekey_parse_hash;
9031 sort_by_digest = sort_by_digest_4_5;
9032 opti_type = OPTI_TYPE_ZERO_BYTE;
9033 dgst_pos0 = 0;
9034 dgst_pos1 = 1;
9035 dgst_pos2 = 2;
9036 dgst_pos3 = 3;
9037 break;
9038
9039 case 6700: hash_type = HASH_TYPE_SHA1;
9040 salt_type = SALT_TYPE_EMBEDDED;
9041 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9042 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9043 kern_type = KERN_TYPE_SHA1AIX;
9044 dgst_size = DGST_SIZE_4_5;
9045 parse_func = sha1aix_parse_hash;
9046 sort_by_digest = sort_by_digest_4_5;
9047 opti_type = OPTI_TYPE_ZERO_BYTE;
9048 dgst_pos0 = 0;
9049 dgst_pos1 = 1;
9050 dgst_pos2 = 2;
9051 dgst_pos3 = 3;
9052 break;
9053
9054 case 6800: hash_type = HASH_TYPE_AES;
9055 salt_type = SALT_TYPE_EMBEDDED;
9056 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9057 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9058 kern_type = KERN_TYPE_LASTPASS;
9059 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9060 parse_func = lastpass_parse_hash;
9061 sort_by_digest = sort_by_digest_4_8;
9062 opti_type = OPTI_TYPE_ZERO_BYTE;
9063 dgst_pos0 = 0;
9064 dgst_pos1 = 1;
9065 dgst_pos2 = 2;
9066 dgst_pos3 = 3;
9067 break;
9068
9069 case 6900: hash_type = HASH_TYPE_GOST;
9070 salt_type = SALT_TYPE_NONE;
9071 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9072 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9073 kern_type = KERN_TYPE_GOST;
9074 dgst_size = DGST_SIZE_4_8;
9075 parse_func = gost_parse_hash;
9076 sort_by_digest = sort_by_digest_4_8;
9077 opti_type = OPTI_TYPE_ZERO_BYTE;
9078 dgst_pos0 = 0;
9079 dgst_pos1 = 1;
9080 dgst_pos2 = 2;
9081 dgst_pos3 = 3;
9082 break;
9083
9084 case 7100: hash_type = HASH_TYPE_SHA512;
9085 salt_type = SALT_TYPE_EMBEDDED;
9086 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9087 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9088 kern_type = KERN_TYPE_PBKDF2_SHA512;
9089 dgst_size = DGST_SIZE_8_16;
9090 parse_func = sha512osx_parse_hash;
9091 sort_by_digest = sort_by_digest_8_16;
9092 opti_type = OPTI_TYPE_ZERO_BYTE
9093 | OPTI_TYPE_USES_BITS_64
9094 | OPTI_TYPE_SLOW_HASH_SIMD;
9095 dgst_pos0 = 0;
9096 dgst_pos1 = 1;
9097 dgst_pos2 = 2;
9098 dgst_pos3 = 3;
9099 break;
9100
9101 case 7200: hash_type = HASH_TYPE_SHA512;
9102 salt_type = SALT_TYPE_EMBEDDED;
9103 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9104 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9105 kern_type = KERN_TYPE_PBKDF2_SHA512;
9106 dgst_size = DGST_SIZE_8_16;
9107 parse_func = sha512grub_parse_hash;
9108 sort_by_digest = sort_by_digest_8_16;
9109 opti_type = OPTI_TYPE_ZERO_BYTE
9110 | OPTI_TYPE_USES_BITS_64
9111 | OPTI_TYPE_SLOW_HASH_SIMD;
9112 dgst_pos0 = 0;
9113 dgst_pos1 = 1;
9114 dgst_pos2 = 2;
9115 dgst_pos3 = 3;
9116 break;
9117
9118 case 7300: hash_type = HASH_TYPE_SHA1;
9119 salt_type = SALT_TYPE_EMBEDDED;
9120 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9121 opts_type = OPTS_TYPE_PT_GENERATE_BE
9122 | OPTS_TYPE_ST_ADD80
9123 | OPTS_TYPE_ST_ADDBITS15;
9124 kern_type = KERN_TYPE_RAKP;
9125 dgst_size = DGST_SIZE_4_5;
9126 parse_func = rakp_parse_hash;
9127 sort_by_digest = sort_by_digest_4_5;
9128 opti_type = OPTI_TYPE_ZERO_BYTE
9129 | OPTI_TYPE_NOT_ITERATED;
9130 dgst_pos0 = 3;
9131 dgst_pos1 = 4;
9132 dgst_pos2 = 2;
9133 dgst_pos3 = 1;
9134 break;
9135
9136 case 7400: hash_type = HASH_TYPE_SHA256;
9137 salt_type = SALT_TYPE_EMBEDDED;
9138 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9139 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9140 kern_type = KERN_TYPE_SHA256CRYPT;
9141 dgst_size = DGST_SIZE_4_8;
9142 parse_func = sha256crypt_parse_hash;
9143 sort_by_digest = sort_by_digest_4_8;
9144 opti_type = OPTI_TYPE_ZERO_BYTE;
9145 dgst_pos0 = 0;
9146 dgst_pos1 = 1;
9147 dgst_pos2 = 2;
9148 dgst_pos3 = 3;
9149 break;
9150
9151 case 7500: hash_type = HASH_TYPE_KRB5PA;
9152 salt_type = SALT_TYPE_EMBEDDED;
9153 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9154 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9155 kern_type = KERN_TYPE_KRB5PA;
9156 dgst_size = DGST_SIZE_4_4;
9157 parse_func = krb5pa_parse_hash;
9158 sort_by_digest = sort_by_digest_4_4;
9159 opti_type = OPTI_TYPE_ZERO_BYTE
9160 | OPTI_TYPE_NOT_ITERATED;
9161 dgst_pos0 = 0;
9162 dgst_pos1 = 1;
9163 dgst_pos2 = 2;
9164 dgst_pos3 = 3;
9165 break;
9166
9167 case 7600: hash_type = HASH_TYPE_SHA1;
9168 salt_type = SALT_TYPE_INTERN;
9169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9170 opts_type = OPTS_TYPE_PT_GENERATE_BE
9171 | OPTS_TYPE_PT_ADD80
9172 | OPTS_TYPE_PT_ADDBITS15;
9173 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9174 dgst_size = DGST_SIZE_4_5;
9175 parse_func = redmine_parse_hash;
9176 sort_by_digest = sort_by_digest_4_5;
9177 opti_type = OPTI_TYPE_ZERO_BYTE
9178 | OPTI_TYPE_PRECOMPUTE_INIT
9179 | OPTI_TYPE_EARLY_SKIP
9180 | OPTI_TYPE_NOT_ITERATED
9181 | OPTI_TYPE_PREPENDED_SALT;
9182 dgst_pos0 = 3;
9183 dgst_pos1 = 4;
9184 dgst_pos2 = 2;
9185 dgst_pos3 = 1;
9186 break;
9187
9188 case 7700: hash_type = HASH_TYPE_SAPB;
9189 salt_type = SALT_TYPE_EMBEDDED;
9190 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9191 opts_type = OPTS_TYPE_PT_GENERATE_LE
9192 | OPTS_TYPE_PT_UPPER
9193 | OPTS_TYPE_ST_UPPER;
9194 kern_type = KERN_TYPE_SAPB;
9195 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9196 parse_func = sapb_parse_hash;
9197 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9198 opti_type = OPTI_TYPE_ZERO_BYTE
9199 | OPTI_TYPE_PRECOMPUTE_INIT
9200 | OPTI_TYPE_NOT_ITERATED;
9201 dgst_pos0 = 0;
9202 dgst_pos1 = 1;
9203 dgst_pos2 = 2;
9204 dgst_pos3 = 3;
9205 break;
9206
9207 case 7800: hash_type = HASH_TYPE_SAPG;
9208 salt_type = SALT_TYPE_EMBEDDED;
9209 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9210 opts_type = OPTS_TYPE_PT_GENERATE_BE
9211 | OPTS_TYPE_ST_ADD80
9212 | OPTS_TYPE_ST_UPPER;
9213 kern_type = KERN_TYPE_SAPG;
9214 dgst_size = DGST_SIZE_4_5;
9215 parse_func = sapg_parse_hash;
9216 sort_by_digest = sort_by_digest_4_5;
9217 opti_type = OPTI_TYPE_ZERO_BYTE
9218 | OPTI_TYPE_PRECOMPUTE_INIT
9219 | OPTI_TYPE_NOT_ITERATED;
9220 dgst_pos0 = 3;
9221 dgst_pos1 = 4;
9222 dgst_pos2 = 2;
9223 dgst_pos3 = 1;
9224 break;
9225
9226 case 7900: hash_type = HASH_TYPE_SHA512;
9227 salt_type = SALT_TYPE_EMBEDDED;
9228 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9229 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9230 kern_type = KERN_TYPE_DRUPAL7;
9231 dgst_size = DGST_SIZE_8_8;
9232 parse_func = drupal7_parse_hash;
9233 sort_by_digest = sort_by_digest_8_8;
9234 opti_type = OPTI_TYPE_ZERO_BYTE
9235 | OPTI_TYPE_USES_BITS_64;
9236 dgst_pos0 = 0;
9237 dgst_pos1 = 1;
9238 dgst_pos2 = 2;
9239 dgst_pos3 = 3;
9240 break;
9241
9242 case 8000: hash_type = HASH_TYPE_SHA256;
9243 salt_type = SALT_TYPE_EMBEDDED;
9244 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9245 opts_type = OPTS_TYPE_PT_GENERATE_BE
9246 | OPTS_TYPE_PT_UNICODE
9247 | OPTS_TYPE_ST_ADD80
9248 | OPTS_TYPE_ST_HEX;
9249 kern_type = KERN_TYPE_SYBASEASE;
9250 dgst_size = DGST_SIZE_4_8;
9251 parse_func = sybasease_parse_hash;
9252 sort_by_digest = sort_by_digest_4_8;
9253 opti_type = OPTI_TYPE_ZERO_BYTE
9254 | OPTI_TYPE_PRECOMPUTE_INIT
9255 | OPTI_TYPE_EARLY_SKIP
9256 | OPTI_TYPE_NOT_ITERATED
9257 | OPTI_TYPE_RAW_HASH;
9258 dgst_pos0 = 3;
9259 dgst_pos1 = 7;
9260 dgst_pos2 = 2;
9261 dgst_pos3 = 6;
9262 break;
9263
9264 case 8100: hash_type = HASH_TYPE_SHA1;
9265 salt_type = SALT_TYPE_EMBEDDED;
9266 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9267 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9268 kern_type = KERN_TYPE_NETSCALER;
9269 dgst_size = DGST_SIZE_4_5;
9270 parse_func = netscaler_parse_hash;
9271 sort_by_digest = sort_by_digest_4_5;
9272 opti_type = OPTI_TYPE_ZERO_BYTE
9273 | OPTI_TYPE_PRECOMPUTE_INIT
9274 | OPTI_TYPE_PRECOMPUTE_MERKLE
9275 | OPTI_TYPE_EARLY_SKIP
9276 | OPTI_TYPE_NOT_ITERATED
9277 | OPTI_TYPE_PREPENDED_SALT
9278 | OPTI_TYPE_RAW_HASH;
9279 dgst_pos0 = 3;
9280 dgst_pos1 = 4;
9281 dgst_pos2 = 2;
9282 dgst_pos3 = 1;
9283 break;
9284
9285 case 8200: hash_type = HASH_TYPE_SHA256;
9286 salt_type = SALT_TYPE_EMBEDDED;
9287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9288 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9289 kern_type = KERN_TYPE_CLOUDKEY;
9290 dgst_size = DGST_SIZE_4_8;
9291 parse_func = cloudkey_parse_hash;
9292 sort_by_digest = sort_by_digest_4_8;
9293 opti_type = OPTI_TYPE_ZERO_BYTE;
9294 dgst_pos0 = 0;
9295 dgst_pos1 = 1;
9296 dgst_pos2 = 2;
9297 dgst_pos3 = 3;
9298 break;
9299
9300 case 8300: hash_type = HASH_TYPE_SHA1;
9301 salt_type = SALT_TYPE_EMBEDDED;
9302 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9303 opts_type = OPTS_TYPE_PT_GENERATE_BE
9304 | OPTS_TYPE_ST_HEX
9305 | OPTS_TYPE_ST_ADD80;
9306 kern_type = KERN_TYPE_NSEC3;
9307 dgst_size = DGST_SIZE_4_5;
9308 parse_func = nsec3_parse_hash;
9309 sort_by_digest = sort_by_digest_4_5;
9310 opti_type = OPTI_TYPE_ZERO_BYTE;
9311 dgst_pos0 = 3;
9312 dgst_pos1 = 4;
9313 dgst_pos2 = 2;
9314 dgst_pos3 = 1;
9315 break;
9316
9317 case 8400: hash_type = HASH_TYPE_SHA1;
9318 salt_type = SALT_TYPE_INTERN;
9319 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9320 opts_type = OPTS_TYPE_PT_GENERATE_BE
9321 | OPTS_TYPE_PT_ADD80
9322 | OPTS_TYPE_PT_ADDBITS15;
9323 kern_type = KERN_TYPE_WBB3;
9324 dgst_size = DGST_SIZE_4_5;
9325 parse_func = wbb3_parse_hash;
9326 sort_by_digest = sort_by_digest_4_5;
9327 opti_type = OPTI_TYPE_ZERO_BYTE
9328 | OPTI_TYPE_PRECOMPUTE_INIT
9329 | OPTI_TYPE_NOT_ITERATED;
9330 dgst_pos0 = 3;
9331 dgst_pos1 = 4;
9332 dgst_pos2 = 2;
9333 dgst_pos3 = 1;
9334 break;
9335
9336 case 8500: hash_type = HASH_TYPE_DESRACF;
9337 salt_type = SALT_TYPE_EMBEDDED;
9338 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9339 opts_type = OPTS_TYPE_PT_GENERATE_LE
9340 | OPTS_TYPE_ST_UPPER;
9341 kern_type = KERN_TYPE_RACF;
9342 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9343 parse_func = racf_parse_hash;
9344 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9345 opti_type = OPTI_TYPE_ZERO_BYTE
9346 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9347 dgst_pos0 = 0;
9348 dgst_pos1 = 1;
9349 dgst_pos2 = 2;
9350 dgst_pos3 = 3;
9351 break;
9352
9353 case 8600: hash_type = HASH_TYPE_LOTUS5;
9354 salt_type = SALT_TYPE_NONE;
9355 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9356 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9357 kern_type = KERN_TYPE_LOTUS5;
9358 dgst_size = DGST_SIZE_4_4;
9359 parse_func = lotus5_parse_hash;
9360 sort_by_digest = sort_by_digest_4_4;
9361 opti_type = OPTI_TYPE_EARLY_SKIP
9362 | OPTI_TYPE_NOT_ITERATED
9363 | OPTI_TYPE_NOT_SALTED
9364 | OPTI_TYPE_RAW_HASH;
9365 dgst_pos0 = 0;
9366 dgst_pos1 = 1;
9367 dgst_pos2 = 2;
9368 dgst_pos3 = 3;
9369 break;
9370
9371 case 8700: hash_type = HASH_TYPE_LOTUS6;
9372 salt_type = SALT_TYPE_EMBEDDED;
9373 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9374 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9375 kern_type = KERN_TYPE_LOTUS6;
9376 dgst_size = DGST_SIZE_4_4;
9377 parse_func = lotus6_parse_hash;
9378 sort_by_digest = sort_by_digest_4_4;
9379 opti_type = OPTI_TYPE_EARLY_SKIP
9380 | OPTI_TYPE_NOT_ITERATED
9381 | OPTI_TYPE_RAW_HASH;
9382 dgst_pos0 = 0;
9383 dgst_pos1 = 1;
9384 dgst_pos2 = 2;
9385 dgst_pos3 = 3;
9386 break;
9387
9388 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9389 salt_type = SALT_TYPE_EMBEDDED;
9390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9391 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9392 kern_type = KERN_TYPE_ANDROIDFDE;
9393 dgst_size = DGST_SIZE_4_4;
9394 parse_func = androidfde_parse_hash;
9395 sort_by_digest = sort_by_digest_4_4;
9396 opti_type = OPTI_TYPE_ZERO_BYTE;
9397 dgst_pos0 = 0;
9398 dgst_pos1 = 1;
9399 dgst_pos2 = 2;
9400 dgst_pos3 = 3;
9401 break;
9402
9403 case 8900: hash_type = HASH_TYPE_SCRYPT;
9404 salt_type = SALT_TYPE_EMBEDDED;
9405 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9406 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9407 kern_type = KERN_TYPE_SCRYPT;
9408 dgst_size = DGST_SIZE_4_8;
9409 parse_func = scrypt_parse_hash;
9410 sort_by_digest = sort_by_digest_4_8;
9411 opti_type = OPTI_TYPE_ZERO_BYTE;
9412 dgst_pos0 = 0;
9413 dgst_pos1 = 1;
9414 dgst_pos2 = 2;
9415 dgst_pos3 = 3;
9416 break;
9417
9418 case 9000: hash_type = HASH_TYPE_SHA1;
9419 salt_type = SALT_TYPE_EMBEDDED;
9420 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9421 opts_type = OPTS_TYPE_PT_GENERATE_LE
9422 | OPTS_TYPE_ST_GENERATE_LE;
9423 kern_type = KERN_TYPE_PSAFE2;
9424 dgst_size = DGST_SIZE_4_5;
9425 parse_func = psafe2_parse_hash;
9426 sort_by_digest = sort_by_digest_4_5;
9427 opti_type = OPTI_TYPE_ZERO_BYTE;
9428 dgst_pos0 = 0;
9429 dgst_pos1 = 1;
9430 dgst_pos2 = 2;
9431 dgst_pos3 = 3;
9432 break;
9433
9434 case 9100: hash_type = HASH_TYPE_LOTUS8;
9435 salt_type = SALT_TYPE_EMBEDDED;
9436 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9437 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9438 kern_type = KERN_TYPE_LOTUS8;
9439 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9440 parse_func = lotus8_parse_hash;
9441 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9442 opti_type = OPTI_TYPE_ZERO_BYTE;
9443 dgst_pos0 = 0;
9444 dgst_pos1 = 1;
9445 dgst_pos2 = 2;
9446 dgst_pos3 = 3;
9447 break;
9448
9449 case 9200: hash_type = HASH_TYPE_SHA256;
9450 salt_type = SALT_TYPE_EMBEDDED;
9451 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9452 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9453 kern_type = KERN_TYPE_PBKDF2_SHA256;
9454 dgst_size = DGST_SIZE_4_32;
9455 parse_func = cisco8_parse_hash;
9456 sort_by_digest = sort_by_digest_4_32;
9457 opti_type = OPTI_TYPE_ZERO_BYTE
9458 | OPTI_TYPE_SLOW_HASH_SIMD;
9459 dgst_pos0 = 0;
9460 dgst_pos1 = 1;
9461 dgst_pos2 = 2;
9462 dgst_pos3 = 3;
9463 break;
9464
9465 case 9300: hash_type = HASH_TYPE_SCRYPT;
9466 salt_type = SALT_TYPE_EMBEDDED;
9467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9469 kern_type = KERN_TYPE_SCRYPT;
9470 dgst_size = DGST_SIZE_4_8;
9471 parse_func = cisco9_parse_hash;
9472 sort_by_digest = sort_by_digest_4_8;
9473 opti_type = OPTI_TYPE_ZERO_BYTE;
9474 dgst_pos0 = 0;
9475 dgst_pos1 = 1;
9476 dgst_pos2 = 2;
9477 dgst_pos3 = 3;
9478 break;
9479
9480 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9481 salt_type = SALT_TYPE_EMBEDDED;
9482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9484 kern_type = KERN_TYPE_OFFICE2007;
9485 dgst_size = DGST_SIZE_4_4;
9486 parse_func = office2007_parse_hash;
9487 sort_by_digest = sort_by_digest_4_4;
9488 opti_type = OPTI_TYPE_ZERO_BYTE;
9489 dgst_pos0 = 0;
9490 dgst_pos1 = 1;
9491 dgst_pos2 = 2;
9492 dgst_pos3 = 3;
9493 break;
9494
9495 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9496 salt_type = SALT_TYPE_EMBEDDED;
9497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9499 kern_type = KERN_TYPE_OFFICE2010;
9500 dgst_size = DGST_SIZE_4_4;
9501 parse_func = office2010_parse_hash;
9502 sort_by_digest = sort_by_digest_4_4;
9503 opti_type = OPTI_TYPE_ZERO_BYTE;
9504 dgst_pos0 = 0;
9505 dgst_pos1 = 1;
9506 dgst_pos2 = 2;
9507 dgst_pos3 = 3;
9508 break;
9509
9510 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9511 salt_type = SALT_TYPE_EMBEDDED;
9512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9513 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9514 kern_type = KERN_TYPE_OFFICE2013;
9515 dgst_size = DGST_SIZE_4_4;
9516 parse_func = office2013_parse_hash;
9517 sort_by_digest = sort_by_digest_4_4;
9518 opti_type = OPTI_TYPE_ZERO_BYTE;
9519 dgst_pos0 = 0;
9520 dgst_pos1 = 1;
9521 dgst_pos2 = 2;
9522 dgst_pos3 = 3;
9523 break;
9524
9525 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9526 salt_type = SALT_TYPE_EMBEDDED;
9527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9528 opts_type = OPTS_TYPE_PT_GENERATE_LE
9529 | OPTS_TYPE_PT_ADD80
9530 | OPTS_TYPE_PT_UNICODE;
9531 kern_type = KERN_TYPE_OLDOFFICE01;
9532 dgst_size = DGST_SIZE_4_4;
9533 parse_func = oldoffice01_parse_hash;
9534 sort_by_digest = sort_by_digest_4_4;
9535 opti_type = OPTI_TYPE_ZERO_BYTE
9536 | OPTI_TYPE_PRECOMPUTE_INIT
9537 | OPTI_TYPE_NOT_ITERATED;
9538 dgst_pos0 = 0;
9539 dgst_pos1 = 1;
9540 dgst_pos2 = 2;
9541 dgst_pos3 = 3;
9542 break;
9543
9544 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9545 salt_type = SALT_TYPE_EMBEDDED;
9546 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9547 opts_type = OPTS_TYPE_PT_GENERATE_LE
9548 | OPTS_TYPE_PT_ADD80;
9549 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9550 dgst_size = DGST_SIZE_4_4;
9551 parse_func = oldoffice01cm1_parse_hash;
9552 sort_by_digest = sort_by_digest_4_4;
9553 opti_type = OPTI_TYPE_ZERO_BYTE
9554 | OPTI_TYPE_PRECOMPUTE_INIT
9555 | OPTI_TYPE_NOT_ITERATED;
9556 dgst_pos0 = 0;
9557 dgst_pos1 = 1;
9558 dgst_pos2 = 2;
9559 dgst_pos3 = 3;
9560 break;
9561
9562 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9563 salt_type = SALT_TYPE_EMBEDDED;
9564 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9565 opts_type = OPTS_TYPE_PT_GENERATE_LE
9566 | OPTS_TYPE_PT_ADD80
9567 | OPTS_TYPE_PT_UNICODE
9568 | OPTS_TYPE_PT_NEVERCRACK;
9569 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9570 dgst_size = DGST_SIZE_4_4;
9571 parse_func = oldoffice01cm2_parse_hash;
9572 sort_by_digest = sort_by_digest_4_4;
9573 opti_type = OPTI_TYPE_ZERO_BYTE
9574 | OPTI_TYPE_PRECOMPUTE_INIT
9575 | OPTI_TYPE_NOT_ITERATED;
9576 dgst_pos0 = 0;
9577 dgst_pos1 = 1;
9578 dgst_pos2 = 2;
9579 dgst_pos3 = 3;
9580 break;
9581
9582 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9583 salt_type = SALT_TYPE_EMBEDDED;
9584 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9585 opts_type = OPTS_TYPE_PT_GENERATE_BE
9586 | OPTS_TYPE_PT_ADD80
9587 | OPTS_TYPE_PT_UNICODE;
9588 kern_type = KERN_TYPE_OLDOFFICE34;
9589 dgst_size = DGST_SIZE_4_4;
9590 parse_func = oldoffice34_parse_hash;
9591 sort_by_digest = sort_by_digest_4_4;
9592 opti_type = OPTI_TYPE_ZERO_BYTE
9593 | OPTI_TYPE_PRECOMPUTE_INIT
9594 | OPTI_TYPE_NOT_ITERATED;
9595 dgst_pos0 = 0;
9596 dgst_pos1 = 1;
9597 dgst_pos2 = 2;
9598 dgst_pos3 = 3;
9599 break;
9600
9601 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9602 salt_type = SALT_TYPE_EMBEDDED;
9603 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9604 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9605 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9606 dgst_size = DGST_SIZE_4_4;
9607 parse_func = oldoffice34cm1_parse_hash;
9608 sort_by_digest = sort_by_digest_4_4;
9609 opti_type = OPTI_TYPE_ZERO_BYTE
9610 | OPTI_TYPE_PRECOMPUTE_INIT
9611 | OPTI_TYPE_NOT_ITERATED;
9612 dgst_pos0 = 0;
9613 dgst_pos1 = 1;
9614 dgst_pos2 = 2;
9615 dgst_pos3 = 3;
9616 break;
9617
9618 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9619 salt_type = SALT_TYPE_EMBEDDED;
9620 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9621 opts_type = OPTS_TYPE_PT_GENERATE_BE
9622 | OPTS_TYPE_PT_ADD80
9623 | OPTS_TYPE_PT_UNICODE
9624 | OPTS_TYPE_PT_NEVERCRACK;
9625 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9626 dgst_size = DGST_SIZE_4_4;
9627 parse_func = oldoffice34cm2_parse_hash;
9628 sort_by_digest = sort_by_digest_4_4;
9629 opti_type = OPTI_TYPE_ZERO_BYTE
9630 | OPTI_TYPE_PRECOMPUTE_INIT
9631 | OPTI_TYPE_NOT_ITERATED;
9632 dgst_pos0 = 0;
9633 dgst_pos1 = 1;
9634 dgst_pos2 = 2;
9635 dgst_pos3 = 3;
9636 break;
9637
9638 case 9900: hash_type = HASH_TYPE_MD5;
9639 salt_type = SALT_TYPE_NONE;
9640 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9641 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9642 kern_type = KERN_TYPE_RADMIN2;
9643 dgst_size = DGST_SIZE_4_4;
9644 parse_func = radmin2_parse_hash;
9645 sort_by_digest = sort_by_digest_4_4;
9646 opti_type = OPTI_TYPE_ZERO_BYTE
9647 | OPTI_TYPE_PRECOMPUTE_INIT
9648 | OPTI_TYPE_EARLY_SKIP
9649 | OPTI_TYPE_NOT_ITERATED
9650 | OPTI_TYPE_NOT_SALTED;
9651 dgst_pos0 = 0;
9652 dgst_pos1 = 3;
9653 dgst_pos2 = 2;
9654 dgst_pos3 = 1;
9655 break;
9656
9657 case 10000: hash_type = HASH_TYPE_SHA256;
9658 salt_type = SALT_TYPE_EMBEDDED;
9659 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9660 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9661 kern_type = KERN_TYPE_PBKDF2_SHA256;
9662 dgst_size = DGST_SIZE_4_32;
9663 parse_func = djangopbkdf2_parse_hash;
9664 sort_by_digest = sort_by_digest_4_32;
9665 opti_type = OPTI_TYPE_ZERO_BYTE
9666 | OPTI_TYPE_SLOW_HASH_SIMD;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 10100: hash_type = HASH_TYPE_SIPHASH;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9677 kern_type = KERN_TYPE_SIPHASH;
9678 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9679 parse_func = siphash_parse_hash;
9680 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_NOT_ITERATED
9683 | OPTI_TYPE_RAW_HASH;
9684 dgst_pos0 = 0;
9685 dgst_pos1 = 1;
9686 dgst_pos2 = 2;
9687 dgst_pos3 = 3;
9688 break;
9689
9690 case 10200: hash_type = HASH_TYPE_MD5;
9691 salt_type = SALT_TYPE_EMBEDDED;
9692 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9693 opts_type = OPTS_TYPE_PT_GENERATE_LE
9694 | OPTS_TYPE_ST_ADD80
9695 | OPTS_TYPE_ST_ADDBITS14;
9696 kern_type = KERN_TYPE_HMACMD5_PW;
9697 dgst_size = DGST_SIZE_4_4;
9698 parse_func = crammd5_parse_hash;
9699 sort_by_digest = sort_by_digest_4_4;
9700 opti_type = OPTI_TYPE_ZERO_BYTE
9701 | OPTI_TYPE_NOT_ITERATED;
9702 dgst_pos0 = 0;
9703 dgst_pos1 = 3;
9704 dgst_pos2 = 2;
9705 dgst_pos3 = 1;
9706 break;
9707
9708 case 10300: hash_type = HASH_TYPE_SHA1;
9709 salt_type = SALT_TYPE_EMBEDDED;
9710 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9711 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9712 kern_type = KERN_TYPE_SAPH_SHA1;
9713 dgst_size = DGST_SIZE_4_5;
9714 parse_func = saph_sha1_parse_hash;
9715 sort_by_digest = sort_by_digest_4_5;
9716 opti_type = OPTI_TYPE_ZERO_BYTE;
9717 dgst_pos0 = 0;
9718 dgst_pos1 = 1;
9719 dgst_pos2 = 2;
9720 dgst_pos3 = 3;
9721 break;
9722
9723 case 10400: hash_type = HASH_TYPE_PDFU16;
9724 salt_type = SALT_TYPE_EMBEDDED;
9725 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9726 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9727 kern_type = KERN_TYPE_PDF11;
9728 dgst_size = DGST_SIZE_4_4;
9729 parse_func = pdf11_parse_hash;
9730 sort_by_digest = sort_by_digest_4_4;
9731 opti_type = OPTI_TYPE_ZERO_BYTE
9732 | OPTI_TYPE_NOT_ITERATED;
9733 dgst_pos0 = 0;
9734 dgst_pos1 = 1;
9735 dgst_pos2 = 2;
9736 dgst_pos3 = 3;
9737 break;
9738
9739 case 10410: hash_type = HASH_TYPE_PDFU16;
9740 salt_type = SALT_TYPE_EMBEDDED;
9741 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9742 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9743 kern_type = KERN_TYPE_PDF11CM1;
9744 dgst_size = DGST_SIZE_4_4;
9745 parse_func = pdf11cm1_parse_hash;
9746 sort_by_digest = sort_by_digest_4_4;
9747 opti_type = OPTI_TYPE_ZERO_BYTE
9748 | OPTI_TYPE_NOT_ITERATED;
9749 dgst_pos0 = 0;
9750 dgst_pos1 = 1;
9751 dgst_pos2 = 2;
9752 dgst_pos3 = 3;
9753 break;
9754
9755 case 10420: hash_type = HASH_TYPE_PDFU16;
9756 salt_type = SALT_TYPE_EMBEDDED;
9757 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9758 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9759 kern_type = KERN_TYPE_PDF11CM2;
9760 dgst_size = DGST_SIZE_4_4;
9761 parse_func = pdf11cm2_parse_hash;
9762 sort_by_digest = sort_by_digest_4_4;
9763 opti_type = OPTI_TYPE_ZERO_BYTE
9764 | OPTI_TYPE_NOT_ITERATED;
9765 dgst_pos0 = 0;
9766 dgst_pos1 = 1;
9767 dgst_pos2 = 2;
9768 dgst_pos3 = 3;
9769 break;
9770
9771 case 10500: hash_type = HASH_TYPE_PDFU16;
9772 salt_type = SALT_TYPE_EMBEDDED;
9773 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9774 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9775 kern_type = KERN_TYPE_PDF14;
9776 dgst_size = DGST_SIZE_4_4;
9777 parse_func = pdf14_parse_hash;
9778 sort_by_digest = sort_by_digest_4_4;
9779 opti_type = OPTI_TYPE_ZERO_BYTE
9780 | OPTI_TYPE_NOT_ITERATED;
9781 dgst_pos0 = 0;
9782 dgst_pos1 = 1;
9783 dgst_pos2 = 2;
9784 dgst_pos3 = 3;
9785 break;
9786
9787 case 10600: hash_type = HASH_TYPE_SHA256;
9788 salt_type = SALT_TYPE_EMBEDDED;
9789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9790 opts_type = OPTS_TYPE_PT_GENERATE_BE
9791 | OPTS_TYPE_ST_ADD80
9792 | OPTS_TYPE_ST_ADDBITS15
9793 | OPTS_TYPE_HASH_COPY;
9794 kern_type = KERN_TYPE_SHA256_PWSLT;
9795 dgst_size = DGST_SIZE_4_8;
9796 parse_func = pdf17l3_parse_hash;
9797 sort_by_digest = sort_by_digest_4_8;
9798 opti_type = OPTI_TYPE_ZERO_BYTE
9799 | OPTI_TYPE_PRECOMPUTE_INIT
9800 | OPTI_TYPE_PRECOMPUTE_MERKLE
9801 | OPTI_TYPE_EARLY_SKIP
9802 | OPTI_TYPE_NOT_ITERATED
9803 | OPTI_TYPE_APPENDED_SALT
9804 | OPTI_TYPE_RAW_HASH;
9805 dgst_pos0 = 3;
9806 dgst_pos1 = 7;
9807 dgst_pos2 = 2;
9808 dgst_pos3 = 6;
9809 break;
9810
9811 case 10700: hash_type = HASH_TYPE_PDFU32;
9812 salt_type = SALT_TYPE_EMBEDDED;
9813 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9814 opts_type = OPTS_TYPE_PT_GENERATE_LE
9815 | OPTS_TYPE_HASH_COPY;
9816 kern_type = KERN_TYPE_PDF17L8;
9817 dgst_size = DGST_SIZE_4_8;
9818 parse_func = pdf17l8_parse_hash;
9819 sort_by_digest = sort_by_digest_4_8;
9820 opti_type = OPTI_TYPE_ZERO_BYTE
9821 | OPTI_TYPE_NOT_ITERATED;
9822 dgst_pos0 = 0;
9823 dgst_pos1 = 1;
9824 dgst_pos2 = 2;
9825 dgst_pos3 = 3;
9826 break;
9827
9828 case 10800: hash_type = HASH_TYPE_SHA384;
9829 salt_type = SALT_TYPE_NONE;
9830 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9831 opts_type = OPTS_TYPE_PT_GENERATE_BE
9832 | OPTS_TYPE_PT_ADD80
9833 | OPTS_TYPE_PT_ADDBITS15;
9834 kern_type = KERN_TYPE_SHA384;
9835 dgst_size = DGST_SIZE_8_8;
9836 parse_func = sha384_parse_hash;
9837 sort_by_digest = sort_by_digest_8_8;
9838 opti_type = OPTI_TYPE_ZERO_BYTE
9839 | OPTI_TYPE_PRECOMPUTE_INIT
9840 | OPTI_TYPE_PRECOMPUTE_MERKLE
9841 | OPTI_TYPE_EARLY_SKIP
9842 | OPTI_TYPE_NOT_ITERATED
9843 | OPTI_TYPE_NOT_SALTED
9844 | OPTI_TYPE_USES_BITS_64
9845 | OPTI_TYPE_RAW_HASH;
9846 dgst_pos0 = 6;
9847 dgst_pos1 = 7;
9848 dgst_pos2 = 4;
9849 dgst_pos3 = 5;
9850 break;
9851
9852 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
9853 salt_type = SALT_TYPE_EMBEDDED;
9854 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9855 opts_type = OPTS_TYPE_PT_GENERATE_LE
9856 | OPTS_TYPE_ST_BASE64
9857 | OPTS_TYPE_HASH_COPY;
9858 kern_type = KERN_TYPE_PBKDF2_SHA256;
9859 dgst_size = DGST_SIZE_4_32;
9860 parse_func = pbkdf2_sha256_parse_hash;
9861 sort_by_digest = sort_by_digest_4_32;
9862 opti_type = OPTI_TYPE_ZERO_BYTE
9863 | OPTI_TYPE_SLOW_HASH_SIMD;
9864 dgst_pos0 = 0;
9865 dgst_pos1 = 1;
9866 dgst_pos2 = 2;
9867 dgst_pos3 = 3;
9868 break;
9869
9870 case 11000: hash_type = HASH_TYPE_MD5;
9871 salt_type = SALT_TYPE_INTERN;
9872 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9873 opts_type = OPTS_TYPE_PT_GENERATE_LE
9874 | OPTS_TYPE_PT_ADD80;
9875 kern_type = KERN_TYPE_PRESTASHOP;
9876 dgst_size = DGST_SIZE_4_4;
9877 parse_func = prestashop_parse_hash;
9878 sort_by_digest = sort_by_digest_4_4;
9879 opti_type = OPTI_TYPE_ZERO_BYTE
9880 | OPTI_TYPE_PRECOMPUTE_INIT
9881 | OPTI_TYPE_NOT_ITERATED
9882 | OPTI_TYPE_PREPENDED_SALT;
9883 dgst_pos0 = 0;
9884 dgst_pos1 = 3;
9885 dgst_pos2 = 2;
9886 dgst_pos3 = 1;
9887 break;
9888
9889 case 11100: hash_type = HASH_TYPE_MD5;
9890 salt_type = SALT_TYPE_EMBEDDED;
9891 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9892 opts_type = OPTS_TYPE_PT_GENERATE_LE
9893 | OPTS_TYPE_ST_ADD80;
9894 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
9895 dgst_size = DGST_SIZE_4_4;
9896 parse_func = postgresql_auth_parse_hash;
9897 sort_by_digest = sort_by_digest_4_4;
9898 opti_type = OPTI_TYPE_ZERO_BYTE
9899 | OPTI_TYPE_PRECOMPUTE_INIT
9900 | OPTI_TYPE_PRECOMPUTE_MERKLE
9901 | OPTI_TYPE_EARLY_SKIP;
9902 dgst_pos0 = 0;
9903 dgst_pos1 = 3;
9904 dgst_pos2 = 2;
9905 dgst_pos3 = 1;
9906 break;
9907
9908 case 11200: hash_type = HASH_TYPE_SHA1;
9909 salt_type = SALT_TYPE_EMBEDDED;
9910 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9911 opts_type = OPTS_TYPE_PT_GENERATE_BE
9912 | OPTS_TYPE_PT_ADD80
9913 | OPTS_TYPE_ST_HEX;
9914 kern_type = KERN_TYPE_MYSQL_AUTH;
9915 dgst_size = DGST_SIZE_4_5;
9916 parse_func = mysql_auth_parse_hash;
9917 sort_by_digest = sort_by_digest_4_5;
9918 opti_type = OPTI_TYPE_ZERO_BYTE
9919 | OPTI_TYPE_EARLY_SKIP;
9920 dgst_pos0 = 3;
9921 dgst_pos1 = 4;
9922 dgst_pos2 = 2;
9923 dgst_pos3 = 1;
9924 break;
9925
9926 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
9927 salt_type = SALT_TYPE_EMBEDDED;
9928 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9929 opts_type = OPTS_TYPE_PT_GENERATE_LE
9930 | OPTS_TYPE_ST_HEX
9931 | OPTS_TYPE_ST_ADD80;
9932 kern_type = KERN_TYPE_BITCOIN_WALLET;
9933 dgst_size = DGST_SIZE_4_4;
9934 parse_func = bitcoin_wallet_parse_hash;
9935 sort_by_digest = sort_by_digest_4_4;
9936 opti_type = OPTI_TYPE_ZERO_BYTE;
9937 dgst_pos0 = 0;
9938 dgst_pos1 = 1;
9939 dgst_pos2 = 2;
9940 dgst_pos3 = 3;
9941 break;
9942
9943 case 11400: hash_type = HASH_TYPE_MD5;
9944 salt_type = SALT_TYPE_EMBEDDED;
9945 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9946 opts_type = OPTS_TYPE_PT_GENERATE_LE
9947 | OPTS_TYPE_PT_ADD80
9948 | OPTS_TYPE_HASH_COPY;
9949 kern_type = KERN_TYPE_SIP_AUTH;
9950 dgst_size = DGST_SIZE_4_4;
9951 parse_func = sip_auth_parse_hash;
9952 sort_by_digest = sort_by_digest_4_4;
9953 opti_type = OPTI_TYPE_ZERO_BYTE;
9954 dgst_pos0 = 0;
9955 dgst_pos1 = 3;
9956 dgst_pos2 = 2;
9957 dgst_pos3 = 1;
9958 break;
9959
9960 case 11500: hash_type = HASH_TYPE_CRC32;
9961 salt_type = SALT_TYPE_INTERN;
9962 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9963 opts_type = OPTS_TYPE_PT_GENERATE_LE
9964 | OPTS_TYPE_ST_GENERATE_LE
9965 | OPTS_TYPE_ST_HEX;
9966 kern_type = KERN_TYPE_CRC32;
9967 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9968 parse_func = crc32_parse_hash;
9969 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9970 opti_type = OPTI_TYPE_ZERO_BYTE;
9971 dgst_pos0 = 0;
9972 dgst_pos1 = 1;
9973 dgst_pos2 = 2;
9974 dgst_pos3 = 3;
9975 break;
9976
9977 case 11600: hash_type = HASH_TYPE_AES;
9978 salt_type = SALT_TYPE_EMBEDDED;
9979 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9980 opts_type = OPTS_TYPE_PT_GENERATE_LE
9981 | OPTS_TYPE_PT_NEVERCRACK;
9982 kern_type = KERN_TYPE_SEVEN_ZIP;
9983 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9984 parse_func = seven_zip_parse_hash;
9985 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9986 opti_type = OPTI_TYPE_ZERO_BYTE;
9987 dgst_pos0 = 0;
9988 dgst_pos1 = 1;
9989 dgst_pos2 = 2;
9990 dgst_pos3 = 3;
9991 break;
9992
9993 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
9994 salt_type = SALT_TYPE_NONE;
9995 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9996 opts_type = OPTS_TYPE_PT_GENERATE_LE
9997 | OPTS_TYPE_PT_ADD01;
9998 kern_type = KERN_TYPE_GOST_2012SBOG_256;
9999 dgst_size = DGST_SIZE_4_8;
10000 parse_func = gost2012sbog_256_parse_hash;
10001 sort_by_digest = sort_by_digest_4_8;
10002 opti_type = OPTI_TYPE_ZERO_BYTE;
10003 dgst_pos0 = 0;
10004 dgst_pos1 = 1;
10005 dgst_pos2 = 2;
10006 dgst_pos3 = 3;
10007 break;
10008
10009 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10010 salt_type = SALT_TYPE_NONE;
10011 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10012 opts_type = OPTS_TYPE_PT_GENERATE_LE
10013 | OPTS_TYPE_PT_ADD01;
10014 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10015 dgst_size = DGST_SIZE_4_16;
10016 parse_func = gost2012sbog_512_parse_hash;
10017 sort_by_digest = sort_by_digest_4_16;
10018 opti_type = OPTI_TYPE_ZERO_BYTE;
10019 dgst_pos0 = 0;
10020 dgst_pos1 = 1;
10021 dgst_pos2 = 2;
10022 dgst_pos3 = 3;
10023 break;
10024
10025 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10026 salt_type = SALT_TYPE_EMBEDDED;
10027 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10028 opts_type = OPTS_TYPE_PT_GENERATE_LE
10029 | OPTS_TYPE_ST_BASE64
10030 | OPTS_TYPE_HASH_COPY;
10031 kern_type = KERN_TYPE_PBKDF2_MD5;
10032 dgst_size = DGST_SIZE_4_32;
10033 parse_func = pbkdf2_md5_parse_hash;
10034 sort_by_digest = sort_by_digest_4_32;
10035 opti_type = OPTI_TYPE_ZERO_BYTE
10036 | OPTI_TYPE_SLOW_HASH_SIMD;
10037 dgst_pos0 = 0;
10038 dgst_pos1 = 1;
10039 dgst_pos2 = 2;
10040 dgst_pos3 = 3;
10041 break;
10042
10043 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10044 salt_type = SALT_TYPE_EMBEDDED;
10045 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10046 opts_type = OPTS_TYPE_PT_GENERATE_LE
10047 | OPTS_TYPE_ST_BASE64
10048 | OPTS_TYPE_HASH_COPY;
10049 kern_type = KERN_TYPE_PBKDF2_SHA1;
10050 dgst_size = DGST_SIZE_4_32;
10051 parse_func = pbkdf2_sha1_parse_hash;
10052 sort_by_digest = sort_by_digest_4_32;
10053 opti_type = OPTI_TYPE_ZERO_BYTE
10054 | OPTI_TYPE_SLOW_HASH_SIMD;
10055 dgst_pos0 = 0;
10056 dgst_pos1 = 1;
10057 dgst_pos2 = 2;
10058 dgst_pos3 = 3;
10059 break;
10060
10061 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10062 salt_type = SALT_TYPE_EMBEDDED;
10063 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10064 opts_type = OPTS_TYPE_PT_GENERATE_LE
10065 | OPTS_TYPE_ST_BASE64
10066 | OPTS_TYPE_HASH_COPY;
10067 kern_type = KERN_TYPE_PBKDF2_SHA512;
10068 dgst_size = DGST_SIZE_8_16;
10069 parse_func = pbkdf2_sha512_parse_hash;
10070 sort_by_digest = sort_by_digest_8_16;
10071 opti_type = OPTI_TYPE_ZERO_BYTE
10072 | OPTI_TYPE_USES_BITS_64
10073 | OPTI_TYPE_SLOW_HASH_SIMD;
10074 dgst_pos0 = 0;
10075 dgst_pos1 = 1;
10076 dgst_pos2 = 2;
10077 dgst_pos3 = 3;
10078 break;
10079
10080 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10081 salt_type = SALT_TYPE_EMBEDDED;
10082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10083 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10084 kern_type = KERN_TYPE_ECRYPTFS;
10085 dgst_size = DGST_SIZE_8_8;
10086 parse_func = ecryptfs_parse_hash;
10087 sort_by_digest = sort_by_digest_8_8;
10088 opti_type = OPTI_TYPE_ZERO_BYTE
10089 | OPTI_TYPE_USES_BITS_64;
10090 dgst_pos0 = 0;
10091 dgst_pos1 = 1;
10092 dgst_pos2 = 2;
10093 dgst_pos3 = 3;
10094 break;
10095
10096 case 12300: hash_type = HASH_TYPE_ORACLET;
10097 salt_type = SALT_TYPE_EMBEDDED;
10098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10099 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10100 kern_type = KERN_TYPE_ORACLET;
10101 dgst_size = DGST_SIZE_8_16;
10102 parse_func = oraclet_parse_hash;
10103 sort_by_digest = sort_by_digest_8_16;
10104 opti_type = OPTI_TYPE_ZERO_BYTE
10105 | OPTI_TYPE_USES_BITS_64;
10106 dgst_pos0 = 0;
10107 dgst_pos1 = 1;
10108 dgst_pos2 = 2;
10109 dgst_pos3 = 3;
10110 break;
10111
10112 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10113 salt_type = SALT_TYPE_EMBEDDED;
10114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10116 kern_type = KERN_TYPE_BSDICRYPT;
10117 dgst_size = DGST_SIZE_4_4;
10118 parse_func = bsdicrypt_parse_hash;
10119 sort_by_digest = sort_by_digest_4_4;
10120 opti_type = OPTI_TYPE_ZERO_BYTE
10121 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10122 dgst_pos0 = 0;
10123 dgst_pos1 = 1;
10124 dgst_pos2 = 2;
10125 dgst_pos3 = 3;
10126 break;
10127
10128 case 12500: hash_type = HASH_TYPE_RAR3HP;
10129 salt_type = SALT_TYPE_EMBEDDED;
10130 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10131 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10132 kern_type = KERN_TYPE_RAR3;
10133 dgst_size = DGST_SIZE_4_4;
10134 parse_func = rar3hp_parse_hash;
10135 sort_by_digest = sort_by_digest_4_4;
10136 opti_type = OPTI_TYPE_ZERO_BYTE;
10137 dgst_pos0 = 0;
10138 dgst_pos1 = 1;
10139 dgst_pos2 = 2;
10140 dgst_pos3 = 3;
10141 break;
10142
10143 case 12600: hash_type = HASH_TYPE_SHA256;
10144 salt_type = SALT_TYPE_INTERN;
10145 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10146 opts_type = OPTS_TYPE_PT_GENERATE_BE
10147 | OPTS_TYPE_PT_ADD80;
10148 kern_type = KERN_TYPE_CF10;
10149 dgst_size = DGST_SIZE_4_8;
10150 parse_func = cf10_parse_hash;
10151 sort_by_digest = sort_by_digest_4_8;
10152 opti_type = OPTI_TYPE_ZERO_BYTE
10153 | OPTI_TYPE_PRECOMPUTE_INIT
10154 | OPTI_TYPE_EARLY_SKIP
10155 | OPTI_TYPE_NOT_ITERATED;
10156 dgst_pos0 = 3;
10157 dgst_pos1 = 7;
10158 dgst_pos2 = 2;
10159 dgst_pos3 = 6;
10160 break;
10161
10162 case 12700: hash_type = HASH_TYPE_AES;
10163 salt_type = SALT_TYPE_EMBEDDED;
10164 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10165 opts_type = OPTS_TYPE_PT_GENERATE_LE
10166 | OPTS_TYPE_HASH_COPY;
10167 kern_type = KERN_TYPE_MYWALLET;
10168 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10169 parse_func = mywallet_parse_hash;
10170 sort_by_digest = sort_by_digest_4_5;
10171 opti_type = OPTI_TYPE_ZERO_BYTE;
10172 dgst_pos0 = 0;
10173 dgst_pos1 = 1;
10174 dgst_pos2 = 2;
10175 dgst_pos3 = 3;
10176 break;
10177
10178 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10179 salt_type = SALT_TYPE_EMBEDDED;
10180 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10181 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10182 kern_type = KERN_TYPE_MS_DRSR;
10183 dgst_size = DGST_SIZE_4_8;
10184 parse_func = ms_drsr_parse_hash;
10185 sort_by_digest = sort_by_digest_4_8;
10186 opti_type = OPTI_TYPE_ZERO_BYTE;
10187 dgst_pos0 = 0;
10188 dgst_pos1 = 1;
10189 dgst_pos2 = 2;
10190 dgst_pos3 = 3;
10191 break;
10192
10193 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10194 salt_type = SALT_TYPE_EMBEDDED;
10195 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10196 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10197 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10198 dgst_size = DGST_SIZE_4_8;
10199 parse_func = androidfde_samsung_parse_hash;
10200 sort_by_digest = sort_by_digest_4_8;
10201 opti_type = OPTI_TYPE_ZERO_BYTE;
10202 dgst_pos0 = 0;
10203 dgst_pos1 = 1;
10204 dgst_pos2 = 2;
10205 dgst_pos3 = 3;
10206 break;
10207
10208 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10209 salt_type = SALT_TYPE_EMBEDDED;
10210 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10211 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10212 kern_type = KERN_TYPE_RAR5;
10213 dgst_size = DGST_SIZE_4_4;
10214 parse_func = rar5_parse_hash;
10215 sort_by_digest = sort_by_digest_4_4;
10216 opti_type = OPTI_TYPE_ZERO_BYTE;
10217 dgst_pos0 = 0;
10218 dgst_pos1 = 1;
10219 dgst_pos2 = 2;
10220 dgst_pos3 = 3;
10221 break;
10222
10223 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10224 salt_type = SALT_TYPE_EMBEDDED;
10225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10226 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10227 kern_type = KERN_TYPE_KRB5TGS;
10228 dgst_size = DGST_SIZE_4_4;
10229 parse_func = krb5tgs_parse_hash;
10230 sort_by_digest = sort_by_digest_4_4;
10231 opti_type = OPTI_TYPE_ZERO_BYTE
10232 | OPTI_TYPE_NOT_ITERATED;
10233 dgst_pos0 = 0;
10234 dgst_pos1 = 1;
10235 dgst_pos2 = 2;
10236 dgst_pos3 = 3;
10237 break;
10238
10239 case 13200: hash_type = HASH_TYPE_AES;
10240 salt_type = SALT_TYPE_EMBEDDED;
10241 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10242 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10243 kern_type = KERN_TYPE_AXCRYPT;
10244 dgst_size = DGST_SIZE_4_4;
10245 parse_func = axcrypt_parse_hash;
10246 sort_by_digest = sort_by_digest_4_4;
10247 opti_type = OPTI_TYPE_ZERO_BYTE;
10248 dgst_pos0 = 0;
10249 dgst_pos1 = 1;
10250 dgst_pos2 = 2;
10251 dgst_pos3 = 3;
10252 break;
10253
10254 case 13300: hash_type = HASH_TYPE_SHA1;
10255 salt_type = SALT_TYPE_NONE;
10256 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10257 opts_type = OPTS_TYPE_PT_GENERATE_BE
10258 | OPTS_TYPE_PT_ADD80
10259 | OPTS_TYPE_PT_ADDBITS15;
10260 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10261 dgst_size = DGST_SIZE_4_5;
10262 parse_func = sha1axcrypt_parse_hash;
10263 sort_by_digest = sort_by_digest_4_5;
10264 opti_type = OPTI_TYPE_ZERO_BYTE
10265 | OPTI_TYPE_PRECOMPUTE_INIT
10266 | OPTI_TYPE_EARLY_SKIP
10267 | OPTI_TYPE_NOT_ITERATED
10268 | OPTI_TYPE_NOT_SALTED;
10269 dgst_pos0 = 0;
10270 dgst_pos1 = 4;
10271 dgst_pos2 = 3;
10272 dgst_pos3 = 2;
10273 break;
10274
10275 case 13400: hash_type = HASH_TYPE_AES;
10276 salt_type = SALT_TYPE_EMBEDDED;
10277 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10278 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10279 kern_type = KERN_TYPE_KEEPASS;
10280 dgst_size = DGST_SIZE_4_4;
10281 parse_func = keepass_parse_hash;
10282 sort_by_digest = sort_by_digest_4_4;
10283 opti_type = OPTI_TYPE_ZERO_BYTE;
10284 dgst_pos0 = 0;
10285 dgst_pos1 = 1;
10286 dgst_pos2 = 2;
10287 dgst_pos3 = 3;
10288 break;
10289
10290 case 13500: hash_type = HASH_TYPE_SHA1;
10291 salt_type = SALT_TYPE_EMBEDDED;
10292 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10293 opts_type = OPTS_TYPE_PT_GENERATE_BE
10294 | OPTS_TYPE_PT_UNICODE
10295 | OPTS_TYPE_PT_ADD80;
10296 kern_type = KERN_TYPE_PSTOKEN;
10297 dgst_size = DGST_SIZE_4_5;
10298 parse_func = pstoken_parse_hash;
10299 sort_by_digest = sort_by_digest_4_5;
10300 opti_type = OPTI_TYPE_ZERO_BYTE
10301 | OPTI_TYPE_PRECOMPUTE_INIT
10302 | OPTI_TYPE_EARLY_SKIP
10303 | OPTI_TYPE_NOT_ITERATED
10304 | OPTI_TYPE_PREPENDED_SALT
10305 | OPTI_TYPE_RAW_HASH;
10306 dgst_pos0 = 3;
10307 dgst_pos1 = 4;
10308 dgst_pos2 = 2;
10309 dgst_pos3 = 1;
10310 break;
10311
10312 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10313 salt_type = SALT_TYPE_EMBEDDED;
10314 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10315 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10316 kern_type = KERN_TYPE_ZIP2;
10317 dgst_size = DGST_SIZE_4_4;
10318 parse_func = zip2_parse_hash;
10319 sort_by_digest = sort_by_digest_4_4;
10320 opti_type = OPTI_TYPE_ZERO_BYTE;
10321 dgst_pos0 = 0;
10322 dgst_pos1 = 1;
10323 dgst_pos2 = 2;
10324 dgst_pos3 = 3;
10325 break;
10326
10327 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10328 salt_type = SALT_TYPE_EMBEDDED;
10329 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10330 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10331 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10332 dgst_size = DGST_SIZE_4_5;
10333 parse_func = veracrypt_parse_hash_655331;
10334 sort_by_digest = sort_by_digest_4_5;
10335 opti_type = OPTI_TYPE_ZERO_BYTE;
10336 dgst_pos0 = 0;
10337 dgst_pos1 = 1;
10338 dgst_pos2 = 2;
10339 dgst_pos3 = 3;
10340 break;
10341
10342 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10343 salt_type = SALT_TYPE_EMBEDDED;
10344 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10345 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10346 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10347 dgst_size = DGST_SIZE_4_5;
10348 parse_func = veracrypt_parse_hash_655331;
10349 sort_by_digest = sort_by_digest_4_5;
10350 opti_type = OPTI_TYPE_ZERO_BYTE;
10351 dgst_pos0 = 0;
10352 dgst_pos1 = 1;
10353 dgst_pos2 = 2;
10354 dgst_pos3 = 3;
10355 break;
10356
10357 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10358 salt_type = SALT_TYPE_EMBEDDED;
10359 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10360 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10361 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10362 dgst_size = DGST_SIZE_4_5;
10363 parse_func = veracrypt_parse_hash_655331;
10364 sort_by_digest = sort_by_digest_4_5;
10365 opti_type = OPTI_TYPE_ZERO_BYTE;
10366 dgst_pos0 = 0;
10367 dgst_pos1 = 1;
10368 dgst_pos2 = 2;
10369 dgst_pos3 = 3;
10370 break;
10371
10372 case 13721: hash_type = HASH_TYPE_SHA512;
10373 salt_type = SALT_TYPE_EMBEDDED;
10374 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10375 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10376 kern_type = KERN_TYPE_TCSHA512_XTS512;
10377 dgst_size = DGST_SIZE_8_8;
10378 parse_func = veracrypt_parse_hash_500000;
10379 sort_by_digest = sort_by_digest_8_8;
10380 opti_type = OPTI_TYPE_ZERO_BYTE
10381 | OPTI_TYPE_USES_BITS_64;
10382 dgst_pos0 = 0;
10383 dgst_pos1 = 1;
10384 dgst_pos2 = 2;
10385 dgst_pos3 = 3;
10386 break;
10387
10388 case 13722: hash_type = HASH_TYPE_SHA512;
10389 salt_type = SALT_TYPE_EMBEDDED;
10390 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10391 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10392 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10393 dgst_size = DGST_SIZE_8_8;
10394 parse_func = veracrypt_parse_hash_500000;
10395 sort_by_digest = sort_by_digest_8_8;
10396 opti_type = OPTI_TYPE_ZERO_BYTE
10397 | OPTI_TYPE_USES_BITS_64;
10398 dgst_pos0 = 0;
10399 dgst_pos1 = 1;
10400 dgst_pos2 = 2;
10401 dgst_pos3 = 3;
10402 break;
10403
10404 case 13723: hash_type = HASH_TYPE_SHA512;
10405 salt_type = SALT_TYPE_EMBEDDED;
10406 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10407 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10408 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10409 dgst_size = DGST_SIZE_8_8;
10410 parse_func = veracrypt_parse_hash_500000;
10411 sort_by_digest = sort_by_digest_8_8;
10412 opti_type = OPTI_TYPE_ZERO_BYTE
10413 | OPTI_TYPE_USES_BITS_64;
10414 dgst_pos0 = 0;
10415 dgst_pos1 = 1;
10416 dgst_pos2 = 2;
10417 dgst_pos3 = 3;
10418 break;
10419
10420 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10421 salt_type = SALT_TYPE_EMBEDDED;
10422 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10423 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10424 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10425 dgst_size = DGST_SIZE_4_8;
10426 parse_func = veracrypt_parse_hash_500000;
10427 sort_by_digest = sort_by_digest_4_8;
10428 opti_type = OPTI_TYPE_ZERO_BYTE;
10429 dgst_pos0 = 0;
10430 dgst_pos1 = 1;
10431 dgst_pos2 = 2;
10432 dgst_pos3 = 3;
10433 break;
10434
10435 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10436 salt_type = SALT_TYPE_EMBEDDED;
10437 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10438 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10439 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10440 dgst_size = DGST_SIZE_4_8;
10441 parse_func = veracrypt_parse_hash_500000;
10442 sort_by_digest = sort_by_digest_4_8;
10443 opti_type = OPTI_TYPE_ZERO_BYTE;
10444 dgst_pos0 = 0;
10445 dgst_pos1 = 1;
10446 dgst_pos2 = 2;
10447 dgst_pos3 = 3;
10448 break;
10449
10450 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10451 salt_type = SALT_TYPE_EMBEDDED;
10452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10453 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10454 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10455 dgst_size = DGST_SIZE_4_8;
10456 parse_func = veracrypt_parse_hash_500000;
10457 sort_by_digest = sort_by_digest_4_8;
10458 opti_type = OPTI_TYPE_ZERO_BYTE;
10459 dgst_pos0 = 0;
10460 dgst_pos1 = 1;
10461 dgst_pos2 = 2;
10462 dgst_pos3 = 3;
10463 break;
10464
10465 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10466 salt_type = SALT_TYPE_EMBEDDED;
10467 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10468 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10469 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10470 dgst_size = DGST_SIZE_4_5;
10471 parse_func = veracrypt_parse_hash_327661;
10472 sort_by_digest = sort_by_digest_4_5;
10473 opti_type = OPTI_TYPE_ZERO_BYTE;
10474 dgst_pos0 = 0;
10475 dgst_pos1 = 1;
10476 dgst_pos2 = 2;
10477 dgst_pos3 = 3;
10478 break;
10479
10480 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10481 salt_type = SALT_TYPE_EMBEDDED;
10482 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10483 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10484 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10485 dgst_size = DGST_SIZE_4_5;
10486 parse_func = veracrypt_parse_hash_327661;
10487 sort_by_digest = sort_by_digest_4_5;
10488 opti_type = OPTI_TYPE_ZERO_BYTE;
10489 dgst_pos0 = 0;
10490 dgst_pos1 = 1;
10491 dgst_pos2 = 2;
10492 dgst_pos3 = 3;
10493 break;
10494
10495 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10496 salt_type = SALT_TYPE_EMBEDDED;
10497 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10498 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10499 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10500 dgst_size = DGST_SIZE_4_5;
10501 parse_func = veracrypt_parse_hash_327661;
10502 sort_by_digest = sort_by_digest_4_5;
10503 opti_type = OPTI_TYPE_ZERO_BYTE;
10504 dgst_pos0 = 0;
10505 dgst_pos1 = 1;
10506 dgst_pos2 = 2;
10507 dgst_pos3 = 3;
10508 break;
10509
10510 case 13751: hash_type = HASH_TYPE_SHA256;
10511 salt_type = SALT_TYPE_EMBEDDED;
10512 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10513 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10514 kern_type = KERN_TYPE_VCSHA256_XTS512;
10515 dgst_size = DGST_SIZE_4_8;
10516 parse_func = veracrypt_parse_hash_500000;
10517 sort_by_digest = sort_by_digest_4_8;
10518 opti_type = OPTI_TYPE_ZERO_BYTE;
10519 dgst_pos0 = 0;
10520 dgst_pos1 = 1;
10521 dgst_pos2 = 2;
10522 dgst_pos3 = 3;
10523 break;
10524
10525 case 13752: hash_type = HASH_TYPE_SHA256;
10526 salt_type = SALT_TYPE_EMBEDDED;
10527 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10528 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10529 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10530 dgst_size = DGST_SIZE_4_8;
10531 parse_func = veracrypt_parse_hash_500000;
10532 sort_by_digest = sort_by_digest_4_8;
10533 opti_type = OPTI_TYPE_ZERO_BYTE;
10534 dgst_pos0 = 0;
10535 dgst_pos1 = 1;
10536 dgst_pos2 = 2;
10537 dgst_pos3 = 3;
10538 break;
10539
10540 case 13753: hash_type = HASH_TYPE_SHA256;
10541 salt_type = SALT_TYPE_EMBEDDED;
10542 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10543 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10544 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10545 dgst_size = DGST_SIZE_4_8;
10546 parse_func = veracrypt_parse_hash_500000;
10547 sort_by_digest = sort_by_digest_4_8;
10548 opti_type = OPTI_TYPE_ZERO_BYTE;
10549 dgst_pos0 = 0;
10550 dgst_pos1 = 1;
10551 dgst_pos2 = 2;
10552 dgst_pos3 = 3;
10553 break;
10554
10555 case 13761: hash_type = HASH_TYPE_SHA256;
10556 salt_type = SALT_TYPE_EMBEDDED;
10557 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10558 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10559 kern_type = KERN_TYPE_VCSHA256_XTS512;
10560 dgst_size = DGST_SIZE_4_8;
10561 parse_func = veracrypt_parse_hash_200000;
10562 sort_by_digest = sort_by_digest_4_8;
10563 opti_type = OPTI_TYPE_ZERO_BYTE;
10564 dgst_pos0 = 0;
10565 dgst_pos1 = 1;
10566 dgst_pos2 = 2;
10567 dgst_pos3 = 3;
10568 break;
10569
10570 case 13762: hash_type = HASH_TYPE_SHA256;
10571 salt_type = SALT_TYPE_EMBEDDED;
10572 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10573 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10574 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10575 dgst_size = DGST_SIZE_4_8;
10576 parse_func = veracrypt_parse_hash_200000;
10577 sort_by_digest = sort_by_digest_4_8;
10578 opti_type = OPTI_TYPE_ZERO_BYTE;
10579 dgst_pos0 = 0;
10580 dgst_pos1 = 1;
10581 dgst_pos2 = 2;
10582 dgst_pos3 = 3;
10583 break;
10584
10585 case 13763: hash_type = HASH_TYPE_SHA256;
10586 salt_type = SALT_TYPE_EMBEDDED;
10587 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10588 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10589 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10590 dgst_size = DGST_SIZE_4_8;
10591 parse_func = veracrypt_parse_hash_200000;
10592 sort_by_digest = sort_by_digest_4_8;
10593 opti_type = OPTI_TYPE_ZERO_BYTE;
10594 dgst_pos0 = 0;
10595 dgst_pos1 = 1;
10596 dgst_pos2 = 2;
10597 dgst_pos3 = 3;
10598 break;
10599
10600
10601 default: usage_mini_print (PROGNAME); return (-1);
10602 }
10603
10604 /**
10605 * parser
10606 */
10607
10608 data.parse_func = parse_func;
10609
10610 /**
10611 * misc stuff
10612 */
10613
10614 if (hex_salt)
10615 {
10616 if (salt_type == SALT_TYPE_INTERN)
10617 {
10618 opts_type |= OPTS_TYPE_ST_HEX;
10619 }
10620 else
10621 {
10622 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10623
10624 return (-1);
10625 }
10626 }
10627
10628 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10629 | (salt_type == SALT_TYPE_EXTERN)
10630 | (salt_type == SALT_TYPE_EMBEDDED)
10631 | (salt_type == SALT_TYPE_VIRTUAL));
10632
10633 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10634
10635 data.hash_type = hash_type;
10636 data.attack_mode = attack_mode;
10637 data.attack_kern = attack_kern;
10638 data.attack_exec = attack_exec;
10639 data.kern_type = kern_type;
10640 data.opts_type = opts_type;
10641 data.dgst_size = dgst_size;
10642 data.salt_type = salt_type;
10643 data.isSalted = isSalted;
10644 data.sort_by_digest = sort_by_digest;
10645 data.dgst_pos0 = dgst_pos0;
10646 data.dgst_pos1 = dgst_pos1;
10647 data.dgst_pos2 = dgst_pos2;
10648 data.dgst_pos3 = dgst_pos3;
10649
10650 esalt_size = 0;
10651
10652 switch (hash_mode)
10653 {
10654 case 2500: esalt_size = sizeof (wpa_t); break;
10655 case 5300: esalt_size = sizeof (ikepsk_t); break;
10656 case 5400: esalt_size = sizeof (ikepsk_t); break;
10657 case 5500: esalt_size = sizeof (netntlm_t); break;
10658 case 5600: esalt_size = sizeof (netntlm_t); break;
10659 case 6211: esalt_size = sizeof (tc_t); break;
10660 case 6212: esalt_size = sizeof (tc_t); break;
10661 case 6213: esalt_size = sizeof (tc_t); break;
10662 case 6221: esalt_size = sizeof (tc_t); break;
10663 case 6222: esalt_size = sizeof (tc_t); break;
10664 case 6223: esalt_size = sizeof (tc_t); break;
10665 case 6231: esalt_size = sizeof (tc_t); break;
10666 case 6232: esalt_size = sizeof (tc_t); break;
10667 case 6233: esalt_size = sizeof (tc_t); break;
10668 case 6241: esalt_size = sizeof (tc_t); break;
10669 case 6242: esalt_size = sizeof (tc_t); break;
10670 case 6243: esalt_size = sizeof (tc_t); break;
10671 case 6600: esalt_size = sizeof (agilekey_t); break;
10672 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10673 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10674 case 7300: esalt_size = sizeof (rakp_t); break;
10675 case 7500: esalt_size = sizeof (krb5pa_t); break;
10676 case 8200: esalt_size = sizeof (cloudkey_t); break;
10677 case 8800: esalt_size = sizeof (androidfde_t); break;
10678 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10679 case 9400: esalt_size = sizeof (office2007_t); break;
10680 case 9500: esalt_size = sizeof (office2010_t); break;
10681 case 9600: esalt_size = sizeof (office2013_t); break;
10682 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10683 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10684 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10685 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10686 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10687 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10688 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10689 case 10200: esalt_size = sizeof (cram_md5_t); break;
10690 case 10400: esalt_size = sizeof (pdf_t); break;
10691 case 10410: esalt_size = sizeof (pdf_t); break;
10692 case 10420: esalt_size = sizeof (pdf_t); break;
10693 case 10500: esalt_size = sizeof (pdf_t); break;
10694 case 10600: esalt_size = sizeof (pdf_t); break;
10695 case 10700: esalt_size = sizeof (pdf_t); break;
10696 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10697 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10698 case 11400: esalt_size = sizeof (sip_t); break;
10699 case 11600: esalt_size = sizeof (seven_zip_t); break;
10700 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10701 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10702 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10703 case 13000: esalt_size = sizeof (rar5_t); break;
10704 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10705 case 13400: esalt_size = sizeof (keepass_t); break;
10706 case 13500: esalt_size = sizeof (pstoken_t); break;
10707 case 13600: esalt_size = sizeof (zip2_t); break;
10708 case 13711: esalt_size = sizeof (tc_t); break;
10709 case 13712: esalt_size = sizeof (tc_t); break;
10710 case 13713: esalt_size = sizeof (tc_t); break;
10711 case 13721: esalt_size = sizeof (tc_t); break;
10712 case 13722: esalt_size = sizeof (tc_t); break;
10713 case 13723: esalt_size = sizeof (tc_t); break;
10714 case 13731: esalt_size = sizeof (tc_t); break;
10715 case 13732: esalt_size = sizeof (tc_t); break;
10716 case 13733: esalt_size = sizeof (tc_t); break;
10717 case 13741: esalt_size = sizeof (tc_t); break;
10718 case 13742: esalt_size = sizeof (tc_t); break;
10719 case 13743: esalt_size = sizeof (tc_t); break;
10720 case 13751: esalt_size = sizeof (tc_t); break;
10721 case 13752: esalt_size = sizeof (tc_t); break;
10722 case 13753: esalt_size = sizeof (tc_t); break;
10723 case 13761: esalt_size = sizeof (tc_t); break;
10724 case 13762: esalt_size = sizeof (tc_t); break;
10725 case 13763: esalt_size = sizeof (tc_t); break;
10726 }
10727
10728 data.esalt_size = esalt_size;
10729
10730 /**
10731 * choose dictionary parser
10732 */
10733
10734 if (hash_type == HASH_TYPE_LM)
10735 {
10736 get_next_word_func = get_next_word_lm;
10737 }
10738 else if (opts_type & OPTS_TYPE_PT_UPPER)
10739 {
10740 get_next_word_func = get_next_word_uc;
10741 }
10742 else
10743 {
10744 get_next_word_func = get_next_word_std;
10745 }
10746
10747 /**
10748 * dictstat
10749 */
10750
10751 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10752
10753 #ifdef _POSIX
10754 size_t dictstat_nmemb = 0;
10755 #endif
10756
10757 #ifdef _WIN
10758 uint dictstat_nmemb = 0;
10759 #endif
10760
10761 char dictstat[256] = { 0 };
10762
10763 FILE *dictstat_fp = NULL;
10764
10765 if (keyspace == 0)
10766 {
10767 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10768
10769 dictstat_fp = fopen (dictstat, "rb");
10770
10771 if (dictstat_fp)
10772 {
10773 #ifdef _POSIX
10774 struct stat tmpstat;
10775
10776 fstat (fileno (dictstat_fp), &tmpstat);
10777 #endif
10778
10779 #ifdef _WIN
10780 struct stat64 tmpstat;
10781
10782 _fstat64 (fileno (dictstat_fp), &tmpstat);
10783 #endif
10784
10785 if (tmpstat.st_mtime < COMPTIME)
10786 {
10787 /* with v0.15 the format changed so we have to ensure user is using a good version
10788 since there is no version-header in the dictstat file */
10789
10790 fclose (dictstat_fp);
10791
10792 unlink (dictstat);
10793 }
10794 else
10795 {
10796 while (!feof (dictstat_fp))
10797 {
10798 dictstat_t d;
10799
10800 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
10801
10802 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
10803
10804 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
10805 {
10806 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
10807
10808 return -1;
10809 }
10810 }
10811
10812 fclose (dictstat_fp);
10813 }
10814 }
10815 }
10816
10817 /**
10818 * potfile
10819 */
10820
10821 char potfile[256] = { 0 };
10822
10823 if (potfile_path == NULL)
10824 {
10825 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
10826 }
10827 else
10828 {
10829 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
10830 }
10831
10832 data.pot_fp = NULL;
10833
10834 FILE *out_fp = NULL;
10835 FILE *pot_fp = NULL;
10836
10837 if (show == 1 || left == 1)
10838 {
10839 pot_fp = fopen (potfile, "rb");
10840
10841 if (pot_fp == NULL)
10842 {
10843 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10844
10845 return (-1);
10846 }
10847
10848 if (outfile != NULL)
10849 {
10850 if ((out_fp = fopen (outfile, "ab")) == NULL)
10851 {
10852 log_error ("ERROR: %s: %s", outfile, strerror (errno));
10853
10854 fclose (pot_fp);
10855
10856 return (-1);
10857 }
10858 }
10859 else
10860 {
10861 out_fp = stdout;
10862 }
10863 }
10864 else
10865 {
10866 if (potfile_disable == 0)
10867 {
10868 pot_fp = fopen (potfile, "ab");
10869
10870 if (pot_fp == NULL)
10871 {
10872 log_error ("ERROR: %s: %s", potfile, strerror (errno));
10873
10874 return (-1);
10875 }
10876
10877 data.pot_fp = pot_fp;
10878 }
10879 }
10880
10881 pot_t *pot = NULL;
10882
10883 uint pot_cnt = 0;
10884 uint pot_avail = 0;
10885
10886 if (show == 1 || left == 1)
10887 {
10888 SUPPRESS_OUTPUT = 1;
10889
10890 pot_avail = count_lines (pot_fp);
10891
10892 rewind (pot_fp);
10893
10894 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
10895
10896 uint pot_hashes_avail = 0;
10897
10898 uint line_num = 0;
10899
10900 char *line_buf = (char *) mymalloc (HCBUFSIZ);
10901
10902 while (!feof (pot_fp))
10903 {
10904 line_num++;
10905
10906 int line_len = fgetl (pot_fp, line_buf);
10907
10908 if (line_len == 0) continue;
10909
10910 char *plain_buf = line_buf + line_len;
10911
10912 pot_t *pot_ptr = &pot[pot_cnt];
10913
10914 hash_t *hashes_buf = &pot_ptr->hash;
10915
10916 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
10917 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
10918
10919 if (pot_cnt == pot_hashes_avail)
10920 {
10921 uint pos = 0;
10922
10923 for (pos = 0; pos < INCR_POT; pos++)
10924 {
10925 if ((pot_cnt + pos) >= pot_avail) break;
10926
10927 pot_t *tmp_pot = &pot[pot_cnt + pos];
10928
10929 hash_t *tmp_hash = &tmp_pot->hash;
10930
10931 tmp_hash->digest = mymalloc (dgst_size);
10932
10933 if (isSalted)
10934 {
10935 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
10936 }
10937
10938 if (esalt_size)
10939 {
10940 tmp_hash->esalt = mymalloc (esalt_size);
10941 }
10942
10943 pot_hashes_avail++;
10944 }
10945 }
10946
10947 int plain_len = 0;
10948
10949 int parser_status;
10950
10951 int iter = MAX_CUT_TRIES;
10952
10953 do
10954 {
10955 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
10956 {
10957 if (line_buf[i] == ':')
10958 {
10959 line_len--;
10960
10961 break;
10962 }
10963 }
10964
10965 if (data.hash_mode != 2500)
10966 {
10967 parser_status = parse_func (line_buf, line_len, hashes_buf);
10968 }
10969 else
10970 {
10971 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
10972
10973 if (line_len > max_salt_size)
10974 {
10975 parser_status = PARSER_GLOBAL_LENGTH;
10976 }
10977 else
10978 {
10979 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
10980
10981 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
10982
10983 hashes_buf->salt->salt_len = line_len;
10984
10985 parser_status = PARSER_OK;
10986 }
10987 }
10988
10989 // if NOT parsed without error, we add the ":" to the plain
10990
10991 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
10992 {
10993 plain_len++;
10994 plain_buf--;
10995 }
10996
10997 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
10998
10999 if (parser_status < PARSER_GLOBAL_ZERO)
11000 {
11001 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11002
11003 continue;
11004 }
11005
11006 if (plain_len >= 255) continue;
11007
11008 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11009
11010 pot_ptr->plain_len = plain_len;
11011
11012 pot_cnt++;
11013 }
11014
11015 myfree (line_buf);
11016
11017 fclose (pot_fp);
11018
11019 SUPPRESS_OUTPUT = 0;
11020
11021 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11022 }
11023
11024 /**
11025 * word len
11026 */
11027
11028 uint pw_min = PW_MIN;
11029 uint pw_max = PW_MAX;
11030
11031 switch (hash_mode)
11032 {
11033 case 125: if (pw_max > 32) pw_max = 32;
11034 break;
11035 case 400: if (pw_max > 40) pw_max = 40;
11036 break;
11037 case 500: if (pw_max > 16) pw_max = 16;
11038 break;
11039 case 1500: if (pw_max > 8) pw_max = 8;
11040 break;
11041 case 1600: if (pw_max > 16) pw_max = 16;
11042 break;
11043 case 1800: if (pw_max > 16) pw_max = 16;
11044 break;
11045 case 2100: if (pw_max > 16) pw_max = 16;
11046 break;
11047 case 2500: if (pw_min < 8) pw_min = 8;
11048 break;
11049 case 3000: if (pw_max > 7) pw_max = 7;
11050 break;
11051 case 5200: if (pw_max > 24) pw_max = 24;
11052 break;
11053 case 5800: if (pw_max > 16) pw_max = 16;
11054 break;
11055 case 6300: if (pw_max > 16) pw_max = 16;
11056 break;
11057 case 7400: if (pw_max > 16) pw_max = 16;
11058 break;
11059 case 7900: if (pw_max > 48) pw_max = 48;
11060 break;
11061 case 8500: if (pw_max > 8) pw_max = 8;
11062 break;
11063 case 8600: if (pw_max > 16) pw_max = 16;
11064 break;
11065 case 9710: pw_min = 5;
11066 pw_max = 5;
11067 break;
11068 case 9810: pw_min = 5;
11069 pw_max = 5;
11070 break;
11071 case 10410: pw_min = 5;
11072 pw_max = 5;
11073 break;
11074 case 10300: if (pw_max < 3) pw_min = 3;
11075 if (pw_max > 40) pw_max = 40;
11076 break;
11077 case 10500: if (pw_max < 3) pw_min = 3;
11078 if (pw_max > 40) pw_max = 40;
11079 break;
11080 case 10700: if (pw_max > 16) pw_max = 16;
11081 break;
11082 case 11300: if (pw_max > 40) pw_max = 40;
11083 break;
11084 case 11600: if (pw_max > 32) pw_max = 32;
11085 break;
11086 case 12500: if (pw_max > 20) pw_max = 20;
11087 break;
11088 case 12800: if (pw_max > 24) pw_max = 24;
11089 break;
11090 }
11091
11092 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11093 {
11094 switch (attack_kern)
11095 {
11096 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11097 break;
11098 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11099 break;
11100 }
11101 }
11102
11103 /**
11104 * charsets : keep them together for more easy maintainnce
11105 */
11106
11107 cs_t mp_sys[6] = { { { 0 }, 0 } };
11108 cs_t mp_usr[4] = { { { 0 }, 0 } };
11109
11110 mp_setup_sys (mp_sys);
11111
11112 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11113 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11114 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11115 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11116
11117 /**
11118 * load hashes, part I: find input mode, count hashes
11119 */
11120
11121 uint hashlist_mode = 0;
11122 uint hashlist_format = HLFMT_HASHCAT;
11123
11124 uint hashes_avail = 0;
11125
11126 if (benchmark == 0)
11127 {
11128 struct stat f;
11129
11130 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11131
11132 if ((hash_mode == 2500) ||
11133 (hash_mode == 5200) ||
11134 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11135 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11136 (hash_mode == 9000))
11137 {
11138 hashlist_mode = HL_MODE_ARG;
11139
11140 char *hashfile = myargv[optind];
11141
11142 data.hashfile = hashfile;
11143
11144 logfile_top_var_string ("target", hashfile);
11145 }
11146
11147 if (hashlist_mode == HL_MODE_ARG)
11148 {
11149 if (hash_mode == 2500)
11150 {
11151 struct stat st;
11152
11153 if (stat (data.hashfile, &st) == -1)
11154 {
11155 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11156
11157 return (-1);
11158 }
11159
11160 hashes_avail = st.st_size / sizeof (hccap_t);
11161 }
11162 else
11163 {
11164 hashes_avail = 1;
11165 }
11166 }
11167 else if (hashlist_mode == HL_MODE_FILE)
11168 {
11169 char *hashfile = myargv[optind];
11170
11171 data.hashfile = hashfile;
11172
11173 logfile_top_var_string ("target", hashfile);
11174
11175 FILE *fp = NULL;
11176
11177 if ((fp = fopen (hashfile, "rb")) == NULL)
11178 {
11179 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11180
11181 return (-1);
11182 }
11183
11184 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11185
11186 hashes_avail = count_lines (fp);
11187
11188 rewind (fp);
11189
11190 if (hashes_avail == 0)
11191 {
11192 log_error ("ERROR: hashfile is empty or corrupt");
11193
11194 fclose (fp);
11195
11196 return (-1);
11197 }
11198
11199 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11200
11201 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11202 {
11203 log_error ("ERROR: remove not supported in native hashfile-format mode");
11204
11205 fclose (fp);
11206
11207 return (-1);
11208 }
11209
11210 fclose (fp);
11211 }
11212 }
11213 else
11214 {
11215 hashlist_mode = HL_MODE_ARG;
11216
11217 hashes_avail = 1;
11218 }
11219
11220 if (hash_mode == 3000) hashes_avail *= 2;
11221
11222 data.hashlist_mode = hashlist_mode;
11223 data.hashlist_format = hashlist_format;
11224
11225 logfile_top_uint (hashlist_mode);
11226 logfile_top_uint (hashlist_format);
11227
11228 /**
11229 * load hashes, part II: allocate required memory, set pointers
11230 */
11231
11232 hash_t *hashes_buf = NULL;
11233 void *digests_buf = NULL;
11234 salt_t *salts_buf = NULL;
11235 void *esalts_buf = NULL;
11236
11237 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11238
11239 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11240
11241 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11242 {
11243 u32 hash_pos;
11244
11245 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11246 {
11247 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11248
11249 hashes_buf[hash_pos].hash_info = hash_info;
11250
11251 if (username && (remove || show || left))
11252 {
11253 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11254 }
11255
11256 if (benchmark)
11257 {
11258 hash_info->orighash = (char *) mymalloc (256);
11259 }
11260 }
11261 }
11262
11263 if (isSalted)
11264 {
11265 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11266
11267 if (esalt_size)
11268 {
11269 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11270 }
11271 }
11272 else
11273 {
11274 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11275 }
11276
11277 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11278 {
11279 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11280
11281 if (isSalted)
11282 {
11283 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11284
11285 if (esalt_size)
11286 {
11287 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11288 }
11289 }
11290 else
11291 {
11292 hashes_buf[hash_pos].salt = &salts_buf[0];
11293 }
11294 }
11295
11296 /**
11297 * load hashes, part III: parse hashes or generate them if benchmark
11298 */
11299
11300 uint hashes_cnt = 0;
11301
11302 if (benchmark == 0)
11303 {
11304 if (keyspace == 1)
11305 {
11306 // useless to read hash file for keyspace, cheat a little bit w/ optind
11307 }
11308 else if (hashes_avail == 0)
11309 {
11310 }
11311 else if (hashlist_mode == HL_MODE_ARG)
11312 {
11313 char *input_buf = myargv[optind];
11314
11315 uint input_len = strlen (input_buf);
11316
11317 logfile_top_var_string ("target", input_buf);
11318
11319 char *hash_buf = NULL;
11320 int hash_len = 0;
11321
11322 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11323
11324 bool hash_fmt_error = 0;
11325
11326 if (hash_len < 1) hash_fmt_error = 1;
11327 if (hash_buf == NULL) hash_fmt_error = 1;
11328
11329 if (hash_fmt_error)
11330 {
11331 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11332 }
11333 else
11334 {
11335 if (opts_type & OPTS_TYPE_HASH_COPY)
11336 {
11337 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11338
11339 hash_info_tmp->orighash = mystrdup (hash_buf);
11340 }
11341
11342 if (isSalted)
11343 {
11344 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11345 }
11346
11347 int parser_status = PARSER_OK;
11348
11349 if (hash_mode == 2500)
11350 {
11351 if (hash_len == 0)
11352 {
11353 log_error ("ERROR: hccap file not specified");
11354
11355 return (-1);
11356 }
11357
11358 hashlist_mode = HL_MODE_FILE;
11359
11360 data.hashlist_mode = hashlist_mode;
11361
11362 FILE *fp = fopen (hash_buf, "rb");
11363
11364 if (fp == NULL)
11365 {
11366 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11367
11368 return (-1);
11369 }
11370
11371 if (hashes_avail < 1)
11372 {
11373 log_error ("ERROR: hccap file is empty or corrupt");
11374
11375 fclose (fp);
11376
11377 return (-1);
11378 }
11379
11380 uint hccap_size = sizeof (hccap_t);
11381
11382 char *in = (char *) mymalloc (hccap_size);
11383
11384 while (!feof (fp))
11385 {
11386 int n = fread (in, hccap_size, 1, fp);
11387
11388 if (n != 1)
11389 {
11390 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11391
11392 break;
11393 }
11394
11395 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11396
11397 if (parser_status != PARSER_OK)
11398 {
11399 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11400
11401 continue;
11402 }
11403
11404 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11405
11406 if ((show == 1) || (left == 1))
11407 {
11408 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11409
11410 char *salt_ptr = (char *) tmp_salt->salt_buf;
11411
11412 int cur_pos = tmp_salt->salt_len;
11413 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11414
11415 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11416
11417 // do the appending task
11418
11419 snprintf (salt_ptr + cur_pos,
11420 rem_len,
11421 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11422 wpa->orig_mac1[0],
11423 wpa->orig_mac1[1],
11424 wpa->orig_mac1[2],
11425 wpa->orig_mac1[3],
11426 wpa->orig_mac1[4],
11427 wpa->orig_mac1[5],
11428 wpa->orig_mac2[0],
11429 wpa->orig_mac2[1],
11430 wpa->orig_mac2[2],
11431 wpa->orig_mac2[3],
11432 wpa->orig_mac2[4],
11433 wpa->orig_mac2[5]);
11434
11435 // memset () the remaining part of the salt
11436
11437 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11438 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11439
11440 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11441
11442 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11443 }
11444
11445 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);
11446 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);
11447
11448 hashes_cnt++;
11449 }
11450
11451 fclose (fp);
11452
11453 myfree (in);
11454 }
11455 else if (hash_mode == 3000)
11456 {
11457 if (hash_len == 32)
11458 {
11459 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11460
11461 hash_t *lm_hash_left = NULL;
11462
11463 if (parser_status == PARSER_OK)
11464 {
11465 lm_hash_left = &hashes_buf[hashes_cnt];
11466
11467 hashes_cnt++;
11468 }
11469 else
11470 {
11471 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11472 }
11473
11474 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11475
11476 hash_t *lm_hash_right = NULL;
11477
11478 if (parser_status == PARSER_OK)
11479 {
11480 lm_hash_right = &hashes_buf[hashes_cnt];
11481
11482 hashes_cnt++;
11483 }
11484 else
11485 {
11486 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11487 }
11488
11489 // show / left
11490
11491 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11492 {
11493 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);
11494 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);
11495 }
11496 }
11497 else
11498 {
11499 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11500
11501 if (parser_status == PARSER_OK)
11502 {
11503 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11504 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11505 }
11506
11507 if (parser_status == PARSER_OK)
11508 {
11509 hashes_cnt++;
11510 }
11511 else
11512 {
11513 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11514 }
11515 }
11516 }
11517 else
11518 {
11519 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11520
11521 if (parser_status == PARSER_OK)
11522 {
11523 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11524 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11525 }
11526
11527 if (parser_status == PARSER_OK)
11528 {
11529 hashes_cnt++;
11530 }
11531 else
11532 {
11533 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11534 }
11535 }
11536 }
11537 }
11538 else if (hashlist_mode == HL_MODE_FILE)
11539 {
11540 char *hashfile = data.hashfile;
11541
11542 FILE *fp;
11543
11544 if ((fp = fopen (hashfile, "rb")) == NULL)
11545 {
11546 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11547
11548 return (-1);
11549 }
11550
11551 uint line_num = 0;
11552
11553 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11554
11555 while (!feof (fp))
11556 {
11557 line_num++;
11558
11559 int line_len = fgetl (fp, line_buf);
11560
11561 if (line_len == 0) continue;
11562
11563 char *hash_buf = NULL;
11564 int hash_len = 0;
11565
11566 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11567
11568 bool hash_fmt_error = 0;
11569
11570 if (hash_len < 1) hash_fmt_error = 1;
11571 if (hash_buf == NULL) hash_fmt_error = 1;
11572
11573 if (hash_fmt_error)
11574 {
11575 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11576
11577 continue;
11578 }
11579
11580 if (username)
11581 {
11582 char *user_buf = NULL;
11583 int user_len = 0;
11584
11585 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11586
11587 if (remove || show)
11588 {
11589 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11590
11591 *user = (user_t *) mymalloc (sizeof (user_t));
11592
11593 user_t *user_ptr = *user;
11594
11595 if (user_buf != NULL)
11596 {
11597 user_ptr->user_name = mystrdup (user_buf);
11598 }
11599 else
11600 {
11601 user_ptr->user_name = mystrdup ("");
11602 }
11603
11604 user_ptr->user_len = user_len;
11605 }
11606 }
11607
11608 if (opts_type & OPTS_TYPE_HASH_COPY)
11609 {
11610 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11611
11612 hash_info_tmp->orighash = mystrdup (hash_buf);
11613 }
11614
11615 if (isSalted)
11616 {
11617 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11618 }
11619
11620 if (hash_mode == 3000)
11621 {
11622 if (hash_len == 32)
11623 {
11624 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11625
11626 if (parser_status < PARSER_GLOBAL_ZERO)
11627 {
11628 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11629
11630 continue;
11631 }
11632
11633 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11634
11635 hashes_cnt++;
11636
11637 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11638
11639 if (parser_status < PARSER_GLOBAL_ZERO)
11640 {
11641 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11642
11643 continue;
11644 }
11645
11646 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11647
11648 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);
11649
11650 hashes_cnt++;
11651
11652 // show / left
11653
11654 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);
11655 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);
11656 }
11657 else
11658 {
11659 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11660
11661 if (parser_status < PARSER_GLOBAL_ZERO)
11662 {
11663 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11664
11665 continue;
11666 }
11667
11668 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);
11669
11670 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11671 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11672
11673 hashes_cnt++;
11674 }
11675 }
11676 else
11677 {
11678 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11679
11680 if (parser_status < PARSER_GLOBAL_ZERO)
11681 {
11682 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11683
11684 continue;
11685 }
11686
11687 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);
11688
11689 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11690 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11691
11692 hashes_cnt++;
11693 }
11694 }
11695
11696 myfree (line_buf);
11697
11698 fclose (fp);
11699
11700 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11701
11702 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11703 }
11704 }
11705 else
11706 {
11707 if (isSalted)
11708 {
11709 hashes_buf[0].salt->salt_len = 8;
11710
11711 // special salt handling
11712
11713 switch (hash_mode)
11714 {
11715 case 1500: hashes_buf[0].salt->salt_len = 2;
11716 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11717 break;
11718 case 1731: hashes_buf[0].salt->salt_len = 4;
11719 break;
11720 case 2410: hashes_buf[0].salt->salt_len = 4;
11721 break;
11722 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11723 break;
11724 case 3100: hashes_buf[0].salt->salt_len = 1;
11725 break;
11726 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11727 break;
11728 case 5800: hashes_buf[0].salt->salt_len = 16;
11729 break;
11730 case 6800: hashes_buf[0].salt->salt_len = 32;
11731 break;
11732 case 8400: hashes_buf[0].salt->salt_len = 40;
11733 break;
11734 case 8800: hashes_buf[0].salt->salt_len = 16;
11735 break;
11736 case 8900: hashes_buf[0].salt->salt_len = 16;
11737 hashes_buf[0].salt->scrypt_N = 1024;
11738 hashes_buf[0].salt->scrypt_r = 1;
11739 hashes_buf[0].salt->scrypt_p = 1;
11740 break;
11741 case 9100: hashes_buf[0].salt->salt_len = 16;
11742 break;
11743 case 9300: hashes_buf[0].salt->salt_len = 14;
11744 hashes_buf[0].salt->scrypt_N = 16384;
11745 hashes_buf[0].salt->scrypt_r = 1;
11746 hashes_buf[0].salt->scrypt_p = 1;
11747 break;
11748 case 9400: hashes_buf[0].salt->salt_len = 16;
11749 break;
11750 case 9500: hashes_buf[0].salt->salt_len = 16;
11751 break;
11752 case 9600: hashes_buf[0].salt->salt_len = 16;
11753 break;
11754 case 9700: hashes_buf[0].salt->salt_len = 16;
11755 break;
11756 case 9710: hashes_buf[0].salt->salt_len = 16;
11757 break;
11758 case 9720: hashes_buf[0].salt->salt_len = 16;
11759 break;
11760 case 9800: hashes_buf[0].salt->salt_len = 16;
11761 break;
11762 case 9810: hashes_buf[0].salt->salt_len = 16;
11763 break;
11764 case 9820: hashes_buf[0].salt->salt_len = 16;
11765 break;
11766 case 10300: hashes_buf[0].salt->salt_len = 12;
11767 break;
11768 case 11500: hashes_buf[0].salt->salt_len = 4;
11769 break;
11770 case 11600: hashes_buf[0].salt->salt_len = 4;
11771 break;
11772 case 12400: hashes_buf[0].salt->salt_len = 4;
11773 break;
11774 case 12500: hashes_buf[0].salt->salt_len = 8;
11775 break;
11776 case 12600: hashes_buf[0].salt->salt_len = 64;
11777 break;
11778 }
11779
11780 // special esalt handling
11781
11782 switch (hash_mode)
11783 {
11784 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
11785 break;
11786 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11787 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11788 break;
11789 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
11790 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
11791 break;
11792 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11793 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11794 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11795 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11796 break;
11797 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
11798 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
11799 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
11800 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
11801 break;
11802 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
11803 break;
11804 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11805 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11806 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11807 break;
11808 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11809 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11810 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11811 break;
11812 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11813 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11814 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11815 break;
11816 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11817 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
11818 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
11819 break;
11820 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11821 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11822 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11823 break;
11824 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
11825 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
11826 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
11827 break;
11828 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
11829 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
11830 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
11831 break;
11832 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
11833 break;
11834 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
11835 break;
11836 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
11837 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
11838 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
11839 break;
11840 }
11841 }
11842
11843 // set hashfile
11844
11845 switch (hash_mode)
11846 {
11847 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
11848 break;
11849 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
11850 break;
11851 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
11852 break;
11853 case 6211: data.hashfile = mystrdup ("hashcat.tc");
11854 break;
11855 case 6212: data.hashfile = mystrdup ("hashcat.tc");
11856 break;
11857 case 6213: data.hashfile = mystrdup ("hashcat.tc");
11858 break;
11859 case 6221: data.hashfile = mystrdup ("hashcat.tc");
11860 break;
11861 case 6222: data.hashfile = mystrdup ("hashcat.tc");
11862 break;
11863 case 6223: data.hashfile = mystrdup ("hashcat.tc");
11864 break;
11865 case 6231: data.hashfile = mystrdup ("hashcat.tc");
11866 break;
11867 case 6232: data.hashfile = mystrdup ("hashcat.tc");
11868 break;
11869 case 6233: data.hashfile = mystrdup ("hashcat.tc");
11870 break;
11871 case 6241: data.hashfile = mystrdup ("hashcat.tc");
11872 break;
11873 case 6242: data.hashfile = mystrdup ("hashcat.tc");
11874 break;
11875 case 6243: data.hashfile = mystrdup ("hashcat.tc");
11876 break;
11877 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
11878 break;
11879 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
11880 break;
11881 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
11882 break;
11883 case 13711: data.hashfile = mystrdup ("hashcat.vc");
11884 break;
11885 case 13712: data.hashfile = mystrdup ("hashcat.vc");
11886 break;
11887 case 13713: data.hashfile = mystrdup ("hashcat.vc");
11888 break;
11889 case 13721: data.hashfile = mystrdup ("hashcat.vc");
11890 break;
11891 case 13722: data.hashfile = mystrdup ("hashcat.vc");
11892 break;
11893 case 13723: data.hashfile = mystrdup ("hashcat.vc");
11894 break;
11895 case 13731: data.hashfile = mystrdup ("hashcat.vc");
11896 break;
11897 case 13732: data.hashfile = mystrdup ("hashcat.vc");
11898 break;
11899 case 13733: data.hashfile = mystrdup ("hashcat.vc");
11900 break;
11901 case 13741: data.hashfile = mystrdup ("hashcat.vc");
11902 break;
11903 case 13742: data.hashfile = mystrdup ("hashcat.vc");
11904 break;
11905 case 13743: data.hashfile = mystrdup ("hashcat.vc");
11906 break;
11907 case 13751: data.hashfile = mystrdup ("hashcat.vc");
11908 break;
11909 case 13752: data.hashfile = mystrdup ("hashcat.vc");
11910 break;
11911 case 13753: data.hashfile = mystrdup ("hashcat.vc");
11912 break;
11913 case 13761: data.hashfile = mystrdup ("hashcat.vc");
11914 break;
11915 case 13762: data.hashfile = mystrdup ("hashcat.vc");
11916 break;
11917 case 13763: data.hashfile = mystrdup ("hashcat.vc");
11918 break;
11919 }
11920
11921 // set default iterations
11922
11923 switch (hash_mode)
11924 {
11925 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
11926 break;
11927 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11928 break;
11929 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11930 break;
11931 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11932 break;
11933 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
11934 break;
11935 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
11936 break;
11937 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
11938 break;
11939 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
11940 break;
11941 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
11942 break;
11943 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
11944 break;
11945 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11946 break;
11947 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11948 break;
11949 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
11950 break;
11951 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11952 break;
11953 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11954 break;
11955 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11956 break;
11957 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11958 break;
11959 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11960 break;
11961 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11962 break;
11963 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11964 break;
11965 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11966 break;
11967 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
11968 break;
11969 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
11970 break;
11971 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
11972 break;
11973 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
11974 break;
11975 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
11976 break;
11977 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
11978 break;
11979 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
11980 break;
11981 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
11982 break;
11983 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
11984 break;
11985 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
11986 break;
11987 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
11988 break;
11989 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
11990 break;
11991 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
11992 break;
11993 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
11994 break;
11995 case 8900: hashes_buf[0].salt->salt_iter = 1;
11996 break;
11997 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
11998 break;
11999 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12000 break;
12001 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12002 break;
12003 case 9300: hashes_buf[0].salt->salt_iter = 1;
12004 break;
12005 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12006 break;
12007 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12008 break;
12009 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12010 break;
12011 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12012 break;
12013 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12014 break;
12015 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12016 break;
12017 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12018 break;
12019 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12020 break;
12021 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12022 break;
12023 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12024 break;
12025 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12026 break;
12027 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12028 break;
12029 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12030 break;
12031 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12032 break;
12033 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12034 break;
12035 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12036 break;
12037 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12038 break;
12039 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12040 break;
12041 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12042 break;
12043 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12044 break;
12045 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12046 break;
12047 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12048 break;
12049 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12050 break;
12051 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12052 break;
12053 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12054 break;
12055 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12056 break;
12057 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12058 break;
12059 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12060 break;
12061 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12062 break;
12063 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12064 break;
12065 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12066 break;
12067 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12068 break;
12069 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12070 break;
12071 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12072 break;
12073 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12074 break;
12075 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12076 break;
12077 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12078 break;
12079 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12080 break;
12081 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12082 break;
12083 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12084 break;
12085 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12086 break;
12087 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12088 break;
12089 }
12090
12091 hashes_cnt = 1;
12092 }
12093
12094 if (show == 1 || left == 1)
12095 {
12096 for (uint i = 0; i < pot_cnt; i++)
12097 {
12098 pot_t *pot_ptr = &pot[i];
12099
12100 hash_t *hashes_buf = &pot_ptr->hash;
12101
12102 local_free (hashes_buf->digest);
12103
12104 if (isSalted)
12105 {
12106 local_free (hashes_buf->salt);
12107 }
12108 }
12109
12110 local_free (pot);
12111
12112 if (data.quiet == 0) log_info_nn ("");
12113
12114 return (0);
12115 }
12116
12117 if (keyspace == 0)
12118 {
12119 if (hashes_cnt == 0)
12120 {
12121 log_error ("ERROR: No hashes loaded");
12122
12123 return (-1);
12124 }
12125 }
12126
12127 /**
12128 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12129 */
12130
12131 if (data.outfile != NULL)
12132 {
12133 if (data.hashfile != NULL)
12134 {
12135 #ifdef _POSIX
12136 struct stat tmpstat_outfile;
12137 struct stat tmpstat_hashfile;
12138 #endif
12139
12140 #ifdef _WIN
12141 struct stat64 tmpstat_outfile;
12142 struct stat64 tmpstat_hashfile;
12143 #endif
12144
12145 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12146
12147 if (tmp_outfile_fp)
12148 {
12149 #ifdef _POSIX
12150 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12151 #endif
12152
12153 #ifdef _WIN
12154 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12155 #endif
12156
12157 fclose (tmp_outfile_fp);
12158 }
12159
12160 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12161
12162 if (tmp_hashfile_fp)
12163 {
12164 #ifdef _POSIX
12165 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12166 #endif
12167
12168 #ifdef _WIN
12169 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12170 #endif
12171
12172 fclose (tmp_hashfile_fp);
12173 }
12174
12175 if (tmp_outfile_fp && tmp_outfile_fp)
12176 {
12177 tmpstat_outfile.st_mode = 0;
12178 tmpstat_outfile.st_nlink = 0;
12179 tmpstat_outfile.st_uid = 0;
12180 tmpstat_outfile.st_gid = 0;
12181 tmpstat_outfile.st_rdev = 0;
12182 tmpstat_outfile.st_atime = 0;
12183
12184 tmpstat_hashfile.st_mode = 0;
12185 tmpstat_hashfile.st_nlink = 0;
12186 tmpstat_hashfile.st_uid = 0;
12187 tmpstat_hashfile.st_gid = 0;
12188 tmpstat_hashfile.st_rdev = 0;
12189 tmpstat_hashfile.st_atime = 0;
12190
12191 #ifdef _POSIX
12192 tmpstat_outfile.st_blksize = 0;
12193 tmpstat_outfile.st_blocks = 0;
12194
12195 tmpstat_hashfile.st_blksize = 0;
12196 tmpstat_hashfile.st_blocks = 0;
12197 #endif
12198
12199 #ifdef _POSIX
12200 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12201 {
12202 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12203
12204 return (-1);
12205 }
12206 #endif
12207
12208 #ifdef _WIN
12209 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12210 {
12211 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12212
12213 return (-1);
12214 }
12215 #endif
12216 }
12217 }
12218 }
12219
12220 /**
12221 * Remove duplicates
12222 */
12223
12224 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12225
12226 if (isSalted)
12227 {
12228 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12229 }
12230 else
12231 {
12232 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12233 }
12234
12235 uint hashes_cnt_orig = hashes_cnt;
12236
12237 hashes_cnt = 1;
12238
12239 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12240 {
12241 if (isSalted)
12242 {
12243 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12244 {
12245 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12246 }
12247 }
12248 else
12249 {
12250 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12251 }
12252
12253 if (hashes_pos > hashes_cnt)
12254 {
12255 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12256 }
12257
12258 hashes_cnt++;
12259 }
12260
12261 /**
12262 * Potfile removes
12263 */
12264
12265 uint potfile_remove_cracks = 0;
12266
12267 if (potfile_disable == 0)
12268 {
12269 hash_t hash_buf;
12270
12271 hash_buf.digest = mymalloc (dgst_size);
12272 hash_buf.salt = NULL;
12273 hash_buf.esalt = NULL;
12274 hash_buf.hash_info = NULL;
12275 hash_buf.cracked = 0;
12276
12277 if (isSalted)
12278 {
12279 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12280 }
12281
12282 if (esalt_size)
12283 {
12284 hash_buf.esalt = mymalloc (esalt_size);
12285 }
12286
12287 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12288
12289 // no solution for these special hash types (for instane because they use hashfile in output etc)
12290 if ((hash_mode != 5200) &&
12291 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12292 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12293 (hash_mode != 9000))
12294 {
12295 FILE *fp = fopen (potfile, "rb");
12296
12297 if (fp != NULL)
12298 {
12299 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12300
12301 // to be safe work with a copy (because of line_len loop, i etc)
12302 // moved up here because it's easier to handle continue case
12303 // it's just 64kb
12304
12305 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12306
12307 while (!feof (fp))
12308 {
12309 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12310
12311 if (ptr == NULL) break;
12312
12313 int line_len = strlen (line_buf);
12314
12315 if (line_len == 0) continue;
12316
12317 int iter = MAX_CUT_TRIES;
12318
12319 for (int i = line_len - 1; i && iter; i--, line_len--)
12320 {
12321 if (line_buf[i] != ':') continue;
12322
12323 if (isSalted)
12324 {
12325 memset (hash_buf.salt, 0, sizeof (salt_t));
12326 }
12327
12328 hash_t *found = NULL;
12329
12330 if (hash_mode == 6800)
12331 {
12332 if (i < 64) // 64 = 16 * uint in salt_buf[]
12333 {
12334 // manipulate salt_buf
12335 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12336
12337 hash_buf.salt->salt_len = i;
12338
12339 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12340 }
12341 }
12342 else if (hash_mode == 2500)
12343 {
12344 if (i < 64) // 64 = 16 * uint in salt_buf[]
12345 {
12346 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12347 // manipulate salt_buf
12348
12349 memcpy (line_buf_cpy, line_buf, i);
12350
12351 char *mac2_pos = strrchr (line_buf_cpy, ':');
12352
12353 if (mac2_pos == NULL) continue;
12354
12355 mac2_pos[0] = 0;
12356 mac2_pos++;
12357
12358 if (strlen (mac2_pos) != 12) continue;
12359
12360 char *mac1_pos = strrchr (line_buf_cpy, ':');
12361
12362 if (mac1_pos == NULL) continue;
12363
12364 mac1_pos[0] = 0;
12365 mac1_pos++;
12366
12367 if (strlen (mac1_pos) != 12) continue;
12368
12369 uint essid_length = mac1_pos - line_buf_cpy - 1;
12370
12371 // here we need the ESSID
12372 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12373
12374 hash_buf.salt->salt_len = essid_length;
12375
12376 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12377
12378 if (found)
12379 {
12380 wpa_t *wpa = (wpa_t *) found->esalt;
12381
12382 // compare hex string(s) vs binary MAC address(es)
12383
12384 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12385 {
12386 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12387 {
12388 found = NULL;
12389
12390 break;
12391 }
12392 }
12393
12394 // early skip ;)
12395 if (!found) continue;
12396
12397 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12398 {
12399 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12400 {
12401 found = NULL;
12402
12403 break;
12404 }
12405 }
12406 }
12407 }
12408 }
12409 else
12410 {
12411 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12412
12413 if (parser_status == PARSER_OK)
12414 {
12415 if (isSalted)
12416 {
12417 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12418 }
12419 else
12420 {
12421 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12422 }
12423 }
12424 }
12425
12426 if (found == NULL) continue;
12427
12428 if (!found->cracked) potfile_remove_cracks++;
12429
12430 found->cracked = 1;
12431
12432 if (found) break;
12433
12434 iter--;
12435 }
12436 }
12437
12438 myfree (line_buf_cpy);
12439
12440 myfree (line_buf);
12441
12442 fclose (fp);
12443 }
12444 }
12445
12446 if (esalt_size)
12447 {
12448 local_free (hash_buf.esalt);
12449 }
12450
12451 if (isSalted)
12452 {
12453 local_free (hash_buf.salt);
12454 }
12455
12456 local_free (hash_buf.digest);
12457 }
12458
12459 /**
12460 * Now generate all the buffers required for later
12461 */
12462
12463 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12464
12465 salt_t *salts_buf_new = NULL;
12466 void *esalts_buf_new = NULL;
12467
12468 if (isSalted)
12469 {
12470 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12471
12472 if (esalt_size)
12473 {
12474 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12475 }
12476 }
12477 else
12478 {
12479 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12480 }
12481
12482 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12483
12484 uint digests_cnt = hashes_cnt;
12485 uint digests_done = 0;
12486
12487 size_t size_digests = digests_cnt * dgst_size;
12488 size_t size_shown = digests_cnt * sizeof (uint);
12489
12490 uint *digests_shown = (uint *) mymalloc (size_shown);
12491 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12492
12493 uint salts_cnt = 0;
12494 uint salts_done = 0;
12495
12496 hashinfo_t **hash_info = NULL;
12497
12498 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12499 {
12500 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12501
12502 if (username && (remove || show))
12503 {
12504 uint user_pos;
12505
12506 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12507 {
12508 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12509
12510 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12511 }
12512 }
12513 }
12514
12515 uint *salts_shown = (uint *) mymalloc (size_shown);
12516
12517 salt_t *salt_buf;
12518
12519 {
12520 // copied from inner loop
12521
12522 salt_buf = &salts_buf_new[salts_cnt];
12523
12524 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12525
12526 if (esalt_size)
12527 {
12528 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12529 }
12530
12531 salt_buf->digests_cnt = 0;
12532 salt_buf->digests_done = 0;
12533 salt_buf->digests_offset = 0;
12534
12535 salts_cnt++;
12536 }
12537
12538 if (hashes_buf[0].cracked == 1)
12539 {
12540 digests_shown[0] = 1;
12541
12542 digests_done++;
12543
12544 salt_buf->digests_done++;
12545 }
12546
12547 salt_buf->digests_cnt++;
12548
12549 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12550
12551 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12552 {
12553 hash_info[0] = hashes_buf[0].hash_info;
12554 }
12555
12556 // copy from inner loop
12557
12558 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12559 {
12560 if (isSalted)
12561 {
12562 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12563 {
12564 salt_buf = &salts_buf_new[salts_cnt];
12565
12566 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12567
12568 if (esalt_size)
12569 {
12570 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12571 }
12572
12573 salt_buf->digests_cnt = 0;
12574 salt_buf->digests_done = 0;
12575 salt_buf->digests_offset = hashes_pos;
12576
12577 salts_cnt++;
12578 }
12579 }
12580
12581 if (hashes_buf[hashes_pos].cracked == 1)
12582 {
12583 digests_shown[hashes_pos] = 1;
12584
12585 digests_done++;
12586
12587 salt_buf->digests_done++;
12588 }
12589
12590 salt_buf->digests_cnt++;
12591
12592 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12593
12594 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12595 {
12596 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12597 }
12598 }
12599
12600 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12601 {
12602 salt_t *salt_buf = &salts_buf_new[salt_pos];
12603
12604 if (salt_buf->digests_done == salt_buf->digests_cnt)
12605 {
12606 salts_shown[salt_pos] = 1;
12607
12608 salts_done++;
12609 }
12610
12611 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12612 }
12613
12614 local_free (digests_buf);
12615 local_free (salts_buf);
12616 local_free (esalts_buf);
12617
12618 digests_buf = digests_buf_new;
12619 salts_buf = salts_buf_new;
12620 esalts_buf = esalts_buf_new;
12621
12622 local_free (hashes_buf);
12623
12624 /**
12625 * special modification not set from parser
12626 */
12627
12628 switch (hash_mode)
12629 {
12630 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12631 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12632 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12633 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12634 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12635 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12636 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12637 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12638 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12639 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12640 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12641 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12642 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12643 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12644 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12645 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12646 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12647 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12648 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12649 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12650 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12651 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12652 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12653 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12654 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12655 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12656 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12657 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12658 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12659 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12660 }
12661
12662 if (truecrypt_keyfiles)
12663 {
12664 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12665
12666 char *keyfiles = strdup (truecrypt_keyfiles);
12667
12668 char *keyfile = strtok (keyfiles, ",");
12669
12670 do
12671 {
12672 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12673
12674 } while ((keyfile = strtok (NULL, ",")) != NULL);
12675
12676 free (keyfiles);
12677 }
12678
12679 if (veracrypt_keyfiles)
12680 {
12681 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12682
12683 char *keyfiles = strdup (veracrypt_keyfiles);
12684
12685 char *keyfile = strtok (keyfiles, ",");
12686
12687 do
12688 {
12689 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12690
12691 } while ((keyfile = strtok (NULL, ",")) != NULL);
12692
12693 free (keyfiles);
12694 }
12695
12696 data.digests_cnt = digests_cnt;
12697 data.digests_done = digests_done;
12698 data.digests_buf = digests_buf;
12699 data.digests_shown = digests_shown;
12700 data.digests_shown_tmp = digests_shown_tmp;
12701
12702 data.salts_cnt = salts_cnt;
12703 data.salts_done = salts_done;
12704 data.salts_buf = salts_buf;
12705 data.salts_shown = salts_shown;
12706
12707 data.esalts_buf = esalts_buf;
12708 data.hash_info = hash_info;
12709
12710 /**
12711 * Automatic Optimizers
12712 */
12713
12714 if (salts_cnt == 1)
12715 opti_type |= OPTI_TYPE_SINGLE_SALT;
12716
12717 if (digests_cnt == 1)
12718 opti_type |= OPTI_TYPE_SINGLE_HASH;
12719
12720 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12721 opti_type |= OPTI_TYPE_NOT_ITERATED;
12722
12723 if (attack_mode == ATTACK_MODE_BF)
12724 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12725
12726 data.opti_type = opti_type;
12727
12728 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12729 {
12730 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12731 {
12732 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12733 {
12734 if (opts_type & OPTS_TYPE_ST_ADD80)
12735 {
12736 opts_type &= ~OPTS_TYPE_ST_ADD80;
12737 opts_type |= OPTS_TYPE_PT_ADD80;
12738 }
12739
12740 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12741 {
12742 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12743 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12744 }
12745
12746 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12747 {
12748 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12749 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12750 }
12751 }
12752 }
12753 }
12754
12755 /**
12756 * Some algorithm, like descrypt, can benefit from JIT compilation
12757 */
12758
12759 int force_jit_compilation = -1;
12760
12761 if (hash_mode == 8900)
12762 {
12763 force_jit_compilation = 8900;
12764 }
12765 else if (hash_mode == 9300)
12766 {
12767 force_jit_compilation = 8900;
12768 }
12769 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12770 {
12771 force_jit_compilation = 1500;
12772 }
12773
12774 /**
12775 * generate bitmap tables
12776 */
12777
12778 const uint bitmap_shift1 = 5;
12779 const uint bitmap_shift2 = 13;
12780
12781 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
12782
12783 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12784 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12785 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12786 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12787 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12788 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12789 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12790 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
12791
12792 uint bitmap_bits;
12793 uint bitmap_nums;
12794 uint bitmap_mask;
12795 uint bitmap_size;
12796
12797 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
12798 {
12799 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
12800
12801 bitmap_nums = 1 << bitmap_bits;
12802
12803 bitmap_mask = bitmap_nums - 1;
12804
12805 bitmap_size = bitmap_nums * sizeof (uint);
12806
12807 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
12808
12809 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;
12810 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;
12811
12812 break;
12813 }
12814
12815 bitmap_nums = 1 << bitmap_bits;
12816
12817 bitmap_mask = bitmap_nums - 1;
12818
12819 bitmap_size = bitmap_nums * sizeof (uint);
12820
12821 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);
12822 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);
12823
12824 /**
12825 * prepare quick rule
12826 */
12827
12828 data.rule_buf_l = rule_buf_l;
12829 data.rule_buf_r = rule_buf_r;
12830
12831 int rule_len_l = (int) strlen (rule_buf_l);
12832 int rule_len_r = (int) strlen (rule_buf_r);
12833
12834 data.rule_len_l = rule_len_l;
12835 data.rule_len_r = rule_len_r;
12836
12837 /**
12838 * load rules
12839 */
12840
12841 uint *all_kernel_rules_cnt = NULL;
12842
12843 kernel_rule_t **all_kernel_rules_buf = NULL;
12844
12845 if (rp_files_cnt)
12846 {
12847 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
12848
12849 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
12850 }
12851
12852 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
12853
12854 int rule_len = 0;
12855
12856 for (uint i = 0; i < rp_files_cnt; i++)
12857 {
12858 uint kernel_rules_avail = 0;
12859
12860 uint kernel_rules_cnt = 0;
12861
12862 kernel_rule_t *kernel_rules_buf = NULL;
12863
12864 char *rp_file = rp_files[i];
12865
12866 char in[BLOCK_SIZE] = { 0 };
12867 char out[BLOCK_SIZE] = { 0 };
12868
12869 FILE *fp = NULL;
12870
12871 uint rule_line = 0;
12872
12873 if ((fp = fopen (rp_file, "rb")) == NULL)
12874 {
12875 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
12876
12877 return (-1);
12878 }
12879
12880 while (!feof (fp))
12881 {
12882 memset (rule_buf, 0, HCBUFSIZ);
12883
12884 rule_len = fgetl (fp, rule_buf);
12885
12886 rule_line++;
12887
12888 if (rule_len == 0) continue;
12889
12890 if (rule_buf[0] == '#') continue;
12891
12892 if (kernel_rules_avail == kernel_rules_cnt)
12893 {
12894 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
12895
12896 kernel_rules_avail += INCR_RULES;
12897 }
12898
12899 memset (in, 0, BLOCK_SIZE);
12900 memset (out, 0, BLOCK_SIZE);
12901
12902 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
12903
12904 if (result == -1)
12905 {
12906 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12907
12908 continue;
12909 }
12910
12911 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
12912 {
12913 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12914
12915 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
12916
12917 continue;
12918 }
12919
12920 /* its so slow
12921 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
12922 {
12923 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
12924
12925 continue;
12926 }
12927 */
12928
12929 kernel_rules_cnt++;
12930 }
12931
12932 fclose (fp);
12933
12934 all_kernel_rules_cnt[i] = kernel_rules_cnt;
12935
12936 all_kernel_rules_buf[i] = kernel_rules_buf;
12937 }
12938
12939 /**
12940 * merge rules or automatic rule generator
12941 */
12942
12943 uint kernel_rules_cnt = 0;
12944
12945 kernel_rule_t *kernel_rules_buf = NULL;
12946
12947 if (attack_mode == ATTACK_MODE_STRAIGHT)
12948 {
12949 if (rp_files_cnt)
12950 {
12951 kernel_rules_cnt = 1;
12952
12953 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
12954
12955 repeats[0] = kernel_rules_cnt;
12956
12957 for (uint i = 0; i < rp_files_cnt; i++)
12958 {
12959 kernel_rules_cnt *= all_kernel_rules_cnt[i];
12960
12961 repeats[i + 1] = kernel_rules_cnt;
12962 }
12963
12964 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
12965
12966 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
12967
12968 for (uint i = 0; i < kernel_rules_cnt; i++)
12969 {
12970 uint out_pos = 0;
12971
12972 kernel_rule_t *out = &kernel_rules_buf[i];
12973
12974 for (uint j = 0; j < rp_files_cnt; j++)
12975 {
12976 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
12977 uint in_pos;
12978
12979 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
12980
12981 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
12982 {
12983 if (out_pos == RULES_MAX - 1)
12984 {
12985 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
12986
12987 break;
12988 }
12989
12990 out->cmds[out_pos] = in->cmds[in_pos];
12991 }
12992 }
12993 }
12994
12995 local_free (repeats);
12996 }
12997 else if (rp_gen)
12998 {
12999 uint kernel_rules_avail = 0;
13000
13001 while (kernel_rules_cnt < rp_gen)
13002 {
13003 if (kernel_rules_avail == kernel_rules_cnt)
13004 {
13005 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13006
13007 kernel_rules_avail += INCR_RULES;
13008 }
13009
13010 memset (rule_buf, 0, HCBUFSIZ);
13011
13012 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13013
13014 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13015
13016 kernel_rules_cnt++;
13017 }
13018 }
13019 }
13020
13021 myfree (rule_buf);
13022
13023 /**
13024 * generate NOP rules
13025 */
13026
13027 if (kernel_rules_cnt == 0)
13028 {
13029 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13030
13031 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13032
13033 kernel_rules_cnt++;
13034 }
13035
13036 data.kernel_rules_cnt = kernel_rules_cnt;
13037 data.kernel_rules_buf = kernel_rules_buf;
13038
13039 /**
13040 * OpenCL platforms: detect
13041 */
13042
13043 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13044 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13045
13046 cl_uint platforms_cnt = 0;
13047 cl_uint platform_devices_cnt = 0;
13048
13049 if (keyspace == 0)
13050 {
13051 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13052
13053 if (platforms_cnt == 0)
13054 {
13055 log_info ("");
13056 log_info ("ATTENTION! No OpenCL compatible platform found");
13057 log_info ("");
13058 log_info ("You're probably missing the OpenCL runtime installation");
13059 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13060 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13061 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13062 log_info ("");
13063
13064 return (-1);
13065 }
13066
13067 if (opencl_platforms_filter != (uint) -1)
13068 {
13069 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13070
13071 if (opencl_platforms_filter > platform_cnt_mask)
13072 {
13073 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13074
13075 return (-1);
13076 }
13077 }
13078 }
13079
13080 /**
13081 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13082 */
13083
13084 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13085 {
13086 cl_platform_id platform = platforms[platform_id];
13087
13088 char platform_vendor[INFOSZ] = { 0 };
13089
13090 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13091
13092 #ifdef HAVE_HWMON
13093 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13094 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13095 {
13096 // make sure that we do not directly control the fan for NVidia
13097
13098 gpu_temp_retain = 0;
13099
13100 data.gpu_temp_retain = gpu_temp_retain;
13101 }
13102 #endif // HAVE_NVML || HAVE_NVAPI
13103 #endif
13104 }
13105
13106 /**
13107 * OpenCL device types:
13108 * 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.
13109 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13110 */
13111
13112 if (opencl_device_types == NULL)
13113 {
13114 cl_device_type device_types_all = 0;
13115
13116 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13117 {
13118 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13119
13120 cl_platform_id platform = platforms[platform_id];
13121
13122 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13123
13124 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13125 {
13126 cl_device_id device = platform_devices[platform_devices_id];
13127
13128 cl_device_type device_type;
13129
13130 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13131
13132 device_types_all |= device_type;
13133 }
13134 }
13135
13136 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13137 {
13138 device_types_filter |= CL_DEVICE_TYPE_CPU;
13139 }
13140 }
13141
13142 /**
13143 * OpenCL devices: simply push all devices from all platforms into the same device array
13144 */
13145
13146 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13147
13148 data.devices_param = devices_param;
13149
13150 uint devices_cnt = 0;
13151
13152 uint devices_active = 0;
13153
13154 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13155 {
13156 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13157
13158 cl_platform_id platform = platforms[platform_id];
13159
13160 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13161
13162 char platform_vendor[INFOSZ] = { 0 };
13163
13164 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13165
13166 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13167 // this causes trouble with vendor id based macros
13168 // we'll assign generic to those without special optimization available
13169
13170 cl_uint vendor_id = 0;
13171
13172 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13173 {
13174 vendor_id = VENDOR_ID_AMD;
13175 }
13176 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13177 {
13178 vendor_id = VENDOR_ID_APPLE;
13179 }
13180 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13181 {
13182 vendor_id = VENDOR_ID_INTEL_BEIGNET;
13183 }
13184 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13185 {
13186 vendor_id = VENDOR_ID_INTEL_SDK;
13187 }
13188 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13189 {
13190 vendor_id = VENDOR_ID_MESA;
13191 }
13192 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13193 {
13194 vendor_id = VENDOR_ID_NV;
13195 }
13196 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13197 {
13198 vendor_id = VENDOR_ID_POCL;
13199 }
13200 else
13201 {
13202 vendor_id = VENDOR_ID_GENERIC;
13203 }
13204
13205 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13206 {
13207 size_t param_value_size = 0;
13208
13209 const uint device_id = devices_cnt;
13210
13211 hc_device_param_t *device_param = &data.devices_param[device_id];
13212
13213 device_param->vendor_id = vendor_id;
13214
13215 device_param->device = platform_devices[platform_devices_id];
13216
13217 device_param->device_id = device_id;
13218
13219 device_param->platform_devices_id = platform_devices_id;
13220
13221 // device_type
13222
13223 cl_device_type device_type;
13224
13225 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13226
13227 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13228
13229 device_param->device_type = device_type;
13230
13231 // device_name
13232
13233 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13234
13235 char *device_name = (char *) mymalloc (param_value_size);
13236
13237 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13238
13239 device_param->device_name = device_name;
13240
13241 // tuning db
13242
13243 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13244
13245 // device_version
13246
13247 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13248
13249 char *device_version = (char *) mymalloc (param_value_size);
13250
13251 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13252
13253 device_param->device_version = device_version;
13254
13255 // device_opencl_version
13256
13257 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13258
13259 char *device_opencl_version = (char *) mymalloc (param_value_size);
13260
13261 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13262
13263 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13264
13265 myfree (device_opencl_version);
13266
13267 // vector_width
13268
13269 cl_uint vector_width;
13270
13271 if (opencl_vector_width_chgd == 0)
13272 {
13273 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13274 {
13275 if (opti_type & OPTI_TYPE_USES_BITS_64)
13276 {
13277 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13278 }
13279 else
13280 {
13281 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13282 }
13283 }
13284 else
13285 {
13286 vector_width = (cl_uint) tuningdb_entry->vector_width;
13287 }
13288 }
13289 else
13290 {
13291 vector_width = opencl_vector_width;
13292 }
13293
13294 if (vector_width > 16) vector_width = 16;
13295
13296 device_param->vector_width = vector_width;
13297
13298 // max_compute_units
13299
13300 cl_uint device_processors;
13301
13302 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13303
13304 device_param->device_processors = device_processors;
13305
13306 // device_maxmem_alloc
13307 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13308
13309 cl_ulong device_maxmem_alloc;
13310
13311 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13312
13313 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13314
13315 // device_global_mem
13316
13317 cl_ulong device_global_mem;
13318
13319 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13320
13321 device_param->device_global_mem = device_global_mem;
13322
13323 // max_work_group_size
13324
13325 size_t device_maxworkgroup_size;
13326
13327 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13328
13329 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13330
13331 // max_clock_frequency
13332
13333 cl_uint device_maxclock_frequency;
13334
13335 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13336
13337 device_param->device_maxclock_frequency = device_maxclock_frequency;
13338
13339 // device_endian_little
13340
13341 cl_bool device_endian_little;
13342
13343 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13344
13345 if (device_endian_little == CL_FALSE)
13346 {
13347 log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13348
13349 device_param->skipped = 1;
13350 }
13351
13352 // device_available
13353
13354 cl_bool device_available;
13355
13356 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13357
13358 if (device_available == CL_FALSE)
13359 {
13360 log_info ("Device #%u: WARNING: device not available", device_id + 1);
13361
13362 device_param->skipped = 1;
13363 }
13364
13365 // device_compiler_available
13366
13367 cl_bool device_compiler_available;
13368
13369 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13370
13371 if (device_compiler_available == CL_FALSE)
13372 {
13373 log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13374
13375 device_param->skipped = 1;
13376 }
13377
13378 // device_execution_capabilities
13379
13380 cl_device_exec_capabilities device_execution_capabilities;
13381
13382 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13383
13384 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13385 {
13386 log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13387
13388 device_param->skipped = 1;
13389 }
13390
13391 // device_extensions
13392
13393 size_t device_extensions_size;
13394
13395 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13396
13397 char *device_extensions = mymalloc (device_extensions_size + 1);
13398
13399 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13400
13401 if (strstr (device_extensions, "base_atomics") == 0)
13402 {
13403 log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13404
13405 device_param->skipped = 1;
13406 }
13407
13408 if (strstr (device_extensions, "byte_addressable_store") == 0)
13409 {
13410 log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13411
13412 device_param->skipped = 1;
13413 }
13414
13415 myfree (device_extensions);
13416
13417 // device_local_mem_size
13418
13419 cl_ulong device_local_mem_size;
13420
13421 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13422
13423 if (device_local_mem_size < 32768)
13424 {
13425 log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13426
13427 device_param->skipped = 1;
13428 }
13429
13430
13431 // skipped
13432
13433 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13434 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13435
13436 // driver_version
13437
13438 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13439
13440 char *driver_version = (char *) mymalloc (param_value_size);
13441
13442 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13443
13444 device_param->driver_version = driver_version;
13445
13446 // device_name_chksum
13447
13448 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13449
13450 #if __x86_64__
13451 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);
13452 #else
13453 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);
13454 #endif
13455
13456 uint device_name_digest[4] = { 0 };
13457
13458 md5_64 ((uint *) device_name_chksum, device_name_digest);
13459
13460 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13461
13462 device_param->device_name_chksum = device_name_chksum;
13463
13464 // device_processor_cores
13465
13466 if (device_type & CL_DEVICE_TYPE_CPU)
13467 {
13468 cl_uint device_processor_cores = 1;
13469
13470 device_param->device_processor_cores = device_processor_cores;
13471 }
13472
13473 if (device_type & CL_DEVICE_TYPE_GPU)
13474 {
13475 if (vendor_id == VENDOR_ID_AMD)
13476 {
13477 cl_uint device_processor_cores = 0;
13478
13479 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13480
13481 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13482
13483 device_param->device_processor_cores = device_processor_cores;
13484 }
13485 else if (vendor_id == VENDOR_ID_NV)
13486 {
13487 cl_uint kernel_exec_timeout = 0;
13488
13489 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13490
13491 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13492
13493 device_param->kernel_exec_timeout = kernel_exec_timeout;
13494
13495 cl_uint device_processor_cores = 0;
13496
13497 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13498
13499 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13500
13501 device_param->device_processor_cores = device_processor_cores;
13502
13503 cl_uint sm_minor = 0;
13504 cl_uint sm_major = 0;
13505
13506 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13507 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13508
13509 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13510 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13511
13512 device_param->sm_minor = sm_minor;
13513 device_param->sm_major = sm_major;
13514 }
13515 else
13516 {
13517 cl_uint device_processor_cores = 1;
13518
13519 device_param->device_processor_cores = device_processor_cores;
13520 }
13521 }
13522
13523 // display results
13524
13525 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13526 {
13527 if (status_automat == 0)
13528 {
13529 if (device_param->skipped == 0)
13530 {
13531 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU",
13532 device_id + 1,
13533 device_name,
13534 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13535 (unsigned int) (device_global_mem / 1024 / 1024),
13536 (unsigned int) (device_maxclock_frequency),
13537 (unsigned int) device_processors);
13538 }
13539 else
13540 {
13541 log_info ("Device #%u: %s, skipped",
13542 device_id + 1,
13543 device_name);
13544 }
13545 }
13546 }
13547
13548 // common driver check
13549
13550 if (device_param->skipped == 0)
13551 {
13552 if (device_type & CL_DEVICE_TYPE_GPU)
13553 {
13554 if (vendor_id == VENDOR_ID_AMD)
13555 {
13556 int catalyst_check = (force == 1) ? 0 : 1;
13557
13558 int catalyst_warn = 0;
13559
13560 int catalyst_broken = 0;
13561
13562 if (catalyst_check == 1)
13563 {
13564 catalyst_warn = 1;
13565
13566 // v14.9 and higher
13567 if (atoi (device_param->driver_version) >= 1573)
13568 {
13569 catalyst_warn = 0;
13570 }
13571
13572 catalyst_check = 0;
13573 }
13574
13575 if (catalyst_broken == 1)
13576 {
13577 log_info ("");
13578 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13579 log_info ("It will pass over cracked hashes and does not report them as cracked");
13580 log_info ("You are STRONGLY encouraged not to use it");
13581 log_info ("You can use --force to override this but do not post error reports if you do so");
13582 log_info ("");
13583
13584 return (-1);
13585 }
13586
13587 if (catalyst_warn == 1)
13588 {
13589 log_info ("");
13590 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13591 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13592 log_info ("See hashcat's homepage for official supported catalyst drivers");
13593 #ifdef _WIN
13594 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13595 #endif
13596 log_info ("You can use --force to override this but do not post error reports if you do so");
13597 log_info ("");
13598
13599 return (-1);
13600 }
13601 }
13602 else if (vendor_id == VENDOR_ID_NV)
13603 {
13604 if (device_param->kernel_exec_timeout != 0)
13605 {
13606 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);
13607 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13608 }
13609 }
13610 }
13611
13612 if (device_type & CL_DEVICE_TYPE_CPU)
13613 {
13614 if (vendor_id == VENDOR_ID_AMD)
13615 {
13616 if (force == 0)
13617 {
13618 log_info ("");
13619 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13620 log_info ("You are STRONGLY encouraged not to use it");
13621 log_info ("You can use --force to override this but do not post error reports if you do so");
13622 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13623 log_info ("");
13624
13625 return (-1);
13626 }
13627 }
13628 }
13629
13630 /**
13631 * kernel accel and loops tuning db adjustment
13632 */
13633
13634 device_param->kernel_accel_min = 1;
13635 device_param->kernel_accel_max = 1024;
13636
13637 device_param->kernel_loops_min = 1;
13638 device_param->kernel_loops_max = 1024;
13639
13640 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13641
13642 if (tuningdb_entry)
13643 {
13644 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13645 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13646
13647 if (_kernel_accel)
13648 {
13649 device_param->kernel_accel_min = _kernel_accel;
13650 device_param->kernel_accel_max = _kernel_accel;
13651 }
13652
13653 if (_kernel_loops)
13654 {
13655 if (workload_profile == 1)
13656 {
13657 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13658 }
13659 else if (workload_profile == 2)
13660 {
13661 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13662 }
13663
13664 device_param->kernel_loops_min = _kernel_loops;
13665 device_param->kernel_loops_max = _kernel_loops;
13666 }
13667 }
13668
13669 // commandline parameters overwrite tuningdb entries
13670
13671 if (kernel_accel)
13672 {
13673 device_param->kernel_accel_min = kernel_accel;
13674 device_param->kernel_accel_max = kernel_accel;
13675 }
13676
13677 if (kernel_loops)
13678 {
13679 device_param->kernel_loops_min = kernel_loops;
13680 device_param->kernel_loops_max = kernel_loops;
13681 }
13682
13683 /**
13684 * activate device
13685 */
13686
13687 devices_active++;
13688 }
13689
13690 // next please
13691
13692 devices_cnt++;
13693 }
13694 }
13695
13696 if (keyspace == 0 && devices_active == 0)
13697 {
13698 log_error ("ERROR: No devices found/left");
13699
13700 return (-1);
13701 }
13702
13703 // 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)
13704
13705 if (devices_filter != (uint) -1)
13706 {
13707 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
13708
13709 if (devices_filter > devices_cnt_mask)
13710 {
13711 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
13712
13713 return (-1);
13714 }
13715 }
13716
13717 data.devices_cnt = devices_cnt;
13718
13719 data.devices_active = devices_active;
13720
13721 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13722 {
13723 if (status_automat == 0)
13724 {
13725 log_info ("");
13726 }
13727 }
13728
13729 /**
13730 * HM devices: init
13731 */
13732
13733 #ifdef HAVE_HWMON
13734 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13735 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13736 #endif
13737
13738 #ifdef HAVE_ADL
13739 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } };
13740 #endif
13741
13742 if (gpu_temp_disable == 0)
13743 {
13744 #if defined(WIN) && defined(HAVE_NVAPI)
13745 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
13746
13747 if (nvapi_init (nvapi) == 0)
13748 data.hm_nv = nvapi;
13749
13750 if (data.hm_nv)
13751 {
13752 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
13753 {
13754 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13755
13756 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13757
13758 int tmp_out = 0;
13759
13760 for (int i = 0; i < tmp_in; i++)
13761 {
13762 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13763 }
13764
13765 for (int i = 0; i < tmp_out; i++)
13766 {
13767 NV_GPU_COOLER_SETTINGS pCoolerSettings;
13768
13769 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
13770
13771 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;
13772 }
13773 }
13774 }
13775 #endif // WIN && HAVE_NVAPI
13776
13777 #if defined(LINUX) && defined(HAVE_NVML)
13778 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
13779
13780 if (nvml_init (nvml) == 0)
13781 data.hm_nv = nvml;
13782
13783 if (data.hm_nv)
13784 {
13785 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
13786 {
13787 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
13788
13789 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
13790
13791 int tmp_out = 0;
13792
13793 for (int i = 0; i < tmp_in; i++)
13794 {
13795 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
13796 }
13797
13798 for (int i = 0; i < tmp_out; i++)
13799 {
13800 unsigned int speed;
13801
13802 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;
13803 }
13804 }
13805 }
13806 #endif // LINUX && HAVE_NVML
13807
13808 data.hm_amd = NULL;
13809
13810 #ifdef HAVE_ADL
13811 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
13812
13813 if (adl_init (adl) == 0)
13814 data.hm_amd = adl;
13815
13816 if (data.hm_amd)
13817 {
13818 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
13819 {
13820 // total number of adapters
13821
13822 int hm_adapters_num;
13823
13824 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
13825
13826 // adapter info
13827
13828 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
13829
13830 if (lpAdapterInfo == NULL) return (-1);
13831
13832 // get a list (of ids of) valid/usable adapters
13833
13834 int num_adl_adapters = 0;
13835
13836 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
13837
13838 if (num_adl_adapters > 0)
13839 {
13840 hc_thread_mutex_lock (mux_adl);
13841
13842 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
13843
13844 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13845
13846 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13847 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
13848
13849 hc_thread_mutex_unlock (mux_adl);
13850 }
13851
13852 myfree (valid_adl_device_list);
13853 myfree (lpAdapterInfo);
13854 }
13855 }
13856 #endif // HAVE_ADL
13857
13858 if (data.hm_amd == NULL && data.hm_nv == NULL)
13859 {
13860 gpu_temp_disable = 1;
13861 }
13862 }
13863
13864 /**
13865 * OpenCL devices: allocate buffer for device specific information
13866 */
13867
13868 #ifdef HAVE_HWMON
13869 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
13870
13871 #ifdef HAVE_ADL
13872 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
13873
13874 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
13875 #endif // ADL
13876 #endif
13877
13878 /**
13879 * enable custom signal handler(s)
13880 */
13881
13882 if (benchmark == 0)
13883 {
13884 hc_signal (sigHandler_default);
13885 }
13886 else
13887 {
13888 hc_signal (sigHandler_benchmark);
13889 }
13890
13891 /**
13892 * User-defined GPU temp handling
13893 */
13894
13895 #ifdef HAVE_HWMON
13896 if (gpu_temp_disable == 1)
13897 {
13898 gpu_temp_abort = 0;
13899 gpu_temp_retain = 0;
13900 }
13901
13902 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
13903 {
13904 if (gpu_temp_abort < gpu_temp_retain)
13905 {
13906 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
13907
13908 return (-1);
13909 }
13910 }
13911
13912 data.gpu_temp_disable = gpu_temp_disable;
13913 data.gpu_temp_abort = gpu_temp_abort;
13914 data.gpu_temp_retain = gpu_temp_retain;
13915 #endif
13916
13917 /**
13918 * inform the user
13919 */
13920
13921 if (data.quiet == 0)
13922 {
13923 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
13924
13925 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);
13926
13927 if (attack_mode == ATTACK_MODE_STRAIGHT)
13928 {
13929 log_info ("Rules: %u", kernel_rules_cnt);
13930 }
13931
13932 if (opti_type)
13933 {
13934 log_info ("Applicable Optimizers:");
13935
13936 for (uint i = 0; i < 32; i++)
13937 {
13938 const uint opti_bit = 1u << i;
13939
13940 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
13941 }
13942 }
13943
13944 /**
13945 * Watchdog and Temperature balance
13946 */
13947
13948 #ifdef HAVE_HWMON
13949 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
13950 {
13951 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
13952 }
13953
13954 if (gpu_temp_abort == 0)
13955 {
13956 log_info ("Watchdog: Temperature abort trigger disabled");
13957 }
13958 else
13959 {
13960 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
13961 }
13962
13963 if (gpu_temp_retain == 0)
13964 {
13965 log_info ("Watchdog: Temperature retain trigger disabled");
13966 }
13967 else
13968 {
13969 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
13970 }
13971
13972 if (data.quiet == 0) log_info ("");
13973 #endif
13974 }
13975
13976 /**
13977 * HM devices: copy
13978 */
13979
13980 if (gpu_temp_disable == 0)
13981 {
13982 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
13983 {
13984 hc_device_param_t *device_param = &data.devices_param[device_id];
13985
13986 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
13987
13988 if (device_param->skipped) continue;
13989
13990 const uint platform_devices_id = device_param->platform_devices_id;
13991
13992 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13993 if (device_param->vendor_id == VENDOR_ID_NV)
13994 {
13995 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
13996 }
13997 #endif
13998
13999 #ifdef HAVE_ADL
14000 if (device_param->vendor_id == VENDOR_ID_AMD)
14001 {
14002 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14003 }
14004 #endif
14005 }
14006 }
14007
14008 /*
14009 * Temporary fix:
14010 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14011 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14012 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14013 * Driver / ADL bug?
14014 */
14015
14016 #ifdef HAVE_ADL
14017 if (powertune_enable == 1)
14018 {
14019 hc_thread_mutex_lock (mux_adl);
14020
14021 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14022 {
14023 hc_device_param_t *device_param = &data.devices_param[device_id];
14024
14025 if (device_param->skipped) continue;
14026
14027 if (data.hm_device[device_id].od_version == 6)
14028 {
14029 // set powertune value only
14030
14031 int powertune_supported = 0;
14032
14033 int ADL_rc = 0;
14034
14035 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14036 {
14037 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14038
14039 return (-1);
14040 }
14041
14042 if (powertune_supported != 0)
14043 {
14044 // powertune set
14045 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14046
14047 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14048 {
14049 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14050
14051 return (-1);
14052 }
14053
14054 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14055 {
14056 log_error ("ERROR: Failed to set new ADL PowerControl values");
14057
14058 return (-1);
14059 }
14060 }
14061 }
14062 }
14063
14064 hc_thread_mutex_unlock (mux_adl);
14065 }
14066 #endif // HAVE_ADK
14067 #endif // HAVE_HWMON
14068
14069 #ifdef DEBUG
14070 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14071 #endif
14072
14073 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14074
14075 uint kernel_power_all = 0;
14076
14077 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14078 {
14079 /**
14080 * host buffer
14081 */
14082
14083 hc_device_param_t *device_param = &data.devices_param[device_id];
14084
14085 if (device_param->skipped) continue;
14086
14087 /**
14088 * device properties
14089 */
14090
14091 const char *device_name_chksum = device_param->device_name_chksum;
14092 const u32 device_processors = device_param->device_processors;
14093 const u32 device_processor_cores = device_param->device_processor_cores;
14094
14095 /**
14096 * create context for each device
14097 */
14098
14099 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14100
14101 /**
14102 * create command-queue
14103 */
14104
14105 // not supported with NV
14106 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14107
14108 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14109
14110 /**
14111 * kernel threads: some algorithms need a fixed kernel-threads count
14112 * because of shared memory usage or bitslice
14113 * there needs to be some upper limit, otherwise there's too much overhead
14114 */
14115
14116 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14117
14118 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14119 {
14120 kernel_threads = KERNEL_THREADS_MAX_CPU;
14121 }
14122
14123 if (hash_mode == 1500) kernel_threads = 64; // DES
14124 if (hash_mode == 3000) kernel_threads = 64; // DES
14125 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14126 if (hash_mode == 7500) kernel_threads = 64; // RC4
14127 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14128 if (hash_mode == 9700) kernel_threads = 64; // RC4
14129 if (hash_mode == 9710) kernel_threads = 64; // RC4
14130 if (hash_mode == 9800) kernel_threads = 64; // RC4
14131 if (hash_mode == 9810) kernel_threads = 64; // RC4
14132 if (hash_mode == 10400) kernel_threads = 64; // RC4
14133 if (hash_mode == 10410) kernel_threads = 64; // RC4
14134 if (hash_mode == 10500) kernel_threads = 64; // RC4
14135 if (hash_mode == 13100) kernel_threads = 64; // RC4
14136
14137 /**
14138 * create input buffers on device : calculate size of fixed memory buffers
14139 */
14140
14141 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14142 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14143
14144 device_param->size_root_css = size_root_css;
14145 device_param->size_markov_css = size_markov_css;
14146
14147 size_t size_results = sizeof (uint);
14148
14149 device_param->size_results = size_results;
14150
14151 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14152 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14153
14154 size_t size_plains = digests_cnt * sizeof (plain_t);
14155 size_t size_salts = salts_cnt * sizeof (salt_t);
14156 size_t size_esalts = salts_cnt * esalt_size;
14157
14158 device_param->size_plains = size_plains;
14159 device_param->size_digests = size_digests;
14160 device_param->size_shown = size_shown;
14161 device_param->size_salts = size_salts;
14162
14163 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14164 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14165 size_t size_tm = 32 * sizeof (bs_word_t);
14166
14167 // scryptV stuff
14168
14169 size_t size_scryptV = 1;
14170
14171 if ((hash_mode == 8900) || (hash_mode == 9300))
14172 {
14173 uint tmto_start = 0;
14174 uint tmto_stop = 10;
14175
14176 if (scrypt_tmto)
14177 {
14178 tmto_start = scrypt_tmto;
14179 }
14180 else
14181 {
14182 // in case the user did not specify the tmto manually
14183 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14184 // but set the lower end only in case the user has a device with too less memory
14185
14186 if (hash_mode == 8900)
14187 {
14188 if (device_param->vendor_id == VENDOR_ID_AMD)
14189 {
14190 tmto_start = 1;
14191 }
14192 else if (device_param->vendor_id == VENDOR_ID_NV)
14193 {
14194 tmto_start = 2;
14195 }
14196 }
14197 else if (hash_mode == 9300)
14198 {
14199 if (device_param->vendor_id == VENDOR_ID_AMD)
14200 {
14201 tmto_start = 2;
14202 }
14203 else if (device_param->vendor_id == VENDOR_ID_NV)
14204 {
14205 tmto_start = 2;
14206 }
14207 }
14208 }
14209
14210 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14211 {
14212 // TODO: in theory the following calculation needs to be done per salt, not global
14213 // we assume all hashes have the same scrypt settings
14214
14215 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14216
14217 size_scryptV /= 1 << tmto;
14218
14219 size_scryptV *= device_processors * device_processor_cores;
14220
14221 if (size_scryptV > device_param->device_maxmem_alloc)
14222 {
14223 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14224
14225 continue;
14226 }
14227
14228 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14229 {
14230 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14231 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14232 }
14233
14234 break;
14235 }
14236
14237 if (data.salts_buf[0].scrypt_phy == 0)
14238 {
14239 log_error ("ERROR: can't allocate enough device memory");
14240
14241 return -1;
14242 }
14243
14244 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14245 }
14246
14247 /**
14248 * some algorithms need a fixed kernel-loops count
14249 */
14250
14251 if (hash_mode == 1500)
14252 {
14253 const u32 kernel_loops_fixed = 1024;
14254
14255 device_param->kernel_loops_min = kernel_loops_fixed;
14256 device_param->kernel_loops_max = kernel_loops_fixed;
14257 }
14258
14259 if (hash_mode == 3000)
14260 {
14261 const u32 kernel_loops_fixed = 1024;
14262
14263 device_param->kernel_loops_min = kernel_loops_fixed;
14264 device_param->kernel_loops_max = kernel_loops_fixed;
14265 }
14266
14267 if (hash_mode == 8900)
14268 {
14269 const u32 kernel_loops_fixed = 1;
14270
14271 device_param->kernel_loops_min = kernel_loops_fixed;
14272 device_param->kernel_loops_max = kernel_loops_fixed;
14273 }
14274
14275 if (hash_mode == 9300)
14276 {
14277 const u32 kernel_loops_fixed = 1;
14278
14279 device_param->kernel_loops_min = kernel_loops_fixed;
14280 device_param->kernel_loops_max = kernel_loops_fixed;
14281 }
14282
14283 if (hash_mode == 12500)
14284 {
14285 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14286
14287 device_param->kernel_loops_min = kernel_loops_fixed;
14288 device_param->kernel_loops_max = kernel_loops_fixed;
14289 }
14290
14291 /**
14292 * some algorithms have a maximum kernel-loops count
14293 */
14294
14295 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14296 {
14297 u32 innerloop_cnt = 0;
14298
14299 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14300 {
14301 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14302 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14303 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14304 }
14305 else
14306 {
14307 innerloop_cnt = data.salts_buf[0].salt_iter;
14308 }
14309
14310 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14311 (innerloop_cnt <= device_param->kernel_loops_max))
14312 {
14313 device_param->kernel_loops_max = innerloop_cnt;
14314 }
14315 }
14316
14317 u32 kernel_accel_min = device_param->kernel_accel_min;
14318 u32 kernel_accel_max = device_param->kernel_accel_max;
14319
14320 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14321
14322 size_t size_pws = 4;
14323 size_t size_tmps = 4;
14324 size_t size_hooks = 4;
14325
14326 while (kernel_accel_max >= kernel_accel_min)
14327 {
14328 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14329
14330 // size_pws
14331
14332 size_pws = kernel_power_max * sizeof (pw_t);
14333
14334 // size_tmps
14335
14336 switch (hash_mode)
14337 {
14338 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14339 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14340 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14341 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14342 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14343 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14344 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14345 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14346 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14347 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14348 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14349 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14350 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14351 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14352 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14353 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14354 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14355 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14356 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14357 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14358 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14359 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14360 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14361 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14362 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14363 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14364 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14365 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14366 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14367 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14368 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14369 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14370 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14371 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14372 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14373 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14374 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14375 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14376 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14377 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14378 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14379 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14380 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14381 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14382 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14383 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14384 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14385 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14386 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14387 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14388 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14389 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14390 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14391 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14392 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14393 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14394 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14395 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14396 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14397 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14398 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14399 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14400 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14401 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14402 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14403 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14404 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14405 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14406 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14407 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14408 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14409 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14410 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14411 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14412 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14413 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14414 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14415 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14416 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14417 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14418 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14419 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14420 };
14421
14422 // size_hooks
14423
14424 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14425 {
14426 // none yet
14427 }
14428
14429 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14430 // if not, decrease amplifier and try again
14431
14432 int skip = 0;
14433
14434 if (size_pws > device_param->device_maxmem_alloc) skip = 1;
14435 if (size_tmps > device_param->device_maxmem_alloc) skip = 1;
14436 if (size_hooks > device_param->device_maxmem_alloc) skip = 1;
14437
14438 if (( bitmap_size
14439 + bitmap_size
14440 + bitmap_size
14441 + bitmap_size
14442 + bitmap_size
14443 + bitmap_size
14444 + bitmap_size
14445 + bitmap_size
14446 + size_bfs
14447 + size_combs
14448 + size_digests
14449 + size_esalts
14450 + size_hooks
14451 + size_markov_css
14452 + size_plains
14453 + size_pws
14454 + size_pws // not a bug
14455 + size_results
14456 + size_root_css
14457 + size_rules
14458 + size_rules_c
14459 + size_salts
14460 + size_scryptV
14461 + size_shown
14462 + size_tm
14463 + size_tmps) > device_param->device_global_mem) skip = 1;
14464
14465 if (skip == 1)
14466 {
14467 kernel_accel_max--;
14468
14469 continue;
14470 }
14471
14472 break;
14473 }
14474
14475 /*
14476 if (kernel_accel_max == 0)
14477 {
14478 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14479
14480 return -1;
14481 }
14482 */
14483
14484 device_param->kernel_accel_min = kernel_accel_min;
14485 device_param->kernel_accel_max = kernel_accel_max;
14486
14487 /*
14488 if (kernel_accel_max < kernel_accel)
14489 {
14490 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14491
14492 device_param->kernel_accel = kernel_accel_max;
14493 }
14494 */
14495
14496 device_param->size_bfs = size_bfs;
14497 device_param->size_combs = size_combs;
14498 device_param->size_rules = size_rules;
14499 device_param->size_rules_c = size_rules_c;
14500 device_param->size_pws = size_pws;
14501 device_param->size_tmps = size_tmps;
14502 device_param->size_hooks = size_hooks;
14503
14504 // do not confuse kernel_accel_max with kernel_accel here
14505
14506 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14507
14508 device_param->kernel_threads = kernel_threads;
14509 device_param->kernel_power_user = kernel_power;
14510
14511 kernel_power_all += kernel_power;
14512
14513 /**
14514 * default building options
14515 */
14516
14517 char build_opts[1024] = { 0 };
14518
14519 // we don't have sm_* on vendors not NV but it doesn't matter
14520
14521 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);
14522
14523 if (device_param->vendor_id == VENDOR_ID_INTEL_SDK)
14524 {
14525 // we do vectorizing much better than the auto-vectorizer
14526
14527 char build_opts_new[1024] = { 0 };
14528
14529 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14530
14531 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14532 }
14533
14534 #ifdef DEBUG
14535 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14536 #endif
14537
14538 /**
14539 * main kernel
14540 */
14541
14542 {
14543 /**
14544 * kernel source filename
14545 */
14546
14547 char source_file[256] = { 0 };
14548
14549 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14550
14551 struct stat sst;
14552
14553 if (stat (source_file, &sst) == -1)
14554 {
14555 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14556
14557 return -1;
14558 }
14559
14560 /**
14561 * kernel cached filename
14562 */
14563
14564 char cached_file[256] = { 0 };
14565
14566 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14567
14568 int cached = 1;
14569
14570 struct stat cst;
14571
14572 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14573 {
14574 cached = 0;
14575 }
14576
14577 /**
14578 * kernel compile or load
14579 */
14580
14581 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14582
14583 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14584
14585 if (force_jit_compilation == -1)
14586 {
14587 if (cached == 0)
14588 {
14589 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14590
14591 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14592
14593 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14594
14595 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14596
14597 #ifdef DEBUG
14598 size_t build_log_size = 0;
14599
14600 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14601
14602 if (build_log_size > 1)
14603 {
14604 char *build_log = (char *) malloc (build_log_size + 1);
14605
14606 memset (build_log, 0, build_log_size + 1);
14607
14608 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14609
14610 puts (build_log);
14611
14612 free (build_log);
14613 }
14614 #endif
14615
14616 if (rc != 0)
14617 {
14618 device_param->skipped = true;
14619
14620 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14621
14622 continue;
14623 }
14624
14625 size_t binary_size;
14626
14627 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14628
14629 u8 *binary = (u8 *) mymalloc (binary_size);
14630
14631 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14632
14633 writeProgramBin (cached_file, binary, binary_size);
14634
14635 local_free (binary);
14636 }
14637 else
14638 {
14639 #ifdef DEBUG
14640 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14641 #endif
14642
14643 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14644
14645 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14646
14647 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14648 }
14649 }
14650 else
14651 {
14652 #ifdef DEBUG
14653 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14654 #endif
14655
14656 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14657
14658 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14659
14660 char build_opts_update[1024] = { 0 };
14661
14662 if (force_jit_compilation == 1500)
14663 {
14664 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14665 }
14666 else if (force_jit_compilation == 8900)
14667 {
14668 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);
14669 }
14670 else
14671 {
14672 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14673 }
14674
14675 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14676
14677 #ifdef DEBUG
14678 size_t build_log_size = 0;
14679
14680 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14681
14682 if (build_log_size > 1)
14683 {
14684 char *build_log = (char *) malloc (build_log_size + 1);
14685
14686 memset (build_log, 0, build_log_size + 1);
14687
14688 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14689
14690 puts (build_log);
14691
14692 free (build_log);
14693 }
14694 #endif
14695
14696 if (rc != 0)
14697 {
14698 device_param->skipped = true;
14699
14700 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14701 }
14702 }
14703
14704 local_free (kernel_lengths);
14705 local_free (kernel_sources[0]);
14706 local_free (kernel_sources);
14707 }
14708
14709 /**
14710 * word generator kernel
14711 */
14712
14713 if (attack_mode != ATTACK_MODE_STRAIGHT)
14714 {
14715 /**
14716 * kernel mp source filename
14717 */
14718
14719 char source_file[256] = { 0 };
14720
14721 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
14722
14723 struct stat sst;
14724
14725 if (stat (source_file, &sst) == -1)
14726 {
14727 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14728
14729 return -1;
14730 }
14731
14732 /**
14733 * kernel mp cached filename
14734 */
14735
14736 char cached_file[256] = { 0 };
14737
14738 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
14739
14740 int cached = 1;
14741
14742 struct stat cst;
14743
14744 if (stat (cached_file, &cst) == -1)
14745 {
14746 cached = 0;
14747 }
14748
14749 /**
14750 * kernel compile or load
14751 */
14752
14753 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14754
14755 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14756
14757 if (cached == 0)
14758 {
14759 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14760 if (quiet == 0) log_info ("");
14761
14762 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14763
14764 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14765
14766 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
14767
14768 if (rc != 0)
14769 {
14770 device_param->skipped = true;
14771
14772 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14773
14774 continue;
14775 }
14776
14777 size_t binary_size;
14778
14779 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14780
14781 u8 *binary = (u8 *) mymalloc (binary_size);
14782
14783 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14784
14785 writeProgramBin (cached_file, binary, binary_size);
14786
14787 local_free (binary);
14788 }
14789 else
14790 {
14791 #ifdef DEBUG
14792 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14793 #endif
14794
14795 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14796
14797 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14798
14799 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
14800 }
14801
14802 local_free (kernel_lengths);
14803 local_free (kernel_sources[0]);
14804 local_free (kernel_sources);
14805 }
14806
14807 /**
14808 * amplifier kernel
14809 */
14810
14811 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14812 {
14813
14814 }
14815 else
14816 {
14817 /**
14818 * kernel amp source filename
14819 */
14820
14821 char source_file[256] = { 0 };
14822
14823 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
14824
14825 struct stat sst;
14826
14827 if (stat (source_file, &sst) == -1)
14828 {
14829 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14830
14831 return -1;
14832 }
14833
14834 /**
14835 * kernel amp cached filename
14836 */
14837
14838 char cached_file[256] = { 0 };
14839
14840 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
14841
14842 int cached = 1;
14843
14844 struct stat cst;
14845
14846 if (stat (cached_file, &cst) == -1)
14847 {
14848 cached = 0;
14849 }
14850
14851 /**
14852 * kernel compile or load
14853 */
14854
14855 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14856
14857 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14858
14859 if (cached == 0)
14860 {
14861 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14862 if (quiet == 0) log_info ("");
14863
14864 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14865
14866 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14867
14868 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
14869
14870 if (rc != 0)
14871 {
14872 device_param->skipped = true;
14873
14874 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14875
14876 continue;
14877 }
14878
14879 size_t binary_size;
14880
14881 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14882
14883 u8 *binary = (u8 *) mymalloc (binary_size);
14884
14885 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14886
14887 writeProgramBin (cached_file, binary, binary_size);
14888
14889 local_free (binary);
14890 }
14891 else
14892 {
14893 #ifdef DEBUG
14894 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14895 #endif
14896
14897 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14898
14899 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14900
14901 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
14902 }
14903
14904 local_free (kernel_lengths);
14905 local_free (kernel_sources[0]);
14906 local_free (kernel_sources);
14907 }
14908
14909 // some algorithm collide too fast, make that impossible
14910
14911 if (benchmark == 1)
14912 {
14913 ((uint *) digests_buf)[0] = -1;
14914 ((uint *) digests_buf)[1] = -1;
14915 ((uint *) digests_buf)[2] = -1;
14916 ((uint *) digests_buf)[3] = -1;
14917 }
14918
14919 /**
14920 * global buffers
14921 */
14922
14923 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14924 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
14925 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
14926 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
14927 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14928 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14929 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14930 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14931 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14932 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14933 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14934 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
14935 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
14936 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
14937 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
14938 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
14939 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
14940 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
14941
14942 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);
14943 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);
14944 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);
14945 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);
14946 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);
14947 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);
14948 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);
14949 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);
14950 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
14951 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
14952 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
14953
14954 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
14955 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
14956 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
14957 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
14958 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
14959 run_kernel_bzero (device_param, device_param->d_result, size_results);
14960
14961 /**
14962 * special buffers
14963 */
14964
14965 if (attack_kern == ATTACK_KERN_STRAIGHT)
14966 {
14967 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
14968 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
14969
14970 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
14971
14972 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
14973 }
14974 else if (attack_kern == ATTACK_KERN_COMBI)
14975 {
14976 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14977 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
14978 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14979 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14980
14981 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
14982 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
14983 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14984 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14985 }
14986 else if (attack_kern == ATTACK_KERN_BF)
14987 {
14988 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14989 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
14990 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
14991 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
14992 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
14993
14994 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
14995 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
14996 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
14997 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
14998 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
14999 }
15000
15001 if (size_esalts)
15002 {
15003 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15004
15005 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15006 }
15007
15008 /**
15009 * main host data
15010 */
15011
15012 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15013
15014 device_param->pws_buf = pws_buf;
15015
15016 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15017
15018 device_param->combs_buf = combs_buf;
15019
15020 void *hooks_buf = mymalloc (size_hooks);
15021
15022 device_param->hooks_buf = hooks_buf;
15023
15024 /**
15025 * kernel args
15026 */
15027
15028 device_param->kernel_params_buf32[21] = bitmap_mask;
15029 device_param->kernel_params_buf32[22] = bitmap_shift1;
15030 device_param->kernel_params_buf32[23] = bitmap_shift2;
15031 device_param->kernel_params_buf32[24] = 0; // salt_pos
15032 device_param->kernel_params_buf32[25] = 0; // loop_pos
15033 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15034 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15035 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15036 device_param->kernel_params_buf32[29] = 0; // digests_offset
15037 device_param->kernel_params_buf32[30] = 0; // combs_mode
15038 device_param->kernel_params_buf32[31] = 0; // gid_max
15039
15040 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15041 ? &device_param->d_pws_buf
15042 : &device_param->d_pws_amp_buf;
15043 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15044 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15045 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15046 device_param->kernel_params[ 4] = &device_param->d_tmps;
15047 device_param->kernel_params[ 5] = &device_param->d_hooks;
15048 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15049 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15050 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15051 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15052 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15053 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15054 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15055 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15056 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15057 device_param->kernel_params[15] = &device_param->d_digests_buf;
15058 device_param->kernel_params[16] = &device_param->d_digests_shown;
15059 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15060 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15061 device_param->kernel_params[19] = &device_param->d_result;
15062 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15063 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15064 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15065 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15066 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15067 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15068 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15069 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15070 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15071 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15072 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15073 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15074
15075 device_param->kernel_params_mp_buf64[3] = 0;
15076 device_param->kernel_params_mp_buf32[4] = 0;
15077 device_param->kernel_params_mp_buf32[5] = 0;
15078 device_param->kernel_params_mp_buf32[6] = 0;
15079 device_param->kernel_params_mp_buf32[7] = 0;
15080 device_param->kernel_params_mp_buf32[8] = 0;
15081
15082 device_param->kernel_params_mp[0] = NULL;
15083 device_param->kernel_params_mp[1] = NULL;
15084 device_param->kernel_params_mp[2] = NULL;
15085 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15086 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15087 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15088 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15089 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15090 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15091
15092 device_param->kernel_params_mp_l_buf64[3] = 0;
15093 device_param->kernel_params_mp_l_buf32[4] = 0;
15094 device_param->kernel_params_mp_l_buf32[5] = 0;
15095 device_param->kernel_params_mp_l_buf32[6] = 0;
15096 device_param->kernel_params_mp_l_buf32[7] = 0;
15097 device_param->kernel_params_mp_l_buf32[8] = 0;
15098 device_param->kernel_params_mp_l_buf32[9] = 0;
15099
15100 device_param->kernel_params_mp_l[0] = NULL;
15101 device_param->kernel_params_mp_l[1] = NULL;
15102 device_param->kernel_params_mp_l[2] = NULL;
15103 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15104 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15105 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15106 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15107 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15108 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15109 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15110
15111 device_param->kernel_params_mp_r_buf64[3] = 0;
15112 device_param->kernel_params_mp_r_buf32[4] = 0;
15113 device_param->kernel_params_mp_r_buf32[5] = 0;
15114 device_param->kernel_params_mp_r_buf32[6] = 0;
15115 device_param->kernel_params_mp_r_buf32[7] = 0;
15116 device_param->kernel_params_mp_r_buf32[8] = 0;
15117
15118 device_param->kernel_params_mp_r[0] = NULL;
15119 device_param->kernel_params_mp_r[1] = NULL;
15120 device_param->kernel_params_mp_r[2] = NULL;
15121 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15122 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15123 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15124 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15125 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15126 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15127
15128 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15129 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15130
15131 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15132 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15133 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15134 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15135 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15136 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15137 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15138
15139 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15140 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15141
15142 /**
15143 * kernel name
15144 */
15145
15146 size_t kernel_wgs_tmp;
15147
15148 char kernel_name[64] = { 0 };
15149
15150 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15151 {
15152 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15153 {
15154 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15155
15156 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15157
15158 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15159
15160 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15161
15162 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15163
15164 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15165 }
15166 else
15167 {
15168 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15169
15170 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15171
15172 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15173
15174 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15175
15176 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15177
15178 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15179 }
15180
15181 if (data.attack_mode == ATTACK_MODE_BF)
15182 {
15183 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15184 {
15185 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15186
15187 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15188
15189 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);
15190 }
15191 }
15192 }
15193 else
15194 {
15195 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15196
15197 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15198
15199 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15200
15201 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15202
15203 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15204
15205 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15206
15207 if (opts_type & OPTS_TYPE_HOOK12)
15208 {
15209 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15210
15211 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15212
15213 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);
15214 }
15215
15216 if (opts_type & OPTS_TYPE_HOOK23)
15217 {
15218 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15219
15220 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15221
15222 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);
15223 }
15224 }
15225
15226 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);
15227 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);
15228 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);
15229
15230 for (uint i = 0; i <= 20; i++)
15231 {
15232 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15233 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15234 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15235
15236 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15237 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15238 }
15239
15240 for (uint i = 21; i <= 31; i++)
15241 {
15242 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15243 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15244 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15245
15246 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15247 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15248 }
15249
15250 if (attack_mode == ATTACK_MODE_BF)
15251 {
15252 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15253 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15254
15255 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);
15256 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);
15257
15258 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15259 {
15260 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15261 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15262 }
15263 }
15264 else if (attack_mode == ATTACK_MODE_HYBRID1)
15265 {
15266 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15267
15268 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);
15269 }
15270 else if (attack_mode == ATTACK_MODE_HYBRID2)
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
15277 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15278 {
15279 // nothing to do
15280 }
15281 else
15282 {
15283 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15284
15285 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);
15286 }
15287
15288 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15289 {
15290 // nothing to do
15291 }
15292 else
15293 {
15294 for (uint i = 0; i < 5; i++)
15295 {
15296 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15297 }
15298
15299 for (uint i = 5; i < 7; i++)
15300 {
15301 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15302 }
15303 }
15304
15305 // maybe this has been updated by clGetKernelWorkGroupInfo()
15306 // value can only be decreased, so we don't need to reallocate buffers
15307
15308 device_param->kernel_threads = kernel_threads;
15309
15310 /**
15311 * Store initial fanspeed if gpu_temp_retain is enabled
15312 */
15313
15314 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15315 int gpu_temp_retain_set = 0;
15316
15317 if (gpu_temp_disable == 0)
15318 {
15319 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15320 {
15321 hc_thread_mutex_lock (mux_adl);
15322
15323 if (data.hm_device[device_id].fan_supported == 1)
15324 {
15325 if (gpu_temp_retain_chgd == 0)
15326 {
15327 uint cur_temp = 0;
15328 uint default_temp = 0;
15329
15330 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);
15331
15332 if (ADL_rc == ADL_OK)
15333 {
15334 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15335
15336 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15337
15338 // special case with multi gpu setups: always use minimum retain
15339
15340 if (gpu_temp_retain_set == 0)
15341 {
15342 gpu_temp_retain = gpu_temp_retain_target;
15343 gpu_temp_retain_set = 1;
15344 }
15345 else
15346 {
15347 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15348 }
15349
15350 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15351 }
15352 }
15353
15354 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15355
15356 temp_retain_fanspeed_value[device_id] = fan_speed;
15357
15358 if (fan_speed == -1)
15359 {
15360 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15361
15362 temp_retain_fanspeed_value[device_id] = 0;
15363 }
15364 }
15365
15366 hc_thread_mutex_unlock (mux_adl);
15367 }
15368 }
15369
15370 /**
15371 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15372 */
15373
15374 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15375 {
15376 hc_thread_mutex_lock (mux_adl);
15377
15378 if (data.hm_device[device_id].od_version == 6)
15379 {
15380 int ADL_rc;
15381
15382 // check powertune capabilities first, if not available then skip device
15383
15384 int powertune_supported = 0;
15385
15386 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15387 {
15388 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15389
15390 return (-1);
15391 }
15392
15393 if (powertune_supported != 0)
15394 {
15395 // powercontrol settings
15396
15397 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15398
15399 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15400 {
15401 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15402 }
15403
15404 if (ADL_rc != ADL_OK)
15405 {
15406 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15407
15408 return (-1);
15409 }
15410
15411 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15412 {
15413 log_error ("ERROR: Failed to set new ADL PowerControl values");
15414
15415 return (-1);
15416 }
15417
15418 // clocks
15419
15420 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15421
15422 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15423
15424 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)
15425 {
15426 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15427
15428 return (-1);
15429 }
15430
15431 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15432
15433 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15434
15435 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15436 {
15437 log_error ("ERROR: Failed to get ADL device capabilities");
15438
15439 return (-1);
15440 }
15441
15442 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15443 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15444
15445 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15446 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15447
15448 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15449 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15450
15451 // warning if profile has too low max values
15452
15453 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15454 {
15455 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15456 }
15457
15458 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15459 {
15460 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15461 }
15462
15463 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15464
15465 performance_state->iNumberOfPerformanceLevels = 2;
15466
15467 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15468 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15469 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15470 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15471
15472 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)
15473 {
15474 log_info ("ERROR: Failed to set ADL performance state");
15475
15476 return (-1);
15477 }
15478
15479 local_free (performance_state);
15480 }
15481 }
15482
15483 hc_thread_mutex_unlock (mux_adl);
15484 }
15485 #endif // HAVE_HWMON && HAVE_ADL
15486 }
15487
15488 data.kernel_power_all = kernel_power_all;
15489
15490 if (data.quiet == 0) log_info_nn ("");
15491
15492 /**
15493 * In benchmark-mode, inform user which algorithm is checked
15494 */
15495
15496 if (benchmark == 1)
15497 {
15498 if (status_automat == 0)
15499 {
15500 quiet = 0;
15501
15502 data.quiet = quiet;
15503
15504 char *hash_type = strhashtype (data.hash_mode); // not a bug
15505
15506 log_info ("Hashtype: %s", hash_type);
15507 log_info ("");
15508 }
15509 }
15510
15511 /**
15512 * keep track of the progress
15513 */
15514
15515 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15516 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15517 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15518
15519 /**
15520 * open filehandles
15521 */
15522
15523 #if _WIN
15524 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15525 {
15526 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15527
15528 return (-1);
15529 }
15530
15531 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15532 {
15533 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15534
15535 return (-1);
15536 }
15537
15538 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15539 {
15540 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15541
15542 return (-1);
15543 }
15544 #endif
15545
15546 /**
15547 * dictionary pad
15548 */
15549
15550 segment_size *= (1024 * 1024);
15551
15552 data.segment_size = segment_size;
15553
15554 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15555
15556 wl_data->buf = (char *) mymalloc (segment_size);
15557 wl_data->avail = segment_size;
15558 wl_data->incr = segment_size;
15559 wl_data->cnt = 0;
15560 wl_data->pos = 0;
15561
15562 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15563
15564 data.wordlist_mode = wordlist_mode;
15565
15566 cs_t *css_buf = NULL;
15567 uint css_cnt = 0;
15568 uint dictcnt = 0;
15569 uint maskcnt = 1;
15570 char **masks = NULL;
15571 char **dictfiles = NULL;
15572
15573 uint mask_from_file = 0;
15574
15575 if (attack_mode == ATTACK_MODE_STRAIGHT)
15576 {
15577 if (wordlist_mode == WL_MODE_FILE)
15578 {
15579 int wls_left = myargc - (optind + 1);
15580
15581 for (int i = 0; i < wls_left; i++)
15582 {
15583 char *l0_filename = myargv[optind + 1 + i];
15584
15585 struct stat l0_stat;
15586
15587 if (stat (l0_filename, &l0_stat) == -1)
15588 {
15589 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15590
15591 return (-1);
15592 }
15593
15594 uint is_dir = S_ISDIR (l0_stat.st_mode);
15595
15596 if (is_dir == 0)
15597 {
15598 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15599
15600 dictcnt++;
15601
15602 dictfiles[dictcnt - 1] = l0_filename;
15603 }
15604 else
15605 {
15606 // do not allow --keyspace w/ a directory
15607
15608 if (keyspace == 1)
15609 {
15610 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15611
15612 return (-1);
15613 }
15614
15615 char **dictionary_files = NULL;
15616
15617 dictionary_files = scan_directory (l0_filename);
15618
15619 if (dictionary_files != NULL)
15620 {
15621 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15622
15623 for (int d = 0; dictionary_files[d] != NULL; d++)
15624 {
15625 char *l1_filename = dictionary_files[d];
15626
15627 struct stat l1_stat;
15628
15629 if (stat (l1_filename, &l1_stat) == -1)
15630 {
15631 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15632
15633 return (-1);
15634 }
15635
15636 if (S_ISREG (l1_stat.st_mode))
15637 {
15638 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15639
15640 dictcnt++;
15641
15642 dictfiles[dictcnt - 1] = strdup (l1_filename);
15643 }
15644 }
15645 }
15646
15647 local_free (dictionary_files);
15648 }
15649 }
15650
15651 if (dictcnt < 1)
15652 {
15653 log_error ("ERROR: No usable dictionary file found.");
15654
15655 return (-1);
15656 }
15657 }
15658 else if (wordlist_mode == WL_MODE_STDIN)
15659 {
15660 dictcnt = 1;
15661 }
15662 }
15663 else if (attack_mode == ATTACK_MODE_COMBI)
15664 {
15665 // display
15666
15667 char *dictfile1 = myargv[optind + 1 + 0];
15668 char *dictfile2 = myargv[optind + 1 + 1];
15669
15670 // find the bigger dictionary and use as base
15671
15672 FILE *fp1 = NULL;
15673 FILE *fp2 = NULL;
15674
15675 struct stat tmp_stat;
15676
15677 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
15678 {
15679 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15680
15681 return (-1);
15682 }
15683
15684 if (stat (dictfile1, &tmp_stat) == -1)
15685 {
15686 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
15687
15688 fclose (fp1);
15689
15690 return (-1);
15691 }
15692
15693 if (S_ISDIR (tmp_stat.st_mode))
15694 {
15695 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
15696
15697 fclose (fp1);
15698
15699 return (-1);
15700 }
15701
15702 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
15703 {
15704 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15705
15706 fclose (fp1);
15707
15708 return (-1);
15709 }
15710
15711 if (stat (dictfile2, &tmp_stat) == -1)
15712 {
15713 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
15714
15715 fclose (fp1);
15716 fclose (fp2);
15717
15718 return (-1);
15719 }
15720
15721 if (S_ISDIR (tmp_stat.st_mode))
15722 {
15723 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
15724
15725 fclose (fp1);
15726 fclose (fp2);
15727
15728 return (-1);
15729 }
15730
15731 data.combs_cnt = 1;
15732
15733 data.quiet = 1;
15734
15735 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
15736
15737 data.quiet = quiet;
15738
15739 if (words1_cnt == 0)
15740 {
15741 log_error ("ERROR: %s: empty file", dictfile1);
15742
15743 fclose (fp1);
15744 fclose (fp2);
15745
15746 return (-1);
15747 }
15748
15749 data.combs_cnt = 1;
15750
15751 data.quiet = 1;
15752
15753 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
15754
15755 data.quiet = quiet;
15756
15757 if (words2_cnt == 0)
15758 {
15759 log_error ("ERROR: %s: empty file", dictfile2);
15760
15761 fclose (fp1);
15762 fclose (fp2);
15763
15764 return (-1);
15765 }
15766
15767 fclose (fp1);
15768 fclose (fp2);
15769
15770 data.dictfile = dictfile1;
15771 data.dictfile2 = dictfile2;
15772
15773 if (words1_cnt >= words2_cnt)
15774 {
15775 data.combs_cnt = words2_cnt;
15776 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15777
15778 dictfiles = &data.dictfile;
15779
15780 dictcnt = 1;
15781 }
15782 else
15783 {
15784 data.combs_cnt = words1_cnt;
15785 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
15786
15787 dictfiles = &data.dictfile2;
15788
15789 dictcnt = 1;
15790
15791 // we also have to switch wordlist related rules!
15792
15793 char *tmpc = data.rule_buf_l;
15794
15795 data.rule_buf_l = data.rule_buf_r;
15796 data.rule_buf_r = tmpc;
15797
15798 int tmpi = data.rule_len_l;
15799
15800 data.rule_len_l = data.rule_len_r;
15801 data.rule_len_r = tmpi;
15802 }
15803 }
15804 else if (attack_mode == ATTACK_MODE_BF)
15805 {
15806 char *mask = NULL;
15807
15808 maskcnt = 0;
15809
15810 if (benchmark == 0)
15811 {
15812 mask = myargv[optind + 1];
15813
15814 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
15815
15816 if ((optind + 2) <= myargc)
15817 {
15818 struct stat file_stat;
15819
15820 if (stat (mask, &file_stat) == -1)
15821 {
15822 maskcnt = 1;
15823
15824 masks[maskcnt - 1] = mystrdup (mask);
15825 }
15826 else
15827 {
15828 int wls_left = myargc - (optind + 1);
15829
15830 uint masks_avail = INCR_MASKS;
15831
15832 for (int i = 0; i < wls_left; i++)
15833 {
15834 if (i != 0)
15835 {
15836 mask = myargv[optind + 1 + i];
15837
15838 if (stat (mask, &file_stat) == -1)
15839 {
15840 log_error ("ERROR: %s: %s", mask, strerror (errno));
15841
15842 return (-1);
15843 }
15844 }
15845
15846 uint is_file = S_ISREG (file_stat.st_mode);
15847
15848 if (is_file == 1)
15849 {
15850 FILE *mask_fp;
15851
15852 if ((mask_fp = fopen (mask, "r")) == NULL)
15853 {
15854 log_error ("ERROR: %s: %s", mask, strerror (errno));
15855
15856 return (-1);
15857 }
15858
15859 char *line_buf = (char *) mymalloc (HCBUFSIZ);
15860
15861 while (!feof (mask_fp))
15862 {
15863 memset (line_buf, 0, HCBUFSIZ);
15864
15865 int line_len = fgetl (mask_fp, line_buf);
15866
15867 if (line_len == 0) continue;
15868
15869 if (line_buf[0] == '#') continue;
15870
15871 if (masks_avail == maskcnt)
15872 {
15873 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
15874
15875 masks_avail += INCR_MASKS;
15876 }
15877
15878 masks[maskcnt] = mystrdup (line_buf);
15879
15880 maskcnt++;
15881 }
15882
15883 myfree (line_buf);
15884
15885 fclose (mask_fp);
15886 }
15887 else
15888 {
15889 log_error ("ERROR: %s: unsupported file-type", mask);
15890
15891 return (-1);
15892 }
15893 }
15894
15895 mask_from_file = 1;
15896 }
15897 }
15898 else
15899 {
15900 custom_charset_1 = (char *) "?l?d?u";
15901 custom_charset_2 = (char *) "?l?d";
15902 custom_charset_3 = (char *) "?l?d*!$@_";
15903
15904 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
15905 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
15906 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
15907
15908 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
15909
15910 wordlist_mode = WL_MODE_MASK;
15911
15912 data.wordlist_mode = wordlist_mode;
15913
15914 increment = 1;
15915
15916 maskcnt = 1;
15917 }
15918 }
15919 else
15920 {
15921 /**
15922 * generate full masks and charsets
15923 */
15924
15925 masks = (char **) mymalloc (sizeof (char *));
15926
15927 switch (hash_mode)
15928 {
15929 case 1731: pw_min = 5;
15930 pw_max = 5;
15931 mask = mystrdup ("?b?b?b?b?b");
15932 break;
15933 case 12500: pw_min = 5;
15934 pw_max = 5;
15935 mask = mystrdup ("?b?b?b?b?b");
15936 break;
15937 default: pw_min = 7;
15938 pw_max = 7;
15939 mask = mystrdup ("?b?b?b?b?b?b?b");
15940 break;
15941 }
15942
15943 maskcnt = 1;
15944
15945 masks[maskcnt - 1] = mystrdup (mask);
15946
15947 wordlist_mode = WL_MODE_MASK;
15948
15949 data.wordlist_mode = wordlist_mode;
15950
15951 increment = 1;
15952 }
15953
15954 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
15955
15956 if (increment)
15957 {
15958 if (increment_min > pw_min) pw_min = increment_min;
15959
15960 if (increment_max < pw_max) pw_max = increment_max;
15961 }
15962 }
15963 else if (attack_mode == ATTACK_MODE_HYBRID1)
15964 {
15965 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
15966
15967 // display
15968
15969 char *mask = myargv[myargc - 1];
15970
15971 maskcnt = 0;
15972
15973 masks = (char **) mymalloc (1 * sizeof (char *));
15974
15975 // mod
15976
15977 struct stat file_stat;
15978
15979 if (stat (mask, &file_stat) == -1)
15980 {
15981 maskcnt = 1;
15982
15983 masks[maskcnt - 1] = mystrdup (mask);
15984 }
15985 else
15986 {
15987 uint is_file = S_ISREG (file_stat.st_mode);
15988
15989 if (is_file == 1)
15990 {
15991 FILE *mask_fp;
15992
15993 if ((mask_fp = fopen (mask, "r")) == NULL)
15994 {
15995 log_error ("ERROR: %s: %s", mask, strerror (errno));
15996
15997 return (-1);
15998 }
15999
16000 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16001
16002 uint masks_avail = 1;
16003
16004 while (!feof (mask_fp))
16005 {
16006 memset (line_buf, 0, HCBUFSIZ);
16007
16008 int line_len = fgetl (mask_fp, line_buf);
16009
16010 if (line_len == 0) continue;
16011
16012 if (line_buf[0] == '#') continue;
16013
16014 if (masks_avail == maskcnt)
16015 {
16016 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16017
16018 masks_avail += INCR_MASKS;
16019 }
16020
16021 masks[maskcnt] = mystrdup (line_buf);
16022
16023 maskcnt++;
16024 }
16025
16026 myfree (line_buf);
16027
16028 fclose (mask_fp);
16029
16030 mask_from_file = 1;
16031 }
16032 else
16033 {
16034 maskcnt = 1;
16035
16036 masks[maskcnt - 1] = mystrdup (mask);
16037 }
16038 }
16039
16040 // base
16041
16042 int wls_left = myargc - (optind + 2);
16043
16044 for (int i = 0; i < wls_left; i++)
16045 {
16046 char *filename = myargv[optind + 1 + i];
16047
16048 struct stat file_stat;
16049
16050 if (stat (filename, &file_stat) == -1)
16051 {
16052 log_error ("ERROR: %s: %s", filename, strerror (errno));
16053
16054 return (-1);
16055 }
16056
16057 uint is_dir = S_ISDIR (file_stat.st_mode);
16058
16059 if (is_dir == 0)
16060 {
16061 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16062
16063 dictcnt++;
16064
16065 dictfiles[dictcnt - 1] = filename;
16066 }
16067 else
16068 {
16069 // do not allow --keyspace w/ a directory
16070
16071 if (keyspace == 1)
16072 {
16073 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16074
16075 return (-1);
16076 }
16077
16078 char **dictionary_files = NULL;
16079
16080 dictionary_files = scan_directory (filename);
16081
16082 if (dictionary_files != NULL)
16083 {
16084 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16085
16086 for (int d = 0; dictionary_files[d] != NULL; d++)
16087 {
16088 char *l1_filename = dictionary_files[d];
16089
16090 struct stat l1_stat;
16091
16092 if (stat (l1_filename, &l1_stat) == -1)
16093 {
16094 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16095
16096 return (-1);
16097 }
16098
16099 if (S_ISREG (l1_stat.st_mode))
16100 {
16101 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16102
16103 dictcnt++;
16104
16105 dictfiles[dictcnt - 1] = strdup (l1_filename);
16106 }
16107 }
16108 }
16109
16110 local_free (dictionary_files);
16111 }
16112 }
16113
16114 if (dictcnt < 1)
16115 {
16116 log_error ("ERROR: No usable dictionary file found.");
16117
16118 return (-1);
16119 }
16120
16121 if (increment)
16122 {
16123 maskcnt = 0;
16124
16125 uint mask_min = increment_min; // we can't reject smaller masks here
16126 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16127
16128 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16129 {
16130 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16131
16132 if (cur_mask == NULL) break;
16133
16134 masks[maskcnt] = cur_mask;
16135
16136 maskcnt++;
16137
16138 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16139 }
16140 }
16141 }
16142 else if (attack_mode == ATTACK_MODE_HYBRID2)
16143 {
16144 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16145
16146 // display
16147
16148 char *mask = myargv[optind + 1 + 0];
16149
16150 maskcnt = 0;
16151
16152 masks = (char **) mymalloc (1 * sizeof (char *));
16153
16154 // mod
16155
16156 struct stat file_stat;
16157
16158 if (stat (mask, &file_stat) == -1)
16159 {
16160 maskcnt = 1;
16161
16162 masks[maskcnt - 1] = mystrdup (mask);
16163 }
16164 else
16165 {
16166 uint is_file = S_ISREG (file_stat.st_mode);
16167
16168 if (is_file == 1)
16169 {
16170 FILE *mask_fp;
16171
16172 if ((mask_fp = fopen (mask, "r")) == NULL)
16173 {
16174 log_error ("ERROR: %s: %s", mask, strerror (errno));
16175
16176 return (-1);
16177 }
16178
16179 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16180
16181 uint masks_avail = 1;
16182
16183 while (!feof (mask_fp))
16184 {
16185 memset (line_buf, 0, HCBUFSIZ);
16186
16187 int line_len = fgetl (mask_fp, line_buf);
16188
16189 if (line_len == 0) continue;
16190
16191 if (line_buf[0] == '#') continue;
16192
16193 if (masks_avail == maskcnt)
16194 {
16195 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16196
16197 masks_avail += INCR_MASKS;
16198 }
16199
16200 masks[maskcnt] = mystrdup (line_buf);
16201
16202 maskcnt++;
16203 }
16204
16205 myfree (line_buf);
16206
16207 fclose (mask_fp);
16208
16209 mask_from_file = 1;
16210 }
16211 else
16212 {
16213 maskcnt = 1;
16214
16215 masks[maskcnt - 1] = mystrdup (mask);
16216 }
16217 }
16218
16219 // base
16220
16221 int wls_left = myargc - (optind + 2);
16222
16223 for (int i = 0; i < wls_left; i++)
16224 {
16225 char *filename = myargv[optind + 2 + i];
16226
16227 struct stat file_stat;
16228
16229 if (stat (filename, &file_stat) == -1)
16230 {
16231 log_error ("ERROR: %s: %s", filename, strerror (errno));
16232
16233 return (-1);
16234 }
16235
16236 uint is_dir = S_ISDIR (file_stat.st_mode);
16237
16238 if (is_dir == 0)
16239 {
16240 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16241
16242 dictcnt++;
16243
16244 dictfiles[dictcnt - 1] = filename;
16245 }
16246 else
16247 {
16248 // do not allow --keyspace w/ a directory
16249
16250 if (keyspace == 1)
16251 {
16252 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16253
16254 return (-1);
16255 }
16256
16257 char **dictionary_files = NULL;
16258
16259 dictionary_files = scan_directory (filename);
16260
16261 if (dictionary_files != NULL)
16262 {
16263 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16264
16265 for (int d = 0; dictionary_files[d] != NULL; d++)
16266 {
16267 char *l1_filename = dictionary_files[d];
16268
16269 struct stat l1_stat;
16270
16271 if (stat (l1_filename, &l1_stat) == -1)
16272 {
16273 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16274
16275 return (-1);
16276 }
16277
16278 if (S_ISREG (l1_stat.st_mode))
16279 {
16280 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16281
16282 dictcnt++;
16283
16284 dictfiles[dictcnt - 1] = strdup (l1_filename);
16285 }
16286 }
16287 }
16288
16289 local_free (dictionary_files);
16290 }
16291 }
16292
16293 if (dictcnt < 1)
16294 {
16295 log_error ("ERROR: No usable dictionary file found.");
16296
16297 return (-1);
16298 }
16299
16300 if (increment)
16301 {
16302 maskcnt = 0;
16303
16304 uint mask_min = increment_min; // we can't reject smaller masks here
16305 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16306
16307 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16308 {
16309 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16310
16311 if (cur_mask == NULL) break;
16312
16313 masks[maskcnt] = cur_mask;
16314
16315 maskcnt++;
16316
16317 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16318 }
16319 }
16320 }
16321
16322 data.pw_min = pw_min;
16323 data.pw_max = pw_max;
16324
16325 /**
16326 * weak hash check
16327 */
16328
16329 if (weak_hash_threshold >= salts_cnt)
16330 {
16331 hc_device_param_t *device_param = NULL;
16332
16333 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16334 {
16335 device_param = &data.devices_param[device_id];
16336
16337 if (device_param->skipped) continue;
16338
16339 break;
16340 }
16341
16342 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16343
16344 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16345 {
16346 weak_hash_check (device_param, salt_pos);
16347 }
16348
16349 // Display hack, guarantee that there is at least one \r before real start
16350
16351 //if (data.quiet == 0) log_info ("");
16352 }
16353
16354 /**
16355 * status and monitor threads
16356 */
16357
16358 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16359
16360 hc_thread_t i_thread = 0;
16361
16362 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16363 {
16364 hc_thread_create (i_thread, thread_keypress, &benchmark);
16365 }
16366
16367 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16368
16369 uint ni_threads_cnt = 0;
16370
16371 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16372
16373 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16374
16375 ni_threads_cnt++;
16376
16377 /**
16378 * Outfile remove
16379 */
16380
16381 if (keyspace == 0)
16382 {
16383 if (outfile_check_timer != 0)
16384 {
16385 if (data.outfile_check_directory != NULL)
16386 {
16387 if ((hash_mode != 5200) &&
16388 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16389 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16390 (hash_mode != 9000))
16391 {
16392 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16393
16394 ni_threads_cnt++;
16395 }
16396 else
16397 {
16398 outfile_check_timer = 0;
16399 }
16400 }
16401 else
16402 {
16403 outfile_check_timer = 0;
16404 }
16405 }
16406 }
16407
16408 /**
16409 * Inform the user if we got some hashes remove because of the pot file remove feature
16410 */
16411
16412 if (data.quiet == 0)
16413 {
16414 if (potfile_remove_cracks > 0)
16415 {
16416 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16417 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16418 }
16419 }
16420
16421 data.outfile_check_timer = outfile_check_timer;
16422
16423 /**
16424 * main loop
16425 */
16426
16427 char **induction_dictionaries = NULL;
16428
16429 int induction_dictionaries_cnt = 0;
16430
16431 hcstat_table_t *root_table_buf = NULL;
16432 hcstat_table_t *markov_table_buf = NULL;
16433
16434 uint initial_restore_done = 0;
16435
16436 data.maskcnt = maskcnt;
16437
16438 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16439 {
16440 if (data.devices_status == STATUS_CRACKED) break;
16441
16442 data.devices_status = STATUS_INIT;
16443
16444 if (maskpos > rd->maskpos)
16445 {
16446 rd->dictpos = 0;
16447 }
16448
16449 rd->maskpos = maskpos;
16450 data.maskpos = maskpos;
16451
16452 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16453 {
16454 char *mask = masks[maskpos];
16455
16456 if (mask_from_file == 1)
16457 {
16458 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16459
16460 char *str_ptr;
16461 uint str_pos;
16462
16463 uint mask_offset = 0;
16464
16465 uint separator_cnt;
16466
16467 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16468 {
16469 str_ptr = strstr (mask + mask_offset, ",");
16470
16471 if (str_ptr == NULL) break;
16472
16473 str_pos = str_ptr - mask;
16474
16475 // escaped separator, i.e. "\,"
16476
16477 if (str_pos > 0)
16478 {
16479 if (mask[str_pos - 1] == '\\')
16480 {
16481 separator_cnt --;
16482
16483 mask_offset = str_pos + 1;
16484
16485 continue;
16486 }
16487 }
16488
16489 // reset the offset
16490
16491 mask_offset = 0;
16492
16493 mask[str_pos] = '\0';
16494
16495 switch (separator_cnt)
16496 {
16497 case 0:
16498 mp_reset_usr (mp_usr, 0);
16499
16500 custom_charset_1 = mask;
16501 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16502 break;
16503
16504 case 1:
16505 mp_reset_usr (mp_usr, 1);
16506
16507 custom_charset_2 = mask;
16508 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16509 break;
16510
16511 case 2:
16512 mp_reset_usr (mp_usr, 2);
16513
16514 custom_charset_3 = mask;
16515 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16516 break;
16517
16518 case 3:
16519 mp_reset_usr (mp_usr, 3);
16520
16521 custom_charset_4 = mask;
16522 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16523 break;
16524 }
16525
16526 mask = mask + str_pos + 1;
16527 }
16528 }
16529
16530 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16531 {
16532 if (maskpos > 0)
16533 {
16534 local_free (css_buf);
16535 local_free (data.root_css_buf);
16536 local_free (data.markov_css_buf);
16537
16538 local_free (masks[maskpos - 1]);
16539 }
16540
16541 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16542
16543 data.mask = mask;
16544 data.css_cnt = css_cnt;
16545 data.css_buf = css_buf;
16546
16547 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16548
16549 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16550
16551 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16552 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16553
16554 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16555
16556 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16557
16558 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16559 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16560
16561 data.root_css_buf = root_css_buf;
16562 data.markov_css_buf = markov_css_buf;
16563
16564 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16565
16566 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16567
16568 local_free (root_table_buf);
16569 local_free (markov_table_buf);
16570
16571 // args
16572
16573 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16574 {
16575 hc_device_param_t *device_param = &data.devices_param[device_id];
16576
16577 if (device_param->skipped) continue;
16578
16579 device_param->kernel_params_mp[0] = &device_param->d_combs;
16580 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16581 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16582
16583 device_param->kernel_params_mp_buf64[3] = 0;
16584 device_param->kernel_params_mp_buf32[4] = css_cnt;
16585 device_param->kernel_params_mp_buf32[5] = 0;
16586 device_param->kernel_params_mp_buf32[6] = 0;
16587 device_param->kernel_params_mp_buf32[7] = 0;
16588
16589 if (attack_mode == ATTACK_MODE_HYBRID1)
16590 {
16591 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16592 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16593 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16594 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16595 }
16596 else if (attack_mode == ATTACK_MODE_HYBRID2)
16597 {
16598 device_param->kernel_params_mp_buf32[5] = 0;
16599 device_param->kernel_params_mp_buf32[6] = 0;
16600 device_param->kernel_params_mp_buf32[7] = 0;
16601 }
16602
16603 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]);
16604 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]);
16605 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]);
16606
16607 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);
16608 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);
16609 }
16610 }
16611 else if (attack_mode == ATTACK_MODE_BF)
16612 {
16613 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16614
16615 if (increment)
16616 {
16617 for (uint i = 0; i < dictcnt; i++)
16618 {
16619 local_free (dictfiles[i]);
16620 }
16621
16622 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16623 {
16624 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16625
16626 if (l1_filename == NULL) break;
16627
16628 dictcnt++;
16629
16630 dictfiles[dictcnt - 1] = l1_filename;
16631 }
16632 }
16633 else
16634 {
16635 dictcnt++;
16636
16637 dictfiles[dictcnt - 1] = mask;
16638 }
16639
16640 if (dictcnt == 0)
16641 {
16642 log_error ("ERROR: Mask is too small");
16643
16644 return (-1);
16645 }
16646 }
16647 }
16648
16649 free (induction_dictionaries);
16650
16651 // induction_dictionaries_cnt = 0; // implied
16652
16653 if (attack_mode != ATTACK_MODE_BF)
16654 {
16655 if (keyspace == 0)
16656 {
16657 induction_dictionaries = scan_directory (induction_directory);
16658
16659 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
16660 }
16661 }
16662
16663 if (induction_dictionaries_cnt)
16664 {
16665 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
16666 }
16667
16668 /**
16669 * prevent the user from using --keyspace together w/ maskfile and or dictfile
16670 */
16671 if (keyspace == 1)
16672 {
16673 if ((maskcnt > 1) || (dictcnt > 1))
16674 {
16675 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
16676
16677 return (-1);
16678 }
16679 }
16680
16681 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
16682 {
16683 char *subid = logfile_generate_subid ();
16684
16685 data.subid = subid;
16686
16687 logfile_sub_msg ("START");
16688
16689 data.devices_status = STATUS_INIT;
16690
16691 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
16692 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
16693 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
16694
16695 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
16696
16697 data.cpt_pos = 0;
16698
16699 data.cpt_start = time (NULL);
16700
16701 data.cpt_total = 0;
16702
16703 if (data.restore == 0)
16704 {
16705 rd->words_cur = skip;
16706
16707 skip = 0;
16708
16709 data.skip = 0;
16710 }
16711
16712 data.ms_paused = 0;
16713
16714 data.words_cur = rd->words_cur;
16715
16716 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16717 {
16718 hc_device_param_t *device_param = &data.devices_param[device_id];
16719
16720 if (device_param->skipped) continue;
16721
16722 device_param->speed_pos = 0;
16723
16724 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
16725 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
16726
16727 device_param->exec_pos = 0;
16728
16729 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
16730
16731 device_param->kernel_power = device_param->kernel_power_user;
16732
16733 device_param->outerloop_pos = 0;
16734 device_param->outerloop_left = 0;
16735 device_param->innerloop_pos = 0;
16736 device_param->innerloop_left = 0;
16737
16738 // some more resets:
16739
16740 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
16741
16742 device_param->pws_cnt = 0;
16743
16744 device_param->words_off = 0;
16745 device_param->words_done = 0;
16746 }
16747
16748 data.kernel_power_div = 0;
16749
16750 // figure out some workload
16751
16752 if (attack_mode == ATTACK_MODE_STRAIGHT)
16753 {
16754 if (data.wordlist_mode == WL_MODE_FILE)
16755 {
16756 char *dictfile = NULL;
16757
16758 if (induction_dictionaries_cnt)
16759 {
16760 dictfile = induction_dictionaries[0];
16761 }
16762 else
16763 {
16764 dictfile = dictfiles[dictpos];
16765 }
16766
16767 data.dictfile = dictfile;
16768
16769 logfile_sub_string (dictfile);
16770
16771 for (uint i = 0; i < rp_files_cnt; i++)
16772 {
16773 logfile_sub_var_string ("rulefile", rp_files[i]);
16774 }
16775
16776 FILE *fd2 = fopen (dictfile, "rb");
16777
16778 if (fd2 == NULL)
16779 {
16780 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16781
16782 return (-1);
16783 }
16784
16785 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16786
16787 fclose (fd2);
16788
16789 if (data.words_cnt == 0)
16790 {
16791 if (data.devices_status == STATUS_CRACKED) break;
16792 if (data.devices_status == STATUS_ABORTED) break;
16793
16794 dictpos++;
16795
16796 continue;
16797 }
16798 }
16799 }
16800 else if (attack_mode == ATTACK_MODE_COMBI)
16801 {
16802 char *dictfile = data.dictfile;
16803 char *dictfile2 = data.dictfile2;
16804
16805 logfile_sub_string (dictfile);
16806 logfile_sub_string (dictfile2);
16807
16808 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
16809 {
16810 FILE *fd2 = fopen (dictfile, "rb");
16811
16812 if (fd2 == NULL)
16813 {
16814 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16815
16816 return (-1);
16817 }
16818
16819 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16820
16821 fclose (fd2);
16822 }
16823 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
16824 {
16825 FILE *fd2 = fopen (dictfile2, "rb");
16826
16827 if (fd2 == NULL)
16828 {
16829 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16830
16831 return (-1);
16832 }
16833
16834 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
16835
16836 fclose (fd2);
16837 }
16838
16839 if (data.words_cnt == 0)
16840 {
16841 if (data.devices_status == STATUS_CRACKED) break;
16842 if (data.devices_status == STATUS_ABORTED) break;
16843
16844 dictpos++;
16845
16846 continue;
16847 }
16848 }
16849 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16850 {
16851 char *dictfile = NULL;
16852
16853 if (induction_dictionaries_cnt)
16854 {
16855 dictfile = induction_dictionaries[0];
16856 }
16857 else
16858 {
16859 dictfile = dictfiles[dictpos];
16860 }
16861
16862 data.dictfile = dictfile;
16863
16864 char *mask = data.mask;
16865
16866 logfile_sub_string (dictfile);
16867 logfile_sub_string (mask);
16868
16869 FILE *fd2 = fopen (dictfile, "rb");
16870
16871 if (fd2 == NULL)
16872 {
16873 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
16874
16875 return (-1);
16876 }
16877
16878 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
16879
16880 fclose (fd2);
16881
16882 if (data.words_cnt == 0)
16883 {
16884 if (data.devices_status == STATUS_CRACKED) break;
16885 if (data.devices_status == STATUS_ABORTED) break;
16886
16887 dictpos++;
16888
16889 continue;
16890 }
16891 }
16892 else if (attack_mode == ATTACK_MODE_BF)
16893 {
16894 local_free (css_buf);
16895 local_free (data.root_css_buf);
16896 local_free (data.markov_css_buf);
16897
16898 char *mask = dictfiles[dictpos];
16899
16900 logfile_sub_string (mask);
16901
16902 // base
16903
16904 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16905
16906 if (opts_type & OPTS_TYPE_PT_UNICODE)
16907 {
16908 uint css_cnt_unicode = css_cnt * 2;
16909
16910 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
16911
16912 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
16913 {
16914 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
16915
16916 css_buf_unicode[j + 1].cs_buf[0] = 0;
16917 css_buf_unicode[j + 1].cs_len = 1;
16918 }
16919
16920 free (css_buf);
16921
16922 css_buf = css_buf_unicode;
16923 css_cnt = css_cnt_unicode;
16924 }
16925
16926 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
16927
16928 uint mask_min = pw_min;
16929 uint mask_max = pw_max;
16930
16931 if (opts_type & OPTS_TYPE_PT_UNICODE)
16932 {
16933 mask_min *= 2;
16934 mask_max *= 2;
16935 }
16936
16937 if ((css_cnt < mask_min) || (css_cnt > mask_max))
16938 {
16939 if (css_cnt < mask_min)
16940 {
16941 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
16942 }
16943
16944 if (css_cnt > mask_max)
16945 {
16946 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
16947 }
16948
16949 // skip to next mask
16950
16951 dictpos++;
16952
16953 rd->dictpos = dictpos;
16954
16955 logfile_sub_msg ("STOP");
16956
16957 continue;
16958 }
16959
16960 uint save_css_cnt = css_cnt;
16961
16962 if (opti_type & OPTI_TYPE_SINGLE_HASH)
16963 {
16964 if (opti_type & OPTI_TYPE_APPENDED_SALT)
16965 {
16966 uint salt_len = (uint) data.salts_buf[0].salt_len;
16967 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
16968
16969 uint css_cnt_salt = css_cnt + salt_len;
16970
16971 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
16972
16973 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
16974
16975 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
16976 {
16977 css_buf_salt[j].cs_buf[0] = salt_buf[i];
16978 css_buf_salt[j].cs_len = 1;
16979 }
16980
16981 free (css_buf);
16982
16983 css_buf = css_buf_salt;
16984 css_cnt = css_cnt_salt;
16985 }
16986 }
16987
16988 data.mask = mask;
16989 data.css_cnt = css_cnt;
16990 data.css_buf = css_buf;
16991
16992 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
16993
16994 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16995
16996 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16997
16998 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16999 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17000
17001 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17002
17003 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17004
17005 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17006 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17007
17008 data.root_css_buf = root_css_buf;
17009 data.markov_css_buf = markov_css_buf;
17010
17011 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17012
17013 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17014
17015 local_free (root_table_buf);
17016 local_free (markov_table_buf);
17017
17018 // copy + args
17019
17020 uint css_cnt_l = css_cnt;
17021 uint css_cnt_r;
17022
17023 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17024 {
17025 if (save_css_cnt < 6)
17026 {
17027 css_cnt_r = 1;
17028 }
17029 else if (save_css_cnt == 6)
17030 {
17031 css_cnt_r = 2;
17032 }
17033 else
17034 {
17035 if (opts_type & OPTS_TYPE_PT_UNICODE)
17036 {
17037 if (save_css_cnt == 8 || save_css_cnt == 10)
17038 {
17039 css_cnt_r = 2;
17040 }
17041 else
17042 {
17043 css_cnt_r = 4;
17044 }
17045 }
17046 else
17047 {
17048 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17049 {
17050 css_cnt_r = 3;
17051 }
17052 else
17053 {
17054 css_cnt_r = 4;
17055 }
17056 }
17057 }
17058 }
17059 else
17060 {
17061 css_cnt_r = 1;
17062
17063 /* unfinished code?
17064 int sum = css_buf[css_cnt_r - 1].cs_len;
17065
17066 for (uint i = 1; i < 4 && i < css_cnt; i++)
17067 {
17068 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17069
17070 css_cnt_r++;
17071
17072 sum *= css_buf[css_cnt_r - 1].cs_len;
17073 }
17074 */
17075 }
17076
17077 css_cnt_l -= css_cnt_r;
17078
17079 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17080
17081 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17082 {
17083 hc_device_param_t *device_param = &data.devices_param[device_id];
17084
17085 if (device_param->skipped) continue;
17086
17087 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17088 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17089 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17090
17091 device_param->kernel_params_mp_l_buf64[3] = 0;
17092 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17093 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17094 device_param->kernel_params_mp_l_buf32[6] = 0;
17095 device_param->kernel_params_mp_l_buf32[7] = 0;
17096 device_param->kernel_params_mp_l_buf32[8] = 0;
17097
17098 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17099 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17100 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17101 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17102
17103 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17104 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17105 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17106
17107 device_param->kernel_params_mp_r_buf64[3] = 0;
17108 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17109 device_param->kernel_params_mp_r_buf32[5] = 0;
17110 device_param->kernel_params_mp_r_buf32[6] = 0;
17111 device_param->kernel_params_mp_r_buf32[7] = 0;
17112
17113 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]);
17114 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]);
17115 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]);
17116
17117 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]);
17118 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]);
17119 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]);
17120
17121 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);
17122 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);
17123 }
17124 }
17125
17126 u64 words_base = data.words_cnt;
17127
17128 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17129 {
17130 if (data.kernel_rules_cnt)
17131 {
17132 words_base /= data.kernel_rules_cnt;
17133 }
17134 }
17135 else if (data.attack_kern == ATTACK_KERN_COMBI)
17136 {
17137 if (data.combs_cnt)
17138 {
17139 words_base /= data.combs_cnt;
17140 }
17141 }
17142 else if (data.attack_kern == ATTACK_KERN_BF)
17143 {
17144 if (data.bfs_cnt)
17145 {
17146 words_base /= data.bfs_cnt;
17147 }
17148 }
17149
17150 data.words_base = words_base;
17151
17152 if (keyspace == 1)
17153 {
17154 log_info ("%llu", (unsigned long long int) words_base);
17155
17156 return (0);
17157 }
17158
17159 if (data.words_cur > data.words_base)
17160 {
17161 log_error ("ERROR: restore value greater keyspace");
17162
17163 return (-1);
17164 }
17165
17166 if (data.words_cur)
17167 {
17168 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17169 {
17170 for (uint i = 0; i < data.salts_cnt; i++)
17171 {
17172 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17173 }
17174 }
17175 else if (data.attack_kern == ATTACK_KERN_COMBI)
17176 {
17177 for (uint i = 0; i < data.salts_cnt; i++)
17178 {
17179 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17180 }
17181 }
17182 else if (data.attack_kern == ATTACK_KERN_BF)
17183 {
17184 for (uint i = 0; i < data.salts_cnt; i++)
17185 {
17186 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17187 }
17188 }
17189 }
17190
17191 /*
17192 * Inform user about possible slow speeds
17193 */
17194
17195 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17196 {
17197 if (data.words_base < kernel_power_all)
17198 {
17199 if (quiet == 0)
17200 {
17201 log_info ("ATTENTION!");
17202 log_info (" The wordlist or mask you are using is too small.");
17203 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17204 log_info (" The cracking speed will drop.");
17205 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17206 log_info ("");
17207 }
17208 }
17209 }
17210
17211 /*
17212 * Update loopback file
17213 */
17214
17215 if (loopback == 1)
17216 {
17217 time_t now;
17218
17219 time (&now);
17220
17221 uint random_num = get_random_num (0, 9999);
17222
17223 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17224
17225 data.loopback_file = loopback_file;
17226 }
17227
17228 /*
17229 * Update dictionary statistic
17230 */
17231
17232 if (keyspace == 0)
17233 {
17234 dictstat_fp = fopen (dictstat, "wb");
17235
17236 if (dictstat_fp)
17237 {
17238 lock_file (dictstat_fp);
17239
17240 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17241
17242 fclose (dictstat_fp);
17243 }
17244 }
17245
17246 data.devices_status = STATUS_RUNNING;
17247
17248 if (initial_restore_done == 0)
17249 {
17250 if (data.restore_disable == 0) cycle_restore ();
17251
17252 initial_restore_done = 1;
17253 }
17254
17255 hc_timer_set (&data.timer_running);
17256
17257 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17258 {
17259 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17260 {
17261 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17262 if (quiet == 0) fflush (stdout);
17263 }
17264 }
17265 else if (wordlist_mode == WL_MODE_STDIN)
17266 {
17267 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17268 if (data.quiet == 0) log_info ("");
17269 }
17270
17271 time_t runtime_start;
17272
17273 time (&runtime_start);
17274
17275 data.runtime_start = runtime_start;
17276
17277 /**
17278 * create cracker threads
17279 */
17280
17281 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17282
17283 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17284 {
17285 hc_device_param_t *device_param = &devices_param[device_id];
17286
17287 if (wordlist_mode == WL_MODE_STDIN)
17288 {
17289 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17290 }
17291 else
17292 {
17293 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17294 }
17295 }
17296
17297 // wait for crack threads to exit
17298
17299 hc_thread_wait (data.devices_cnt, c_threads);
17300
17301 local_free (c_threads);
17302
17303 data.restore = 0;
17304
17305 // finalize task
17306
17307 logfile_sub_var_uint ("status-after-work", data.devices_status);
17308
17309 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17310
17311 if (data.devices_status == STATUS_CRACKED) break;
17312 if (data.devices_status == STATUS_ABORTED) break;
17313
17314 if (data.devices_status == STATUS_BYPASS)
17315 {
17316 data.devices_status = STATUS_RUNNING;
17317 }
17318
17319 if (induction_dictionaries_cnt)
17320 {
17321 unlink (induction_dictionaries[0]);
17322 }
17323
17324 free (induction_dictionaries);
17325
17326 if (attack_mode != ATTACK_MODE_BF)
17327 {
17328 induction_dictionaries = scan_directory (induction_directory);
17329
17330 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17331 }
17332
17333 if (benchmark == 0)
17334 {
17335 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17336 {
17337 if (quiet == 0) clear_prompt ();
17338
17339 if (quiet == 0) log_info ("");
17340
17341 if (status == 1)
17342 {
17343 status_display ();
17344 }
17345 else
17346 {
17347 if (quiet == 0) status_display ();
17348 }
17349
17350 if (quiet == 0) log_info ("");
17351 }
17352 }
17353
17354 if (attack_mode == ATTACK_MODE_BF)
17355 {
17356 dictpos++;
17357
17358 rd->dictpos = dictpos;
17359 }
17360 else
17361 {
17362 if (induction_dictionaries_cnt)
17363 {
17364 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17365 }
17366 else
17367 {
17368 dictpos++;
17369
17370 rd->dictpos = dictpos;
17371 }
17372 }
17373
17374 time_t runtime_stop;
17375
17376 time (&runtime_stop);
17377
17378 data.runtime_stop = runtime_stop;
17379
17380 logfile_sub_uint (runtime_start);
17381 logfile_sub_uint (runtime_stop);
17382
17383 logfile_sub_msg ("STOP");
17384
17385 global_free (subid);
17386 }
17387
17388 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17389
17390 if (data.devices_status == STATUS_CRACKED) break;
17391 if (data.devices_status == STATUS_ABORTED) break;
17392 if (data.devices_status == STATUS_QUIT) break;
17393
17394 if (data.devices_status == STATUS_BYPASS)
17395 {
17396 data.devices_status = STATUS_RUNNING;
17397 }
17398 }
17399
17400 // 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
17401
17402 if (attack_mode == ATTACK_MODE_STRAIGHT)
17403 {
17404 if (data.wordlist_mode == WL_MODE_FILE)
17405 {
17406 if (data.dictfile == NULL)
17407 {
17408 if (dictfiles != NULL)
17409 {
17410 data.dictfile = dictfiles[0];
17411
17412 hc_timer_set (&data.timer_running);
17413 }
17414 }
17415 }
17416 }
17417 // NOTE: combi is okay because it is already set beforehand
17418 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17419 {
17420 if (data.dictfile == NULL)
17421 {
17422 if (dictfiles != NULL)
17423 {
17424 hc_timer_set (&data.timer_running);
17425
17426 data.dictfile = dictfiles[0];
17427 }
17428 }
17429 }
17430 else if (attack_mode == ATTACK_MODE_BF)
17431 {
17432 if (data.mask == NULL)
17433 {
17434 hc_timer_set (&data.timer_running);
17435
17436 data.mask = masks[0];
17437 }
17438 }
17439
17440 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17441 {
17442 data.devices_status = STATUS_EXHAUSTED;
17443 }
17444
17445 // if cracked / aborted remove last induction dictionary
17446
17447 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17448 {
17449 struct stat induct_stat;
17450
17451 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17452 {
17453 unlink (induction_dictionaries[file_pos]);
17454 }
17455 }
17456
17457 // wait for non-interactive threads
17458
17459 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17460 {
17461 hc_thread_wait (1, &ni_threads[thread_idx]);
17462 }
17463
17464 local_free (ni_threads);
17465
17466 // wait for interactive threads
17467
17468 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17469 {
17470 hc_thread_wait (1, &i_thread);
17471 }
17472
17473 // we dont need restore file anymore
17474 if (data.restore_disable == 0)
17475 {
17476 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17477 {
17478 unlink (eff_restore_file);
17479 unlink (new_restore_file);
17480 }
17481 else
17482 {
17483 cycle_restore ();
17484 }
17485 }
17486
17487 // finally save left hashes
17488
17489 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17490 {
17491 save_hash ();
17492 }
17493
17494 /**
17495 * Clean up
17496 */
17497
17498 if (benchmark == 1)
17499 {
17500 status_benchmark ();
17501
17502 if (status_automat == 0)
17503 {
17504 log_info ("");
17505 }
17506 }
17507 else
17508 {
17509 if (quiet == 0) clear_prompt ();
17510
17511 if (quiet == 0) log_info ("");
17512
17513 if (status == 1)
17514 {
17515 status_display ();
17516 }
17517 else
17518 {
17519 if (quiet == 0) status_display ();
17520 }
17521
17522 if (quiet == 0) log_info ("");
17523 }
17524
17525 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17526 {
17527 hc_device_param_t *device_param = &data.devices_param[device_id];
17528
17529 if (device_param->skipped) continue;
17530
17531 local_free (device_param->combs_buf);
17532
17533 local_free (device_param->hooks_buf);
17534
17535 local_free (device_param->device_name);
17536
17537 local_free (device_param->device_name_chksum);
17538
17539 local_free (device_param->device_version);
17540
17541 local_free (device_param->driver_version);
17542
17543 if (device_param->pws_buf) myfree (device_param->pws_buf);
17544 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17545 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17546 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17547 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17548 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17549 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17550 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17551 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17552 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17553 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17554 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17555 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17556 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17557 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17558 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17559 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17560 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17561 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17562 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17563 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17564 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17565 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17566 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17567 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17568 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17569 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17570 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17571 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17572
17573 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17574 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17575 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17576 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17577 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17578 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17579 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17580 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17581 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17582 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17583
17584 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17585 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17586 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17587
17588 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17589 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17590 }
17591
17592 // reset default fan speed
17593
17594 #ifdef HAVE_HWMON
17595 if (gpu_temp_disable == 0)
17596 {
17597 #ifdef HAVE_ADL
17598 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17599 {
17600 hc_thread_mutex_lock (mux_adl);
17601
17602 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17603 {
17604 hc_device_param_t *device_param = &data.devices_param[device_id];
17605
17606 if (device_param->skipped) continue;
17607
17608 if (data.hm_device[device_id].fan_supported == 1)
17609 {
17610 int fanspeed = temp_retain_fanspeed_value[device_id];
17611
17612 if (fanspeed == -1) continue;
17613
17614 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17615
17616 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17617 }
17618 }
17619
17620 hc_thread_mutex_unlock (mux_adl);
17621 }
17622 #endif // HAVE_ADL
17623 }
17624
17625 #ifdef HAVE_ADL
17626 // reset power tuning
17627
17628 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17629 {
17630 hc_thread_mutex_lock (mux_adl);
17631
17632 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17633 {
17634 hc_device_param_t *device_param = &data.devices_param[device_id];
17635
17636 if (device_param->skipped) continue;
17637
17638 if (data.hm_device[device_id].od_version == 6)
17639 {
17640 // check powertune capabilities first, if not available then skip device
17641
17642 int powertune_supported = 0;
17643
17644 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
17645 {
17646 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
17647
17648 return (-1);
17649 }
17650
17651 if (powertune_supported != 0)
17652 {
17653 // powercontrol settings
17654
17655 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)
17656 {
17657 log_info ("ERROR: Failed to restore the ADL PowerControl values");
17658
17659 return (-1);
17660 }
17661
17662 // clocks
17663
17664 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
17665
17666 performance_state->iNumberOfPerformanceLevels = 2;
17667
17668 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
17669 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
17670 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
17671 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
17672
17673 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)
17674 {
17675 log_info ("ERROR: Failed to restore ADL performance state");
17676
17677 return (-1);
17678 }
17679
17680 local_free (performance_state);
17681 }
17682 }
17683 }
17684
17685 hc_thread_mutex_unlock (mux_adl);
17686 }
17687 #endif // HAVE_ADL
17688
17689 if (gpu_temp_disable == 0)
17690 {
17691 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
17692 if (data.hm_nv)
17693 {
17694 #if defined(LINUX) && defined(HAVE_NVML)
17695
17696 hm_NVML_nvmlShutdown (data.hm_nv);
17697
17698 nvml_close (data.hm_nv);
17699
17700 #elif defined(WIN) && (HAVE_NVAPI)
17701
17702 hm_NvAPI_Unload (data.hm_nv);
17703
17704 nvapi_close (data.hm_nv);
17705
17706 #endif
17707
17708 data.hm_nv = NULL;
17709 }
17710 #endif
17711
17712 #ifdef HAVE_ADL
17713 if (data.hm_amd)
17714 {
17715 hm_ADL_Main_Control_Destroy (data.hm_amd);
17716
17717 adl_close (data.hm_amd);
17718 data.hm_amd = NULL;
17719 }
17720 #endif
17721 }
17722 #endif // HAVE_HWMON
17723
17724 // free memory
17725
17726 local_free (masks);
17727
17728 local_free (dictstat_base);
17729
17730 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
17731 {
17732 pot_t *pot_ptr = &pot[pot_pos];
17733
17734 hash_t *hash = &pot_ptr->hash;
17735
17736 local_free (hash->digest);
17737
17738 if (isSalted)
17739 {
17740 local_free (hash->salt);
17741 }
17742 }
17743
17744 local_free (pot);
17745
17746 local_free (all_kernel_rules_cnt);
17747 local_free (all_kernel_rules_buf);
17748
17749 local_free (wl_data->buf);
17750 local_free (wl_data);
17751
17752 local_free (bitmap_s1_a);
17753 local_free (bitmap_s1_b);
17754 local_free (bitmap_s1_c);
17755 local_free (bitmap_s1_d);
17756 local_free (bitmap_s2_a);
17757 local_free (bitmap_s2_b);
17758 local_free (bitmap_s2_c);
17759 local_free (bitmap_s2_d);
17760
17761 #ifdef HAVE_HWMON
17762 local_free (temp_retain_fanspeed_value);
17763 #ifdef HAVE_ADL
17764 local_free (od_clock_mem_status);
17765 local_free (od_power_control_status);
17766 #endif // ADL
17767 #endif
17768
17769 global_free (devices_param);
17770
17771 global_free (kernel_rules_buf);
17772
17773 global_free (root_css_buf);
17774 global_free (markov_css_buf);
17775
17776 global_free (digests_buf);
17777 global_free (digests_shown);
17778 global_free (digests_shown_tmp);
17779
17780 global_free (salts_buf);
17781 global_free (salts_shown);
17782
17783 global_free (esalts_buf);
17784
17785 global_free (words_progress_done);
17786 global_free (words_progress_rejected);
17787 global_free (words_progress_restored);
17788
17789 if (pot_fp) fclose (pot_fp);
17790
17791 if (data.devices_status == STATUS_QUIT) break;
17792 }
17793
17794 // destroy others mutex
17795
17796 hc_thread_mutex_delete (mux_dispatcher);
17797 hc_thread_mutex_delete (mux_counter);
17798 hc_thread_mutex_delete (mux_display);
17799 hc_thread_mutex_delete (mux_adl);
17800
17801 // free memory
17802
17803 local_free (eff_restore_file);
17804 local_free (new_restore_file);
17805
17806 local_free (rd);
17807
17808 // tuning db
17809
17810 tuning_db_destroy (tuning_db);
17811
17812 // loopback
17813
17814 local_free (loopback_file);
17815
17816 if (loopback == 1) unlink (loopback_file);
17817
17818 // induction directory
17819
17820 if (induction_dir == NULL)
17821 {
17822 if (attack_mode != ATTACK_MODE_BF)
17823 {
17824 if (rmdir (induction_directory) == -1)
17825 {
17826 if (errno == ENOENT)
17827 {
17828 // good, we can ignore
17829 }
17830 else if (errno == ENOTEMPTY)
17831 {
17832 // good, we can ignore
17833 }
17834 else
17835 {
17836 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
17837
17838 return (-1);
17839 }
17840 }
17841
17842 local_free (induction_directory);
17843 }
17844 }
17845
17846 // outfile-check directory
17847
17848 if (outfile_check_dir == NULL)
17849 {
17850 if (rmdir (outfile_check_directory) == -1)
17851 {
17852 if (errno == ENOENT)
17853 {
17854 // good, we can ignore
17855 }
17856 else if (errno == ENOTEMPTY)
17857 {
17858 // good, we can ignore
17859 }
17860 else
17861 {
17862 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
17863
17864 return (-1);
17865 }
17866 }
17867
17868 local_free (outfile_check_directory);
17869 }
17870
17871 time_t proc_stop;
17872
17873 time (&proc_stop);
17874
17875 logfile_top_uint (proc_start);
17876 logfile_top_uint (proc_stop);
17877
17878 logfile_top_msg ("STOP");
17879
17880 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
17881 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
17882
17883 if (data.ocl) ocl_close (data.ocl);
17884
17885 if (data.devices_status == STATUS_ABORTED) return 2;
17886 if (data.devices_status == STATUS_QUIT) return 2;
17887 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
17888 if (data.devices_status == STATUS_EXHAUSTED) return 1;
17889 if (data.devices_status == STATUS_CRACKED) return 0;
17890
17891 return -1;
17892 }
Hashcat additions to support pwdhash