projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Add NvAPI_GPU_GetPerfDecreaseInfo() -- but i doesn't work, so deactive it
[hashcat.git] / src / hashcat.c
1 /**
2 * Authors.....: Jens Steube <jens.steube@gmail.com>
3 * Gabriele Gristina <matrix@hashcat.net>
4 * magnum <john.magnum@hushmail.com>
5 *
6 * License.....: MIT
7 */
8
9 #ifdef OSX
10 #include <stdio.h>
11 #endif
12
13 #include <common.h>
14 #include <shared.h>
15 #include <rp_kernel_on_cpu.h>
16 #include <getopt.h>
17
18 const char *PROGNAME = "hashcat";
19 const uint VERSION_BIN = 300;
20 const uint RESTORE_MIN = 300;
21
22 double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 };
23
24 #define INCR_RULES 10000
25 #define INCR_SALTS 100000
26 #define INCR_MASKS 1000
27 #define INCR_POT 1000
28
29 #define USAGE 0
30 #define VERSION 0
31 #define QUIET 0
32 #define MARKOV_THRESHOLD 0
33 #define MARKOV_DISABLE 0
34 #define MARKOV_CLASSIC 0
35 #define BENCHMARK 0
36 #define RESTORE 0
37 #define RESTORE_TIMER 60
38 #define RESTORE_DISABLE 0
39 #define STATUS 0
40 #define STATUS_TIMER 10
41 #define MACHINE_READABLE 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 70
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 "- [ Options ] -",
353 "",
354 " Options Short / Long | Type | Description | Example",
355 "===============================|======|======================================================|=======================",
356 " -m, --hash-type | Num | Hash-type, see references below | -m 1000",
357 " -a, --attack-mode | Num | Attack-mode, see references below | -a 3",
358 " -V, --version | | Print version |",
359 " -h, --help | | Print help |",
360 " --quiet | | Suppress output |",
361 " --hex-charset | | Assume charset is given in hex |",
362 " --hex-salt | | Assume salt is given in hex |",
363 " --hex-wordlist | | Assume words in wordlist is given in hex |",
364 " --force | | Ignore warnings |",
365 " --status | | Enable automatic update of the status-screen |",
366 " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1",
367 " --machine-readable | | Display the status view in a machine readable format |",
368 " --loopback | | Add new plains to induct directory |",
369 " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0",
370 " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat",
371 " --markov-disable | | Disables markov-chains, emulates classic brute-force |",
372 " --markov-classic | | Enables classic markov-chains, no per-position |",
373 " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50",
374 " --runtime | Num | Abort session after X seconds of runtime | --runtime=10",
375 " --session | Str | Define specific session name | --session=mysession",
376 " --restore | | Restore session from --session |",
377 " --restore-disable | | Do not write restore file |",
378 " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt",
379 " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7",
380 " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |",
381 " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30",
382 " -p, --separator | Char | Separator char for hashlists and outfile | -p :",
383 " --show | | Show cracked passwords only |",
384 " --left | | Show un-cracked passwords only |",
385 " --username | | Enable ignoring of usernames in hashfile |",
386 " --remove | | Enable remove of hash once it is cracked |",
387 " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30",
388 " --potfile-disable | | Do not write potfile |",
389 " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot",
390 " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4",
391 " --debug-file | File | Output file for debugging rules | --debug-file=good.log",
392 " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts",
393 " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x",
394 " --logfile-disable | | Disable the logfile |",
395 " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png",
396 " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt",
397 " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000",
398 " -b, --benchmark | | Run benchmark |",
399 " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32",
400 " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24",
401 " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24",
402 " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3",
403 " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2",
404 " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1",
405 " --opencl-device-types | Str | OpenCL device-types to use, separate with comma | --opencl-device-type=1",
406 " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4",
407 " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3",
408 " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64",
409 " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256",
410 " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |",
411 #ifdef HAVE_HWMON
412 " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100",
413 " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95",
414 #ifdef HAVE_ADL
415 " --powertune-enable | | Enable automatic power tuning (AMD OverDrive 6 only) |",
416 #endif
417 #endif
418 " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3",
419 " -s, --skip | Num | Skip X words from the start | -s 1000000",
420 " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000",
421 " --keyspace | | Show keyspace base:mod values and quit |",
422 " -j, --rule-left | Rule | Single Rule applied to each word from left wordlist | -j 'c'",
423 " -k, --rule-right | Rule | Single Rule applied to each word from right wordlist | -k '^-'",
424 " -r, --rules-file | File | Multiple Rules applied to each word from wordlists | -r rules/best64.rule",
425 " -g, --generate-rules | Num | Generate X random rules | -g 10000",
426 " --generate-rules-func-min | Num | Force min X funcs per rule |",
427 " --generate-rules-func-max | Num | Force max X funcs per rule |",
428 " --generate-rules-seed | Num | Force RNG seed set to X |",
429 " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u",
430 " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s",
431 " -3, --custom-charset3 | CS | User-defined charset ?3 |",
432 " -4, --custom-charset4 | CS | User-defined charset ?4 |",
433 " -i, --increment | | Enable mask increment mode |",
434 " --increment-min | Num | Start mask incrementing at X | --increment-min=4",
435 " --increment-max | Num | Stop mask incrementing at X | --increment-max=8",
436 "",
437 "- [ Hash modes ] -",
438 "",
439 " # | Name | Category",
440 " ======+==================================================+======================================",
441 " 900 | MD4 | Raw Hash",
442 " 0 | MD5 | Raw Hash",
443 " 5100 | Half MD5 | Raw Hash",
444 " 100 | SHA1 | Raw Hash",
445 " 10800 | SHA-384 | Raw Hash",
446 " 1400 | SHA-256 | Raw Hash",
447 " 1700 | SHA-512 | Raw Hash",
448 " 5000 | SHA-3(Keccak) | Raw Hash",
449 " 10100 | SipHash | Raw Hash",
450 " 6000 | RipeMD160 | Raw Hash",
451 " 6100 | Whirlpool | Raw Hash",
452 " 6900 | GOST R 34.11-94 | Raw Hash",
453 " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash",
454 " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash",
455 " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated",
456 " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated",
457 " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
458 " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
459 " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
460 " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated",
461 " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated",
462 " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated",
463 " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated",
464 " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated",
465 " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated",
466 " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
467 " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
468 " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated",
469 " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated",
470 " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated",
471 " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated",
472 " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated",
473 " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
474 " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
475 " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated",
476 " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated",
477 " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated",
478 " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated",
479 " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated",
480 " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated",
481 " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated",
482 " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated",
483 " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated",
484 " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated",
485 " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated",
486 " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated",
487 " 400 | phpass | Generic KDF",
488 " 8900 | scrypt | Generic KDF",
489 " 11900 | PBKDF2-HMAC-MD5 | Generic KDF",
490 " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF",
491 " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF",
492 " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF",
493 " 23 | Skype | Network protocols",
494 " 2500 | WPA/WPA2 | Network protocols",
495 " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols",
496 " 5300 | IKE-PSK MD5 | Network protocols",
497 " 5400 | IKE-PSK SHA1 | Network protocols",
498 " 5500 | NetNTLMv1 | Network protocols",
499 " 5500 | NetNTLMv1 + ESS | Network protocols",
500 " 5600 | NetNTLMv2 | Network protocols",
501 " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols",
502 " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols",
503 " 8300 | DNSSEC (NSEC3) | Network protocols",
504 " 10200 | Cram MD5 | Network protocols",
505 " 11100 | PostgreSQL CRAM (MD5) | Network protocols",
506 " 11200 | MySQL CRAM (SHA1) | Network protocols",
507 " 11400 | SIP digest authentication (MD5) | Network protocols",
508 " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols",
509 " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks",
510 " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks",
511 " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
512 " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks",
513 " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks",
514 " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks",
515 " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks",
516 " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
517 " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks",
518 " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks",
519 " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks",
520 " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks",
521 " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks",
522 " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks",
523 " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks",
524 " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks",
525 " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks",
526 " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks",
527 " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks",
528 " 12 | PostgreSQL | Database Server",
529 " 131 | MSSQL(2000) | Database Server",
530 " 132 | MSSQL(2005) | Database Server",
531 " 1731 | MSSQL(2012) | Database Server",
532 " 1731 | MSSQL(2014) | Database Server",
533 " 200 | MySQL323 | Database Server",
534 " 300 | MySQL4.1/MySQL5 | Database Server",
535 " 3100 | Oracle H: Type (Oracle 7+) | Database Server",
536 " 112 | Oracle S: Type (Oracle 11+) | Database Server",
537 " 12300 | Oracle T: Type (Oracle 12+) | Database Server",
538 " 8000 | Sybase ASE | Database Server",
539 " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server",
540 " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server",
541 " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server",
542 " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server",
543 " 1421 | hMailServer | HTTP, SMTP, LDAP Server",
544 " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server",
545 " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server",
546 " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server",
547 " 11500 | CRC32 | Checksums",
548 " 3000 | LM | Operating-Systems",
549 " 1000 | NTLM | Operating-Systems",
550 " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems",
551 " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems",
552 " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems",
553 " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems",
554 " 12400 | BSDiCrypt, Extended DES | Operating-Systems",
555 " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems",
556 " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems",
557 " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems",
558 " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems",
559 " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems",
560 " 1722 | OSX v10.7 | Operating-Systems",
561 " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems",
562 " 6300 | AIX {smd5} | Operating-Systems",
563 " 6700 | AIX {ssha1} | Operating-Systems",
564 " 6400 | AIX {ssha256} | Operating-Systems",
565 " 6500 | AIX {ssha512} | Operating-Systems",
566 " 2400 | Cisco-PIX | Operating-Systems",
567 " 2410 | Cisco-ASA | Operating-Systems",
568 " 500 | Cisco-IOS $1$ | Operating-Systems",
569 " 5700 | Cisco-IOS $4$ | Operating-Systems",
570 " 9200 | Cisco-IOS $8$ | Operating-Systems",
571 " 9300 | Cisco-IOS $9$ | Operating-Systems",
572 " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems",
573 " 501 | Juniper IVE | Operating-Systems",
574 " 5800 | Android PIN | Operating-Systems",
575 " 8100 | Citrix Netscaler | Operating-Systems",
576 " 8500 | RACF | Operating-Systems",
577 " 7200 | GRUB 2 | Operating-Systems",
578 " 9900 | Radmin2 | Operating-Systems",
579 " 125 | ArubaOS | Operating-Systems",
580 " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)",
581 " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)",
582 " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)",
583 " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)",
584 " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)",
585 " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)",
586 " 133 | PeopleSoft | Enterprise Application Software (EAS)",
587 " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)",
588 " 11600 | 7-Zip | Archives",
589 " 12500 | RAR3-hp | Archives",
590 " 13000 | RAR5 | Archives",
591 " 13200 | AxCrypt | Archives",
592 " 13300 | AxCrypt in memory SHA1 | Archives",
593 " 13600 | WinZip | Archives",
594 " 62XY | TrueCrypt | Full-Disk encryptions (FDE)",
595 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
596 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
597 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
598 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
599 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
600 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
601 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
602 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
603 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
604 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
605 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
606 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
607 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
608 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
609 " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)",
610 " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)",
611 " 12200 | eCryptfs | Full-Disk encryptions (FDE)",
612 " 137XY | VeraCrypt | Full-Disk encryptions (FDE)",
613 " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)",
614 " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)",
615 " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)",
616 " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)",
617 " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)",
618 " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)",
619 " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)",
620 " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)",
621 " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)",
622 " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)",
623 " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)",
624 " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)",
625 " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)",
626 " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)",
627 " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)",
628 " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)",
629 " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents",
630 " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents",
631 " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents",
632 " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents",
633 " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents",
634 " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents",
635 " 9400 | MS Office 2007 | Documents",
636 " 9500 | MS Office 2010 | Documents",
637 " 9600 | MS Office 2013 | Documents",
638 " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents",
639 " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents",
640 " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents",
641 " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents",
642 " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents",
643 " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents",
644 " 9000 | Password Safe v2 | Password Managers",
645 " 5200 | Password Safe v3 | Password Managers",
646 " 6800 | Lastpass + Lastpass sniffed | Password Managers",
647 " 6600 | 1Password, agilekeychain | Password Managers",
648 " 8200 | 1Password, cloudkeychain | Password Managers",
649 " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers",
650 " 12700 | Blockchain, My Wallet | Password Managers",
651 " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers",
652 "",
653 "- [ Outfile Formats ] -",
654 "",
655 " # | Format",
656 " ===+========",
657 " 1 | hash[:salt]",
658 " 2 | plain",
659 " 3 | hash[:salt]:plain",
660 " 4 | hex_plain",
661 " 5 | hash[:salt]:hex_plain",
662 " 6 | plain:hex_plain",
663 " 7 | hash[:salt]:plain:hex_plain",
664 " 8 | crackpos",
665 " 9 | hash[:salt]:crack_pos",
666 " 10 | plain:crack_pos",
667 " 11 | hash[:salt]:plain:crack_pos",
668 " 12 | hex_plain:crack_pos",
669 " 13 | hash[:salt]:hex_plain:crack_pos",
670 " 14 | plain:hex_plain:crack_pos",
671 " 15 | hash[:salt]:plain:hex_plain:crack_pos",
672 "",
673 "- [ Rule Debugging Modes ] -",
674 "",
675 " # | Format",
676 " ===+========",
677 " 1 | Finding-Rule",
678 " 2 | Original-Word",
679 " 3 | Original-Word:Finding-Rule",
680 " 4 | Original-Word:Finding-Rule:Processed-Word",
681 "",
682 "- [ Attack Modes ] -",
683 "",
684 " # | Mode",
685 " ===+======",
686 " 0 | Straight",
687 " 1 | Combination",
688 " 3 | Brute-force",
689 " 6 | Hybrid Wordlist + Mask",
690 " 7 | Hybrid Mask + Wordlist",
691 "",
692 "- [ Built-in Charsets ] -",
693 "",
694 " ? | Charset",
695 " ===+=========",
696 " l | abcdefghijklmnopqrstuvwxyz",
697 " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ",
698 " d | 0123456789",
699 " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~",
700 " a | ?l?u?d?s",
701 " b | 0x00 - 0xff",
702 "",
703 "- [ OpenCL Device Types ] -",
704 "",
705 " # | Device Type",
706 " ===+=============",
707 " 1 | CPU",
708 " 2 | GPU",
709 " 3 | FPGA, DSP, Co-Processor",
710 "",
711 "- [ Workload Profiles ] -",
712 "",
713 " # | Performance | Runtime | Power Consumption | Desktop Impact",
714 " ===+=============+=========+===================+=================",
715 " 1 | Low | 2 ms | Low | Minimal",
716 " 2 | Default | 12 ms | Economic | Noticeable",
717 " 3 | High | 96 ms | High | Unresponsive",
718 " 4 | Nightmare | 480 ms | Insane | Headless",
719 "",
720 "If you have no idea what just happened then visit the following pages:",
721 "",
722 "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild",
723 "* https://hashcat.net/wiki/#frequently_asked_questions",
724 "",
725 NULL
726 };
727
728 /**
729 * hashcat specific functions
730 */
731
732 static double get_avg_exec_time (hc_device_param_t *device_param, const int last_num_entries)
733 {
734 int exec_pos = (int) device_param->exec_pos - last_num_entries;
735
736 if (exec_pos < 0) exec_pos += EXEC_CACHE;
737
738 double exec_ms_sum = 0;
739
740 int exec_ms_cnt = 0;
741
742 for (int i = 0; i < last_num_entries; i++)
743 {
744 double exec_ms = device_param->exec_ms[(exec_pos + i) % EXEC_CACHE];
745
746 if (exec_ms)
747 {
748 exec_ms_sum += exec_ms;
749
750 exec_ms_cnt++;
751 }
752 }
753
754 if (exec_ms_cnt == 0) return 0;
755
756 return exec_ms_sum / exec_ms_cnt;
757 }
758
759 void status_display_machine_readable ()
760 {
761 FILE *out = stdout;
762
763 fprintf (out, "STATUS\t%u\t", data.devices_status);
764
765 /**
766 * speed new
767 */
768
769 fprintf (out, "SPEED\t");
770
771 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
772 {
773 hc_device_param_t *device_param = &data.devices_param[device_id];
774
775 if (device_param->skipped) continue;
776
777 u64 speed_cnt = 0;
778 double speed_ms = 0;
779
780 for (int i = 0; i < SPEED_CACHE; i++)
781 {
782 speed_cnt += device_param->speed_cnt[i];
783 speed_ms += device_param->speed_ms[i];
784 }
785
786 speed_cnt /= SPEED_CACHE;
787 speed_ms /= SPEED_CACHE;
788
789 fprintf (out, "%llu\t%f\t", (unsigned long long int) speed_cnt, speed_ms);
790 }
791
792 /**
793 * exec time
794 */
795
796 fprintf (out, "EXEC_RUNTIME\t");
797
798 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
799 {
800 hc_device_param_t *device_param = &data.devices_param[device_id];
801
802 if (device_param->skipped) continue;
803
804 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
805
806 fprintf (out, "%f\t", exec_ms_avg);
807 }
808
809 /**
810 * words_cur
811 */
812
813 u64 words_cur = get_lowest_words_done ();
814
815 fprintf (out, "CURKU\t%llu\t", (unsigned long long int) words_cur);
816
817 /**
818 * counter
819 */
820
821 u64 progress_total = data.words_cnt * data.salts_cnt;
822
823 u64 all_done = 0;
824 u64 all_rejected = 0;
825 u64 all_restored = 0;
826
827 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
828 {
829 all_done += data.words_progress_done[salt_pos];
830 all_rejected += data.words_progress_rejected[salt_pos];
831 all_restored += data.words_progress_restored[salt_pos];
832 }
833
834 u64 progress_cur = all_restored + all_done + all_rejected;
835 u64 progress_end = progress_total;
836
837 u64 progress_skip = 0;
838
839 if (data.skip)
840 {
841 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
842
843 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
844 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
845 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
846 }
847
848 if (data.limit)
849 {
850 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
851
852 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
853 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
854 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
855 }
856
857 u64 progress_cur_relative_skip = progress_cur - progress_skip;
858 u64 progress_end_relative_skip = progress_end - progress_skip;
859
860 fprintf (out, "PROGRESS\t%llu\t%llu\t", (unsigned long long int) progress_cur_relative_skip, (unsigned long long int) progress_end_relative_skip);
861
862 /**
863 * cracks
864 */
865
866 fprintf (out, "RECHASH\t%u\t%u\t", data.digests_done, data.digests_cnt);
867 fprintf (out, "RECSALT\t%u\t%u\t", data.salts_done, data.salts_cnt);
868
869 /**
870 * temperature
871 */
872
873 #ifdef HAVE_HWMON
874 if (data.gpu_temp_disable == 0)
875 {
876 fprintf (out, "TEMP\t");
877
878 hc_thread_mutex_lock (mux_adl);
879
880 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
881 {
882 hc_device_param_t *device_param = &data.devices_param[device_id];
883
884 if (device_param->skipped) continue;
885
886 int temp = hm_get_temperature_with_device_id (device_id);
887
888 fprintf (out, "%d\t", temp);
889 }
890
891 hc_thread_mutex_unlock (mux_adl);
892 }
893 #endif // HAVE_HWMON
894
895 /**
896 * flush
897 */
898
899 #ifdef _WIN
900 fputc ('\r', out);
901 fputc ('\n', out);
902 #endif
903
904 #ifdef _POSIX
905 fputc ('\n', out);
906 #endif
907
908 fflush (out);
909 }
910
911 void status_display ()
912 {
913 if (data.devices_status == STATUS_INIT) return;
914 if (data.devices_status == STATUS_STARTING) return;
915 if (data.devices_status == STATUS_BYPASS) return;
916
917 if (data.machine_readable == 1)
918 {
919 status_display_machine_readable ();
920
921 return;
922 }
923
924 char tmp_buf[1000] = { 0 };
925
926 uint tmp_len = 0;
927
928 log_info ("Session.Name...: %s", data.session);
929
930 char *status_type = strstatus (data.devices_status);
931
932 uint hash_mode = data.hash_mode;
933
934 char *hash_type = strhashtype (hash_mode); // not a bug
935
936 log_info ("Status.........: %s", status_type);
937
938 /**
939 * show rules
940 */
941
942 if (data.rp_files_cnt)
943 {
944 uint i;
945
946 for (i = 0, tmp_len = 0; i < data.rp_files_cnt - 1 && tmp_len < sizeof (tmp_buf); i++)
947 {
948 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s), ", data.rp_files[i]);
949 }
950
951 snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "File (%s)", data.rp_files[i]);
952
953 log_info ("Rules.Type.....: %s", tmp_buf);
954
955 tmp_len = 0;
956 }
957
958 if (data.rp_gen)
959 {
960 log_info ("Rules.Type.....: Generated (%u)", data.rp_gen);
961
962 if (data.rp_gen_seed)
963 {
964 log_info ("Rules.Seed.....: %u", data.rp_gen_seed);
965 }
966 }
967
968 /**
969 * show input
970 */
971
972 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
973 {
974 if (data.wordlist_mode == WL_MODE_FILE)
975 {
976 if (data.dictfile != NULL) log_info ("Input.Mode.....: File (%s)", data.dictfile);
977 }
978 else if (data.wordlist_mode == WL_MODE_STDIN)
979 {
980 log_info ("Input.Mode.....: Pipe");
981 }
982 }
983 else if (data.attack_mode == ATTACK_MODE_COMBI)
984 {
985 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
986 if (data.dictfile2 != NULL) log_info ("Input.Right....: File (%s)", data.dictfile2);
987 }
988 else if (data.attack_mode == ATTACK_MODE_BF)
989 {
990 char *mask = data.mask;
991
992 if (mask != NULL)
993 {
994 uint mask_len = data.css_cnt;
995
996 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, "Mask (%s)", mask);
997
998 if (mask_len > 0)
999 {
1000 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
1001 {
1002 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
1003 {
1004 mask_len -= data.salts_buf[0].salt_len;
1005 }
1006 }
1007
1008 if (data.opts_type & OPTS_TYPE_PT_UNICODE) mask_len /= 2;
1009
1010 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " [%i]", mask_len);
1011 }
1012
1013 if (data.maskcnt > 1)
1014 {
1015 float mask_percentage = (float) data.maskpos / (float) data.maskcnt;
1016
1017 tmp_len += snprintf (tmp_buf + tmp_len, sizeof (tmp_buf) - tmp_len, " (%.02f%%)", mask_percentage * 100);
1018 }
1019
1020 log_info ("Input.Mode.....: %s", tmp_buf);
1021 }
1022
1023 tmp_len = 0;
1024 }
1025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
1026 {
1027 if (data.dictfile != NULL) log_info ("Input.Left.....: File (%s)", data.dictfile);
1028 if (data.mask != NULL) log_info ("Input.Right....: Mask (%s) [%i]", data.mask, data.css_cnt);
1029 }
1030 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
1031 {
1032 if (data.mask != NULL) log_info ("Input.Left.....: Mask (%s) [%i]", data.mask, data.css_cnt);
1033 if (data.dictfile != NULL) log_info ("Input.Right....: File (%s)", data.dictfile);
1034 }
1035
1036 if (data.digests_cnt == 1)
1037 {
1038 if (data.hash_mode == 2500)
1039 {
1040 wpa_t *wpa = (wpa_t *) data.esalts_buf;
1041
1042 log_info ("Hash.Target....: %s (%02x:%02x:%02x:%02x:%02x:%02x <-> %02x:%02x:%02x:%02x:%02x:%02x)",
1043 (char *) data.salts_buf[0].salt_buf,
1044 wpa->orig_mac1[0],
1045 wpa->orig_mac1[1],
1046 wpa->orig_mac1[2],
1047 wpa->orig_mac1[3],
1048 wpa->orig_mac1[4],
1049 wpa->orig_mac1[5],
1050 wpa->orig_mac2[0],
1051 wpa->orig_mac2[1],
1052 wpa->orig_mac2[2],
1053 wpa->orig_mac2[3],
1054 wpa->orig_mac2[4],
1055 wpa->orig_mac2[5]);
1056 }
1057 else if (data.hash_mode == 5200)
1058 {
1059 log_info ("Hash.Target....: File (%s)", data.hashfile);
1060 }
1061 else if (data.hash_mode == 9000)
1062 {
1063 log_info ("Hash.Target....: File (%s)", data.hashfile);
1064 }
1065 else if ((data.hash_mode >= 6200) && (data.hash_mode <= 6299))
1066 {
1067 log_info ("Hash.Target....: File (%s)", data.hashfile);
1068 }
1069 else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799))
1070 {
1071 log_info ("Hash.Target....: File (%s)", data.hashfile);
1072 }
1073 else
1074 {
1075 char out_buf[HCBUFSIZ] = { 0 };
1076
1077 ascii_digest (out_buf, 0, 0);
1078
1079 // limit length
1080 if (strlen (out_buf) > 40)
1081 {
1082 out_buf[41] = '.';
1083 out_buf[42] = '.';
1084 out_buf[43] = '.';
1085 out_buf[44] = 0;
1086 }
1087
1088 log_info ("Hash.Target....: %s", out_buf);
1089 }
1090 }
1091 else
1092 {
1093 if (data.hash_mode == 3000)
1094 {
1095 char out_buf1[32] = { 0 };
1096 char out_buf2[32] = { 0 };
1097
1098 ascii_digest (out_buf1, 0, 0);
1099 ascii_digest (out_buf2, 0, 1);
1100
1101 log_info ("Hash.Target....: %s, %s", out_buf1, out_buf2);
1102 }
1103 else
1104 {
1105 log_info ("Hash.Target....: File (%s)", data.hashfile);
1106 }
1107 }
1108
1109 log_info ("Hash.Type......: %s", hash_type);
1110
1111 /**
1112 * speed new
1113 */
1114
1115 u64 speed_cnt[DEVICES_MAX] = { 0 };
1116 double speed_ms[DEVICES_MAX] = { 0 };
1117
1118 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1119 {
1120 hc_device_param_t *device_param = &data.devices_param[device_id];
1121
1122 if (device_param->skipped) continue;
1123
1124 speed_cnt[device_id] = 0;
1125 speed_ms[device_id] = 0;
1126
1127 for (int i = 0; i < SPEED_CACHE; i++)
1128 {
1129 speed_cnt[device_id] += device_param->speed_cnt[i];
1130 speed_ms[device_id] += device_param->speed_ms[i];
1131 }
1132
1133 speed_cnt[device_id] /= SPEED_CACHE;
1134 speed_ms[device_id] /= SPEED_CACHE;
1135 }
1136
1137 double hashes_all_ms = 0;
1138
1139 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1140
1141 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1142 {
1143 hc_device_param_t *device_param = &data.devices_param[device_id];
1144
1145 if (device_param->skipped) continue;
1146
1147 hashes_dev_ms[device_id] = 0;
1148
1149 if (speed_ms[device_id])
1150 {
1151 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1152
1153 hashes_all_ms += hashes_dev_ms[device_id];
1154 }
1155 }
1156
1157 /**
1158 * exec time
1159 */
1160
1161 double exec_all_ms[DEVICES_MAX] = { 0 };
1162
1163 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1164 {
1165 hc_device_param_t *device_param = &data.devices_param[device_id];
1166
1167 if (device_param->skipped) continue;
1168
1169 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1170
1171 exec_all_ms[device_id] = exec_ms_avg;
1172 }
1173
1174 /**
1175 * timers
1176 */
1177
1178 double ms_running = 0;
1179
1180 hc_timer_get (data.timer_running, ms_running);
1181
1182 double ms_paused = data.ms_paused;
1183
1184 if (data.devices_status == STATUS_PAUSED)
1185 {
1186 double ms_paused_tmp = 0;
1187
1188 hc_timer_get (data.timer_paused, ms_paused_tmp);
1189
1190 ms_paused += ms_paused_tmp;
1191 }
1192
1193 #ifdef WIN
1194
1195 __time64_t sec_run = ms_running / 1000;
1196
1197 #else
1198
1199 time_t sec_run = ms_running / 1000;
1200
1201 #endif
1202
1203 if (sec_run)
1204 {
1205 char display_run[32] = { 0 };
1206
1207 struct tm tm_run;
1208
1209 struct tm *tmp = NULL;
1210
1211 #ifdef WIN
1212
1213 tmp = _gmtime64 (&sec_run);
1214
1215 #else
1216
1217 tmp = gmtime (&sec_run);
1218
1219 #endif
1220
1221 if (tmp != NULL)
1222 {
1223 memset (&tm_run, 0, sizeof (tm_run));
1224
1225 memcpy (&tm_run, tmp, sizeof (tm_run));
1226
1227 format_timer_display (&tm_run, display_run, sizeof (tm_run));
1228
1229 char *start = ctime (&data.proc_start);
1230
1231 size_t start_len = strlen (start);
1232
1233 if (start[start_len - 1] == '\n') start[start_len - 1] = 0;
1234 if (start[start_len - 2] == '\r') start[start_len - 2] = 0;
1235
1236 log_info ("Time.Started...: %s (%s)", start, display_run);
1237 }
1238 }
1239 else
1240 {
1241 log_info ("Time.Started...: 0 secs");
1242 }
1243
1244 /**
1245 * counters
1246 */
1247
1248 u64 progress_total = data.words_cnt * data.salts_cnt;
1249
1250 u64 all_done = 0;
1251 u64 all_rejected = 0;
1252 u64 all_restored = 0;
1253
1254 u64 progress_noneed = 0;
1255
1256 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
1257 {
1258 all_done += data.words_progress_done[salt_pos];
1259 all_rejected += data.words_progress_rejected[salt_pos];
1260 all_restored += data.words_progress_restored[salt_pos];
1261
1262 // Important for ETA only
1263
1264 if (data.salts_shown[salt_pos] == 1)
1265 {
1266 const u64 all = data.words_progress_done[salt_pos]
1267 + data.words_progress_rejected[salt_pos]
1268 + data.words_progress_restored[salt_pos];
1269
1270 const u64 left = data.words_cnt - all;
1271
1272 progress_noneed += left;
1273 }
1274 }
1275
1276 u64 progress_cur = all_restored + all_done + all_rejected;
1277 u64 progress_end = progress_total;
1278
1279 u64 progress_skip = 0;
1280
1281 if (data.skip)
1282 {
1283 progress_skip = MIN (data.skip, data.words_base) * data.salts_cnt;
1284
1285 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_skip *= data.kernel_rules_cnt;
1286 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_skip *= data.combs_cnt;
1287 else if (data.attack_kern == ATTACK_KERN_BF) progress_skip *= data.bfs_cnt;
1288 }
1289
1290 if (data.limit)
1291 {
1292 progress_end = MIN (data.limit, data.words_base) * data.salts_cnt;
1293
1294 if (data.attack_kern == ATTACK_KERN_STRAIGHT) progress_end *= data.kernel_rules_cnt;
1295 else if (data.attack_kern == ATTACK_KERN_COMBI) progress_end *= data.combs_cnt;
1296 else if (data.attack_kern == ATTACK_KERN_BF) progress_end *= data.bfs_cnt;
1297 }
1298
1299 u64 progress_cur_relative_skip = progress_cur - progress_skip;
1300 u64 progress_end_relative_skip = progress_end - progress_skip;
1301
1302 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1303 {
1304 if (data.devices_status != STATUS_CRACKED)
1305 {
1306 #ifdef WIN
1307 __time64_t sec_etc = 0;
1308 #else
1309 time_t sec_etc = 0;
1310 #endif
1311
1312 if (hashes_all_ms)
1313 {
1314 u64 progress_left_relative_skip = progress_end_relative_skip - progress_cur_relative_skip;
1315
1316 u64 ms_left = (progress_left_relative_skip - progress_noneed) / hashes_all_ms;
1317
1318 sec_etc = ms_left / 1000;
1319 }
1320
1321 if (sec_etc == 0)
1322 {
1323 //log_info ("Time.Estimated.: 0 secs");
1324 }
1325 else if ((u64) sec_etc > ETC_MAX)
1326 {
1327 log_info ("Time.Estimated.: > 10 Years");
1328 }
1329 else
1330 {
1331 char display_etc[32] = { 0 };
1332
1333 struct tm tm_etc;
1334
1335 struct tm *tmp = NULL;
1336
1337 #ifdef WIN
1338
1339 tmp = _gmtime64 (&sec_etc);
1340
1341 #else
1342
1343 tmp = gmtime (&sec_etc);
1344
1345 #endif
1346
1347 if (tmp != NULL)
1348 {
1349 memset (&tm_etc, 0, sizeof (tm_etc));
1350
1351 memcpy (&tm_etc, tmp, sizeof (tm_etc));
1352
1353 format_timer_display (&tm_etc, display_etc, sizeof (display_etc));
1354
1355 time_t now;
1356
1357 time (&now);
1358
1359 now += sec_etc;
1360
1361 char *etc = ctime (&now);
1362
1363 size_t etc_len = strlen (etc);
1364
1365 if (etc[etc_len - 1] == '\n') etc[etc_len - 1] = 0;
1366 if (etc[etc_len - 2] == '\r') etc[etc_len - 2] = 0;
1367
1368 log_info ("Time.Estimated.: %s (%s)", etc, display_etc);
1369 }
1370 }
1371 }
1372 }
1373
1374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1375 {
1376 hc_device_param_t *device_param = &data.devices_param[device_id];
1377
1378 if (device_param->skipped) continue;
1379
1380 char display_dev_cur[16] = { 0 };
1381
1382 strncpy (display_dev_cur, "0.00", 4);
1383
1384 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1385
1386 log_info ("Speed.Dev.#%d...: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1387 }
1388
1389 char display_all_cur[16] = { 0 };
1390
1391 strncpy (display_all_cur, "0.00", 4);
1392
1393 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1394
1395 if (data.devices_active > 1) log_info ("Speed.Dev.#*...: %9sH/s", display_all_cur);
1396
1397 const float digests_percent = (float) data.digests_done / data.digests_cnt;
1398 const float salts_percent = (float) data.salts_done / data.salts_cnt;
1399
1400 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);
1401
1402 // crack-per-time
1403
1404 if (data.digests_cnt > 100)
1405 {
1406 time_t now = time (NULL);
1407
1408 int cpt_cur_min = 0;
1409 int cpt_cur_hour = 0;
1410 int cpt_cur_day = 0;
1411
1412 for (int i = 0; i < CPT_BUF; i++)
1413 {
1414 const uint cracked = data.cpt_buf[i].cracked;
1415 const time_t timestamp = data.cpt_buf[i].timestamp;
1416
1417 if ((timestamp + 60) > now)
1418 {
1419 cpt_cur_min += cracked;
1420 }
1421
1422 if ((timestamp + 3600) > now)
1423 {
1424 cpt_cur_hour += cracked;
1425 }
1426
1427 if ((timestamp + 86400) > now)
1428 {
1429 cpt_cur_day += cracked;
1430 }
1431 }
1432
1433 double ms_real = ms_running - ms_paused;
1434
1435 float cpt_avg_min = (float) data.cpt_total / ((ms_real / 1000) / 60);
1436 float cpt_avg_hour = (float) data.cpt_total / ((ms_real / 1000) / 3600);
1437 float cpt_avg_day = (float) data.cpt_total / ((ms_real / 1000) / 86400);
1438
1439 if ((data.cpt_start + 86400) < now)
1440 {
1441 log_info ("Recovered/Time.: CUR:%llu,%llu,%llu AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1442 cpt_cur_min,
1443 cpt_cur_hour,
1444 cpt_cur_day,
1445 cpt_avg_min,
1446 cpt_avg_hour,
1447 cpt_avg_day);
1448 }
1449 else if ((data.cpt_start + 3600) < now)
1450 {
1451 log_info ("Recovered/Time.: CUR:%llu,%llu,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1452 cpt_cur_min,
1453 cpt_cur_hour,
1454 cpt_avg_min,
1455 cpt_avg_hour,
1456 cpt_avg_day);
1457 }
1458 else if ((data.cpt_start + 60) < now)
1459 {
1460 log_info ("Recovered/Time.: CUR:%llu,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1461 cpt_cur_min,
1462 cpt_avg_min,
1463 cpt_avg_hour,
1464 cpt_avg_day);
1465 }
1466 else
1467 {
1468 log_info ("Recovered/Time.: CUR:N/A,N/A,N/A AVG:%0.2f,%0.2f,%0.2f (Min,Hour,Day)",
1469 cpt_avg_min,
1470 cpt_avg_hour,
1471 cpt_avg_day);
1472 }
1473 }
1474
1475 // Restore point
1476
1477 u64 restore_point = get_lowest_words_done ();
1478
1479 u64 restore_total = data.words_base;
1480
1481 float percent_restore = 0;
1482
1483 if (restore_total != 0) percent_restore = (float) restore_point / (float) restore_total;
1484
1485 if (progress_end_relative_skip)
1486 {
1487 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1488 {
1489 float percent_finished = (float) progress_cur_relative_skip / (float) progress_end_relative_skip;
1490 float percent_rejected = 0.0;
1491
1492 if (progress_cur)
1493 {
1494 percent_rejected = (float) (all_rejected) / (float) progress_cur;
1495 }
1496
1497 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);
1498 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (unsigned long long int) all_rejected, (unsigned long long int) progress_cur_relative_skip, percent_rejected * 100);
1499
1500 if (data.restore_disable == 0)
1501 {
1502 if (percent_finished != 1)
1503 {
1504 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (unsigned long long int) restore_point, (unsigned long long int) restore_total, percent_restore * 100);
1505 }
1506 }
1507 }
1508 }
1509 else
1510 {
1511 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
1512 {
1513 log_info ("Progress.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1514 log_info ("Rejected.......: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1515
1516 if (data.restore_disable == 0)
1517 {
1518 log_info ("Restore.Point..: %llu/%llu (%.02f%%)", (u64) 0, (u64) 0, (float) 100);
1519 }
1520 }
1521 else
1522 {
1523 log_info ("Progress.......: %llu", (unsigned long long int) progress_cur_relative_skip);
1524 log_info ("Rejected.......: %llu", (unsigned long long int) all_rejected);
1525
1526 // --restore not allowed if stdin is used -- really? why?
1527
1528 //if (data.restore_disable == 0)
1529 //{
1530 // log_info ("Restore.Point..: %llu", (unsigned long long int) restore_point);
1531 //}
1532 }
1533 }
1534
1535 #ifdef HAVE_HWMON
1536 if (data.gpu_temp_disable == 0)
1537 {
1538 hc_thread_mutex_lock (mux_adl);
1539
1540 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1541 {
1542 hc_device_param_t *device_param = &data.devices_param[device_id];
1543
1544 if (device_param->skipped) continue;
1545
1546 const int num_temperature = hm_get_temperature_with_device_id (device_id);
1547 const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id);
1548 const int num_utilization = hm_get_utilization_with_device_id (device_id);
1549 const int num_corespeed = hm_get_corespeed_with_device_id (device_id);
1550 const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id);
1551 const int num_buslanes = hm_get_buslanes_with_device_id (device_id);
1552 // not working
1553 //const int num_throttle = hm_get_throttle_with_device_id (device_id);
1554
1555 char output_buf[256] = { 0 };
1556
1557 int output_len = 0;
1558
1559 if (num_temperature >= 0)
1560 {
1561 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature);
1562
1563 output_len = strlen (output_buf);
1564 }
1565
1566 if (num_fanspeed >= 0)
1567 {
1568 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed);
1569
1570 output_len = strlen (output_buf);
1571 }
1572
1573 if (num_utilization >= 0)
1574 {
1575 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization);
1576
1577 output_len = strlen (output_buf);
1578 }
1579
1580 if (num_corespeed >= 0)
1581 {
1582 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed);
1583
1584 output_len = strlen (output_buf);
1585 }
1586
1587 if (num_memoryspeed >= 0)
1588 {
1589 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed);
1590
1591 output_len = strlen (output_buf);
1592 }
1593
1594 if (num_buslanes >= 0)
1595 {
1596 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes);
1597
1598 output_len = strlen (output_buf);
1599 }
1600
1601 /*
1602 if (num_throttle >= 0)
1603 {
1604 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Throttle:%u", num_throttle);
1605
1606 output_len = strlen (output_buf);
1607 }
1608 */
1609
1610 if (output_len == 0)
1611 {
1612 snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A");
1613
1614 output_len = strlen (output_buf);
1615 }
1616
1617 log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf);
1618 }
1619
1620 hc_thread_mutex_unlock (mux_adl);
1621 }
1622 #endif // HAVE_HWMON
1623 }
1624
1625 static void status_benchmark_automate ()
1626 {
1627 u64 speed_cnt[DEVICES_MAX] = { 0 };
1628 double speed_ms[DEVICES_MAX] = { 0 };
1629
1630 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1631 {
1632 hc_device_param_t *device_param = &data.devices_param[device_id];
1633
1634 if (device_param->skipped) continue;
1635
1636 speed_cnt[device_id] = device_param->speed_cnt[0];
1637 speed_ms[device_id] = device_param->speed_ms[0];
1638 }
1639
1640 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1641
1642 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1643 {
1644 hc_device_param_t *device_param = &data.devices_param[device_id];
1645
1646 if (device_param->skipped) continue;
1647
1648 hashes_dev_ms[device_id] = 0;
1649
1650 if (speed_ms[device_id])
1651 {
1652 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1653 }
1654 }
1655
1656 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1657 {
1658 hc_device_param_t *device_param = &data.devices_param[device_id];
1659
1660 if (device_param->skipped) continue;
1661
1662 log_info ("%u:%u:%llu", device_id + 1, data.hash_mode, (unsigned long long int) (hashes_dev_ms[device_id] * 1000));
1663 }
1664 }
1665
1666 static void status_benchmark ()
1667 {
1668 if (data.devices_status == STATUS_INIT) return;
1669 if (data.devices_status == STATUS_STARTING) return;
1670 if (data.devices_status == STATUS_BYPASS) return;
1671
1672 if (data.machine_readable == 1)
1673 {
1674 status_benchmark_automate ();
1675
1676 return;
1677 }
1678
1679 u64 speed_cnt[DEVICES_MAX] = { 0 };
1680 double speed_ms[DEVICES_MAX] = { 0 };
1681
1682 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1683 {
1684 hc_device_param_t *device_param = &data.devices_param[device_id];
1685
1686 if (device_param->skipped) continue;
1687
1688 speed_cnt[device_id] = device_param->speed_cnt[0];
1689 speed_ms[device_id] = device_param->speed_ms[0];
1690 }
1691
1692 double hashes_all_ms = 0;
1693
1694 double hashes_dev_ms[DEVICES_MAX] = { 0 };
1695
1696 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1697 {
1698 hc_device_param_t *device_param = &data.devices_param[device_id];
1699
1700 if (device_param->skipped) continue;
1701
1702 hashes_dev_ms[device_id] = 0;
1703
1704 if (speed_ms[device_id])
1705 {
1706 hashes_dev_ms[device_id] = (double) speed_cnt[device_id] / speed_ms[device_id];
1707
1708 hashes_all_ms += hashes_dev_ms[device_id];
1709 }
1710 }
1711
1712 /**
1713 * exec time
1714 */
1715
1716 double exec_all_ms[DEVICES_MAX] = { 0 };
1717
1718 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1719 {
1720 hc_device_param_t *device_param = &data.devices_param[device_id];
1721
1722 if (device_param->skipped) continue;
1723
1724 double exec_ms_avg = get_avg_exec_time (device_param, EXEC_CACHE);
1725
1726 exec_all_ms[device_id] = exec_ms_avg;
1727 }
1728
1729 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
1730 {
1731 hc_device_param_t *device_param = &data.devices_param[device_id];
1732
1733 if (device_param->skipped) continue;
1734
1735 char display_dev_cur[16] = { 0 };
1736
1737 strncpy (display_dev_cur, "0.00", 4);
1738
1739 format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur));
1740
1741 log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]);
1742 }
1743
1744 char display_all_cur[16] = { 0 };
1745
1746 strncpy (display_all_cur, "0.00", 4);
1747
1748 format_speed_display (hashes_all_ms * 1000, display_all_cur, sizeof (display_all_cur));
1749
1750 if (data.devices_active > 1) log_info ("Speed.Dev.#*.: %9sH/s", display_all_cur);
1751 }
1752
1753 /**
1754 * hashcat -only- functions
1755 */
1756
1757 static void generate_source_kernel_filename (const uint attack_exec, const uint attack_kern, const uint kern_type, char *shared_dir, char *source_file)
1758 {
1759 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1760 {
1761 if (attack_kern == ATTACK_KERN_STRAIGHT)
1762 snprintf (source_file, 255, "%s/OpenCL/m%05d_a0.cl", shared_dir, (int) kern_type);
1763 else if (attack_kern == ATTACK_KERN_COMBI)
1764 snprintf (source_file, 255, "%s/OpenCL/m%05d_a1.cl", shared_dir, (int) kern_type);
1765 else if (attack_kern == ATTACK_KERN_BF)
1766 snprintf (source_file, 255, "%s/OpenCL/m%05d_a3.cl", shared_dir, (int) kern_type);
1767 }
1768 else
1769 snprintf (source_file, 255, "%s/OpenCL/m%05d.cl", shared_dir, (int) kern_type);
1770 }
1771
1772 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)
1773 {
1774 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
1775 {
1776 if (attack_kern == ATTACK_KERN_STRAIGHT)
1777 snprintf (cached_file, 255, "%s/kernels/m%05d_a0.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1778 else if (attack_kern == ATTACK_KERN_COMBI)
1779 snprintf (cached_file, 255, "%s/kernels/m%05d_a1.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1780 else if (attack_kern == ATTACK_KERN_BF)
1781 snprintf (cached_file, 255, "%s/kernels/m%05d_a3.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1782 }
1783 else
1784 {
1785 snprintf (cached_file, 255, "%s/kernels/m%05d.%s.kernel", profile_dir, (int) kern_type, device_name_chksum);
1786 }
1787 }
1788
1789 static void generate_source_kernel_mp_filename (const uint opti_type, const uint opts_type, char *shared_dir, char *source_file)
1790 {
1791 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1792 {
1793 snprintf (source_file, 255, "%s/OpenCL/markov_be.cl", shared_dir);
1794 }
1795 else
1796 {
1797 snprintf (source_file, 255, "%s/OpenCL/markov_le.cl", shared_dir);
1798 }
1799 }
1800
1801 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)
1802 {
1803 if ((opti_type & OPTI_TYPE_BRUTE_FORCE) && (opts_type & OPTS_TYPE_PT_GENERATE_BE))
1804 {
1805 snprintf (cached_file, 255, "%s/kernels/markov_be.%s.kernel", profile_dir, device_name_chksum);
1806 }
1807 else
1808 {
1809 snprintf (cached_file, 255, "%s/kernels/markov_le.%s.kernel", profile_dir, device_name_chksum);
1810 }
1811 }
1812
1813 static void generate_source_kernel_amp_filename (const uint attack_kern, char *shared_dir, char *source_file)
1814 {
1815 snprintf (source_file, 255, "%s/OpenCL/amp_a%d.cl", shared_dir, attack_kern);
1816 }
1817
1818 static void generate_cached_kernel_amp_filename (const uint attack_kern, char *profile_dir, const char *device_name_chksum, char *cached_file)
1819 {
1820 snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
1821 }
1822
1823 static uint convert_from_hex (char *line_buf, const uint line_len)
1824 {
1825 if (line_len & 1) return (line_len); // not in hex
1826
1827 if (data.hex_wordlist == 1)
1828 {
1829 uint i;
1830 uint j;
1831
1832 for (i = 0, j = 0; j < line_len; i += 1, j += 2)
1833 {
1834 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1835 }
1836
1837 memset (line_buf + i, 0, line_len - i);
1838
1839 return (i);
1840 }
1841 else if (line_len >= 6) // $HEX[] = 6
1842 {
1843 if (line_buf[0] != '$') return (line_len);
1844 if (line_buf[1] != 'H') return (line_len);
1845 if (line_buf[2] != 'E') return (line_len);
1846 if (line_buf[3] != 'X') return (line_len);
1847 if (line_buf[4] != '[') return (line_len);
1848 if (line_buf[line_len - 1] != ']') return (line_len);
1849
1850 uint i;
1851 uint j;
1852
1853 for (i = 0, j = 5; j < line_len - 1; i += 1, j += 2)
1854 {
1855 line_buf[i] = hex_to_u8 ((const u8 *) &line_buf[j]);
1856 }
1857
1858 memset (line_buf + i, 0, line_len - i);
1859
1860 return (i);
1861 }
1862
1863 return (line_len);
1864 }
1865
1866 static void clear_prompt ()
1867 {
1868 fputc ('\r', stdout);
1869
1870 for (size_t i = 0; i < strlen (PROMPT); i++)
1871 {
1872 fputc (' ', stdout);
1873 }
1874
1875 fputc ('\r', stdout);
1876
1877 fflush (stdout);
1878 }
1879
1880 static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t *pw)
1881 {
1882 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);
1883 }
1884
1885 static void check_hash (hc_device_param_t *device_param, plain_t *plain)
1886 {
1887 char *outfile = data.outfile;
1888 uint quiet = data.quiet;
1889 FILE *pot_fp = data.pot_fp;
1890 uint loopback = data.loopback;
1891 uint debug_mode = data.debug_mode;
1892 char *debug_file = data.debug_file;
1893
1894 char debug_rule_buf[BLOCK_SIZE] = { 0 };
1895 int debug_rule_len = 0; // -1 error
1896 uint debug_plain_len = 0;
1897
1898 u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
1899
1900 // hash
1901
1902 char out_buf[HCBUFSIZ] = { 0 };
1903
1904 const u32 salt_pos = plain->salt_pos;
1905 const u32 digest_pos = plain->digest_pos; // relative
1906 const u32 gidvid = plain->gidvid;
1907 const u32 il_pos = plain->il_pos;
1908
1909 ascii_digest (out_buf, salt_pos, digest_pos);
1910
1911 // plain
1912
1913 u64 crackpos = device_param->words_off;
1914
1915 uint plain_buf[16] = { 0 };
1916
1917 u8 *plain_ptr = (u8 *) plain_buf;
1918
1919 unsigned int plain_len = 0;
1920
1921 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
1922 {
1923 pw_t pw;
1924
1925 gidd_to_pw_t (device_param, gidvid, &pw);
1926
1927 for (int i = 0; i < 16; i++)
1928 {
1929 plain_buf[i] = pw.i[i];
1930 }
1931
1932 plain_len = pw.pw_len;
1933
1934 const uint off = device_param->innerloop_pos + il_pos;
1935
1936 if (debug_mode > 0)
1937 {
1938 debug_rule_len = 0;
1939
1940 // save rule
1941 if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
1942 {
1943 memset (debug_rule_buf, 0, sizeof (debug_rule_buf));
1944
1945 debug_rule_len = kernel_rule_to_cpu_rule (debug_rule_buf, &data.kernel_rules_buf[off]);
1946 }
1947
1948 // save plain
1949 if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
1950 {
1951 memset (debug_plain_ptr, 0, sizeof (debug_plain_ptr));
1952
1953 memcpy (debug_plain_ptr, plain_ptr, plain_len);
1954
1955 debug_plain_len = plain_len;
1956 }
1957 }
1958
1959 plain_len = apply_rules (data.kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], plain_len);
1960
1961 crackpos += gidvid;
1962 crackpos *= data.kernel_rules_cnt;
1963 crackpos += device_param->innerloop_pos + il_pos;
1964
1965 if (plain_len > data.pw_max) plain_len = data.pw_max;
1966 }
1967 else if (data.attack_mode == ATTACK_MODE_COMBI)
1968 {
1969 pw_t pw;
1970
1971 gidd_to_pw_t (device_param, gidvid, &pw);
1972
1973 for (int i = 0; i < 16; i++)
1974 {
1975 plain_buf[i] = pw.i[i];
1976 }
1977
1978 plain_len = pw.pw_len;
1979
1980 char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
1981 uint comb_len = device_param->combs_buf[il_pos].pw_len;
1982
1983 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
1984 {
1985 memcpy (plain_ptr + plain_len, comb_buf, comb_len);
1986 }
1987 else
1988 {
1989 memmove (plain_ptr + comb_len, plain_ptr, plain_len);
1990
1991 memcpy (plain_ptr, comb_buf, comb_len);
1992 }
1993
1994 plain_len += comb_len;
1995
1996 crackpos += gidvid;
1997 crackpos *= data.combs_cnt;
1998 crackpos += device_param->innerloop_pos + il_pos;
1999
2000 if (data.pw_max != PW_DICTMAX1)
2001 {
2002 if (plain_len > data.pw_max) plain_len = data.pw_max;
2003 }
2004 }
2005 else if (data.attack_mode == ATTACK_MODE_BF)
2006 {
2007 u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
2008 u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
2009
2010 uint l_start = device_param->kernel_params_mp_l_buf32[5];
2011 uint r_start = device_param->kernel_params_mp_r_buf32[5];
2012
2013 uint l_stop = device_param->kernel_params_mp_l_buf32[4];
2014 uint r_stop = device_param->kernel_params_mp_r_buf32[4];
2015
2016 sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop);
2017 sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop);
2018
2019 plain_len = data.css_cnt;
2020
2021 crackpos += gidvid;
2022 crackpos *= data.bfs_cnt;
2023 crackpos += device_param->innerloop_pos + il_pos;
2024 }
2025 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
2026 {
2027 pw_t pw;
2028
2029 gidd_to_pw_t (device_param, gidvid, &pw);
2030
2031 for (int i = 0; i < 16; i++)
2032 {
2033 plain_buf[i] = pw.i[i];
2034 }
2035
2036 plain_len = pw.pw_len;
2037
2038 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2039
2040 uint start = 0;
2041 uint stop = device_param->kernel_params_mp_buf32[4];
2042
2043 sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop);
2044
2045 plain_len += start + stop;
2046
2047 crackpos += gidvid;
2048 crackpos *= data.combs_cnt;
2049 crackpos += device_param->innerloop_pos + il_pos;
2050
2051 if (data.pw_max != PW_DICTMAX1)
2052 {
2053 if (plain_len > data.pw_max) plain_len = data.pw_max;
2054 }
2055 }
2056 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2057 {
2058 pw_t pw;
2059
2060 gidd_to_pw_t (device_param, gidvid, &pw);
2061
2062 for (int i = 0; i < 16; i++)
2063 {
2064 plain_buf[i] = pw.i[i];
2065 }
2066
2067 plain_len = pw.pw_len;
2068
2069 u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
2070
2071 uint start = 0;
2072 uint stop = device_param->kernel_params_mp_buf32[4];
2073
2074 memmove (plain_ptr + stop, plain_ptr, plain_len);
2075
2076 sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop);
2077
2078 plain_len += start + stop;
2079
2080 crackpos += gidvid;
2081 crackpos *= data.combs_cnt;
2082 crackpos += device_param->innerloop_pos + il_pos;
2083
2084 if (data.pw_max != PW_DICTMAX1)
2085 {
2086 if (plain_len > data.pw_max) plain_len = data.pw_max;
2087 }
2088 }
2089
2090 if (data.attack_mode == ATTACK_MODE_BF)
2091 {
2092 if (data.opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
2093 {
2094 if (data.opti_type & OPTI_TYPE_SINGLE_HASH)
2095 {
2096 if (data.opti_type & OPTI_TYPE_APPENDED_SALT)
2097 {
2098 plain_len = plain_len - data.salts_buf[0].salt_len;
2099 }
2100 }
2101
2102 if (data.opts_type & OPTS_TYPE_PT_UNICODE)
2103 {
2104 for (uint i = 0, j = 0; i < plain_len; i += 2, j += 1)
2105 {
2106 plain_ptr[j] = plain_ptr[i];
2107 }
2108
2109 plain_len = plain_len / 2;
2110 }
2111 }
2112 }
2113
2114 // if enabled, update also the potfile
2115
2116 if (pot_fp)
2117 {
2118 lock_file (pot_fp);
2119
2120 fprintf (pot_fp, "%s:", out_buf);
2121
2122 format_plain (pot_fp, plain_ptr, plain_len, 1);
2123
2124 fputc ('\n', pot_fp);
2125
2126 fflush (pot_fp);
2127
2128 unlock_file (pot_fp);
2129 }
2130
2131 // outfile
2132
2133 FILE *out_fp = NULL;
2134
2135 if (outfile != NULL)
2136 {
2137 if ((out_fp = fopen (outfile, "ab")) == NULL)
2138 {
2139 log_error ("ERROR: %s: %s", outfile, strerror (errno));
2140
2141 out_fp = stdout;
2142 }
2143
2144 lock_file (out_fp);
2145 }
2146 else
2147 {
2148 out_fp = stdout;
2149
2150 if (quiet == 0) clear_prompt ();
2151 }
2152
2153 format_output (out_fp, out_buf, plain_ptr, plain_len, crackpos, NULL, 0);
2154
2155 if (outfile != NULL)
2156 {
2157 if (out_fp != stdout)
2158 {
2159 fclose (out_fp);
2160 }
2161 }
2162 else
2163 {
2164 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
2165 {
2166 if ((data.devices_status != STATUS_CRACKED) && (data.status != 1))
2167 {
2168 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
2169 if (quiet == 0) fflush (stdout);
2170 }
2171 }
2172 }
2173
2174 // loopback
2175
2176 if (loopback)
2177 {
2178 char *loopback_file = data.loopback_file;
2179
2180 FILE *fb_fp = NULL;
2181
2182 if ((fb_fp = fopen (loopback_file, "ab")) != NULL)
2183 {
2184 lock_file (fb_fp);
2185
2186 format_plain (fb_fp, plain_ptr, plain_len, 1);
2187
2188 fputc ('\n', fb_fp);
2189
2190 fclose (fb_fp);
2191 }
2192 }
2193
2194 // (rule) debug mode
2195
2196 // the next check implies that:
2197 // - (data.attack_mode == ATTACK_MODE_STRAIGHT)
2198 // - debug_mode > 0
2199
2200 if ((debug_plain_len > 0) || (debug_rule_len > 0))
2201 {
2202 if (debug_rule_len < 0) debug_rule_len = 0;
2203
2204 if ((quiet == 0) && (debug_file == NULL)) clear_prompt ();
2205
2206 format_debug (debug_file, debug_mode, debug_plain_ptr, debug_plain_len, plain_ptr, plain_len, debug_rule_buf, debug_rule_len);
2207
2208 if ((quiet == 0) && (debug_file == NULL))
2209 {
2210 fprintf (stdout, "%s", PROMPT);
2211
2212 fflush (stdout);
2213 }
2214 }
2215 }
2216
2217 static void check_cracked (hc_device_param_t *device_param, const uint salt_pos)
2218 {
2219 salt_t *salt_buf = &data.salts_buf[salt_pos];
2220
2221 u32 num_cracked;
2222
2223 hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2224
2225 if (num_cracked)
2226 {
2227 // display hack (for weak hashes etc, it could be that there is still something to clear on the current line)
2228
2229 log_info_nn ("");
2230
2231 plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t));
2232
2233 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);
2234
2235 uint cpt_cracked = 0;
2236
2237 for (uint i = 0; i < num_cracked; i++)
2238 {
2239 const uint hash_pos = cracked[i].hash_pos;
2240
2241 if (data.digests_shown[hash_pos] == 1) continue;
2242
2243 hc_thread_mutex_lock (mux_display);
2244
2245 if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0)
2246 {
2247 data.digests_shown[hash_pos] = 1;
2248
2249 data.digests_done++;
2250
2251 cpt_cracked++;
2252
2253 salt_buf->digests_done++;
2254
2255 if (salt_buf->digests_done == salt_buf->digests_cnt)
2256 {
2257 data.salts_shown[salt_pos] = 1;
2258
2259 data.salts_done++;
2260 }
2261 }
2262
2263 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
2264
2265 hc_thread_mutex_unlock (mux_display);
2266
2267 check_hash (device_param, &cracked[i]);
2268 }
2269
2270 myfree (cracked);
2271
2272 if (cpt_cracked > 0)
2273 {
2274 hc_thread_mutex_lock (mux_display);
2275
2276 data.cpt_buf[data.cpt_pos].timestamp = time (NULL);
2277 data.cpt_buf[data.cpt_pos].cracked = cpt_cracked;
2278
2279 data.cpt_pos++;
2280
2281 data.cpt_total += cpt_cracked;
2282
2283 if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0;
2284
2285 hc_thread_mutex_unlock (mux_display);
2286 }
2287
2288 if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK)
2289 {
2290 // we need to reset cracked state on the device
2291 // otherwise host thinks again and again the hash was cracked
2292 // and returns invalid password each time
2293
2294 memset (data.digests_shown_tmp, 0, salt_buf->digests_cnt * sizeof (uint));
2295
2296 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);
2297 }
2298
2299 num_cracked = 0;
2300
2301 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL);
2302 }
2303 }
2304
2305 static void save_hash ()
2306 {
2307 char *hashfile = data.hashfile;
2308
2309 char new_hashfile[256] = { 0 };
2310 char old_hashfile[256] = { 0 };
2311
2312 snprintf (new_hashfile, 255, "%s.new", hashfile);
2313 snprintf (old_hashfile, 255, "%s.old", hashfile);
2314
2315 unlink (new_hashfile);
2316
2317 char separator = data.separator;
2318
2319 FILE *fp = fopen (new_hashfile, "wb");
2320
2321 if (fp == NULL)
2322 {
2323 log_error ("ERROR: %s: %s", new_hashfile, strerror (errno));
2324
2325 exit (-1);
2326 }
2327
2328 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
2329 {
2330 if (data.salts_shown[salt_pos] == 1) continue;
2331
2332 salt_t *salt_buf = &data.salts_buf[salt_pos];
2333
2334 for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++)
2335 {
2336 uint idx = salt_buf->digests_offset + digest_pos;
2337
2338 if (data.digests_shown[idx] == 1) continue;
2339
2340 if (data.hash_mode != 2500)
2341 {
2342 char out_buf[HCBUFSIZ] = { 0 };
2343
2344 if (data.username == 1)
2345 {
2346 user_t *user = data.hash_info[idx]->user;
2347
2348 uint i;
2349
2350 for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp);
2351
2352 fputc (separator, fp);
2353 }
2354
2355 ascii_digest (out_buf, salt_pos, digest_pos);
2356
2357 fputs (out_buf, fp);
2358
2359 log_out (fp, "");
2360 }
2361 else
2362 {
2363 hccap_t hccap;
2364
2365 to_hccap_t (&hccap, salt_pos, digest_pos);
2366
2367 fwrite (&hccap, sizeof (hccap_t), 1, fp);
2368 }
2369 }
2370 }
2371
2372 fflush (fp);
2373
2374 fclose (fp);
2375
2376 unlink (old_hashfile);
2377
2378 if (rename (hashfile, old_hashfile) != 0)
2379 {
2380 log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno));
2381
2382 exit (-1);
2383 }
2384
2385 unlink (hashfile);
2386
2387 if (rename (new_hashfile, hashfile) != 0)
2388 {
2389 log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno));
2390
2391 exit (-1);
2392 }
2393
2394 unlink (old_hashfile);
2395 }
2396
2397 static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all)
2398 {
2399 // function called only in case kernel_power_all > words_left
2400
2401 float kernel_power_div = (float) (total_left) / kernel_power_all;
2402
2403 kernel_power_div += kernel_power_div / 100;
2404
2405 u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2406
2407 while (kernel_power_new < total_left)
2408 {
2409 kernel_power_div += kernel_power_div / 100;
2410
2411 kernel_power_new = (u32) (kernel_power_all * kernel_power_div);
2412 }
2413
2414 if (data.quiet == 0)
2415 {
2416 clear_prompt ();
2417
2418 //log_info ("");
2419
2420 log_info ("INFO: approaching final keyspace, workload adjusted");
2421 log_info ("");
2422
2423 fprintf (stdout, "%s", PROMPT);
2424
2425 fflush (stdout);
2426 }
2427
2428 if ((kernel_power_all * kernel_power_div) < 8) return 1;
2429
2430 return kernel_power_div;
2431 }
2432
2433 static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update)
2434 {
2435 uint num_elements = num;
2436
2437 device_param->kernel_params_buf32[30] = data.combs_mode;
2438 device_param->kernel_params_buf32[31] = num;
2439
2440 uint kernel_threads = device_param->kernel_threads;
2441
2442 while (num_elements % kernel_threads) num_elements++;
2443
2444 cl_kernel kernel = NULL;
2445
2446 switch (kern_run)
2447 {
2448 case KERN_RUN_1: kernel = device_param->kernel1; break;
2449 case KERN_RUN_12: kernel = device_param->kernel12; break;
2450 case KERN_RUN_2: kernel = device_param->kernel2; break;
2451 case KERN_RUN_23: kernel = device_param->kernel23; break;
2452 case KERN_RUN_3: kernel = device_param->kernel3; break;
2453 }
2454
2455 hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]);
2456 hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]);
2457 hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]);
2458 hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]);
2459 hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]);
2460 hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]);
2461 hc_clSetKernelArg (data.ocl, kernel, 27, sizeof (cl_uint), device_param->kernel_params[27]);
2462 hc_clSetKernelArg (data.ocl, kernel, 28, sizeof (cl_uint), device_param->kernel_params[28]);
2463 hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]);
2464 hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]);
2465 hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]);
2466
2467 cl_event event;
2468
2469 if ((data.opts_type & OPTS_TYPE_PT_BITSLICE) && (data.attack_mode == ATTACK_MODE_BF))
2470 {
2471 const size_t global_work_size[3] = { num_elements, 32, 1 };
2472 const size_t local_work_size[3] = { kernel_threads / 32, 32, 1 };
2473
2474 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 2, NULL, global_work_size, local_work_size, 0, NULL, &event);
2475 }
2476 else
2477 {
2478 if (kern_run == KERN_RUN_2)
2479 {
2480 if (data.opti_type & OPTI_TYPE_SLOW_HASH_SIMD)
2481 {
2482 num_elements = CEIL ((float) num_elements / device_param->vector_width);
2483 }
2484 }
2485
2486 while (num_elements % kernel_threads) num_elements++;
2487
2488 const size_t global_work_size[3] = { num_elements, 1, 1 };
2489 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2490
2491 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, &event);
2492 }
2493
2494 hc_clFlush (data.ocl, device_param->command_queue);
2495
2496 hc_clWaitForEvents (data.ocl, 1, &event);
2497
2498 if (event_update)
2499 {
2500 cl_ulong time_start;
2501 cl_ulong time_end;
2502
2503 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL);
2504 hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL);
2505
2506 const double exec_time = (double) (time_end - time_start) / 1000000.0;
2507
2508 uint exec_pos = device_param->exec_pos;
2509
2510 device_param->exec_ms[exec_pos] = exec_time;
2511
2512 exec_pos++;
2513
2514 if (exec_pos == EXEC_CACHE)
2515 {
2516 exec_pos = 0;
2517 }
2518
2519 device_param->exec_pos = exec_pos;
2520 }
2521
2522 hc_clReleaseEvent (data.ocl, event);
2523
2524 hc_clFinish (data.ocl, device_param->command_queue);
2525 }
2526
2527 static void run_kernel_mp (const uint kern_run, hc_device_param_t *device_param, const uint num)
2528 {
2529 uint num_elements = num;
2530
2531 switch (kern_run)
2532 {
2533 case KERN_RUN_MP: device_param->kernel_params_mp_buf32[8] = num; break;
2534 case KERN_RUN_MP_R: device_param->kernel_params_mp_r_buf32[8] = num; break;
2535 case KERN_RUN_MP_L: device_param->kernel_params_mp_l_buf32[9] = num; break;
2536 }
2537
2538 // causes problems with special threads like in bcrypt
2539 // const uint kernel_threads = device_param->kernel_threads;
2540
2541 uint kernel_threads = device_param->kernel_threads;
2542
2543 while (num_elements % kernel_threads) num_elements++;
2544
2545 cl_kernel kernel = NULL;
2546
2547 switch (kern_run)
2548 {
2549 case KERN_RUN_MP: kernel = device_param->kernel_mp; break;
2550 case KERN_RUN_MP_R: kernel = device_param->kernel_mp_r; break;
2551 case KERN_RUN_MP_L: kernel = device_param->kernel_mp_l; break;
2552 }
2553
2554 switch (kern_run)
2555 {
2556 case KERN_RUN_MP: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp[3]);
2557 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp[4]);
2558 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp[5]);
2559 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp[6]);
2560 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp[7]);
2561 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp[8]);
2562 break;
2563 case KERN_RUN_MP_R: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_r[3]);
2564 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_r[4]);
2565 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_r[5]);
2566 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_r[6]);
2567 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_r[7]);
2568 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_r[8]);
2569 break;
2570 case KERN_RUN_MP_L: hc_clSetKernelArg (data.ocl, kernel, 3, sizeof (cl_ulong), device_param->kernel_params_mp_l[3]);
2571 hc_clSetKernelArg (data.ocl, kernel, 4, sizeof (cl_uint), device_param->kernel_params_mp_l[4]);
2572 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_mp_l[5]);
2573 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_mp_l[6]);
2574 hc_clSetKernelArg (data.ocl, kernel, 7, sizeof (cl_uint), device_param->kernel_params_mp_l[7]);
2575 hc_clSetKernelArg (data.ocl, kernel, 8, sizeof (cl_uint), device_param->kernel_params_mp_l[8]);
2576 hc_clSetKernelArg (data.ocl, kernel, 9, sizeof (cl_uint), device_param->kernel_params_mp_l[9]);
2577 break;
2578 }
2579
2580 const size_t global_work_size[3] = { num_elements, 1, 1 };
2581 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2582
2583 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2584
2585 hc_clFlush (data.ocl, device_param->command_queue);
2586
2587 hc_clFinish (data.ocl, device_param->command_queue);
2588 }
2589
2590 static void run_kernel_tm (hc_device_param_t *device_param)
2591 {
2592 const uint num_elements = 1024; // fixed
2593
2594 uint kernel_threads = 32;
2595
2596 cl_kernel kernel = device_param->kernel_tm;
2597
2598 const size_t global_work_size[3] = { num_elements, 1, 1 };
2599 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2600
2601 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2602
2603 hc_clFlush (data.ocl, device_param->command_queue);
2604
2605 hc_clFinish (data.ocl, device_param->command_queue);
2606 }
2607
2608 static void run_kernel_amp (hc_device_param_t *device_param, const uint num)
2609 {
2610 uint num_elements = num;
2611
2612 device_param->kernel_params_amp_buf32[5] = data.combs_mode;
2613 device_param->kernel_params_amp_buf32[6] = num_elements;
2614
2615 // causes problems with special threads like in bcrypt
2616 // const uint kernel_threads = device_param->kernel_threads;
2617
2618 uint kernel_threads = device_param->kernel_threads;
2619
2620 while (num_elements % kernel_threads) num_elements++;
2621
2622 cl_kernel kernel = device_param->kernel_amp;
2623
2624 hc_clSetKernelArg (data.ocl, kernel, 5, sizeof (cl_uint), device_param->kernel_params_amp[5]);
2625 hc_clSetKernelArg (data.ocl, kernel, 6, sizeof (cl_uint), device_param->kernel_params_amp[6]);
2626
2627 const size_t global_work_size[3] = { num_elements, 1, 1 };
2628 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2629
2630 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2631
2632 hc_clFlush (data.ocl, device_param->command_queue);
2633
2634 hc_clFinish (data.ocl, device_param->command_queue);
2635 }
2636
2637 static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num)
2638 {
2639 const u32 num16d = num / 16;
2640 const u32 num16m = num % 16;
2641
2642 if (num16d)
2643 {
2644 device_param->kernel_params_memset_buf32[1] = value;
2645 device_param->kernel_params_memset_buf32[2] = num16d;
2646
2647 uint kernel_threads = device_param->kernel_threads;
2648
2649 uint num_elements = num16d;
2650
2651 while (num_elements % kernel_threads) num_elements++;
2652
2653 cl_kernel kernel = device_param->kernel_memset;
2654
2655 hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf);
2656 hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
2657 hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
2658
2659 const size_t global_work_size[3] = { num_elements, 1, 1 };
2660 const size_t local_work_size[3] = { kernel_threads, 1, 1 };
2661
2662 hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL);
2663
2664 hc_clFlush (data.ocl, device_param->command_queue);
2665
2666 hc_clFinish (data.ocl, device_param->command_queue);
2667 }
2668
2669 if (num16m)
2670 {
2671 u32 tmp[4];
2672
2673 tmp[0] = value;
2674 tmp[1] = value;
2675 tmp[2] = value;
2676 tmp[3] = value;
2677
2678 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL);
2679 }
2680 }
2681
2682 static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size)
2683 {
2684 run_kernel_memset (device_param, buf, 0, size);
2685
2686 /*
2687 int rc = -1;
2688
2689 if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD)
2690 {
2691 // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting
2692
2693 const cl_uchar zero = 0;
2694
2695 rc = hc_clEnqueueFillBuffer (data.ocl, device_param->command_queue, buf, &zero, sizeof (cl_uchar), 0, size, 0, NULL, NULL);
2696 }
2697
2698 if (rc != 0)
2699 {
2700 // NOTE: clEnqueueFillBuffer () always fails with -59
2701 // IOW, it's not supported by Nvidia drivers <= 352.21, also pocl segfaults, also on apple
2702 // How's that possible, OpenCL 1.2 support is advertised??
2703 // We need to workaround...
2704
2705 #define FILLSZ 0x100000
2706
2707 char *tmp = (char *) mymalloc (FILLSZ);
2708
2709 for (size_t i = 0; i < size; i += FILLSZ)
2710 {
2711 const size_t left = size - i;
2712
2713 const size_t fillsz = MIN (FILLSZ, left);
2714
2715 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, i, fillsz, tmp, 0, NULL, NULL);
2716 }
2717
2718 myfree (tmp);
2719 }
2720 */
2721 }
2722
2723 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)
2724 {
2725 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2726 {
2727 if (attack_mode == ATTACK_MODE_BF)
2728 {
2729 if (opts_type & OPTS_TYPE_PT_BITSLICE)
2730 {
2731 const uint size_tm = 32 * sizeof (bs_word_t);
2732
2733 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
2734
2735 run_kernel_tm (device_param);
2736
2737 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);
2738 }
2739 }
2740
2741 if (highest_pw_len < 16)
2742 {
2743 run_kernel (KERN_RUN_1, device_param, pws_cnt, true);
2744 }
2745 else if (highest_pw_len < 32)
2746 {
2747 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2748 }
2749 else
2750 {
2751 run_kernel (KERN_RUN_3, device_param, pws_cnt, true);
2752 }
2753 }
2754 else
2755 {
2756 run_kernel_amp (device_param, pws_cnt);
2757
2758 run_kernel (KERN_RUN_1, device_param, pws_cnt, false);
2759
2760 if (opts_type & OPTS_TYPE_HOOK12)
2761 {
2762 run_kernel (KERN_RUN_12, device_param, pws_cnt, false);
2763 }
2764
2765 uint iter = salt_buf->salt_iter;
2766
2767 uint loop_step = device_param->kernel_loops;
2768
2769 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
2770 {
2771 uint loop_left = iter - loop_pos;
2772
2773 loop_left = MIN (loop_left, loop_step);
2774
2775 device_param->kernel_params_buf32[25] = loop_pos;
2776 device_param->kernel_params_buf32[26] = loop_left;
2777
2778 run_kernel (KERN_RUN_2, device_param, pws_cnt, true);
2779
2780 if (data.devices_status == STATUS_CRACKED) break;
2781 if (data.devices_status == STATUS_ABORTED) break;
2782 if (data.devices_status == STATUS_QUIT) break;
2783
2784 /**
2785 * speed
2786 */
2787
2788 const float iter_part = (float) (loop_pos + loop_left) / iter;
2789
2790 const u64 perf_sum_all = pws_cnt * iter_part;
2791
2792 double speed_ms;
2793
2794 hc_timer_get (device_param->timer_speed, speed_ms);
2795
2796 const u32 speed_pos = device_param->speed_pos;
2797
2798 device_param->speed_cnt[speed_pos] = perf_sum_all;
2799
2800 device_param->speed_ms[speed_pos] = speed_ms;
2801
2802 if (data.benchmark == 1)
2803 {
2804 if (speed_ms > 4096) data.devices_status = STATUS_ABORTED;
2805 }
2806 }
2807
2808 if (opts_type & OPTS_TYPE_HOOK23)
2809 {
2810 run_kernel (KERN_RUN_23, device_param, pws_cnt, false);
2811
2812 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);
2813
2814 // do something with data
2815
2816 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);
2817 }
2818
2819 run_kernel (KERN_RUN_3, device_param, pws_cnt, false);
2820 }
2821 }
2822
2823 static int run_rule_engine (const int rule_len, const char *rule_buf)
2824 {
2825 if (rule_len == 0)
2826 {
2827 return 0;
2828 }
2829 else if (rule_len == 1)
2830 {
2831 if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0;
2832 }
2833
2834 return 1;
2835 }
2836
2837 static void run_copy (hc_device_param_t *device_param, const uint pws_cnt)
2838 {
2839 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
2840 {
2841 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);
2842 }
2843 else if (data.attack_kern == ATTACK_KERN_COMBI)
2844 {
2845 if (data.attack_mode == ATTACK_MODE_COMBI)
2846 {
2847 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
2848 {
2849 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2850 {
2851 for (u32 i = 0; i < pws_cnt; i++)
2852 {
2853 const u32 pw_len = device_param->pws_buf[i].pw_len;
2854
2855 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2856
2857 ptr[pw_len] = 0x01;
2858 }
2859 }
2860 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2861 {
2862 for (u32 i = 0; i < pws_cnt; i++)
2863 {
2864 const u32 pw_len = device_param->pws_buf[i].pw_len;
2865
2866 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2867
2868 ptr[pw_len] = 0x80;
2869 }
2870 }
2871 }
2872 }
2873 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
2874 {
2875 if (data.opts_type & OPTS_TYPE_PT_ADD01)
2876 {
2877 for (u32 i = 0; i < pws_cnt; i++)
2878 {
2879 const u32 pw_len = device_param->pws_buf[i].pw_len;
2880
2881 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2882
2883 ptr[pw_len] = 0x01;
2884 }
2885 }
2886 else if (data.opts_type & OPTS_TYPE_PT_ADD80)
2887 {
2888 for (u32 i = 0; i < pws_cnt; i++)
2889 {
2890 const u32 pw_len = device_param->pws_buf[i].pw_len;
2891
2892 u8 *ptr = (u8 *) device_param->pws_buf[i].i;
2893
2894 ptr[pw_len] = 0x80;
2895 }
2896 }
2897 }
2898
2899 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);
2900 }
2901 else if (data.attack_kern == ATTACK_KERN_BF)
2902 {
2903 const u64 off = device_param->words_off;
2904
2905 device_param->kernel_params_mp_l_buf64[3] = off;
2906
2907 run_kernel_mp (KERN_RUN_MP_L, device_param, pws_cnt);
2908 }
2909 }
2910
2911 static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops)
2912 {
2913 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel;
2914
2915 device_param->kernel_params_buf32[25] = 0;
2916 device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set
2917 device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes
2918
2919 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
2920 {
2921 run_kernel (KERN_RUN_1, device_param, kernel_power, true);
2922 }
2923 else
2924 {
2925 run_kernel (KERN_RUN_2, device_param, kernel_power, true);
2926 }
2927
2928 const double exec_ms_prev = get_avg_exec_time (device_param, 1);
2929
2930 return exec_ms_prev;
2931 }
2932
2933 static void autotune (hc_device_param_t *device_param)
2934 {
2935 const double target_ms = TARGET_MS_PROFILE[data.workload_profile - 1];
2936
2937 const u32 kernel_accel_min = device_param->kernel_accel_min;
2938 const u32 kernel_accel_max = device_param->kernel_accel_max;
2939
2940 const u32 kernel_loops_min = device_param->kernel_loops_min;
2941 const u32 kernel_loops_max = device_param->kernel_loops_max;
2942
2943 u32 kernel_accel = kernel_accel_min;
2944 u32 kernel_loops = kernel_loops_min;
2945
2946 // in this case the user specified a fixed -u and -n on the commandline
2947 // no way to tune anything
2948 // but we need to run a few caching rounds
2949
2950 if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max))
2951 {
2952 try_run (device_param, kernel_accel, kernel_loops);
2953 try_run (device_param, kernel_accel, kernel_loops);
2954 try_run (device_param, kernel_accel, kernel_loops);
2955 try_run (device_param, kernel_accel, kernel_loops);
2956
2957 device_param->kernel_accel = kernel_accel;
2958 device_param->kernel_loops = kernel_loops;
2959
2960 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
2961
2962 device_param->kernel_power = kernel_power;
2963
2964 return;
2965 }
2966
2967 // from here it's clear we are allowed to autotune
2968 // so let's init some fake words
2969
2970 const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max;
2971
2972 run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t));
2973
2974 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2975 {
2976 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 7, kernel_power_max * sizeof (pw_t));
2977 }
2978
2979 /*
2980 for (u32 i = 0; i < kernel_power_max; i++)
2981 {
2982 device_param->pws_buf[i].i[0] = i;
2983 device_param->pws_buf[i].i[1] = 0x01234567;
2984 device_param->pws_buf[i].pw_len = 7;
2985 }
2986
2987 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);
2988
2989 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
2990 {
2991 run_kernel_amp (device_param, kernel_power_max);
2992 }
2993 */
2994
2995 #define VERIFIER_CNT 1
2996
2997 // first find out highest kernel-loops that stays below target_ms
2998
2999 if (kernel_loops_min < kernel_loops_max)
3000 {
3001 for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1)
3002 {
3003 double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops);
3004
3005 for (int i = 0; i < VERIFIER_CNT; i++)
3006 {
3007 double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops);
3008
3009 exec_ms = MIN (exec_ms, exec_ms_v);
3010 }
3011
3012 if (exec_ms < target_ms) break;
3013 }
3014 }
3015
3016 // now the same for kernel-accel but with the new kernel-loops from previous loop set
3017
3018 #define STEPS_CNT 10
3019
3020 if (kernel_accel_min < kernel_accel_max)
3021 {
3022 for (int i = 0; i < STEPS_CNT; i++)
3023 {
3024 const u32 kernel_accel_try = 1 << i;
3025
3026 if (kernel_accel_try < kernel_accel_min) continue;
3027 if (kernel_accel_try > kernel_accel_max) break;
3028
3029 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops);
3030
3031 for (int i = 0; i < VERIFIER_CNT; i++)
3032 {
3033 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops);
3034
3035 exec_ms = MIN (exec_ms, exec_ms_v);
3036 }
3037
3038 if (exec_ms > target_ms) break;
3039
3040 kernel_accel = kernel_accel_try;
3041 }
3042 }
3043
3044 // at this point we want to know the actual runtime for the following reason:
3045 // we need a reference for the balancing loop following up, and this
3046 // the balancing loop can have an effect that the creates a new opportunity, for example:
3047 // if the target is 95 ms and the current runtime is 48ms the above loop
3048 // stopped the execution because the previous exec_ms was > 95ms
3049 // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms
3050 // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms
3051
3052 double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops);
3053
3054 for (int i = 0; i < VERIFIER_CNT; i++)
3055 {
3056 double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops);
3057
3058 exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v);
3059 }
3060
3061 u32 diff = kernel_loops - kernel_accel;
3062
3063 if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max))
3064 {
3065 u32 kernel_accel_orig = kernel_accel;
3066 u32 kernel_loops_orig = kernel_loops;
3067
3068 for (u32 f = 1; f < 1024; f++)
3069 {
3070 const u32 kernel_accel_try = (float) kernel_accel_orig * f;
3071 const u32 kernel_loops_try = (float) kernel_loops_orig / f;
3072
3073 if (kernel_accel_try > kernel_accel_max) break;
3074 if (kernel_loops_try < kernel_loops_min) break;
3075
3076 u32 diff_new = kernel_loops_try - kernel_accel_try;
3077
3078 if (diff_new > diff) break;
3079
3080 diff_new = diff;
3081
3082 double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try);
3083
3084 for (int i = 0; i < VERIFIER_CNT; i++)
3085 {
3086 double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try);
3087
3088 exec_ms = MIN (exec_ms, exec_ms_v);
3089 }
3090
3091 if (exec_ms < exec_ms_pre_final)
3092 {
3093 exec_ms_pre_final = exec_ms;
3094
3095 kernel_accel = kernel_accel_try;
3096 kernel_loops = kernel_loops_try;
3097 }
3098 }
3099 }
3100
3101 const double exec_left = target_ms / exec_ms_pre_final;
3102
3103 const double accel_left = kernel_accel_max / kernel_accel;
3104
3105 const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int
3106
3107 if (exec_accel_min >= 1.0)
3108 {
3109 // this is safe to not overflow kernel_accel_max because of accel_left
3110
3111 kernel_accel = (double) kernel_accel * exec_accel_min;
3112 }
3113
3114 // reset them fake words
3115
3116 /*
3117 memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t));
3118
3119 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);
3120 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);
3121 */
3122
3123 run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t));
3124
3125 if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL)
3126 {
3127 run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t));
3128 }
3129
3130 // reset timer
3131
3132 device_param->exec_pos = 0;
3133
3134 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
3135
3136 // store
3137
3138 device_param->kernel_accel = kernel_accel;
3139 device_param->kernel_loops = kernel_loops;
3140
3141 const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel;
3142
3143 device_param->kernel_power = kernel_power;
3144
3145 #ifdef DEBUG
3146
3147 if (data.quiet == 0)
3148 {
3149 clear_prompt ();
3150
3151 log_info ("Device #%u: autotuned kernel-accel to %u\n"
3152 "Device #%u: autotuned kernel-loops to %u\n",
3153 device_param->device_id + 1, kernel_accel,
3154 device_param->device_id + 1, kernel_loops);
3155
3156 fprintf (stdout, "%s", PROMPT);
3157
3158 fflush (stdout);
3159 }
3160
3161 #endif
3162 }
3163
3164 static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt)
3165 {
3166 char *line_buf = (char *) mymalloc (HCBUFSIZ);
3167
3168 // init speed timer
3169
3170 uint speed_pos = device_param->speed_pos;
3171
3172 #ifdef _POSIX
3173 if (device_param->timer_speed.tv_sec == 0)
3174 {
3175 hc_timer_set (&device_param->timer_speed);
3176 }
3177 #endif
3178
3179 #ifdef _WIN
3180 if (device_param->timer_speed.QuadPart == 0)
3181 {
3182 hc_timer_set (&device_param->timer_speed);
3183 }
3184 #endif
3185
3186 // find higest password length, this is for optimization stuff
3187
3188 uint highest_pw_len = 0;
3189
3190 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3191 {
3192 }
3193 else if (data.attack_kern == ATTACK_KERN_COMBI)
3194 {
3195 }
3196 else if (data.attack_kern == ATTACK_KERN_BF)
3197 {
3198 highest_pw_len = device_param->kernel_params_mp_l_buf32[4]
3199 + device_param->kernel_params_mp_l_buf32[5];
3200 }
3201
3202 // iteration type
3203
3204 uint innerloop_step = 0;
3205 uint innerloop_cnt = 0;
3206
3207 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
3208 else innerloop_step = 1;
3209
3210 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
3211 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
3212 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
3213
3214 // loop start: most outer loop = salt iteration, then innerloops (if multi)
3215
3216 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
3217 {
3218 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3219
3220 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3221
3222 if (data.devices_status == STATUS_CRACKED) break;
3223 if (data.devices_status == STATUS_ABORTED) break;
3224 if (data.devices_status == STATUS_QUIT) break;
3225 if (data.devices_status == STATUS_BYPASS) break;
3226
3227 salt_t *salt_buf = &data.salts_buf[salt_pos];
3228
3229 device_param->kernel_params_buf32[24] = salt_pos;
3230 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
3231 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
3232
3233 FILE *combs_fp = device_param->combs_fp;
3234
3235 if (data.attack_mode == ATTACK_MODE_COMBI)
3236 {
3237 rewind (combs_fp);
3238 }
3239
3240 // innerloops
3241
3242 for (uint innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
3243 {
3244 while (data.devices_status == STATUS_PAUSED) hc_sleep (1);
3245
3246 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3247
3248 if (data.devices_status == STATUS_CRACKED) break;
3249 if (data.devices_status == STATUS_ABORTED) break;
3250 if (data.devices_status == STATUS_QUIT) break;
3251 if (data.devices_status == STATUS_BYPASS) break;
3252
3253 uint innerloop_left = innerloop_cnt - innerloop_pos;
3254
3255 if (innerloop_left > innerloop_step) innerloop_left = innerloop_step;
3256
3257 device_param->innerloop_pos = innerloop_pos;
3258 device_param->innerloop_left = innerloop_left;
3259
3260 device_param->kernel_params_buf32[27] = innerloop_left;
3261
3262 // i think we can get rid of this
3263 if (innerloop_left == 0)
3264 {
3265 puts ("bug, how should this happen????\n");
3266
3267 continue;
3268 }
3269
3270 if (data.salts_shown[salt_pos] == 1)
3271 {
3272 data.words_progress_done[salt_pos] += (u64) pws_cnt * (u64) innerloop_left;
3273
3274 continue;
3275 }
3276
3277 // initialize amplifiers
3278
3279 if (data.attack_mode == ATTACK_MODE_COMBI)
3280 {
3281 uint i = 0;
3282
3283 while (i < innerloop_left)
3284 {
3285 if (feof (combs_fp)) break;
3286
3287 int line_len = fgetl (combs_fp, line_buf);
3288
3289 if (line_len >= PW_MAX1) continue;
3290
3291 line_len = convert_from_hex (line_buf, line_len);
3292
3293 char *line_buf_new = line_buf;
3294
3295 if (run_rule_engine (data.rule_len_r, data.rule_buf_r))
3296 {
3297 char rule_buf_out[BLOCK_SIZE] = { 0 };
3298
3299 int rule_len_out = _old_apply_rule (data.rule_buf_r, data.rule_len_r, line_buf, line_len, rule_buf_out);
3300
3301 if (rule_len_out < 0)
3302 {
3303 data.words_progress_rejected[salt_pos] += pws_cnt;
3304
3305 continue;
3306 }
3307
3308 line_len = rule_len_out;
3309
3310 line_buf_new = rule_buf_out;
3311 }
3312
3313 line_len = MIN (line_len, PW_DICTMAX);
3314
3315 u8 *ptr = (u8 *) device_param->combs_buf[i].i;
3316
3317 memcpy (ptr, line_buf_new, line_len);
3318
3319 memset (ptr + line_len, 0, PW_DICTMAX1 - line_len);
3320
3321 if (data.opts_type & OPTS_TYPE_PT_UPPER)
3322 {
3323 uppercase (ptr, line_len);
3324 }
3325
3326 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
3327 {
3328 if (data.opts_type & OPTS_TYPE_PT_ADD80)
3329 {
3330 ptr[line_len] = 0x80;
3331 }
3332
3333 if (data.opts_type & OPTS_TYPE_PT_ADD01)
3334 {
3335 ptr[line_len] = 0x01;
3336 }
3337 }
3338
3339 device_param->combs_buf[i].pw_len = line_len;
3340
3341 i++;
3342 }
3343
3344 for (uint j = i; j < innerloop_left; j++)
3345 {
3346 device_param->combs_buf[j].i[0] = 0;
3347 device_param->combs_buf[j].i[1] = 0;
3348 device_param->combs_buf[j].i[2] = 0;
3349 device_param->combs_buf[j].i[3] = 0;
3350 device_param->combs_buf[j].i[4] = 0;
3351 device_param->combs_buf[j].i[5] = 0;
3352 device_param->combs_buf[j].i[6] = 0;
3353 device_param->combs_buf[j].i[7] = 0;
3354
3355 device_param->combs_buf[j].pw_len = 0;
3356 }
3357
3358 innerloop_left = i;
3359 }
3360 else if (data.attack_mode == ATTACK_MODE_BF)
3361 {
3362 u64 off = innerloop_pos;
3363
3364 device_param->kernel_params_mp_r_buf64[3] = off;
3365
3366 run_kernel_mp (KERN_RUN_MP_R, device_param, innerloop_left);
3367 }
3368 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3369 {
3370 u64 off = innerloop_pos;
3371
3372 device_param->kernel_params_mp_buf64[3] = off;
3373
3374 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3375 }
3376 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3377 {
3378 u64 off = innerloop_pos;
3379
3380 device_param->kernel_params_mp_buf64[3] = off;
3381
3382 run_kernel_mp (KERN_RUN_MP, device_param, innerloop_left);
3383 }
3384
3385 // copy amplifiers
3386
3387 if (data.attack_mode == ATTACK_MODE_STRAIGHT)
3388 {
3389 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);
3390 }
3391 else if (data.attack_mode == ATTACK_MODE_COMBI)
3392 {
3393 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);
3394 }
3395 else if (data.attack_mode == ATTACK_MODE_BF)
3396 {
3397 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);
3398 }
3399 else if (data.attack_mode == ATTACK_MODE_HYBRID1)
3400 {
3401 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);
3402 }
3403 else if (data.attack_mode == ATTACK_MODE_HYBRID2)
3404 {
3405 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);
3406 }
3407
3408 if (data.benchmark == 1)
3409 {
3410 hc_timer_set (&device_param->timer_speed);
3411 }
3412
3413 choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt);
3414
3415 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
3416
3417 if (data.devices_status == STATUS_CRACKED) break;
3418 if (data.devices_status == STATUS_ABORTED) break;
3419 if (data.devices_status == STATUS_QUIT) break;
3420
3421 /**
3422 * result
3423 */
3424
3425 check_cracked (device_param, salt_pos);
3426
3427 /**
3428 * progress
3429 */
3430
3431 u64 perf_sum_all = (u64) pws_cnt * (u64) innerloop_left;
3432
3433 hc_thread_mutex_lock (mux_counter);
3434
3435 data.words_progress_done[salt_pos] += perf_sum_all;
3436
3437 hc_thread_mutex_unlock (mux_counter);
3438
3439 /**
3440 * speed
3441 */
3442
3443 double speed_ms;
3444
3445 hc_timer_get (device_param->timer_speed, speed_ms);
3446
3447 hc_timer_set (&device_param->timer_speed);
3448
3449 // current speed
3450
3451 //hc_thread_mutex_lock (mux_display);
3452
3453 device_param->speed_cnt[speed_pos] = perf_sum_all;
3454
3455 device_param->speed_ms[speed_pos] = speed_ms;
3456
3457 //hc_thread_mutex_unlock (mux_display);
3458
3459 speed_pos++;
3460
3461 if (speed_pos == SPEED_CACHE)
3462 {
3463 speed_pos = 0;
3464 }
3465
3466 /**
3467 * benchmark
3468 */
3469
3470 if (data.benchmark == 1) break;
3471 }
3472 }
3473
3474 device_param->speed_pos = speed_pos;
3475
3476 myfree (line_buf);
3477 }
3478
3479 static void load_segment (wl_data_t *wl_data, FILE *fd)
3480 {
3481 // NOTE: use (never changing) ->incr here instead of ->avail otherwise the buffer gets bigger and bigger
3482
3483 wl_data->pos = 0;
3484
3485 wl_data->cnt = fread (wl_data->buf, 1, wl_data->incr - 1000, fd);
3486
3487 wl_data->buf[wl_data->cnt] = 0;
3488
3489 if (wl_data->cnt == 0) return;
3490
3491 if (wl_data->buf[wl_data->cnt - 1] == '\n') return;
3492
3493 while (!feof (fd))
3494 {
3495 if (wl_data->cnt == wl_data->avail)
3496 {
3497 wl_data->buf = (char *) myrealloc (wl_data->buf, wl_data->avail, wl_data->incr);
3498
3499 wl_data->avail += wl_data->incr;
3500 }
3501
3502 const int c = fgetc (fd);
3503
3504 if (c == EOF) break;
3505
3506 wl_data->buf[wl_data->cnt] = (char) c;
3507
3508 wl_data->cnt++;
3509
3510 if (c == '\n') break;
3511 }
3512
3513 // ensure stream ends with a newline
3514
3515 if (wl_data->buf[wl_data->cnt - 1] != '\n')
3516 {
3517 wl_data->cnt++;
3518
3519 wl_data->buf[wl_data->cnt - 1] = '\n';
3520 }
3521
3522 return;
3523 }
3524
3525 static void get_next_word_lm (char *buf, u32 sz, u32 *len, u32 *off)
3526 {
3527 char *ptr = buf;
3528
3529 for (u32 i = 0; i < sz; i++, ptr++)
3530 {
3531 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3532
3533 if (i == 7)
3534 {
3535 *off = i;
3536 *len = i;
3537
3538 return;
3539 }
3540
3541 if (*ptr != '\n') continue;
3542
3543 *off = i + 1;
3544
3545 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3546
3547 *len = i;
3548
3549 return;
3550 }
3551
3552 *off = sz;
3553 *len = sz;
3554 }
3555
3556 static void get_next_word_uc (char *buf, u32 sz, u32 *len, u32 *off)
3557 {
3558 char *ptr = buf;
3559
3560 for (u32 i = 0; i < sz; i++, ptr++)
3561 {
3562 if (*ptr >= 'a' && *ptr <= 'z') *ptr -= 0x20;
3563
3564 if (*ptr != '\n') continue;
3565
3566 *off = i + 1;
3567
3568 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3569
3570 *len = i;
3571
3572 return;
3573 }
3574
3575 *off = sz;
3576 *len = sz;
3577 }
3578
3579 static void get_next_word_std (char *buf, u32 sz, u32 *len, u32 *off)
3580 {
3581 char *ptr = buf;
3582
3583 for (u32 i = 0; i < sz; i++, ptr++)
3584 {
3585 if (*ptr != '\n') continue;
3586
3587 *off = i + 1;
3588
3589 if ((i > 0) && (buf[i - 1] == '\r')) i--;
3590
3591 *len = i;
3592
3593 return;
3594 }
3595
3596 *off = sz;
3597 *len = sz;
3598 }
3599
3600 static void get_next_word (wl_data_t *wl_data, FILE *fd, char **out_buf, uint *out_len)
3601 {
3602 while (wl_data->pos < wl_data->cnt)
3603 {
3604 uint off;
3605 uint len;
3606
3607 char *ptr = wl_data->buf + wl_data->pos;
3608
3609 get_next_word_func (ptr, wl_data->cnt - wl_data->pos, &len, &off);
3610
3611 wl_data->pos += off;
3612
3613 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3614 {
3615 char rule_buf_out[BLOCK_SIZE] = { 0 };
3616
3617 int rule_len_out = -1;
3618
3619 if (len < BLOCK_SIZE)
3620 {
3621 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, ptr, len, rule_buf_out);
3622 }
3623
3624 if (rule_len_out < 0)
3625 {
3626 continue;
3627 }
3628
3629 if (rule_len_out > PW_MAX)
3630 {
3631 continue;
3632 }
3633 }
3634 else
3635 {
3636 if (len > PW_MAX)
3637 {
3638 continue;
3639 }
3640 }
3641
3642 *out_buf = ptr;
3643 *out_len = len;
3644
3645 return;
3646 }
3647
3648 if (feof (fd))
3649 {
3650 fprintf (stderr, "BUG feof()!!\n");
3651
3652 return;
3653 }
3654
3655 load_segment (wl_data, fd);
3656
3657 get_next_word (wl_data, fd, out_buf, out_len);
3658 }
3659
3660 #ifdef _POSIX
3661 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, size_t *dictstat_nmemb)
3662 #endif
3663
3664 #ifdef _WIN
3665 static u64 count_words (wl_data_t *wl_data, FILE *fd, char *dictfile, dictstat_t *dictstat_base, uint *dictstat_nmemb)
3666 #endif
3667 {
3668 hc_signal (NULL);
3669
3670 dictstat_t d;
3671
3672 d.cnt = 0;
3673
3674 #ifdef _POSIX
3675 fstat (fileno (fd), &d.stat);
3676 #endif
3677
3678 #ifdef _WIN
3679 _fstat64 (fileno (fd), &d.stat);
3680 #endif
3681
3682 d.stat.st_mode = 0;
3683 d.stat.st_nlink = 0;
3684 d.stat.st_uid = 0;
3685 d.stat.st_gid = 0;
3686 d.stat.st_rdev = 0;
3687 d.stat.st_atime = 0;
3688
3689 #ifdef _POSIX
3690 d.stat.st_blksize = 0;
3691 d.stat.st_blocks = 0;
3692 #endif
3693
3694 if (d.stat.st_size == 0) return 0;
3695
3696 dictstat_t *d_cache = (dictstat_t *) lfind (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3697
3698 if (run_rule_engine (data.rule_len_l, data.rule_buf_l) == 0)
3699 {
3700 if (d_cache)
3701 {
3702 u64 cnt = d_cache->cnt;
3703
3704 u64 keyspace = cnt;
3705
3706 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3707 {
3708 keyspace *= data.kernel_rules_cnt;
3709 }
3710 else if (data.attack_kern == ATTACK_KERN_COMBI)
3711 {
3712 keyspace *= data.combs_cnt;
3713 }
3714
3715 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);
3716 if (data.quiet == 0) log_info ("");
3717
3718 hc_signal (sigHandler_default);
3719
3720 return (keyspace);
3721 }
3722 }
3723
3724 time_t now = 0;
3725 time_t prev = 0;
3726
3727 u64 comp = 0;
3728 u64 cnt = 0;
3729 u64 cnt2 = 0;
3730
3731 while (!feof (fd))
3732 {
3733 load_segment (wl_data, fd);
3734
3735 comp += wl_data->cnt;
3736
3737 u32 i = 0;
3738
3739 while (i < wl_data->cnt)
3740 {
3741 u32 len;
3742 u32 off;
3743
3744 get_next_word_func (wl_data->buf + i, wl_data->cnt - i, &len, &off);
3745
3746 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
3747 {
3748 char rule_buf_out[BLOCK_SIZE] = { 0 };
3749
3750 int rule_len_out = -1;
3751
3752 if (len < BLOCK_SIZE)
3753 {
3754 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, wl_data->buf + i, len, rule_buf_out);
3755 }
3756
3757 if (rule_len_out < 0)
3758 {
3759 len = PW_MAX1;
3760 }
3761 else
3762 {
3763 len = rule_len_out;
3764 }
3765 }
3766
3767 if (len < PW_MAX1)
3768 {
3769 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
3770 {
3771 cnt += data.kernel_rules_cnt;
3772 }
3773 else if (data.attack_kern == ATTACK_KERN_COMBI)
3774 {
3775 cnt += data.combs_cnt;
3776 }
3777
3778 d.cnt++;
3779 }
3780
3781 i += off;
3782
3783 cnt2++;
3784 }
3785
3786 time (&now);
3787
3788 if ((now - prev) == 0) continue;
3789
3790 float percent = (float) comp / (float) d.stat.st_size;
3791
3792 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);
3793
3794 time (&prev);
3795 }
3796
3797 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);
3798 if (data.quiet == 0) log_info ("");
3799
3800 lsearch (&d, dictstat_base, dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
3801
3802 hc_signal (sigHandler_default);
3803
3804 return (cnt);
3805 }
3806
3807 static void *thread_monitor (void *p)
3808 {
3809 uint runtime_check = 0;
3810 uint remove_check = 0;
3811 uint status_check = 0;
3812 uint restore_check = 0;
3813
3814 uint restore_left = data.restore_timer;
3815 uint remove_left = data.remove_timer;
3816 uint status_left = data.status_timer;
3817
3818 #ifdef HAVE_HWMON
3819 uint hwmon_check = 0;
3820
3821 int slowdown_warnings = 0;
3822
3823 // these variables are mainly used for fan control (AMD only)
3824
3825 int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int));
3826
3827 // temperature controller "loopback" values
3828
3829 int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int));
3830 int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int));
3831
3832 #ifdef HAVE_ADL
3833 int temp_threshold = 1; // degrees celcius
3834
3835 int fan_speed_min = 15; // in percentage
3836 int fan_speed_max = 100;
3837 #endif // HAVE_ADL
3838
3839 time_t last_temp_check_time;
3840 #endif // HAVE_HWMON
3841
3842 uint sleep_time = 1;
3843
3844 if (data.runtime)
3845 {
3846 runtime_check = 1;
3847 }
3848
3849 if (data.restore_timer)
3850 {
3851 restore_check = 1;
3852 }
3853
3854 if ((data.remove == 1) && (data.hashlist_mode == HL_MODE_FILE))
3855 {
3856 remove_check = 1;
3857 }
3858
3859 if (data.status == 1)
3860 {
3861 status_check = 1;
3862 }
3863
3864 #ifdef HAVE_HWMON
3865 if (data.gpu_temp_disable == 0)
3866 {
3867 time (&last_temp_check_time);
3868
3869 hwmon_check = 1;
3870 }
3871 #endif
3872
3873 if ((runtime_check == 0) && (remove_check == 0) && (status_check == 0) && (restore_check == 0))
3874 {
3875 #ifdef HAVE_HWMON
3876 if (hwmon_check == 0)
3877 #endif
3878 return (p);
3879 }
3880
3881 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
3882 {
3883 hc_sleep (sleep_time);
3884
3885 if (data.devices_status != STATUS_RUNNING) continue;
3886
3887 #ifdef HAVE_HWMON
3888
3889 if (1)
3890 {
3891 hc_thread_mutex_lock (mux_adl);
3892
3893 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3894 {
3895 hc_device_param_t *device_param = &data.devices_param[device_id];
3896
3897 if (device_param->skipped) continue;
3898
3899 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3900
3901 const int temperature = hm_get_temperature_with_device_id (device_id);
3902
3903 const int threshold = data.hm_device[device_id].gpu_temp_threshold_slowdown;
3904
3905 if (temperature >= threshold)
3906 {
3907 if (slowdown_warnings < 3)
3908 {
3909 if (data.quiet == 0) clear_prompt ();
3910
3911 log_info ("WARNING: Drivers temperature threshold (%dc) hit on GPU #%d, expect performance to drop...", threshold, device_id + 1);
3912
3913 if (slowdown_warnings == 2)
3914 {
3915 log_info ("");
3916 }
3917
3918 if (data.quiet == 0) fprintf (stdout, "%s", PROMPT);
3919 if (data.quiet == 0) fflush (stdout);
3920
3921 slowdown_warnings++;
3922 }
3923 }
3924 else
3925 {
3926 slowdown_warnings = 0;
3927 }
3928 }
3929
3930 hc_thread_mutex_unlock (mux_adl);
3931 }
3932
3933 if (hwmon_check == 1)
3934 {
3935 hc_thread_mutex_lock (mux_adl);
3936
3937 time_t temp_check_time;
3938
3939 time (&temp_check_time);
3940
3941 uint Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
3942
3943 if (Ta == 0) Ta = 1;
3944
3945 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
3946 {
3947 hc_device_param_t *device_param = &data.devices_param[device_id];
3948
3949 if (device_param->skipped) continue;
3950
3951 if ((data.devices_param[device_id].device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
3952
3953 const int temperature = hm_get_temperature_with_device_id (device_id);
3954
3955 if (temperature > (int) data.gpu_temp_abort)
3956 {
3957 log_error ("ERROR: Temperature limit on GPU %d reached, aborting...", device_id + 1);
3958
3959 if (data.devices_status != STATUS_QUIT) myabort ();
3960
3961 break;
3962 }
3963
3964 #ifdef HAVE_ADL
3965 const int gpu_temp_retain = data.gpu_temp_retain;
3966
3967 if (gpu_temp_retain) // VENDOR_ID_AMD implied
3968 {
3969 if (data.hm_device[device_id].fan_supported == 1)
3970 {
3971 int temp_cur = temperature;
3972
3973 int temp_diff_new = gpu_temp_retain - temp_cur;
3974
3975 temp_diff_sum[device_id] = temp_diff_sum[device_id] + temp_diff_new;
3976
3977 // calculate Ta value (time difference in seconds between the last check and this check)
3978
3979 last_temp_check_time = temp_check_time;
3980
3981 float Kp = 1.8;
3982 float Ki = 0.005;
3983 float Kd = 6;
3984
3985 // PID controller (3-term controller: proportional - Kp, integral - Ki, derivative - Kd)
3986
3987 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);
3988
3989 if (abs (fan_diff_required) >= temp_threshold)
3990 {
3991 const int fan_speed_cur = hm_get_fanspeed_with_device_id (device_id);
3992
3993 int fan_speed_level = fan_speed_cur;
3994
3995 if (fan_speed_chgd[device_id] == 0) fan_speed_level = temp_cur;
3996
3997 int fan_speed_new = fan_speed_level - fan_diff_required;
3998
3999 if (fan_speed_new > fan_speed_max) fan_speed_new = fan_speed_max;
4000 if (fan_speed_new < fan_speed_min) fan_speed_new = fan_speed_min;
4001
4002 if (fan_speed_new != fan_speed_cur)
4003 {
4004 int freely_change_fan_speed = (fan_speed_chgd[device_id] == 1);
4005 int fan_speed_must_change = (fan_speed_new > fan_speed_cur);
4006
4007 if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1))
4008 {
4009 hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new);
4010
4011 fan_speed_chgd[device_id] = 1;
4012 }
4013
4014 temp_diff_old[device_id] = temp_diff_new;
4015 }
4016 }
4017 }
4018 }
4019 #endif // HAVE_ADL
4020 }
4021
4022 hc_thread_mutex_unlock (mux_adl);
4023 }
4024 #endif // HAVE_HWMON
4025
4026 if (restore_check == 1)
4027 {
4028 restore_left--;
4029
4030 if (restore_left == 0)
4031 {
4032 if (data.restore_disable == 0) cycle_restore ();
4033
4034 restore_left = data.restore_timer;
4035 }
4036 }
4037
4038 if ((runtime_check == 1) && (data.runtime_start > 0))
4039 {
4040 time_t runtime_cur;
4041
4042 time (&runtime_cur);
4043
4044 int runtime_left = data.runtime_start + data.runtime - runtime_cur;
4045
4046 if (runtime_left <= 0)
4047 {
4048 if (data.benchmark == 0)
4049 {
4050 if (data.quiet == 0) log_info ("\nNOTE: Runtime limit reached, aborting...\n");
4051 }
4052
4053 if (data.devices_status != STATUS_QUIT) myabort ();
4054 }
4055 }
4056
4057 if (remove_check == 1)
4058 {
4059 remove_left--;
4060
4061 if (remove_left == 0)
4062 {
4063 if (data.digests_saved != data.digests_done)
4064 {
4065 data.digests_saved = data.digests_done;
4066
4067 save_hash ();
4068 }
4069
4070 remove_left = data.remove_timer;
4071 }
4072 }
4073
4074 if (status_check == 1)
4075 {
4076 status_left--;
4077
4078 if (status_left == 0)
4079 {
4080 //hc_thread_mutex_lock (mux_display);
4081
4082 if (data.quiet == 0) clear_prompt ();
4083
4084 if (data.quiet == 0) log_info ("");
4085
4086 status_display ();
4087
4088 if (data.quiet == 0) log_info ("");
4089
4090 //hc_thread_mutex_unlock (mux_display);
4091
4092 status_left = data.status_timer;
4093 }
4094 }
4095 }
4096
4097 #ifdef HAVE_HWMON
4098 myfree (fan_speed_chgd);
4099
4100 myfree (temp_diff_old);
4101 myfree (temp_diff_sum);
4102 #endif
4103
4104 p = NULL;
4105
4106 return (p);
4107 }
4108
4109 static void *thread_outfile_remove (void *p)
4110 {
4111 // some hash-dependent constants
4112 char *outfile_dir = data.outfile_check_directory;
4113 uint dgst_size = data.dgst_size;
4114 uint isSalted = data.isSalted;
4115 uint esalt_size = data.esalt_size;
4116 uint hash_mode = data.hash_mode;
4117
4118 uint outfile_check_timer = data.outfile_check_timer;
4119
4120 char separator = data.separator;
4121
4122 // some hash-dependent functions
4123 int (*sort_by_digest) (const void *, const void *) = data.sort_by_digest;
4124 int (*parse_func) (char *, uint, hash_t *) = data.parse_func;
4125
4126 // buffers
4127 hash_t hash_buf = { 0, 0, 0, 0, 0 };
4128
4129 hash_buf.digest = mymalloc (dgst_size);
4130
4131 if (isSalted) hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
4132
4133 if (esalt_size) hash_buf.esalt = (void *) mymalloc (esalt_size);
4134
4135 uint digest_buf[64] = { 0 };
4136
4137 outfile_data_t *out_info = NULL;
4138
4139 char **out_files = NULL;
4140
4141 time_t folder_mtime = 0;
4142
4143 int out_cnt = 0;
4144
4145 uint check_left = outfile_check_timer; // or 1 if we want to check it at startup
4146
4147 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4148 {
4149 hc_sleep (1);
4150
4151 if (data.devices_status != STATUS_RUNNING) continue;
4152
4153 check_left--;
4154
4155 if (check_left == 0)
4156 {
4157 struct stat outfile_check_stat;
4158
4159 if (stat (outfile_dir, &outfile_check_stat) == 0)
4160 {
4161 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
4162
4163 if (is_dir == 1)
4164 {
4165 if (outfile_check_stat.st_mtime > folder_mtime)
4166 {
4167 char **out_files_new = scan_directory (outfile_dir);
4168
4169 int out_cnt_new = count_dictionaries (out_files_new);
4170
4171 outfile_data_t *out_info_new = NULL;
4172
4173 if (out_cnt_new > 0)
4174 {
4175 out_info_new = (outfile_data_t *) mycalloc (out_cnt_new, sizeof (outfile_data_t));
4176
4177 for (int i = 0; i < out_cnt_new; i++)
4178 {
4179 out_info_new[i].file_name = out_files_new[i];
4180
4181 // check if there are files that we have seen/checked before (and not changed)
4182
4183 for (int j = 0; j < out_cnt; j++)
4184 {
4185 if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
4186 {
4187 struct stat outfile_stat;
4188
4189 if (stat (out_info_new[i].file_name, &outfile_stat) == 0)
4190 {
4191 if (outfile_stat.st_ctime == out_info[j].ctime)
4192 {
4193 out_info_new[i].ctime = out_info[j].ctime;
4194 out_info_new[i].seek = out_info[j].seek;
4195 }
4196 }
4197 }
4198 }
4199 }
4200 }
4201
4202 local_free (out_info);
4203 local_free (out_files);
4204
4205 out_files = out_files_new;
4206 out_cnt = out_cnt_new;
4207 out_info = out_info_new;
4208
4209 folder_mtime = outfile_check_stat.st_mtime;
4210 }
4211
4212 for (int j = 0; j < out_cnt; j++)
4213 {
4214 FILE *fp = fopen (out_info[j].file_name, "rb");
4215
4216 if (fp != NULL)
4217 {
4218 //hc_thread_mutex_lock (mux_display);
4219
4220 #ifdef _POSIX
4221 struct stat outfile_stat;
4222
4223 fstat (fileno (fp), &outfile_stat);
4224 #endif
4225
4226 #ifdef _WIN
4227 struct stat64 outfile_stat;
4228
4229 _fstat64 (fileno (fp), &outfile_stat);
4230 #endif
4231
4232 if (outfile_stat.st_ctime > out_info[j].ctime)
4233 {
4234 out_info[j].ctime = outfile_stat.st_ctime;
4235 out_info[j].seek = 0;
4236 }
4237
4238 fseek (fp, out_info[j].seek, SEEK_SET);
4239
4240 char *line_buf = (char *) mymalloc (HCBUFSIZ);
4241
4242 while (!feof (fp))
4243 {
4244 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
4245
4246 if (ptr == NULL) break;
4247
4248 int line_len = strlen (line_buf);
4249
4250 if (line_len <= 0) continue;
4251
4252 int iter = MAX_CUT_TRIES;
4253
4254 for (uint i = line_len - 1; i && iter; i--, line_len--)
4255 {
4256 if (line_buf[i] != separator) continue;
4257
4258 int parser_status = PARSER_OK;
4259
4260 if ((hash_mode != 2500) && (hash_mode != 6800))
4261 {
4262 parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
4263 }
4264
4265 uint found = 0;
4266
4267 if (parser_status == PARSER_OK)
4268 {
4269 for (uint salt_pos = 0; (found == 0) && (salt_pos < data.salts_cnt); salt_pos++)
4270 {
4271 if (data.salts_shown[salt_pos] == 1) continue;
4272
4273 salt_t *salt_buf = &data.salts_buf[salt_pos];
4274
4275 for (uint digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
4276 {
4277 uint idx = salt_buf->digests_offset + digest_pos;
4278
4279 if (data.digests_shown[idx] == 1) continue;
4280
4281 uint cracked = 0;
4282
4283 if (hash_mode == 6800)
4284 {
4285 if (i == salt_buf->salt_len)
4286 {
4287 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4288 }
4289 }
4290 else if (hash_mode == 2500)
4291 {
4292 // BSSID : MAC1 : MAC2 (:plain)
4293 if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
4294 {
4295 cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
4296
4297 if (!cracked) continue;
4298
4299 // now compare MAC1 and MAC2 too, since we have this additional info
4300 char *mac1_pos = line_buf + salt_buf->salt_len + 1;
4301 char *mac2_pos = mac1_pos + 12 + 1;
4302
4303 wpa_t *wpas = (wpa_t *) data.esalts_buf;
4304 wpa_t *wpa = &wpas[salt_pos];
4305
4306 // compare hex string(s) vs binary MAC address(es)
4307
4308 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4309 {
4310 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
4311 {
4312 cracked = 0;
4313
4314 break;
4315 }
4316 }
4317
4318 // early skip ;)
4319 if (!cracked) continue;
4320
4321 for (uint i = 0, j = 0; i < 6; i++, j += 2)
4322 {
4323 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
4324 {
4325 cracked = 0;
4326
4327 break;
4328 }
4329 }
4330 }
4331 }
4332 else
4333 {
4334 char *digests_buf_ptr = (char *) data.digests_buf;
4335
4336 memcpy (digest_buf, digests_buf_ptr + (data.salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
4337
4338 cracked = (sort_by_digest (digest_buf, hash_buf.digest) == 0);
4339 }
4340
4341 if (cracked == 1)
4342 {
4343 found = 1;
4344
4345 data.digests_shown[idx] = 1;
4346
4347 data.digests_done++;
4348
4349 salt_buf->digests_done++;
4350
4351 if (salt_buf->digests_done == salt_buf->digests_cnt)
4352 {
4353 data.salts_shown[salt_pos] = 1;
4354
4355 data.salts_done++;
4356
4357 if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED;
4358 }
4359 }
4360 }
4361
4362 if (data.devices_status == STATUS_CRACKED) break;
4363 }
4364 }
4365
4366 if (found) break;
4367
4368 if (data.devices_status == STATUS_CRACKED) break;
4369
4370 iter--;
4371 }
4372
4373 if (data.devices_status == STATUS_CRACKED) break;
4374 }
4375
4376 myfree (line_buf);
4377
4378 out_info[j].seek = ftell (fp);
4379
4380 //hc_thread_mutex_unlock (mux_display);
4381
4382 fclose (fp);
4383 }
4384 }
4385 }
4386 }
4387
4388 check_left = outfile_check_timer;
4389 }
4390 }
4391
4392 if (esalt_size) local_free (hash_buf.esalt);
4393
4394 if (isSalted) local_free (hash_buf.salt);
4395
4396 local_free (hash_buf.digest);
4397
4398 local_free (out_info);
4399
4400 local_free (out_files);
4401
4402 p = NULL;
4403
4404 return (p);
4405 }
4406
4407 static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len)
4408 {
4409 if (device_param->pws_cnt < device_param->kernel_power)
4410 {
4411 pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt;
4412
4413 u8 *ptr = (u8 *) pw->i;
4414
4415 memcpy (ptr, pw_buf, pw_len);
4416
4417 memset (ptr + pw_len, 0, sizeof (pw->i) - pw_len);
4418
4419 pw->pw_len = pw_len;
4420
4421 device_param->pws_cnt++;
4422 }
4423 else
4424 {
4425 fprintf (stderr, "BUG pw_add()!!\n");
4426
4427 return;
4428 }
4429 }
4430
4431 static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div)
4432 {
4433 hc_thread_mutex_lock (mux_dispatcher);
4434
4435 const u64 words_cur = data.words_cur;
4436 const u64 words_base = (data.limit == 0) ? data.words_base : data.limit;
4437
4438 device_param->words_off = words_cur;
4439
4440 const u64 words_left = words_base - words_cur;
4441
4442 if (allow_div)
4443 {
4444 if (data.kernel_power_all > words_left)
4445 {
4446 if (data.kernel_power_div == 0)
4447 {
4448 data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all);
4449 }
4450 }
4451
4452 if (data.kernel_power_div)
4453 {
4454 if (device_param->kernel_power == device_param->kernel_power_user)
4455 {
4456 const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div;
4457
4458 if (kernel_power_new < device_param->kernel_power)
4459 {
4460 device_param->kernel_power = kernel_power_new;
4461 }
4462 }
4463 }
4464 }
4465
4466 const uint kernel_power = device_param->kernel_power;
4467
4468 uint work = MIN (words_left, kernel_power);
4469
4470 work = MIN (work, max);
4471
4472 data.words_cur += work;
4473
4474 hc_thread_mutex_unlock (mux_dispatcher);
4475
4476 return work;
4477 }
4478
4479 static void *thread_calc_stdin (void *p)
4480 {
4481 hc_device_param_t *device_param = (hc_device_param_t *) p;
4482
4483 if (device_param->skipped) return NULL;
4484
4485 autotune (device_param);
4486
4487 char *buf = (char *) mymalloc (HCBUFSIZ);
4488
4489 const uint attack_kern = data.attack_kern;
4490
4491 const uint kernel_power = device_param->kernel_power;
4492
4493 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4494 {
4495 hc_thread_mutex_lock (mux_dispatcher);
4496
4497 if (feof (stdin) != 0)
4498 {
4499 hc_thread_mutex_unlock (mux_dispatcher);
4500
4501 break;
4502 }
4503
4504 uint words_cur = 0;
4505
4506 while (words_cur < kernel_power)
4507 {
4508 char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin);
4509
4510 if (line_buf == NULL) break;
4511
4512 uint line_len = in_superchop (line_buf);
4513
4514 line_len = convert_from_hex (line_buf, line_len);
4515
4516 // post-process rule engine
4517
4518 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4519 {
4520 char rule_buf_out[BLOCK_SIZE] = { 0 };
4521
4522 int rule_len_out = -1;
4523
4524 if (line_len < BLOCK_SIZE)
4525 {
4526 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4527 }
4528
4529 if (rule_len_out < 0) continue;
4530
4531 line_buf = rule_buf_out;
4532 line_len = rule_len_out;
4533 }
4534
4535 if (line_len > PW_MAX)
4536 {
4537 continue;
4538 }
4539
4540 if (attack_kern == ATTACK_KERN_STRAIGHT)
4541 {
4542 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4543 {
4544 hc_thread_mutex_lock (mux_counter);
4545
4546 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4547 {
4548 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4549 }
4550
4551 hc_thread_mutex_unlock (mux_counter);
4552
4553 continue;
4554 }
4555 }
4556 else if (attack_kern == ATTACK_KERN_COMBI)
4557 {
4558 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4559 // since we still need to combine the plains
4560
4561 if (line_len > data.pw_max)
4562 {
4563 hc_thread_mutex_lock (mux_counter);
4564
4565 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4566 {
4567 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4568 }
4569
4570 hc_thread_mutex_unlock (mux_counter);
4571
4572 continue;
4573 }
4574 }
4575
4576 pw_add (device_param, (u8 *) line_buf, line_len);
4577
4578 words_cur++;
4579
4580 if (data.devices_status == STATUS_CRACKED) break;
4581 if (data.devices_status == STATUS_ABORTED) break;
4582 if (data.devices_status == STATUS_QUIT) break;
4583 if (data.devices_status == STATUS_BYPASS) break;
4584 }
4585
4586 hc_thread_mutex_unlock (mux_dispatcher);
4587
4588 if (data.devices_status == STATUS_CRACKED) break;
4589 if (data.devices_status == STATUS_ABORTED) break;
4590 if (data.devices_status == STATUS_QUIT) break;
4591 if (data.devices_status == STATUS_BYPASS) break;
4592
4593 // flush
4594
4595 const uint pws_cnt = device_param->pws_cnt;
4596
4597 if (pws_cnt)
4598 {
4599 run_copy (device_param, pws_cnt);
4600
4601 run_cracker (device_param, pws_cnt);
4602
4603 device_param->pws_cnt = 0;
4604
4605 /*
4606 still required?
4607 if (attack_kern == ATTACK_KERN_STRAIGHT)
4608 {
4609 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4610 }
4611 else if (attack_kern == ATTACK_KERN_COMBI)
4612 {
4613 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4614 }
4615 */
4616 }
4617 }
4618
4619 device_param->kernel_accel = 0;
4620 device_param->kernel_loops = 0;
4621
4622 myfree (buf);
4623
4624 return NULL;
4625 }
4626
4627 static void *thread_calc (void *p)
4628 {
4629 hc_device_param_t *device_param = (hc_device_param_t *) p;
4630
4631 if (device_param->skipped) return NULL;
4632
4633 autotune (device_param);
4634
4635 const uint attack_mode = data.attack_mode;
4636 const uint attack_kern = data.attack_kern;
4637
4638 if (attack_mode == ATTACK_MODE_BF)
4639 {
4640 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4641 {
4642 const uint work = get_work (device_param, -1, true);
4643
4644 if (work == 0) break;
4645
4646 const u64 words_off = device_param->words_off;
4647 const u64 words_fin = words_off + work;
4648
4649 const uint pws_cnt = work;
4650
4651 device_param->pws_cnt = pws_cnt;
4652
4653 if (pws_cnt)
4654 {
4655 run_copy (device_param, pws_cnt);
4656
4657 run_cracker (device_param, pws_cnt);
4658
4659 device_param->pws_cnt = 0;
4660
4661 /*
4662 still required?
4663 run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs);
4664 */
4665 }
4666
4667 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4668
4669 if (data.devices_status == STATUS_CRACKED) break;
4670 if (data.devices_status == STATUS_ABORTED) break;
4671 if (data.devices_status == STATUS_QUIT) break;
4672 if (data.devices_status == STATUS_BYPASS) break;
4673
4674 if (data.benchmark == 1) break;
4675
4676 device_param->words_done = words_fin;
4677 }
4678 }
4679 else
4680 {
4681 const uint segment_size = data.segment_size;
4682
4683 char *dictfile = data.dictfile;
4684
4685 if (attack_mode == ATTACK_MODE_COMBI)
4686 {
4687 if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4688 {
4689 dictfile = data.dictfile2;
4690 }
4691 }
4692
4693 FILE *fd = fopen (dictfile, "rb");
4694
4695 if (fd == NULL)
4696 {
4697 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
4698
4699 return NULL;
4700 }
4701
4702 if (attack_mode == ATTACK_MODE_COMBI)
4703 {
4704 const uint combs_mode = data.combs_mode;
4705
4706 if (combs_mode == COMBINATOR_MODE_BASE_LEFT)
4707 {
4708 const char *dictfilec = data.dictfile2;
4709
4710 FILE *combs_fp = fopen (dictfilec, "rb");
4711
4712 if (combs_fp == NULL)
4713 {
4714 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4715
4716 fclose (fd);
4717
4718 return NULL;
4719 }
4720
4721 device_param->combs_fp = combs_fp;
4722 }
4723 else if (combs_mode == COMBINATOR_MODE_BASE_RIGHT)
4724 {
4725 const char *dictfilec = data.dictfile;
4726
4727 FILE *combs_fp = fopen (dictfilec, "rb");
4728
4729 if (combs_fp == NULL)
4730 {
4731 log_error ("ERROR: %s: %s", dictfilec, strerror (errno));
4732
4733 fclose (fd);
4734
4735 return NULL;
4736 }
4737
4738 device_param->combs_fp = combs_fp;
4739 }
4740 }
4741
4742 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
4743
4744 wl_data->buf = (char *) mymalloc (segment_size);
4745 wl_data->avail = segment_size;
4746 wl_data->incr = segment_size;
4747 wl_data->cnt = 0;
4748 wl_data->pos = 0;
4749
4750 u64 words_cur = 0;
4751
4752 while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
4753 {
4754 u64 words_off = 0;
4755 u64 words_fin = 0;
4756
4757 bool allow_div = true;
4758
4759 u64 max = -1;
4760
4761 while (max)
4762 {
4763 const uint work = get_work (device_param, max, allow_div);
4764
4765 allow_div = false;
4766
4767 if (work == 0) break;
4768
4769 words_off = device_param->words_off;
4770 words_fin = words_off + work;
4771
4772 char *line_buf;
4773 uint line_len;
4774
4775 for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len);
4776
4777 max = 0;
4778
4779 for ( ; words_cur < words_fin; words_cur++)
4780 {
4781 get_next_word (wl_data, fd, &line_buf, &line_len);
4782
4783 line_len = convert_from_hex (line_buf, line_len);
4784
4785 // post-process rule engine
4786
4787 if (run_rule_engine (data.rule_len_l, data.rule_buf_l))
4788 {
4789 char rule_buf_out[BLOCK_SIZE] = { 0 };
4790
4791 int rule_len_out = -1;
4792
4793 if (line_len < BLOCK_SIZE)
4794 {
4795 rule_len_out = _old_apply_rule (data.rule_buf_l, data.rule_len_l, line_buf, line_len, rule_buf_out);
4796 }
4797
4798 if (rule_len_out < 0) continue;
4799
4800 line_buf = rule_buf_out;
4801 line_len = rule_len_out;
4802 }
4803
4804 if (attack_kern == ATTACK_KERN_STRAIGHT)
4805 {
4806 if ((line_len < data.pw_min) || (line_len > data.pw_max))
4807 {
4808 max++;
4809
4810 hc_thread_mutex_lock (mux_counter);
4811
4812 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4813 {
4814 data.words_progress_rejected[salt_pos] += data.kernel_rules_cnt;
4815 }
4816
4817 hc_thread_mutex_unlock (mux_counter);
4818
4819 continue;
4820 }
4821 }
4822 else if (attack_kern == ATTACK_KERN_COMBI)
4823 {
4824 // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here
4825 // since we still need to combine the plains
4826
4827 if (line_len > data.pw_max)
4828 {
4829 max++;
4830
4831 hc_thread_mutex_lock (mux_counter);
4832
4833 for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++)
4834 {
4835 data.words_progress_rejected[salt_pos] += data.combs_cnt;
4836 }
4837
4838 hc_thread_mutex_unlock (mux_counter);
4839
4840 continue;
4841 }
4842 }
4843
4844 pw_add (device_param, (u8 *) line_buf, line_len);
4845
4846 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4847
4848 if (data.devices_status == STATUS_CRACKED) break;
4849 if (data.devices_status == STATUS_ABORTED) break;
4850 if (data.devices_status == STATUS_QUIT) break;
4851 if (data.devices_status == STATUS_BYPASS) break;
4852 }
4853
4854 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4855
4856 if (data.devices_status == STATUS_CRACKED) break;
4857 if (data.devices_status == STATUS_ABORTED) break;
4858 if (data.devices_status == STATUS_QUIT) break;
4859 if (data.devices_status == STATUS_BYPASS) break;
4860 }
4861
4862 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4863
4864 if (data.devices_status == STATUS_CRACKED) break;
4865 if (data.devices_status == STATUS_ABORTED) break;
4866 if (data.devices_status == STATUS_QUIT) break;
4867 if (data.devices_status == STATUS_BYPASS) break;
4868
4869 //
4870 // flush
4871 //
4872
4873 const uint pws_cnt = device_param->pws_cnt;
4874
4875 if (pws_cnt)
4876 {
4877 run_copy (device_param, pws_cnt);
4878
4879 run_cracker (device_param, pws_cnt);
4880
4881 device_param->pws_cnt = 0;
4882
4883 /*
4884 still required?
4885 if (attack_kern == ATTACK_KERN_STRAIGHT)
4886 {
4887 run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c);
4888 }
4889 else if (attack_kern == ATTACK_KERN_COMBI)
4890 {
4891 run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs);
4892 }
4893 */
4894 }
4895
4896 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
4897
4898 if (data.devices_status == STATUS_CRACKED) break;
4899 if (data.devices_status == STATUS_ABORTED) break;
4900 if (data.devices_status == STATUS_QUIT) break;
4901 if (data.devices_status == STATUS_BYPASS) break;
4902
4903 if (words_fin == 0) break;
4904
4905 device_param->words_done = words_fin;
4906 }
4907
4908 if (attack_mode == ATTACK_MODE_COMBI)
4909 {
4910 fclose (device_param->combs_fp);
4911 }
4912
4913 free (wl_data->buf);
4914 free (wl_data);
4915
4916 fclose (fd);
4917 }
4918
4919 device_param->kernel_accel = 0;
4920 device_param->kernel_loops = 0;
4921
4922 return NULL;
4923 }
4924
4925 static void weak_hash_check (hc_device_param_t *device_param, const uint salt_pos)
4926 {
4927 if (!device_param)
4928 {
4929 log_error ("ERROR: %s : Invalid argument", __func__);
4930
4931 exit (-1);
4932 }
4933
4934 salt_t *salt_buf = &data.salts_buf[salt_pos];
4935
4936 device_param->kernel_params_buf32[24] = salt_pos;
4937 device_param->kernel_params_buf32[27] = 1;
4938 device_param->kernel_params_buf32[28] = salt_buf->digests_cnt;
4939 device_param->kernel_params_buf32[29] = salt_buf->digests_offset;
4940 device_param->kernel_params_buf32[30] = 0;
4941 device_param->kernel_params_buf32[31] = 1;
4942
4943 char *dictfile_old = data.dictfile;
4944
4945 const char *weak_hash_check = "weak-hash-check";
4946
4947 data.dictfile = (char *) weak_hash_check;
4948
4949 uint cmd0_rule_old = data.kernel_rules_buf[0].cmds[0];
4950
4951 data.kernel_rules_buf[0].cmds[0] = 0;
4952
4953 /**
4954 * run the kernel
4955 */
4956
4957 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
4958 {
4959 run_kernel (KERN_RUN_1, device_param, 1, false);
4960 }
4961 else
4962 {
4963 run_kernel (KERN_RUN_1, device_param, 1, false);
4964
4965 uint loop_step = 16;
4966
4967 const uint iter = salt_buf->salt_iter;
4968
4969 for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step)
4970 {
4971 uint loop_left = iter - loop_pos;
4972
4973 loop_left = MIN (loop_left, loop_step);
4974
4975 device_param->kernel_params_buf32[25] = loop_pos;
4976 device_param->kernel_params_buf32[26] = loop_left;
4977
4978 run_kernel (KERN_RUN_2, device_param, 1, false);
4979 }
4980
4981 run_kernel (KERN_RUN_3, device_param, 1, false);
4982 }
4983
4984 /**
4985 * result
4986 */
4987
4988 check_cracked (device_param, salt_pos);
4989
4990 /**
4991 * cleanup
4992 */
4993
4994 device_param->kernel_params_buf32[24] = 0;
4995 device_param->kernel_params_buf32[25] = 0;
4996 device_param->kernel_params_buf32[26] = 0;
4997 device_param->kernel_params_buf32[27] = 0;
4998 device_param->kernel_params_buf32[28] = 0;
4999 device_param->kernel_params_buf32[29] = 0;
5000 device_param->kernel_params_buf32[30] = 0;
5001 device_param->kernel_params_buf32[31] = 0;
5002
5003 data.dictfile = dictfile_old;
5004
5005 data.kernel_rules_buf[0].cmds[0] = cmd0_rule_old;
5006 }
5007
5008 // hlfmt hashcat
5009
5010 static void hlfmt_hash_hashcat (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5011 {
5012 if (data.username == 0)
5013 {
5014 *hashbuf_pos = line_buf;
5015 *hashbuf_len = line_len;
5016 }
5017 else
5018 {
5019 char *pos = line_buf;
5020 int len = line_len;
5021
5022 for (int i = 0; i < line_len; i++, pos++, len--)
5023 {
5024 if (line_buf[i] == data.separator)
5025 {
5026 pos++;
5027
5028 len--;
5029
5030 break;
5031 }
5032 }
5033
5034 *hashbuf_pos = pos;
5035 *hashbuf_len = len;
5036 }
5037 }
5038
5039 static void hlfmt_user_hashcat (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5040 {
5041 char *pos = NULL;
5042 int len = 0;
5043
5044 int sep_cnt = 0;
5045
5046 for (int i = 0; i < line_len; i++)
5047 {
5048 if (line_buf[i] == data.separator)
5049 {
5050 sep_cnt++;
5051
5052 continue;
5053 }
5054
5055 if (sep_cnt == 0)
5056 {
5057 if (pos == NULL) pos = line_buf + i;
5058
5059 len++;
5060 }
5061 }
5062
5063 *userbuf_pos = pos;
5064 *userbuf_len = len;
5065 }
5066
5067 // hlfmt pwdump
5068
5069 static int hlfmt_detect_pwdump (char *line_buf, int line_len)
5070 {
5071 int sep_cnt = 0;
5072
5073 int sep2_len = 0;
5074 int sep3_len = 0;
5075
5076 for (int i = 0; i < line_len; i++)
5077 {
5078 if (line_buf[i] == ':')
5079 {
5080 sep_cnt++;
5081
5082 continue;
5083 }
5084
5085 if (sep_cnt == 2) sep2_len++;
5086 if (sep_cnt == 3) sep3_len++;
5087 }
5088
5089 if ((sep_cnt == 6) && ((sep2_len == 32) || (sep3_len == 32))) return 1;
5090
5091 return 0;
5092 }
5093
5094 static void hlfmt_hash_pwdump (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5095 {
5096 char *pos = NULL;
5097 int len = 0;
5098
5099 int sep_cnt = 0;
5100
5101 for (int i = 0; i < line_len; i++)
5102 {
5103 if (line_buf[i] == ':')
5104 {
5105 sep_cnt++;
5106
5107 continue;
5108 }
5109
5110 if (data.hash_mode == 1000)
5111 {
5112 if (sep_cnt == 3)
5113 {
5114 if (pos == NULL) pos = line_buf + i;
5115
5116 len++;
5117 }
5118 }
5119 else if (data.hash_mode == 3000)
5120 {
5121 if (sep_cnt == 2)
5122 {
5123 if (pos == NULL) pos = line_buf + i;
5124
5125 len++;
5126 }
5127 }
5128 }
5129
5130 *hashbuf_pos = pos;
5131 *hashbuf_len = len;
5132 }
5133
5134 static void hlfmt_user_pwdump (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5135 {
5136 char *pos = NULL;
5137 int len = 0;
5138
5139 int sep_cnt = 0;
5140
5141 for (int i = 0; i < line_len; i++)
5142 {
5143 if (line_buf[i] == ':')
5144 {
5145 sep_cnt++;
5146
5147 continue;
5148 }
5149
5150 if (sep_cnt == 0)
5151 {
5152 if (pos == NULL) pos = line_buf + i;
5153
5154 len++;
5155 }
5156 }
5157
5158 *userbuf_pos = pos;
5159 *userbuf_len = len;
5160 }
5161
5162 // hlfmt passwd
5163
5164 static int hlfmt_detect_passwd (char *line_buf, int line_len)
5165 {
5166 int sep_cnt = 0;
5167
5168 char sep5_first = 0;
5169 char sep6_first = 0;
5170
5171 for (int i = 0; i < line_len; i++)
5172 {
5173 if (line_buf[i] == ':')
5174 {
5175 sep_cnt++;
5176
5177 continue;
5178 }
5179
5180 if (sep_cnt == 5) if (sep5_first == 0) sep5_first = line_buf[i];
5181 if (sep_cnt == 6) if (sep6_first == 0) sep6_first = line_buf[i];
5182 }
5183
5184 if ((sep_cnt == 6) && ((sep5_first == '/') || (sep6_first == '/'))) return 1;
5185
5186 return 0;
5187 }
5188
5189 static void hlfmt_hash_passwd (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5190 {
5191 char *pos = NULL;
5192 int len = 0;
5193
5194 int sep_cnt = 0;
5195
5196 for (int i = 0; i < line_len; i++)
5197 {
5198 if (line_buf[i] == ':')
5199 {
5200 sep_cnt++;
5201
5202 continue;
5203 }
5204
5205 if (sep_cnt == 1)
5206 {
5207 if (pos == NULL) pos = line_buf + i;
5208
5209 len++;
5210 }
5211 }
5212
5213 *hashbuf_pos = pos;
5214 *hashbuf_len = len;
5215 }
5216
5217 static void hlfmt_user_passwd (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5218 {
5219 char *pos = NULL;
5220 int len = 0;
5221
5222 int sep_cnt = 0;
5223
5224 for (int i = 0; i < line_len; i++)
5225 {
5226 if (line_buf[i] == ':')
5227 {
5228 sep_cnt++;
5229
5230 continue;
5231 }
5232
5233 if (sep_cnt == 0)
5234 {
5235 if (pos == NULL) pos = line_buf + i;
5236
5237 len++;
5238 }
5239 }
5240
5241 *userbuf_pos = pos;
5242 *userbuf_len = len;
5243 }
5244
5245 // hlfmt shadow
5246
5247 static int hlfmt_detect_shadow (char *line_buf, int line_len)
5248 {
5249 int sep_cnt = 0;
5250
5251 for (int i = 0; i < line_len; i++)
5252 {
5253 if (line_buf[i] == ':') sep_cnt++;
5254 }
5255
5256 if (sep_cnt == 8) return 1;
5257
5258 return 0;
5259 }
5260
5261 static void hlfmt_hash_shadow (char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5262 {
5263 hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len);
5264 }
5265
5266 static void hlfmt_user_shadow (char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5267 {
5268 hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len);
5269 }
5270
5271 // hlfmt main
5272
5273 static void hlfmt_hash (uint hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len)
5274 {
5275 switch (hashfile_format)
5276 {
5277 case HLFMT_HASHCAT: hlfmt_hash_hashcat (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5278 case HLFMT_PWDUMP: hlfmt_hash_pwdump (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5279 case HLFMT_PASSWD: hlfmt_hash_passwd (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5280 case HLFMT_SHADOW: hlfmt_hash_shadow (line_buf, line_len, hashbuf_pos, hashbuf_len); break;
5281 }
5282 }
5283
5284 static void hlfmt_user (uint hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len)
5285 {
5286 switch (hashfile_format)
5287 {
5288 case HLFMT_HASHCAT: hlfmt_user_hashcat (line_buf, line_len, userbuf_pos, userbuf_len); break;
5289 case HLFMT_PWDUMP: hlfmt_user_pwdump (line_buf, line_len, userbuf_pos, userbuf_len); break;
5290 case HLFMT_PASSWD: hlfmt_user_passwd (line_buf, line_len, userbuf_pos, userbuf_len); break;
5291 case HLFMT_SHADOW: hlfmt_user_shadow (line_buf, line_len, userbuf_pos, userbuf_len); break;
5292 }
5293 }
5294
5295 char *strhlfmt (const uint hashfile_format)
5296 {
5297 switch (hashfile_format)
5298 {
5299 case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); break;
5300 case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); break;
5301 case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); break;
5302 case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); break;
5303 case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); break;
5304 case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); break;
5305 case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); break;
5306 case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); break;
5307 case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); break;
5308 case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); break;
5309 }
5310
5311 return ((char *) "Unknown");
5312 }
5313
5314 static uint hlfmt_detect (FILE *fp, uint max_check)
5315 {
5316 // Exception: those formats are wrongly detected as HLFMT_SHADOW, prevent it
5317
5318 if (data.hash_mode == 5300) return HLFMT_HASHCAT;
5319 if (data.hash_mode == 5400) return HLFMT_HASHCAT;
5320
5321 uint *formats_cnt = (uint *) mycalloc (HLFMTS_CNT, sizeof (uint));
5322
5323 uint num_check = 0;
5324
5325 char *line_buf = (char *) mymalloc (HCBUFSIZ);
5326
5327 while (!feof (fp))
5328 {
5329 int line_len = fgetl (fp, line_buf);
5330
5331 if (line_len == 0) continue;
5332
5333 if (hlfmt_detect_pwdump (line_buf, line_len)) formats_cnt[HLFMT_PWDUMP]++;
5334 if (hlfmt_detect_passwd (line_buf, line_len)) formats_cnt[HLFMT_PASSWD]++;
5335 if (hlfmt_detect_shadow (line_buf, line_len)) formats_cnt[HLFMT_SHADOW]++;
5336
5337 if (num_check == max_check) break;
5338
5339 num_check++;
5340 }
5341
5342 myfree (line_buf);
5343
5344 uint hashlist_format = HLFMT_HASHCAT;
5345
5346 for (int i = 1; i < HLFMTS_CNT; i++)
5347 {
5348 if (formats_cnt[i - 1] >= formats_cnt[i]) continue;
5349
5350 hashlist_format = i;
5351 }
5352
5353 free (formats_cnt);
5354
5355 return hashlist_format;
5356 }
5357
5358 /**
5359 * some further helper function
5360 */
5361
5362 // wrapper around mymalloc for ADL
5363
5364 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5365 void *__stdcall ADL_Main_Memory_Alloc (const int iSize)
5366 {
5367 return mymalloc (iSize);
5368 }
5369 #endif
5370
5371 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)
5372 {
5373 u64 collisions = 0;
5374
5375 const uint dgst_pos0 = data.dgst_pos0;
5376 const uint dgst_pos1 = data.dgst_pos1;
5377 const uint dgst_pos2 = data.dgst_pos2;
5378 const uint dgst_pos3 = data.dgst_pos3;
5379
5380 memset (bitmap_a, 0, bitmap_size);
5381 memset (bitmap_b, 0, bitmap_size);
5382 memset (bitmap_c, 0, bitmap_size);
5383 memset (bitmap_d, 0, bitmap_size);
5384
5385 for (uint i = 0; i < digests_cnt; i++)
5386 {
5387 if (data.digests_shown[i] == 1) continue; // can happen with potfile
5388
5389 uint *digest_ptr = (uint *) digests_buf_ptr;
5390
5391 digests_buf_ptr += dgst_size;
5392
5393 const uint val0 = 1u << (digest_ptr[dgst_pos0] & 0x1f);
5394 const uint val1 = 1u << (digest_ptr[dgst_pos1] & 0x1f);
5395 const uint val2 = 1u << (digest_ptr[dgst_pos2] & 0x1f);
5396 const uint val3 = 1u << (digest_ptr[dgst_pos3] & 0x1f);
5397
5398 const uint idx0 = (digest_ptr[dgst_pos0] >> dgst_shifts) & bitmap_mask;
5399 const uint idx1 = (digest_ptr[dgst_pos1] >> dgst_shifts) & bitmap_mask;
5400 const uint idx2 = (digest_ptr[dgst_pos2] >> dgst_shifts) & bitmap_mask;
5401 const uint idx3 = (digest_ptr[dgst_pos3] >> dgst_shifts) & bitmap_mask;
5402
5403 if (bitmap_a[idx0] & val0) collisions++;
5404 if (bitmap_b[idx1] & val1) collisions++;
5405 if (bitmap_c[idx2] & val2) collisions++;
5406 if (bitmap_d[idx3] & val3) collisions++;
5407
5408 bitmap_a[idx0] |= val0;
5409 bitmap_b[idx1] |= val1;
5410 bitmap_c[idx2] |= val2;
5411 bitmap_d[idx3] |= val3;
5412
5413 if (collisions >= collisions_max) return 0x7fffffff;
5414 }
5415
5416 return collisions;
5417 }
5418
5419 /**
5420 * main
5421 */
5422
5423 #ifdef _WIN
5424 void SetConsoleWindowSize (const int x)
5425 {
5426 HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE);
5427
5428 if (h == INVALID_HANDLE_VALUE) return;
5429
5430 CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
5431
5432 if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return;
5433
5434 SMALL_RECT *sr = &bufferInfo.srWindow;
5435
5436 sr->Right = MAX (sr->Right, x - 1);
5437
5438 COORD co;
5439
5440 co.X = sr->Right + 1;
5441 co.Y = sr->Bottom + 1;
5442
5443 if (!SetConsoleScreenBufferSize (h, co)) return;
5444
5445 if (!SetConsoleWindowInfo (h, TRUE, sr)) return;
5446 }
5447 #endif
5448
5449 int main (int argc, char **argv)
5450 {
5451 #ifdef _WIN
5452 SetConsoleWindowSize (132);
5453 #endif
5454
5455 /**
5456 * To help users a bit
5457 */
5458
5459 char *compute = getenv ("COMPUTE");
5460
5461 if (compute)
5462 {
5463 static char display[100];
5464
5465 snprintf (display, sizeof (display) - 1, "DISPLAY=%s", compute);
5466
5467 putenv (display);
5468 }
5469 else
5470 {
5471 if (getenv ("DISPLAY") == NULL)
5472 putenv ((char *) "DISPLAY=:0");
5473 }
5474
5475 if (getenv ("GPU_MAX_ALLOC_PERCENT") == NULL)
5476 putenv ((char *) "GPU_MAX_ALLOC_PERCENT=100");
5477
5478 if (getenv ("CPU_MAX_ALLOC_PERCENT") == NULL)
5479 putenv ((char *) "CPU_MAX_ALLOC_PERCENT=100");
5480
5481 if (getenv ("GPU_USE_SYNC_OBJECTS") == NULL)
5482 putenv ((char *) "GPU_USE_SYNC_OBJECTS=1");
5483
5484 if (getenv ("CUDA_CACHE_DISABLE") == NULL)
5485 putenv ((char *) "CUDA_CACHE_DISABLE=1");
5486
5487 if (getenv ("POCL_KERNEL_CACHE") == NULL)
5488 putenv ((char *) "POCL_KERNEL_CACHE=0");
5489
5490 umask (077);
5491
5492 /**
5493 * Real init
5494 */
5495
5496 memset (&data, 0, sizeof (hc_global_data_t));
5497
5498 time_t proc_start;
5499
5500 time (&proc_start);
5501
5502 data.proc_start = proc_start;
5503
5504 int myargc = argc;
5505 char **myargv = argv;
5506
5507 hc_thread_mutex_init (mux_dispatcher);
5508 hc_thread_mutex_init (mux_counter);
5509 hc_thread_mutex_init (mux_display);
5510 hc_thread_mutex_init (mux_adl);
5511
5512 /**
5513 * commandline parameters
5514 */
5515
5516 uint usage = USAGE;
5517 uint version = VERSION;
5518 uint quiet = QUIET;
5519 uint benchmark = BENCHMARK;
5520 uint show = SHOW;
5521 uint left = LEFT;
5522 uint username = USERNAME;
5523 uint remove = REMOVE;
5524 uint remove_timer = REMOVE_TIMER;
5525 u64 skip = SKIP;
5526 u64 limit = LIMIT;
5527 uint keyspace = KEYSPACE;
5528 uint potfile_disable = POTFILE_DISABLE;
5529 char *potfile_path = NULL;
5530 uint debug_mode = DEBUG_MODE;
5531 char *debug_file = NULL;
5532 char *induction_dir = NULL;
5533 char *outfile_check_dir = NULL;
5534 uint force = FORCE;
5535 uint runtime = RUNTIME;
5536 uint hash_mode = HASH_MODE;
5537 uint attack_mode = ATTACK_MODE;
5538 uint markov_disable = MARKOV_DISABLE;
5539 uint markov_classic = MARKOV_CLASSIC;
5540 uint markov_threshold = MARKOV_THRESHOLD;
5541 char *markov_hcstat = NULL;
5542 char *outfile = NULL;
5543 uint outfile_format = OUTFILE_FORMAT;
5544 uint outfile_autohex = OUTFILE_AUTOHEX;
5545 uint outfile_check_timer = OUTFILE_CHECK_TIMER;
5546 uint restore = RESTORE;
5547 uint restore_timer = RESTORE_TIMER;
5548 uint restore_disable = RESTORE_DISABLE;
5549 uint status = STATUS;
5550 uint status_timer = STATUS_TIMER;
5551 uint machine_readable = MACHINE_READABLE;
5552 uint loopback = LOOPBACK;
5553 uint weak_hash_threshold = WEAK_HASH_THRESHOLD;
5554 char *session = NULL;
5555 uint hex_charset = HEX_CHARSET;
5556 uint hex_salt = HEX_SALT;
5557 uint hex_wordlist = HEX_WORDLIST;
5558 uint rp_gen = RP_GEN;
5559 uint rp_gen_func_min = RP_GEN_FUNC_MIN;
5560 uint rp_gen_func_max = RP_GEN_FUNC_MAX;
5561 uint rp_gen_seed = RP_GEN_SEED;
5562 char *rule_buf_l = (char *) RULE_BUF_L;
5563 char *rule_buf_r = (char *) RULE_BUF_R;
5564 uint increment = INCREMENT;
5565 uint increment_min = INCREMENT_MIN;
5566 uint increment_max = INCREMENT_MAX;
5567 char *cpu_affinity = NULL;
5568 OCL_PTR *ocl = NULL;
5569 char *opencl_devices = NULL;
5570 char *opencl_platforms = NULL;
5571 char *opencl_device_types = NULL;
5572 uint opencl_vector_width = OPENCL_VECTOR_WIDTH;
5573 char *truecrypt_keyfiles = NULL;
5574 char *veracrypt_keyfiles = NULL;
5575 uint veracrypt_pim = 0;
5576 uint workload_profile = WORKLOAD_PROFILE;
5577 uint kernel_accel = KERNEL_ACCEL;
5578 uint kernel_loops = KERNEL_LOOPS;
5579 uint gpu_temp_disable = GPU_TEMP_DISABLE;
5580 #ifdef HAVE_HWMON
5581 uint gpu_temp_abort = GPU_TEMP_ABORT;
5582 uint gpu_temp_retain = GPU_TEMP_RETAIN;
5583 #ifdef HAVE_ADL
5584 uint powertune_enable = POWERTUNE_ENABLE;
5585 #endif
5586 #endif
5587 uint logfile_disable = LOGFILE_DISABLE;
5588 uint segment_size = SEGMENT_SIZE;
5589 uint scrypt_tmto = SCRYPT_TMTO;
5590 char separator = SEPARATOR;
5591 uint bitmap_min = BITMAP_MIN;
5592 uint bitmap_max = BITMAP_MAX;
5593 char *custom_charset_1 = NULL;
5594 char *custom_charset_2 = NULL;
5595 char *custom_charset_3 = NULL;
5596 char *custom_charset_4 = NULL;
5597
5598 #define IDX_HELP 'h'
5599 #define IDX_VERSION 'V'
5600 #define IDX_VERSION_LOWER 'v'
5601 #define IDX_QUIET 0xff02
5602 #define IDX_SHOW 0xff03
5603 #define IDX_LEFT 0xff04
5604 #define IDX_REMOVE 0xff05
5605 #define IDX_REMOVE_TIMER 0xff37
5606 #define IDX_SKIP 's'
5607 #define IDX_LIMIT 'l'
5608 #define IDX_KEYSPACE 0xff35
5609 #define IDX_POTFILE_DISABLE 0xff06
5610 #define IDX_POTFILE_PATH 0xffe0
5611 #define IDX_DEBUG_MODE 0xff43
5612 #define IDX_DEBUG_FILE 0xff44
5613 #define IDX_INDUCTION_DIR 0xff46
5614 #define IDX_OUTFILE_CHECK_DIR 0xff47
5615 #define IDX_USERNAME 0xff07
5616 #define IDX_FORCE 0xff08
5617 #define IDX_RUNTIME 0xff09
5618 #define IDX_BENCHMARK 'b'
5619 #define IDX_HASH_MODE 'm'
5620 #define IDX_ATTACK_MODE 'a'
5621 #define IDX_RP_FILE 'r'
5622 #define IDX_RP_GEN 'g'
5623 #define IDX_RP_GEN_FUNC_MIN 0xff10
5624 #define IDX_RP_GEN_FUNC_MAX 0xff11
5625 #define IDX_RP_GEN_SEED 0xff34
5626 #define IDX_RULE_BUF_L 'j'
5627 #define IDX_RULE_BUF_R 'k'
5628 #define IDX_INCREMENT 'i'
5629 #define IDX_INCREMENT_MIN 0xff12
5630 #define IDX_INCREMENT_MAX 0xff13
5631 #define IDX_OUTFILE 'o'
5632 #define IDX_OUTFILE_FORMAT 0xff14
5633 #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39
5634 #define IDX_OUTFILE_CHECK_TIMER 0xff45
5635 #define IDX_RESTORE 0xff15
5636 #define IDX_RESTORE_DISABLE 0xff27
5637 #define IDX_STATUS 0xff17
5638 #define IDX_STATUS_TIMER 0xff18
5639 #define IDX_MACHINE_READABLE 0xff50
5640 #define IDX_LOOPBACK 0xff38
5641 #define IDX_WEAK_HASH_THRESHOLD 0xff42
5642 #define IDX_SESSION 0xff19
5643 #define IDX_HEX_CHARSET 0xff20
5644 #define IDX_HEX_SALT 0xff21
5645 #define IDX_HEX_WORDLIST 0xff40
5646 #define IDX_MARKOV_DISABLE 0xff22
5647 #define IDX_MARKOV_CLASSIC 0xff23
5648 #define IDX_MARKOV_THRESHOLD 't'
5649 #define IDX_MARKOV_HCSTAT 0xff24
5650 #define IDX_CPU_AFFINITY 0xff25
5651 #define IDX_OPENCL_DEVICES 'd'
5652 #define IDX_OPENCL_PLATFORMS 0xff72
5653 #define IDX_OPENCL_DEVICE_TYPES 0xff73
5654 #define IDX_OPENCL_VECTOR_WIDTH 0xff74
5655 #define IDX_WORKLOAD_PROFILE 'w'
5656 #define IDX_KERNEL_ACCEL 'n'
5657 #define IDX_KERNEL_LOOPS 'u'
5658 #define IDX_GPU_TEMP_DISABLE 0xff29
5659 #define IDX_GPU_TEMP_ABORT 0xff30
5660 #define IDX_GPU_TEMP_RETAIN 0xff31
5661 #define IDX_POWERTUNE_ENABLE 0xff41
5662 #define IDX_LOGFILE_DISABLE 0xff51
5663 #define IDX_TRUECRYPT_KEYFILES 0xff52
5664 #define IDX_VERACRYPT_KEYFILES 0xff53
5665 #define IDX_VERACRYPT_PIM 0xff54
5666 #define IDX_SCRYPT_TMTO 0xff61
5667 #define IDX_SEGMENT_SIZE 'c'
5668 #define IDX_SEPARATOR 'p'
5669 #define IDX_BITMAP_MIN 0xff70
5670 #define IDX_BITMAP_MAX 0xff71
5671 #define IDX_CUSTOM_CHARSET_1 '1'
5672 #define IDX_CUSTOM_CHARSET_2 '2'
5673 #define IDX_CUSTOM_CHARSET_3 '3'
5674 #define IDX_CUSTOM_CHARSET_4 '4'
5675
5676 char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:";
5677
5678 struct option long_options[] =
5679 {
5680 {"help", no_argument, 0, IDX_HELP},
5681 {"version", no_argument, 0, IDX_VERSION},
5682 {"quiet", no_argument, 0, IDX_QUIET},
5683 {"show", no_argument, 0, IDX_SHOW},
5684 {"left", no_argument, 0, IDX_LEFT},
5685 {"username", no_argument, 0, IDX_USERNAME},
5686 {"remove", no_argument, 0, IDX_REMOVE},
5687 {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER},
5688 {"skip", required_argument, 0, IDX_SKIP},
5689 {"limit", required_argument, 0, IDX_LIMIT},
5690 {"keyspace", no_argument, 0, IDX_KEYSPACE},
5691 {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE},
5692 {"potfile-path", required_argument, 0, IDX_POTFILE_PATH},
5693 {"debug-mode", required_argument, 0, IDX_DEBUG_MODE},
5694 {"debug-file", required_argument, 0, IDX_DEBUG_FILE},
5695 {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR},
5696 {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR},
5697 {"force", no_argument, 0, IDX_FORCE},
5698 {"benchmark", no_argument, 0, IDX_BENCHMARK},
5699 {"restore", no_argument, 0, IDX_RESTORE},
5700 {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE},
5701 {"status", no_argument, 0, IDX_STATUS},
5702 {"status-timer", required_argument, 0, IDX_STATUS_TIMER},
5703 {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE},
5704 {"loopback", no_argument, 0, IDX_LOOPBACK},
5705 {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD},
5706 {"session", required_argument, 0, IDX_SESSION},
5707 {"runtime", required_argument, 0, IDX_RUNTIME},
5708 {"generate-rules", required_argument, 0, IDX_RP_GEN},
5709 {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN},
5710 {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX},
5711 {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED},
5712 {"rule-left", required_argument, 0, IDX_RULE_BUF_L},
5713 {"rule-right", required_argument, 0, IDX_RULE_BUF_R},
5714 {"hash-type", required_argument, 0, IDX_HASH_MODE},
5715 {"attack-mode", required_argument, 0, IDX_ATTACK_MODE},
5716 {"rules-file", required_argument, 0, IDX_RP_FILE},
5717 {"outfile", required_argument, 0, IDX_OUTFILE},
5718 {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT},
5719 {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE},
5720 {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER},
5721 {"hex-charset", no_argument, 0, IDX_HEX_CHARSET},
5722 {"hex-salt", no_argument, 0, IDX_HEX_SALT},
5723 {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST},
5724 {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE},
5725 {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC},
5726 {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD},
5727 {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT},
5728 {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY},
5729 {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES},
5730 {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS},
5731 {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES},
5732 {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH},
5733 {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE},
5734 {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL},
5735 {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS},
5736 {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE},
5737 #ifdef HAVE_HWMON
5738 {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT},
5739 {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN},
5740 #ifdef HAVE_ADL
5741 {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE},
5742 #endif
5743 #endif // HAVE_HWMON
5744 {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE},
5745 {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES},
5746 {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES},
5747 {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM},
5748 {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE},
5749 {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO},
5750 {"seperator", required_argument, 0, IDX_SEPARATOR},
5751 {"separator", required_argument, 0, IDX_SEPARATOR},
5752 {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN},
5753 {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX},
5754 {"increment", no_argument, 0, IDX_INCREMENT},
5755 {"increment-min", required_argument, 0, IDX_INCREMENT_MIN},
5756 {"increment-max", required_argument, 0, IDX_INCREMENT_MAX},
5757 {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1},
5758 {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2},
5759 {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3},
5760 {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4},
5761 {0, 0, 0, 0}
5762 };
5763
5764 uint rp_files_cnt = 0;
5765
5766 char **rp_files = (char **) mycalloc (argc, sizeof (char *));
5767
5768 int option_index = 0;
5769 int c = -1;
5770
5771 optind = 1;
5772 optopt = 0;
5773
5774 while (((c = getopt_long (argc, argv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5775 {
5776 switch (c)
5777 {
5778 case IDX_HELP: usage = 1; break;
5779 case IDX_VERSION:
5780 case IDX_VERSION_LOWER: version = 1; break;
5781 case IDX_RESTORE: restore = 1; break;
5782 case IDX_SESSION: session = optarg; break;
5783 case IDX_SHOW: show = 1; break;
5784 case IDX_LEFT: left = 1; break;
5785 case '?': return (-1);
5786 }
5787 }
5788
5789 if (optopt != 0)
5790 {
5791 log_error ("ERROR: Invalid argument specified");
5792
5793 return (-1);
5794 }
5795
5796 /**
5797 * exit functions
5798 */
5799
5800 if (version)
5801 {
5802 log_info ("%s", VERSION_TAG);
5803
5804 return (0);
5805 }
5806
5807 if (usage)
5808 {
5809 usage_big_print (PROGNAME);
5810
5811 return (0);
5812 }
5813
5814 /**
5815 * session needs to be set, always!
5816 */
5817
5818 if (session == NULL) session = (char *) PROGNAME;
5819
5820 /**
5821 * folders, as discussed on https://github.com/hashcat/hashcat/issues/20
5822 */
5823
5824 char *exec_path = get_exec_path ();
5825
5826 #ifdef LINUX
5827
5828 char *resolved_install_folder = realpath (INSTALL_FOLDER, NULL);
5829 char *resolved_exec_path = realpath (exec_path, NULL);
5830
5831 char *install_dir = get_install_dir (resolved_exec_path);
5832 char *profile_dir = NULL;
5833 char *session_dir = NULL;
5834 char *shared_dir = NULL;
5835
5836 if (strcmp (install_dir, resolved_install_folder) == 0)
5837 {
5838 struct passwd *pw = getpwuid (getuid ());
5839
5840 const char *homedir = pw->pw_dir;
5841
5842 profile_dir = get_profile_dir (homedir);
5843 session_dir = get_session_dir (profile_dir);
5844 shared_dir = strdup (SHARED_FOLDER);
5845
5846 mkdir (profile_dir, 0700);
5847 mkdir (session_dir, 0700);
5848 }
5849 else
5850 {
5851 profile_dir = install_dir;
5852 session_dir = install_dir;
5853 shared_dir = install_dir;
5854 }
5855
5856 myfree (resolved_install_folder);
5857 myfree (resolved_exec_path);
5858
5859 #else
5860
5861 char *install_dir = get_install_dir (exec_path);
5862 char *profile_dir = install_dir;
5863 char *session_dir = install_dir;
5864 char *shared_dir = install_dir;
5865
5866 #endif
5867
5868 data.install_dir = install_dir;
5869 data.profile_dir = profile_dir;
5870 data.session_dir = session_dir;
5871 data.shared_dir = shared_dir;
5872
5873 myfree (exec_path);
5874
5875 /**
5876 * kernel cache, we need to make sure folder exist
5877 */
5878
5879 int kernels_folder_size = strlen (profile_dir) + 1 + 7 + 1 + 1;
5880
5881 char *kernels_folder = (char *) mymalloc (kernels_folder_size);
5882
5883 snprintf (kernels_folder, kernels_folder_size - 1, "%s/kernels", profile_dir);
5884
5885 mkdir (kernels_folder, 0700);
5886
5887 myfree (kernels_folder);
5888
5889 /**
5890 * session
5891 */
5892
5893 size_t session_size = strlen (session_dir) + 1 + strlen (session) + 32;
5894
5895 data.session = session;
5896
5897 char *eff_restore_file = (char *) mymalloc (session_size);
5898 char *new_restore_file = (char *) mymalloc (session_size);
5899
5900 snprintf (eff_restore_file, session_size - 1, "%s/%s.restore", data.session_dir, session);
5901 snprintf (new_restore_file, session_size - 1, "%s/%s.restore.new", data.session_dir, session);
5902
5903 data.eff_restore_file = eff_restore_file;
5904 data.new_restore_file = new_restore_file;
5905
5906 if (((show == 1) || (left == 1)) && (restore == 1))
5907 {
5908 if (show == 1) log_error ("ERROR: Mixing --restore parameter and --show is not supported");
5909 else log_error ("ERROR: Mixing --restore parameter and --left is not supported");
5910
5911 return (-1);
5912 }
5913
5914 // this allows the user to use --show and --left while cracking (i.e. while another instance of hashcat is running)
5915 if ((show == 1) || (left == 1))
5916 {
5917 restore_disable = 1;
5918
5919 restore = 0;
5920 }
5921
5922 data.restore_disable = restore_disable;
5923
5924 restore_data_t *rd = init_restore (argc, argv);
5925
5926 data.rd = rd;
5927
5928 /**
5929 * restore file
5930 */
5931
5932 if (restore == 1)
5933 {
5934 read_restore (eff_restore_file, rd);
5935
5936 if (rd->version_bin < RESTORE_MIN)
5937 {
5938 log_error ("ERROR: Incompatible restore-file version");
5939
5940 return (-1);
5941 }
5942
5943 myargc = rd->argc;
5944 myargv = rd->argv;
5945
5946 #ifdef _POSIX
5947 rd->pid = getpid ();
5948 #elif _WIN
5949 rd->pid = GetCurrentProcessId ();
5950 #endif
5951 }
5952
5953 uint hash_mode_chgd = 0;
5954 uint runtime_chgd = 0;
5955 uint kernel_loops_chgd = 0;
5956 uint kernel_accel_chgd = 0;
5957 uint attack_mode_chgd = 0;
5958 uint outfile_format_chgd = 0;
5959 uint rp_gen_seed_chgd = 0;
5960 uint remove_timer_chgd = 0;
5961 uint increment_min_chgd = 0;
5962 uint increment_max_chgd = 0;
5963 uint workload_profile_chgd = 0;
5964 uint opencl_vector_width_chgd = 0;
5965
5966 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
5967 uint gpu_temp_retain_chgd = 0;
5968 uint gpu_temp_abort_chgd = 0;
5969 #endif
5970
5971 optind = 1;
5972 optopt = 0;
5973 option_index = 0;
5974
5975 while (((c = getopt_long (myargc, myargv, short_options, long_options, &option_index)) != -1) && optopt == 0)
5976 {
5977 switch (c)
5978 {
5979 //case IDX_HELP: usage = 1; break;
5980 //case IDX_VERSION: version = 1; break;
5981 //case IDX_RESTORE: restore = 1; break;
5982 case IDX_QUIET: quiet = 1; break;
5983 //case IDX_SHOW: show = 1; break;
5984 case IDX_SHOW: break;
5985 //case IDX_LEFT: left = 1; break;
5986 case IDX_LEFT: break;
5987 case IDX_USERNAME: username = 1; break;
5988 case IDX_REMOVE: remove = 1; break;
5989 case IDX_REMOVE_TIMER: remove_timer = atoi (optarg);
5990 remove_timer_chgd = 1; break;
5991 case IDX_POTFILE_DISABLE: potfile_disable = 1; break;
5992 case IDX_POTFILE_PATH: potfile_path = optarg; break;
5993 case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break;
5994 case IDX_DEBUG_FILE: debug_file = optarg; break;
5995 case IDX_INDUCTION_DIR: induction_dir = optarg; break;
5996 case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break;
5997 case IDX_FORCE: force = 1; break;
5998 case IDX_SKIP: skip = atoll (optarg); break;
5999 case IDX_LIMIT: limit = atoll (optarg); break;
6000 case IDX_KEYSPACE: keyspace = 1; break;
6001 case IDX_BENCHMARK: benchmark = 1; break;
6002 case IDX_RESTORE: break;
6003 case IDX_RESTORE_DISABLE: restore_disable = 1; break;
6004 case IDX_STATUS: status = 1; break;
6005 case IDX_STATUS_TIMER: status_timer = atoi (optarg); break;
6006 case IDX_MACHINE_READABLE: machine_readable = 1; break;
6007 case IDX_LOOPBACK: loopback = 1; break;
6008 case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break;
6009 //case IDX_SESSION: session = optarg; break;
6010 case IDX_SESSION: break;
6011 case IDX_HASH_MODE: hash_mode = atoi (optarg);
6012 hash_mode_chgd = 1; break;
6013 case IDX_RUNTIME: runtime = atoi (optarg);
6014 runtime_chgd = 1; break;
6015 case IDX_ATTACK_MODE: attack_mode = atoi (optarg);
6016 attack_mode_chgd = 1; break;
6017 case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break;
6018 case IDX_RP_GEN: rp_gen = atoi (optarg); break;
6019 case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break;
6020 case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break;
6021 case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg);
6022 rp_gen_seed_chgd = 1; break;
6023 case IDX_RULE_BUF_L: rule_buf_l = optarg; break;
6024 case IDX_RULE_BUF_R: rule_buf_r = optarg; break;
6025 case IDX_MARKOV_DISABLE: markov_disable = 1; break;
6026 case IDX_MARKOV_CLASSIC: markov_classic = 1; break;
6027 case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break;
6028 case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break;
6029 case IDX_OUTFILE: outfile = optarg; break;
6030 case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg);
6031 outfile_format_chgd = 1; break;
6032 case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break;
6033 case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break;
6034 case IDX_HEX_CHARSET: hex_charset = 1; break;
6035 case IDX_HEX_SALT: hex_salt = 1; break;
6036 case IDX_HEX_WORDLIST: hex_wordlist = 1; break;
6037 case IDX_CPU_AFFINITY: cpu_affinity = optarg; break;
6038 case IDX_OPENCL_DEVICES: opencl_devices = optarg; break;
6039 case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break;
6040 case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break;
6041 case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg);
6042 opencl_vector_width_chgd = 1; break;
6043 case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg);
6044 workload_profile_chgd = 1; break;
6045 case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg);
6046 kernel_accel_chgd = 1; break;
6047 case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg);
6048 kernel_loops_chgd = 1; break;
6049 case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break;
6050 #ifdef HAVE_HWMON
6051 case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg);
6052 #ifdef HAVE_ADL
6053 gpu_temp_abort_chgd = 1;
6054 #endif
6055 break;
6056 case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg);
6057 #ifdef HAVE_ADL
6058 gpu_temp_retain_chgd = 1;
6059 #endif
6060 break;
6061 #ifdef HAVE_ADL
6062 case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break;
6063 #endif
6064 #endif // HAVE_HWMON
6065 case IDX_LOGFILE_DISABLE: logfile_disable = 1; break;
6066 case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break;
6067 case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break;
6068 case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break;
6069 case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break;
6070 case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break;
6071 case IDX_SEPARATOR: separator = optarg[0]; break;
6072 case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break;
6073 case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break;
6074 case IDX_INCREMENT: increment = 1; break;
6075 case IDX_INCREMENT_MIN: increment_min = atoi (optarg);
6076 increment_min_chgd = 1; break;
6077 case IDX_INCREMENT_MAX: increment_max = atoi (optarg);
6078 increment_max_chgd = 1; break;
6079 case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break;
6080 case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break;
6081 case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break;
6082 case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break;
6083
6084 default:
6085 log_error ("ERROR: Invalid argument specified");
6086 return (-1);
6087 }
6088 }
6089
6090 if (optopt != 0)
6091 {
6092 log_error ("ERROR: Invalid argument specified");
6093
6094 return (-1);
6095 }
6096
6097 /**
6098 * Inform user things getting started,
6099 * - this is giving us a visual header before preparations start, so we do not need to clear them afterwards
6100 * - we do not need to check algorithm_pos
6101 */
6102
6103 if (quiet == 0)
6104 {
6105 if (benchmark == 1)
6106 {
6107 if (machine_readable == 0)
6108 {
6109 log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG);
6110 log_info ("");
6111 }
6112 else
6113 {
6114 log_info ("# %s (%s) %s", PROGNAME, VERSION_TAG, ctime (&proc_start));
6115 }
6116 }
6117 else if (restore == 1)
6118 {
6119 log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG);
6120 log_info ("");
6121 }
6122 else
6123 {
6124 log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG);
6125 log_info ("");
6126 }
6127 }
6128
6129 /**
6130 * sanity check
6131 */
6132
6133 if (attack_mode > 7)
6134 {
6135 log_error ("ERROR: Invalid attack-mode specified");
6136
6137 return (-1);
6138 }
6139
6140 if (runtime_chgd && runtime == 0) // just added to remove compiler warnings for runtime_chgd
6141 {
6142 log_error ("ERROR: Invalid runtime specified");
6143
6144 return (-1);
6145 }
6146
6147 if (hash_mode_chgd && hash_mode > 13799) // just added to remove compiler warnings for hash_mode_chgd
6148 {
6149 log_error ("ERROR: Invalid hash-type specified");
6150
6151 return (-1);
6152 }
6153
6154 // renamed hash modes
6155
6156 if (hash_mode_chgd)
6157 {
6158 int n = -1;
6159
6160 switch (hash_mode)
6161 {
6162 case 123: n = 124;
6163 break;
6164 }
6165
6166 if (n >= 0)
6167 {
6168 log_error ("Old -m specified, use -m %d instead", n);
6169
6170 return (-1);
6171 }
6172 }
6173
6174 if (username == 1)
6175 {
6176 if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799)))
6177 {
6178 log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode));
6179
6180 return (-1);
6181 }
6182 }
6183
6184 if (outfile_format > 16)
6185 {
6186 log_error ("ERROR: Invalid outfile-format specified");
6187
6188 return (-1);
6189 }
6190
6191 if (left == 1)
6192 {
6193 if (outfile_format_chgd == 1)
6194 {
6195 if (outfile_format > 1)
6196 {
6197 log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
6198
6199 return (-1);
6200 }
6201 }
6202 else
6203 {
6204 outfile_format = OUTFILE_FMT_HASH;
6205 }
6206 }
6207
6208 if (show == 1)
6209 {
6210 if (outfile_format_chgd == 1)
6211 {
6212 if ((outfile_format > 7) && (outfile_format < 16))
6213 {
6214 log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
6215
6216 return (-1);
6217 }
6218 }
6219 }
6220
6221 if (increment_min < INCREMENT_MIN)
6222 {
6223 log_error ("ERROR: Invalid increment-min specified");
6224
6225 return (-1);
6226 }
6227
6228 if (increment_max > INCREMENT_MAX)
6229 {
6230 log_error ("ERROR: Invalid increment-max specified");
6231
6232 return (-1);
6233 }
6234
6235 if (increment_min > increment_max)
6236 {
6237 log_error ("ERROR: Invalid increment-min specified");
6238
6239 return (-1);
6240 }
6241
6242 if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
6243 {
6244 log_error ("ERROR: increment is not allowed in attack-mode 0");
6245
6246 return (-1);
6247 }
6248
6249 if ((increment == 0) && (increment_min_chgd == 1))
6250 {
6251 log_error ("ERROR: increment-min is only supported together with increment switch");
6252
6253 return (-1);
6254 }
6255
6256 if ((increment == 0) && (increment_max_chgd == 1))
6257 {
6258 log_error ("ERROR: increment-max is only supported together with increment switch");
6259
6260 return (-1);
6261 }
6262
6263 if (rp_files_cnt && rp_gen)
6264 {
6265 log_error ("ERROR: Use of both rules-file and rules-generate is not supported");
6266
6267 return (-1);
6268 }
6269
6270 if (rp_files_cnt || rp_gen)
6271 {
6272 if (attack_mode != ATTACK_MODE_STRAIGHT)
6273 {
6274 log_error ("ERROR: Use of rules-file or rules-generate only allowed in attack-mode 0");
6275
6276 return (-1);
6277 }
6278 }
6279
6280 if (rp_gen_func_min > rp_gen_func_max)
6281 {
6282 log_error ("ERROR: Invalid rp-gen-func-min specified");
6283
6284 return (-1);
6285 }
6286
6287 if (kernel_accel_chgd == 1)
6288 {
6289 if (force == 0)
6290 {
6291 log_info ("The manual use of the option -n (or --kernel-accel) is outdated");
6292 log_info ("Please consider using the option -w instead");
6293 log_info ("You can use --force to override this but do not post error reports if you do so");
6294 log_info ("");
6295
6296 return (-1);
6297 }
6298
6299 if (kernel_accel < 1)
6300 {
6301 log_error ("ERROR: Invalid kernel-accel specified");
6302
6303 return (-1);
6304 }
6305
6306 if (kernel_accel > 1024)
6307 {
6308 log_error ("ERROR: Invalid kernel-accel specified");
6309
6310 return (-1);
6311 }
6312 }
6313
6314 if (kernel_loops_chgd == 1)
6315 {
6316 if (force == 0)
6317 {
6318 log_info ("The manual use of the option -u (or --kernel-loops) is outdated");
6319 log_info ("Please consider using the option -w instead");
6320 log_info ("You can use --force to override this but do not post error reports if you do so");
6321 log_info ("");
6322
6323 return (-1);
6324 }
6325
6326 if (kernel_loops < 1)
6327 {
6328 log_error ("ERROR: Invalid kernel-loops specified");
6329
6330 return (-1);
6331 }
6332
6333 if (kernel_loops > 1024)
6334 {
6335 log_error ("ERROR: Invalid kernel-loops specified");
6336
6337 return (-1);
6338 }
6339 }
6340
6341 if ((workload_profile < 1) || (workload_profile > 4))
6342 {
6343 log_error ("ERROR: workload-profile %i not available", workload_profile);
6344
6345 return (-1);
6346 }
6347
6348 if (opencl_vector_width_chgd && (!is_power_of_2(opencl_vector_width) || opencl_vector_width > 16))
6349 {
6350 log_error ("ERROR: opencl-vector-width %i not allowed", opencl_vector_width);
6351
6352 return (-1);
6353 }
6354
6355 if (show == 1 || left == 1)
6356 {
6357 attack_mode = ATTACK_MODE_NONE;
6358
6359 if (remove == 1)
6360 {
6361 log_error ("ERROR: Mixing remove parameter not allowed with show parameter or left parameter");
6362
6363 return (-1);
6364 }
6365
6366 if (potfile_disable == 1)
6367 {
6368 log_error ("ERROR: Mixing potfile-disable parameter not allowed with show parameter or left parameter");
6369
6370 return (-1);
6371 }
6372 }
6373
6374 uint attack_kern = ATTACK_KERN_NONE;
6375
6376 switch (attack_mode)
6377 {
6378 case ATTACK_MODE_STRAIGHT: attack_kern = ATTACK_KERN_STRAIGHT; break;
6379 case ATTACK_MODE_COMBI: attack_kern = ATTACK_KERN_COMBI; break;
6380 case ATTACK_MODE_BF: attack_kern = ATTACK_KERN_BF; break;
6381 case ATTACK_MODE_HYBRID1: attack_kern = ATTACK_KERN_COMBI; break;
6382 case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break;
6383 }
6384
6385 if (benchmark == 0)
6386 {
6387 if (keyspace == 1)
6388 {
6389 int num_additional_params = 1;
6390
6391 if (attack_kern == ATTACK_KERN_COMBI)
6392 {
6393 num_additional_params = 2;
6394 }
6395
6396 int keyspace_wordlist_specified = myargc - optind - num_additional_params;
6397
6398 if (keyspace_wordlist_specified == 0) optind--;
6399 }
6400
6401 if (attack_kern == ATTACK_KERN_NONE)
6402 {
6403 if ((optind + 1) != myargc)
6404 {
6405 usage_mini_print (myargv[0]);
6406
6407 return (-1);
6408 }
6409 }
6410 else if (attack_kern == ATTACK_KERN_STRAIGHT)
6411 {
6412 if ((optind + 1) > myargc)
6413 {
6414 usage_mini_print (myargv[0]);
6415
6416 return (-1);
6417 }
6418 }
6419 else if (attack_kern == ATTACK_KERN_COMBI)
6420 {
6421 if ((optind + 3) != myargc)
6422 {
6423 usage_mini_print (myargv[0]);
6424
6425 return (-1);
6426 }
6427 }
6428 else if (attack_kern == ATTACK_KERN_BF)
6429 {
6430 if ((optind + 1) > myargc)
6431 {
6432 usage_mini_print (myargv[0]);
6433
6434 return (-1);
6435 }
6436 }
6437 else
6438 {
6439 usage_mini_print (myargv[0]);
6440
6441 return (-1);
6442 }
6443 }
6444 else
6445 {
6446 if (myargv[optind] != 0)
6447 {
6448 log_error ("ERROR: Invalid argument for benchmark mode specified");
6449
6450 return (-1);
6451 }
6452
6453 if (attack_mode_chgd == 1)
6454 {
6455 if (attack_mode != ATTACK_MODE_BF)
6456 {
6457 log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode");
6458
6459 return (-1);
6460 }
6461 }
6462 }
6463
6464 if (skip != 0 && limit != 0)
6465 {
6466 limit += skip;
6467 }
6468
6469 if (keyspace == 1)
6470 {
6471 if (show == 1)
6472 {
6473 log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
6474
6475 return (-1);
6476 }
6477 else if (left == 1)
6478 {
6479 log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
6480
6481 return (-1);
6482 }
6483
6484 potfile_disable = 1;
6485
6486 restore_disable = 1;
6487
6488 restore = 0;
6489
6490 weak_hash_threshold = 0;
6491
6492 quiet = 1;
6493 }
6494
6495 if (remove_timer_chgd == 1)
6496 {
6497 if (remove == 0)
6498 {
6499 log_error ("ERROR: Parameter remove-timer require parameter remove enabled");
6500
6501 return (-1);
6502 }
6503
6504 if (remove_timer < 1)
6505 {
6506 log_error ("ERROR: Parameter remove-timer must have a value greater than or equal to 1");
6507
6508 return (-1);
6509 }
6510 }
6511
6512 if (loopback == 1)
6513 {
6514 if (attack_mode == ATTACK_MODE_STRAIGHT)
6515 {
6516 if ((rp_files_cnt == 0) && (rp_gen == 0))
6517 {
6518 log_error ("ERROR: Parameter loopback not allowed without rules-file or rules-generate");
6519
6520 return (-1);
6521 }
6522 }
6523 else
6524 {
6525 log_error ("ERROR: Parameter loopback allowed in attack-mode 0 only");
6526
6527 return (-1);
6528 }
6529 }
6530
6531 if (debug_mode > 0)
6532 {
6533 if (attack_mode != ATTACK_MODE_STRAIGHT)
6534 {
6535 log_error ("ERROR: Parameter debug-mode option is only available with attack-mode 0");
6536
6537 return (-1);
6538 }
6539
6540 if ((rp_files_cnt == 0) && (rp_gen == 0))
6541 {
6542 log_error ("ERROR: Parameter debug-mode not allowed without rules-file or rules-generate");
6543
6544 return (-1);
6545 }
6546 }
6547
6548 if (debug_mode > 4)
6549 {
6550 log_error ("ERROR: Invalid debug-mode specified");
6551
6552 return (-1);
6553 }
6554
6555 if (debug_file != NULL)
6556 {
6557 if (debug_mode < 1)
6558 {
6559 log_error ("ERROR: Parameter debug-file requires parameter debug-mode to be set");
6560
6561 return (-1);
6562 }
6563 }
6564
6565 if (induction_dir != NULL)
6566 {
6567 if (attack_mode == ATTACK_MODE_BF)
6568 {
6569 log_error ("ERROR: Parameter induction-dir not allowed with brute-force attacks");
6570
6571 return (-1);
6572 }
6573 }
6574
6575 if (attack_mode != ATTACK_MODE_STRAIGHT)
6576 {
6577 if ((weak_hash_threshold != WEAK_HASH_THRESHOLD) && (weak_hash_threshold != 0))
6578 {
6579 log_error ("ERROR: setting --weak-hash-threshold allowed only in straight-attack mode");
6580
6581 return (-1);
6582 }
6583
6584 weak_hash_threshold = 0;
6585 }
6586
6587 /**
6588 * induction directory
6589 */
6590
6591 char *induction_directory = NULL;
6592
6593 if (attack_mode != ATTACK_MODE_BF)
6594 {
6595 if (induction_dir == NULL)
6596 {
6597 induction_directory = (char *) mymalloc (session_size);
6598
6599 snprintf (induction_directory, session_size - 1, "%s/%s.%s", session_dir, session, INDUCT_DIR);
6600
6601 // create induction folder if it does not already exist
6602
6603 if (keyspace == 0)
6604 {
6605 if (rmdir (induction_directory) == -1)
6606 {
6607 if (errno == ENOENT)
6608 {
6609 // good, we can ignore
6610 }
6611 else if (errno == ENOTEMPTY)
6612 {
6613 char *induction_directory_mv = (char *) mymalloc (session_size);
6614
6615 snprintf (induction_directory_mv, session_size - 1, "%s/%s.induct.%d", session_dir, session, (int) proc_start);
6616
6617 if (rename (induction_directory, induction_directory_mv) != 0)
6618 {
6619 log_error ("ERROR: Rename directory %s to %s: %s", induction_directory, induction_directory_mv, strerror (errno));
6620
6621 return (-1);
6622 }
6623 }
6624 else
6625 {
6626 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6627
6628 return (-1);
6629 }
6630 }
6631
6632 if (mkdir (induction_directory, 0700) == -1)
6633 {
6634 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
6635
6636 return (-1);
6637 }
6638 }
6639 }
6640 else
6641 {
6642 induction_directory = induction_dir;
6643 }
6644 }
6645
6646 data.induction_directory = induction_directory;
6647
6648 /**
6649 * loopback
6650 */
6651
6652 size_t loopback_size = strlen (session_dir) + 1 + session_size + strlen (LOOPBACK_FILE) + 12;
6653
6654 char *loopback_file = (char *) mymalloc (loopback_size);
6655
6656 /**
6657 * tuning db
6658 */
6659
6660 char tuning_db_file[256] = { 0 };
6661
6662 snprintf (tuning_db_file, sizeof (tuning_db_file) - 1, "%s/%s", shared_dir, TUNING_DB_FILE);
6663
6664 tuning_db_t *tuning_db = tuning_db_init (tuning_db_file);
6665
6666 /**
6667 * outfile-check directory
6668 */
6669
6670 char *outfile_check_directory = NULL;
6671
6672 if (outfile_check_dir == NULL)
6673 {
6674 outfile_check_directory = (char *) mymalloc (session_size);
6675
6676 snprintf (outfile_check_directory, session_size - 1, "%s/%s.%s", session_dir, session, OUTFILES_DIR);
6677 }
6678 else
6679 {
6680 outfile_check_directory = outfile_check_dir;
6681 }
6682
6683 data.outfile_check_directory = outfile_check_directory;
6684
6685 if (keyspace == 0)
6686 {
6687 struct stat outfile_check_stat;
6688
6689 if (stat (outfile_check_directory, &outfile_check_stat) == 0)
6690 {
6691 uint is_dir = S_ISDIR (outfile_check_stat.st_mode);
6692
6693 if (is_dir == 0)
6694 {
6695 log_error ("ERROR: Directory specified in outfile-check '%s' is not a valid directory", outfile_check_directory);
6696
6697 return (-1);
6698 }
6699 }
6700 else if (outfile_check_dir == NULL)
6701 {
6702 if (mkdir (outfile_check_directory, 0700) == -1)
6703 {
6704 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
6705
6706 return (-1);
6707 }
6708 }
6709 }
6710
6711 /**
6712 * special other stuff
6713 */
6714
6715 if (hash_mode == 9710)
6716 {
6717 outfile_format = 5;
6718 outfile_format_chgd = 1;
6719 }
6720
6721 if (hash_mode == 9810)
6722 {
6723 outfile_format = 5;
6724 outfile_format_chgd = 1;
6725 }
6726
6727 if (hash_mode == 10410)
6728 {
6729 outfile_format = 5;
6730 outfile_format_chgd = 1;
6731 }
6732
6733 /**
6734 * store stuff
6735 */
6736
6737 data.hash_mode = hash_mode;
6738 data.restore = restore;
6739 data.restore_timer = restore_timer;
6740 data.restore_disable = restore_disable;
6741 data.status = status;
6742 data.status_timer = status_timer;
6743 data.machine_readable = machine_readable;
6744 data.loopback = loopback;
6745 data.runtime = runtime;
6746 data.remove = remove;
6747 data.remove_timer = remove_timer;
6748 data.debug_mode = debug_mode;
6749 data.debug_file = debug_file;
6750 data.username = username;
6751 data.quiet = quiet;
6752 data.outfile = outfile;
6753 data.outfile_format = outfile_format;
6754 data.outfile_autohex = outfile_autohex;
6755 data.hex_charset = hex_charset;
6756 data.hex_salt = hex_salt;
6757 data.hex_wordlist = hex_wordlist;
6758 data.separator = separator;
6759 data.rp_files = rp_files;
6760 data.rp_files_cnt = rp_files_cnt;
6761 data.rp_gen = rp_gen;
6762 data.rp_gen_seed = rp_gen_seed;
6763 data.force = force;
6764 data.benchmark = benchmark;
6765 data.skip = skip;
6766 data.limit = limit;
6767 #ifdef HAVE_HWMON
6768 #ifdef HAVE_ADL
6769 data.powertune_enable = powertune_enable;
6770 #endif
6771 #endif
6772 data.logfile_disable = logfile_disable;
6773 data.truecrypt_keyfiles = truecrypt_keyfiles;
6774 data.veracrypt_keyfiles = veracrypt_keyfiles;
6775 data.veracrypt_pim = veracrypt_pim;
6776 data.scrypt_tmto = scrypt_tmto;
6777 data.workload_profile = workload_profile;
6778
6779 /**
6780 * cpu affinity
6781 */
6782
6783 if (cpu_affinity)
6784 {
6785 set_cpu_affinity (cpu_affinity);
6786 }
6787
6788 if (rp_gen_seed_chgd == 0)
6789 {
6790 srand (proc_start);
6791 }
6792 else
6793 {
6794 srand (rp_gen_seed);
6795 }
6796
6797 /**
6798 * logfile init
6799 */
6800
6801 if (logfile_disable == 0)
6802 {
6803 size_t logfile_size = strlen (session_dir) + 1 + strlen (session) + 32;
6804
6805 char *logfile = (char *) mymalloc (logfile_size);
6806
6807 snprintf (logfile, logfile_size - 1, "%s/%s.log", session_dir, session);
6808
6809 data.logfile = logfile;
6810
6811 char *topid = logfile_generate_topid ();
6812
6813 data.topid = topid;
6814 }
6815
6816 // logfile_append() checks for logfile_disable internally to make it easier from here
6817
6818 #define logfile_top_msg(msg) logfile_append ("%s\t%s", data.topid, (msg));
6819 #define logfile_sub_msg(msg) logfile_append ("%s\t%s\t%s", data.topid, data.subid, (msg));
6820 #define logfile_top_var_uint64(var,val) logfile_append ("%s\t%s\t%llu", data.topid, (var), (val));
6821 #define logfile_sub_var_uint64(var,val) logfile_append ("%s\t%s\t%s\t%llu", data.topid, data.subid, (var), (val));
6822 #define logfile_top_var_uint(var,val) logfile_append ("%s\t%s\t%u", data.topid, (var), (val));
6823 #define logfile_sub_var_uint(var,val) logfile_append ("%s\t%s\t%s\t%u", data.topid, data.subid, (var), (val));
6824 #define logfile_top_var_char(var,val) logfile_append ("%s\t%s\t%c", data.topid, (var), (val));
6825 #define logfile_sub_var_char(var,val) logfile_append ("%s\t%s\t%s\t%c", data.topid, data.subid, (var), (val));
6826 #define logfile_top_var_string(var,val) if ((val) != NULL) logfile_append ("%s\t%s\t%s", data.topid, (var), (val));
6827 #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));
6828
6829 #define logfile_top_uint64(var) logfile_top_var_uint64 (#var, (var));
6830 #define logfile_sub_uint64(var) logfile_sub_var_uint64 (#var, (var));
6831 #define logfile_top_uint(var) logfile_top_var_uint (#var, (var));
6832 #define logfile_sub_uint(var) logfile_sub_var_uint (#var, (var));
6833 #define logfile_top_char(var) logfile_top_var_char (#var, (var));
6834 #define logfile_sub_char(var) logfile_sub_var_char (#var, (var));
6835 #define logfile_top_string(var) logfile_top_var_string (#var, (var));
6836 #define logfile_sub_string(var) logfile_sub_var_string (#var, (var));
6837
6838 logfile_top_msg ("START");
6839
6840 logfile_top_uint (attack_mode);
6841 logfile_top_uint (attack_kern);
6842 logfile_top_uint (benchmark);
6843 logfile_top_uint (bitmap_min);
6844 logfile_top_uint (bitmap_max);
6845 logfile_top_uint (debug_mode);
6846 logfile_top_uint (force);
6847 logfile_top_uint (kernel_accel);
6848 logfile_top_uint (kernel_loops);
6849 logfile_top_uint (gpu_temp_disable);
6850 #ifdef HAVE_HWMON
6851 logfile_top_uint (gpu_temp_abort);
6852 logfile_top_uint (gpu_temp_retain);
6853 #endif
6854 logfile_top_uint (hash_mode);
6855 logfile_top_uint (hex_charset);
6856 logfile_top_uint (hex_salt);
6857 logfile_top_uint (hex_wordlist);
6858 logfile_top_uint (increment);
6859 logfile_top_uint (increment_max);
6860 logfile_top_uint (increment_min);
6861 logfile_top_uint (keyspace);
6862 logfile_top_uint (left);
6863 logfile_top_uint (logfile_disable);
6864 logfile_top_uint (loopback);
6865 logfile_top_uint (markov_classic);
6866 logfile_top_uint (markov_disable);
6867 logfile_top_uint (markov_threshold);
6868 logfile_top_uint (outfile_autohex);
6869 logfile_top_uint (outfile_check_timer);
6870 logfile_top_uint (outfile_format);
6871 logfile_top_uint (potfile_disable);
6872 logfile_top_string (potfile_path);
6873 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
6874 logfile_top_uint (powertune_enable);
6875 #endif
6876 logfile_top_uint (scrypt_tmto);
6877 logfile_top_uint (quiet);
6878 logfile_top_uint (remove);
6879 logfile_top_uint (remove_timer);
6880 logfile_top_uint (restore);
6881 logfile_top_uint (restore_disable);
6882 logfile_top_uint (restore_timer);
6883 logfile_top_uint (rp_gen);
6884 logfile_top_uint (rp_gen_func_max);
6885 logfile_top_uint (rp_gen_func_min);
6886 logfile_top_uint (rp_gen_seed);
6887 logfile_top_uint (runtime);
6888 logfile_top_uint (segment_size);
6889 logfile_top_uint (show);
6890 logfile_top_uint (status);
6891 logfile_top_uint (machine_readable);
6892 logfile_top_uint (status_timer);
6893 logfile_top_uint (usage);
6894 logfile_top_uint (username);
6895 logfile_top_uint (version);
6896 logfile_top_uint (weak_hash_threshold);
6897 logfile_top_uint (workload_profile);
6898 logfile_top_uint64 (limit);
6899 logfile_top_uint64 (skip);
6900 logfile_top_char (separator);
6901 logfile_top_string (cpu_affinity);
6902 logfile_top_string (custom_charset_1);
6903 logfile_top_string (custom_charset_2);
6904 logfile_top_string (custom_charset_3);
6905 logfile_top_string (custom_charset_4);
6906 logfile_top_string (debug_file);
6907 logfile_top_string (opencl_devices);
6908 logfile_top_string (opencl_platforms);
6909 logfile_top_string (opencl_device_types);
6910 logfile_top_uint (opencl_vector_width);
6911 logfile_top_string (induction_dir);
6912 logfile_top_string (markov_hcstat);
6913 logfile_top_string (outfile);
6914 logfile_top_string (outfile_check_dir);
6915 logfile_top_string (rule_buf_l);
6916 logfile_top_string (rule_buf_r);
6917 logfile_top_string (session);
6918 logfile_top_string (truecrypt_keyfiles);
6919 logfile_top_string (veracrypt_keyfiles);
6920 logfile_top_uint (veracrypt_pim);
6921
6922 /**
6923 * Init OpenCL library loader
6924 */
6925
6926 if (keyspace == 0)
6927 {
6928 ocl = (OCL_PTR *) mymalloc (sizeof (OCL_PTR));
6929
6930 ocl_init (ocl);
6931
6932 data.ocl = ocl;
6933 }
6934
6935 /**
6936 * OpenCL platform selection
6937 */
6938
6939 u32 opencl_platforms_filter = setup_opencl_platforms_filter (opencl_platforms);
6940
6941 /**
6942 * OpenCL device selection
6943 */
6944
6945 u32 devices_filter = setup_devices_filter (opencl_devices);
6946
6947 /**
6948 * OpenCL device type selection
6949 */
6950
6951 cl_device_type device_types_filter = setup_device_types_filter (opencl_device_types);
6952
6953 /**
6954 * benchmark
6955 */
6956
6957 if (benchmark == 1)
6958 {
6959 /**
6960 * disable useless stuff for benchmark
6961 */
6962
6963 status_timer = 0;
6964 restore_timer = 0;
6965 restore_disable = 1;
6966 potfile_disable = 1;
6967 weak_hash_threshold = 0;
6968 gpu_temp_disable = 1;
6969
6970 #ifdef HAVE_HWMON
6971 #ifdef HAVE_ADL
6972 powertune_enable = 1;
6973 #endif
6974 #endif
6975
6976 data.status_timer = status_timer;
6977 data.restore_timer = restore_timer;
6978 data.restore_disable = restore_disable;
6979
6980 /**
6981 * force attack mode to be bruteforce
6982 */
6983
6984 attack_mode = ATTACK_MODE_BF;
6985 attack_kern = ATTACK_KERN_BF;
6986
6987 if (workload_profile_chgd == 0)
6988 {
6989 workload_profile = 3;
6990
6991 data.workload_profile = workload_profile;
6992 }
6993 }
6994
6995 /**
6996 * config
6997 */
6998
6999 uint hash_type = 0;
7000 uint salt_type = 0;
7001 uint attack_exec = 0;
7002 uint opts_type = 0;
7003 uint kern_type = 0;
7004 uint dgst_size = 0;
7005 uint esalt_size = 0;
7006 uint opti_type = 0;
7007 uint dgst_pos0 = -1;
7008 uint dgst_pos1 = -1;
7009 uint dgst_pos2 = -1;
7010 uint dgst_pos3 = -1;
7011
7012 int (*parse_func) (char *, uint, hash_t *);
7013 int (*sort_by_digest) (const void *, const void *);
7014
7015 uint algorithm_pos = 0;
7016 uint algorithm_max = 1;
7017
7018 uint *algorithms = default_benchmark_algorithms;
7019
7020 if (benchmark == 1 && hash_mode_chgd == 0) algorithm_max = NUM_DEFAULT_BENCHMARK_ALGORITHMS;
7021
7022 for (algorithm_pos = 0; algorithm_pos < algorithm_max; algorithm_pos++)
7023 {
7024 /*
7025 * We need to reset 'rd' in benchmark mode otherwise when the user hits 'bypass'
7026 * the following algos are skipped entirely
7027 */
7028
7029 if (algorithm_pos > 0)
7030 {
7031 local_free (rd);
7032
7033 rd = init_restore (argc, argv);
7034
7035 data.rd = rd;
7036 }
7037
7038 /**
7039 * update hash_mode in case of multihash benchmark
7040 */
7041
7042 if (benchmark == 1)
7043 {
7044 if (hash_mode_chgd == 0)
7045 {
7046 hash_mode = algorithms[algorithm_pos];
7047
7048 data.hash_mode = hash_mode;
7049 }
7050
7051 quiet = 1;
7052
7053 data.quiet = quiet;
7054 }
7055
7056 switch (hash_mode)
7057 {
7058 case 0: hash_type = HASH_TYPE_MD5;
7059 salt_type = SALT_TYPE_NONE;
7060 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7061 opts_type = OPTS_TYPE_PT_GENERATE_LE
7062 | OPTS_TYPE_PT_ADD80
7063 | OPTS_TYPE_PT_ADDBITS14;
7064 kern_type = KERN_TYPE_MD5;
7065 dgst_size = DGST_SIZE_4_4;
7066 parse_func = md5_parse_hash;
7067 sort_by_digest = sort_by_digest_4_4;
7068 opti_type = OPTI_TYPE_ZERO_BYTE
7069 | OPTI_TYPE_PRECOMPUTE_INIT
7070 | OPTI_TYPE_PRECOMPUTE_MERKLE
7071 | OPTI_TYPE_MEET_IN_MIDDLE
7072 | OPTI_TYPE_EARLY_SKIP
7073 | OPTI_TYPE_NOT_ITERATED
7074 | OPTI_TYPE_NOT_SALTED
7075 | OPTI_TYPE_RAW_HASH;
7076 dgst_pos0 = 0;
7077 dgst_pos1 = 3;
7078 dgst_pos2 = 2;
7079 dgst_pos3 = 1;
7080 break;
7081
7082 case 10: hash_type = HASH_TYPE_MD5;
7083 salt_type = SALT_TYPE_INTERN;
7084 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7085 opts_type = OPTS_TYPE_PT_GENERATE_LE
7086 | OPTS_TYPE_ST_ADD80
7087 | OPTS_TYPE_ST_ADDBITS14;
7088 kern_type = KERN_TYPE_MD5_PWSLT;
7089 dgst_size = DGST_SIZE_4_4;
7090 parse_func = md5s_parse_hash;
7091 sort_by_digest = sort_by_digest_4_4;
7092 opti_type = OPTI_TYPE_ZERO_BYTE
7093 | OPTI_TYPE_PRECOMPUTE_INIT
7094 | OPTI_TYPE_PRECOMPUTE_MERKLE
7095 | OPTI_TYPE_MEET_IN_MIDDLE
7096 | OPTI_TYPE_EARLY_SKIP
7097 | OPTI_TYPE_NOT_ITERATED
7098 | OPTI_TYPE_APPENDED_SALT
7099 | OPTI_TYPE_RAW_HASH;
7100 dgst_pos0 = 0;
7101 dgst_pos1 = 3;
7102 dgst_pos2 = 2;
7103 dgst_pos3 = 1;
7104 break;
7105
7106 case 11: hash_type = HASH_TYPE_MD5;
7107 salt_type = SALT_TYPE_INTERN;
7108 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7109 opts_type = OPTS_TYPE_PT_GENERATE_LE
7110 | OPTS_TYPE_ST_ADD80
7111 | OPTS_TYPE_ST_ADDBITS14;
7112 kern_type = KERN_TYPE_MD5_PWSLT;
7113 dgst_size = DGST_SIZE_4_4;
7114 parse_func = joomla_parse_hash;
7115 sort_by_digest = sort_by_digest_4_4;
7116 opti_type = OPTI_TYPE_ZERO_BYTE
7117 | OPTI_TYPE_PRECOMPUTE_INIT
7118 | OPTI_TYPE_PRECOMPUTE_MERKLE
7119 | OPTI_TYPE_MEET_IN_MIDDLE
7120 | OPTI_TYPE_EARLY_SKIP
7121 | OPTI_TYPE_NOT_ITERATED
7122 | OPTI_TYPE_APPENDED_SALT
7123 | OPTI_TYPE_RAW_HASH;
7124 dgst_pos0 = 0;
7125 dgst_pos1 = 3;
7126 dgst_pos2 = 2;
7127 dgst_pos3 = 1;
7128 break;
7129
7130 case 12: hash_type = HASH_TYPE_MD5;
7131 salt_type = SALT_TYPE_INTERN;
7132 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7133 opts_type = OPTS_TYPE_PT_GENERATE_LE
7134 | OPTS_TYPE_ST_ADD80
7135 | OPTS_TYPE_ST_ADDBITS14;
7136 kern_type = KERN_TYPE_MD5_PWSLT;
7137 dgst_size = DGST_SIZE_4_4;
7138 parse_func = postgresql_parse_hash;
7139 sort_by_digest = sort_by_digest_4_4;
7140 opti_type = OPTI_TYPE_ZERO_BYTE
7141 | OPTI_TYPE_PRECOMPUTE_INIT
7142 | OPTI_TYPE_PRECOMPUTE_MERKLE
7143 | OPTI_TYPE_MEET_IN_MIDDLE
7144 | OPTI_TYPE_EARLY_SKIP
7145 | OPTI_TYPE_NOT_ITERATED
7146 | OPTI_TYPE_APPENDED_SALT
7147 | OPTI_TYPE_RAW_HASH;
7148 dgst_pos0 = 0;
7149 dgst_pos1 = 3;
7150 dgst_pos2 = 2;
7151 dgst_pos3 = 1;
7152 break;
7153
7154 case 20: hash_type = HASH_TYPE_MD5;
7155 salt_type = SALT_TYPE_INTERN;
7156 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7157 opts_type = OPTS_TYPE_PT_GENERATE_LE
7158 | OPTS_TYPE_PT_ADD80
7159 | OPTS_TYPE_PT_ADDBITS14;
7160 kern_type = KERN_TYPE_MD5_SLTPW;
7161 dgst_size = DGST_SIZE_4_4;
7162 parse_func = md5s_parse_hash;
7163 sort_by_digest = sort_by_digest_4_4;
7164 opti_type = OPTI_TYPE_ZERO_BYTE
7165 | OPTI_TYPE_PRECOMPUTE_INIT
7166 | OPTI_TYPE_PRECOMPUTE_MERKLE
7167 | OPTI_TYPE_EARLY_SKIP
7168 | OPTI_TYPE_NOT_ITERATED
7169 | OPTI_TYPE_PREPENDED_SALT
7170 | OPTI_TYPE_RAW_HASH;
7171 dgst_pos0 = 0;
7172 dgst_pos1 = 3;
7173 dgst_pos2 = 2;
7174 dgst_pos3 = 1;
7175 break;
7176
7177 case 21: hash_type = HASH_TYPE_MD5;
7178 salt_type = SALT_TYPE_INTERN;
7179 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7180 opts_type = OPTS_TYPE_PT_GENERATE_LE
7181 | OPTS_TYPE_PT_ADD80
7182 | OPTS_TYPE_PT_ADDBITS14;
7183 kern_type = KERN_TYPE_MD5_SLTPW;
7184 dgst_size = DGST_SIZE_4_4;
7185 parse_func = osc_parse_hash;
7186 sort_by_digest = sort_by_digest_4_4;
7187 opti_type = OPTI_TYPE_ZERO_BYTE
7188 | OPTI_TYPE_PRECOMPUTE_INIT
7189 | OPTI_TYPE_PRECOMPUTE_MERKLE
7190 | OPTI_TYPE_EARLY_SKIP
7191 | OPTI_TYPE_NOT_ITERATED
7192 | OPTI_TYPE_PREPENDED_SALT
7193 | OPTI_TYPE_RAW_HASH;
7194 dgst_pos0 = 0;
7195 dgst_pos1 = 3;
7196 dgst_pos2 = 2;
7197 dgst_pos3 = 1;
7198 break;
7199
7200 case 22: hash_type = HASH_TYPE_MD5;
7201 salt_type = SALT_TYPE_EMBEDDED;
7202 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7203 opts_type = OPTS_TYPE_PT_GENERATE_LE
7204 | OPTS_TYPE_PT_ADD80
7205 | OPTS_TYPE_PT_ADDBITS14;
7206 kern_type = KERN_TYPE_MD5_SLTPW;
7207 dgst_size = DGST_SIZE_4_4;
7208 parse_func = netscreen_parse_hash;
7209 sort_by_digest = sort_by_digest_4_4;
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_PREPENDED_SALT
7216 | OPTI_TYPE_RAW_HASH;
7217 dgst_pos0 = 0;
7218 dgst_pos1 = 3;
7219 dgst_pos2 = 2;
7220 dgst_pos3 = 1;
7221 break;
7222
7223 case 23: hash_type = HASH_TYPE_MD5;
7224 salt_type = SALT_TYPE_EMBEDDED;
7225 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7226 opts_type = OPTS_TYPE_PT_GENERATE_LE
7227 | OPTS_TYPE_PT_ADD80
7228 | OPTS_TYPE_PT_ADDBITS14;
7229 kern_type = KERN_TYPE_MD5_SLTPW;
7230 dgst_size = DGST_SIZE_4_4;
7231 parse_func = skype_parse_hash;
7232 sort_by_digest = sort_by_digest_4_4;
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 = 0;
7241 dgst_pos1 = 3;
7242 dgst_pos2 = 2;
7243 dgst_pos3 = 1;
7244 break;
7245
7246 case 30: hash_type = HASH_TYPE_MD5;
7247 salt_type = SALT_TYPE_INTERN;
7248 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7249 opts_type = OPTS_TYPE_PT_GENERATE_LE
7250 | OPTS_TYPE_PT_UNICODE
7251 | OPTS_TYPE_ST_ADD80
7252 | OPTS_TYPE_ST_ADDBITS14;
7253 kern_type = KERN_TYPE_MD5_PWUSLT;
7254 dgst_size = DGST_SIZE_4_4;
7255 parse_func = md5s_parse_hash;
7256 sort_by_digest = sort_by_digest_4_4;
7257 opti_type = OPTI_TYPE_ZERO_BYTE
7258 | OPTI_TYPE_PRECOMPUTE_INIT
7259 | OPTI_TYPE_PRECOMPUTE_MERKLE
7260 | OPTI_TYPE_MEET_IN_MIDDLE
7261 | OPTI_TYPE_EARLY_SKIP
7262 | OPTI_TYPE_NOT_ITERATED
7263 | OPTI_TYPE_APPENDED_SALT
7264 | OPTI_TYPE_RAW_HASH;
7265 dgst_pos0 = 0;
7266 dgst_pos1 = 3;
7267 dgst_pos2 = 2;
7268 dgst_pos3 = 1;
7269 break;
7270
7271 case 40: hash_type = HASH_TYPE_MD5;
7272 salt_type = SALT_TYPE_INTERN;
7273 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7274 opts_type = OPTS_TYPE_PT_GENERATE_LE
7275 | OPTS_TYPE_PT_ADD80
7276 | OPTS_TYPE_PT_ADDBITS14
7277 | OPTS_TYPE_PT_UNICODE;
7278 kern_type = KERN_TYPE_MD5_SLTPWU;
7279 dgst_size = DGST_SIZE_4_4;
7280 parse_func = md5s_parse_hash;
7281 sort_by_digest = sort_by_digest_4_4;
7282 opti_type = OPTI_TYPE_ZERO_BYTE
7283 | OPTI_TYPE_PRECOMPUTE_INIT
7284 | OPTI_TYPE_PRECOMPUTE_MERKLE
7285 | OPTI_TYPE_EARLY_SKIP
7286 | OPTI_TYPE_NOT_ITERATED
7287 | OPTI_TYPE_PREPENDED_SALT
7288 | OPTI_TYPE_RAW_HASH;
7289 dgst_pos0 = 0;
7290 dgst_pos1 = 3;
7291 dgst_pos2 = 2;
7292 dgst_pos3 = 1;
7293 break;
7294
7295 case 50: hash_type = HASH_TYPE_MD5;
7296 salt_type = SALT_TYPE_INTERN;
7297 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7298 opts_type = OPTS_TYPE_PT_GENERATE_LE
7299 | OPTS_TYPE_ST_ADD80
7300 | OPTS_TYPE_ST_ADDBITS14;
7301 kern_type = KERN_TYPE_HMACMD5_PW;
7302 dgst_size = DGST_SIZE_4_4;
7303 parse_func = hmacmd5_parse_hash;
7304 sort_by_digest = sort_by_digest_4_4;
7305 opti_type = OPTI_TYPE_ZERO_BYTE
7306 | OPTI_TYPE_NOT_ITERATED;
7307 dgst_pos0 = 0;
7308 dgst_pos1 = 3;
7309 dgst_pos2 = 2;
7310 dgst_pos3 = 1;
7311 break;
7312
7313 case 60: hash_type = HASH_TYPE_MD5;
7314 salt_type = SALT_TYPE_INTERN;
7315 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7316 opts_type = OPTS_TYPE_PT_GENERATE_LE
7317 | OPTS_TYPE_PT_ADD80
7318 | OPTS_TYPE_PT_ADDBITS14;
7319 kern_type = KERN_TYPE_HMACMD5_SLT;
7320 dgst_size = DGST_SIZE_4_4;
7321 parse_func = hmacmd5_parse_hash;
7322 sort_by_digest = sort_by_digest_4_4;
7323 opti_type = OPTI_TYPE_ZERO_BYTE
7324 | OPTI_TYPE_NOT_ITERATED;
7325 dgst_pos0 = 0;
7326 dgst_pos1 = 3;
7327 dgst_pos2 = 2;
7328 dgst_pos3 = 1;
7329 break;
7330
7331 case 100: hash_type = HASH_TYPE_SHA1;
7332 salt_type = SALT_TYPE_NONE;
7333 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7334 opts_type = OPTS_TYPE_PT_GENERATE_BE
7335 | OPTS_TYPE_PT_ADD80
7336 | OPTS_TYPE_PT_ADDBITS15;
7337 kern_type = KERN_TYPE_SHA1;
7338 dgst_size = DGST_SIZE_4_5;
7339 parse_func = sha1_parse_hash;
7340 sort_by_digest = sort_by_digest_4_5;
7341 opti_type = OPTI_TYPE_ZERO_BYTE
7342 | OPTI_TYPE_PRECOMPUTE_INIT
7343 | OPTI_TYPE_PRECOMPUTE_MERKLE
7344 | OPTI_TYPE_EARLY_SKIP
7345 | OPTI_TYPE_NOT_ITERATED
7346 | OPTI_TYPE_NOT_SALTED
7347 | OPTI_TYPE_RAW_HASH;
7348 dgst_pos0 = 3;
7349 dgst_pos1 = 4;
7350 dgst_pos2 = 2;
7351 dgst_pos3 = 1;
7352 break;
7353
7354 case 101: hash_type = HASH_TYPE_SHA1;
7355 salt_type = SALT_TYPE_NONE;
7356 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7357 opts_type = OPTS_TYPE_PT_GENERATE_BE
7358 | OPTS_TYPE_PT_ADD80
7359 | OPTS_TYPE_PT_ADDBITS15;
7360 kern_type = KERN_TYPE_SHA1;
7361 dgst_size = DGST_SIZE_4_5;
7362 parse_func = sha1b64_parse_hash;
7363 sort_by_digest = sort_by_digest_4_5;
7364 opti_type = OPTI_TYPE_ZERO_BYTE
7365 | OPTI_TYPE_PRECOMPUTE_INIT
7366 | OPTI_TYPE_PRECOMPUTE_MERKLE
7367 | OPTI_TYPE_EARLY_SKIP
7368 | OPTI_TYPE_NOT_ITERATED
7369 | OPTI_TYPE_NOT_SALTED
7370 | OPTI_TYPE_RAW_HASH;
7371 dgst_pos0 = 3;
7372 dgst_pos1 = 4;
7373 dgst_pos2 = 2;
7374 dgst_pos3 = 1;
7375 break;
7376
7377 case 110: hash_type = HASH_TYPE_SHA1;
7378 salt_type = SALT_TYPE_INTERN;
7379 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7380 opts_type = OPTS_TYPE_PT_GENERATE_BE
7381 | OPTS_TYPE_ST_ADD80
7382 | OPTS_TYPE_ST_ADDBITS15;
7383 kern_type = KERN_TYPE_SHA1_PWSLT;
7384 dgst_size = DGST_SIZE_4_5;
7385 parse_func = sha1s_parse_hash;
7386 sort_by_digest = sort_by_digest_4_5;
7387 opti_type = OPTI_TYPE_ZERO_BYTE
7388 | OPTI_TYPE_PRECOMPUTE_INIT
7389 | OPTI_TYPE_PRECOMPUTE_MERKLE
7390 | OPTI_TYPE_EARLY_SKIP
7391 | OPTI_TYPE_NOT_ITERATED
7392 | OPTI_TYPE_APPENDED_SALT
7393 | OPTI_TYPE_RAW_HASH;
7394 dgst_pos0 = 3;
7395 dgst_pos1 = 4;
7396 dgst_pos2 = 2;
7397 dgst_pos3 = 1;
7398 break;
7399
7400 case 111: hash_type = HASH_TYPE_SHA1;
7401 salt_type = SALT_TYPE_EMBEDDED;
7402 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7403 opts_type = OPTS_TYPE_PT_GENERATE_BE
7404 | OPTS_TYPE_ST_ADD80
7405 | OPTS_TYPE_ST_ADDBITS15;
7406 kern_type = KERN_TYPE_SHA1_PWSLT;
7407 dgst_size = DGST_SIZE_4_5;
7408 parse_func = sha1b64s_parse_hash;
7409 sort_by_digest = sort_by_digest_4_5;
7410 opti_type = OPTI_TYPE_ZERO_BYTE
7411 | OPTI_TYPE_PRECOMPUTE_INIT
7412 | OPTI_TYPE_PRECOMPUTE_MERKLE
7413 | OPTI_TYPE_EARLY_SKIP
7414 | OPTI_TYPE_NOT_ITERATED
7415 | OPTI_TYPE_APPENDED_SALT
7416 | OPTI_TYPE_RAW_HASH;
7417 dgst_pos0 = 3;
7418 dgst_pos1 = 4;
7419 dgst_pos2 = 2;
7420 dgst_pos3 = 1;
7421 break;
7422
7423 case 112: hash_type = HASH_TYPE_SHA1;
7424 salt_type = SALT_TYPE_INTERN;
7425 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7426 opts_type = OPTS_TYPE_PT_GENERATE_BE
7427 | OPTS_TYPE_ST_ADD80
7428 | OPTS_TYPE_ST_ADDBITS15
7429 | OPTS_TYPE_ST_HEX;
7430 kern_type = KERN_TYPE_SHA1_PWSLT;
7431 dgst_size = DGST_SIZE_4_5;
7432 parse_func = oracles_parse_hash;
7433 sort_by_digest = sort_by_digest_4_5;
7434 opti_type = OPTI_TYPE_ZERO_BYTE
7435 | OPTI_TYPE_PRECOMPUTE_INIT
7436 | OPTI_TYPE_PRECOMPUTE_MERKLE
7437 | OPTI_TYPE_EARLY_SKIP
7438 | OPTI_TYPE_NOT_ITERATED
7439 | OPTI_TYPE_APPENDED_SALT
7440 | OPTI_TYPE_RAW_HASH;
7441 dgst_pos0 = 3;
7442 dgst_pos1 = 4;
7443 dgst_pos2 = 2;
7444 dgst_pos3 = 1;
7445 break;
7446
7447 case 120: hash_type = HASH_TYPE_SHA1;
7448 salt_type = SALT_TYPE_INTERN;
7449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7450 opts_type = OPTS_TYPE_PT_GENERATE_BE
7451 | OPTS_TYPE_PT_ADD80
7452 | OPTS_TYPE_PT_ADDBITS15;
7453 kern_type = KERN_TYPE_SHA1_SLTPW;
7454 dgst_size = DGST_SIZE_4_5;
7455 parse_func = sha1s_parse_hash;
7456 sort_by_digest = sort_by_digest_4_5;
7457 opti_type = OPTI_TYPE_ZERO_BYTE
7458 | OPTI_TYPE_PRECOMPUTE_INIT
7459 | OPTI_TYPE_PRECOMPUTE_MERKLE
7460 | OPTI_TYPE_EARLY_SKIP
7461 | OPTI_TYPE_NOT_ITERATED
7462 | OPTI_TYPE_PREPENDED_SALT
7463 | OPTI_TYPE_RAW_HASH;
7464 dgst_pos0 = 3;
7465 dgst_pos1 = 4;
7466 dgst_pos2 = 2;
7467 dgst_pos3 = 1;
7468 break;
7469
7470 case 121: hash_type = HASH_TYPE_SHA1;
7471 salt_type = SALT_TYPE_INTERN;
7472 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7473 opts_type = OPTS_TYPE_PT_GENERATE_BE
7474 | OPTS_TYPE_PT_ADD80
7475 | OPTS_TYPE_PT_ADDBITS15
7476 | OPTS_TYPE_ST_LOWER;
7477 kern_type = KERN_TYPE_SHA1_SLTPW;
7478 dgst_size = DGST_SIZE_4_5;
7479 parse_func = smf_parse_hash;
7480 sort_by_digest = sort_by_digest_4_5;
7481 opti_type = OPTI_TYPE_ZERO_BYTE
7482 | OPTI_TYPE_PRECOMPUTE_INIT
7483 | OPTI_TYPE_PRECOMPUTE_MERKLE
7484 | OPTI_TYPE_EARLY_SKIP
7485 | OPTI_TYPE_NOT_ITERATED
7486 | OPTI_TYPE_PREPENDED_SALT
7487 | OPTI_TYPE_RAW_HASH;
7488 dgst_pos0 = 3;
7489 dgst_pos1 = 4;
7490 dgst_pos2 = 2;
7491 dgst_pos3 = 1;
7492 break;
7493
7494 case 122: hash_type = HASH_TYPE_SHA1;
7495 salt_type = SALT_TYPE_EMBEDDED;
7496 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7497 opts_type = OPTS_TYPE_PT_GENERATE_BE
7498 | OPTS_TYPE_PT_ADD80
7499 | OPTS_TYPE_PT_ADDBITS15
7500 | OPTS_TYPE_ST_HEX;
7501 kern_type = KERN_TYPE_SHA1_SLTPW;
7502 dgst_size = DGST_SIZE_4_5;
7503 parse_func = osx1_parse_hash;
7504 sort_by_digest = sort_by_digest_4_5;
7505 opti_type = OPTI_TYPE_ZERO_BYTE
7506 | OPTI_TYPE_PRECOMPUTE_INIT
7507 | OPTI_TYPE_PRECOMPUTE_MERKLE
7508 | OPTI_TYPE_EARLY_SKIP
7509 | OPTI_TYPE_NOT_ITERATED
7510 | OPTI_TYPE_PREPENDED_SALT
7511 | OPTI_TYPE_RAW_HASH;
7512 dgst_pos0 = 3;
7513 dgst_pos1 = 4;
7514 dgst_pos2 = 2;
7515 dgst_pos3 = 1;
7516 break;
7517
7518 case 124: hash_type = HASH_TYPE_SHA1;
7519 salt_type = SALT_TYPE_EMBEDDED;
7520 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7521 opts_type = OPTS_TYPE_PT_GENERATE_BE
7522 | OPTS_TYPE_PT_ADD80
7523 | OPTS_TYPE_PT_ADDBITS15;
7524 kern_type = KERN_TYPE_SHA1_SLTPW;
7525 dgst_size = DGST_SIZE_4_5;
7526 parse_func = djangosha1_parse_hash;
7527 sort_by_digest = sort_by_digest_4_5;
7528 opti_type = OPTI_TYPE_ZERO_BYTE
7529 | OPTI_TYPE_PRECOMPUTE_INIT
7530 | OPTI_TYPE_PRECOMPUTE_MERKLE
7531 | OPTI_TYPE_EARLY_SKIP
7532 | OPTI_TYPE_NOT_ITERATED
7533 | OPTI_TYPE_PREPENDED_SALT
7534 | OPTI_TYPE_RAW_HASH;
7535 dgst_pos0 = 3;
7536 dgst_pos1 = 4;
7537 dgst_pos2 = 2;
7538 dgst_pos3 = 1;
7539 break;
7540
7541 case 125: hash_type = HASH_TYPE_SHA1;
7542 salt_type = SALT_TYPE_EMBEDDED;
7543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7544 opts_type = OPTS_TYPE_PT_GENERATE_BE
7545 | OPTS_TYPE_PT_ADD80
7546 | OPTS_TYPE_PT_ADDBITS15
7547 | OPTS_TYPE_ST_HEX;
7548 kern_type = KERN_TYPE_SHA1_SLTPW;
7549 dgst_size = DGST_SIZE_4_5;
7550 parse_func = arubaos_parse_hash;
7551 sort_by_digest = sort_by_digest_4_5;
7552 opti_type = OPTI_TYPE_ZERO_BYTE
7553 | OPTI_TYPE_PRECOMPUTE_INIT
7554 | OPTI_TYPE_PRECOMPUTE_MERKLE
7555 | OPTI_TYPE_EARLY_SKIP
7556 | OPTI_TYPE_NOT_ITERATED
7557 | OPTI_TYPE_PREPENDED_SALT
7558 | OPTI_TYPE_RAW_HASH;
7559 dgst_pos0 = 3;
7560 dgst_pos1 = 4;
7561 dgst_pos2 = 2;
7562 dgst_pos3 = 1;
7563 break;
7564
7565 case 130: hash_type = HASH_TYPE_SHA1;
7566 salt_type = SALT_TYPE_INTERN;
7567 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7568 opts_type = OPTS_TYPE_PT_GENERATE_BE
7569 | OPTS_TYPE_PT_UNICODE
7570 | OPTS_TYPE_ST_ADD80
7571 | OPTS_TYPE_ST_ADDBITS15;
7572 kern_type = KERN_TYPE_SHA1_PWUSLT;
7573 dgst_size = DGST_SIZE_4_5;
7574 parse_func = sha1s_parse_hash;
7575 sort_by_digest = sort_by_digest_4_5;
7576 opti_type = OPTI_TYPE_ZERO_BYTE
7577 | OPTI_TYPE_PRECOMPUTE_INIT
7578 | OPTI_TYPE_PRECOMPUTE_MERKLE
7579 | OPTI_TYPE_EARLY_SKIP
7580 | OPTI_TYPE_NOT_ITERATED
7581 | OPTI_TYPE_APPENDED_SALT
7582 | OPTI_TYPE_RAW_HASH;
7583 dgst_pos0 = 3;
7584 dgst_pos1 = 4;
7585 dgst_pos2 = 2;
7586 dgst_pos3 = 1;
7587 break;
7588
7589 case 131: hash_type = HASH_TYPE_SHA1;
7590 salt_type = SALT_TYPE_EMBEDDED;
7591 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7592 opts_type = OPTS_TYPE_PT_GENERATE_BE
7593 | OPTS_TYPE_PT_UNICODE
7594 | OPTS_TYPE_PT_UPPER
7595 | OPTS_TYPE_ST_ADD80
7596 | OPTS_TYPE_ST_ADDBITS15
7597 | OPTS_TYPE_ST_HEX;
7598 kern_type = KERN_TYPE_SHA1_PWUSLT;
7599 dgst_size = DGST_SIZE_4_5;
7600 parse_func = mssql2000_parse_hash;
7601 sort_by_digest = sort_by_digest_4_5;
7602 opti_type = OPTI_TYPE_ZERO_BYTE
7603 | OPTI_TYPE_PRECOMPUTE_INIT
7604 | OPTI_TYPE_PRECOMPUTE_MERKLE
7605 | OPTI_TYPE_EARLY_SKIP
7606 | OPTI_TYPE_NOT_ITERATED
7607 | OPTI_TYPE_APPENDED_SALT
7608 | OPTI_TYPE_RAW_HASH;
7609 dgst_pos0 = 3;
7610 dgst_pos1 = 4;
7611 dgst_pos2 = 2;
7612 dgst_pos3 = 1;
7613 break;
7614
7615 case 132: hash_type = HASH_TYPE_SHA1;
7616 salt_type = SALT_TYPE_EMBEDDED;
7617 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7618 opts_type = OPTS_TYPE_PT_GENERATE_BE
7619 | OPTS_TYPE_PT_UNICODE
7620 | OPTS_TYPE_ST_ADD80
7621 | OPTS_TYPE_ST_ADDBITS15
7622 | OPTS_TYPE_ST_HEX;
7623 kern_type = KERN_TYPE_SHA1_PWUSLT;
7624 dgst_size = DGST_SIZE_4_5;
7625 parse_func = mssql2005_parse_hash;
7626 sort_by_digest = sort_by_digest_4_5;
7627 opti_type = OPTI_TYPE_ZERO_BYTE
7628 | OPTI_TYPE_PRECOMPUTE_INIT
7629 | OPTI_TYPE_PRECOMPUTE_MERKLE
7630 | OPTI_TYPE_EARLY_SKIP
7631 | OPTI_TYPE_NOT_ITERATED
7632 | OPTI_TYPE_APPENDED_SALT
7633 | OPTI_TYPE_RAW_HASH;
7634 dgst_pos0 = 3;
7635 dgst_pos1 = 4;
7636 dgst_pos2 = 2;
7637 dgst_pos3 = 1;
7638 break;
7639
7640 case 133: hash_type = HASH_TYPE_SHA1;
7641 salt_type = SALT_TYPE_EMBEDDED;
7642 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7643 opts_type = OPTS_TYPE_PT_GENERATE_BE
7644 | OPTS_TYPE_PT_UNICODE
7645 | OPTS_TYPE_ST_ADD80
7646 | OPTS_TYPE_ST_ADDBITS15;
7647 kern_type = KERN_TYPE_SHA1_PWUSLT;
7648 dgst_size = DGST_SIZE_4_5;
7649 parse_func = peoplesoft_parse_hash;
7650 sort_by_digest = sort_by_digest_4_5;
7651 opti_type = OPTI_TYPE_ZERO_BYTE
7652 | OPTI_TYPE_PRECOMPUTE_INIT
7653 | OPTI_TYPE_PRECOMPUTE_MERKLE
7654 | OPTI_TYPE_EARLY_SKIP
7655 | OPTI_TYPE_NOT_ITERATED
7656 | OPTI_TYPE_APPENDED_SALT
7657 | OPTI_TYPE_RAW_HASH;
7658 dgst_pos0 = 3;
7659 dgst_pos1 = 4;
7660 dgst_pos2 = 2;
7661 dgst_pos3 = 1;
7662 break;
7663
7664 case 140: hash_type = HASH_TYPE_SHA1;
7665 salt_type = SALT_TYPE_INTERN;
7666 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7667 opts_type = OPTS_TYPE_PT_GENERATE_BE
7668 | OPTS_TYPE_PT_ADD80
7669 | OPTS_TYPE_PT_ADDBITS15
7670 | OPTS_TYPE_PT_UNICODE;
7671 kern_type = KERN_TYPE_SHA1_SLTPWU;
7672 dgst_size = DGST_SIZE_4_5;
7673 parse_func = sha1s_parse_hash;
7674 sort_by_digest = sort_by_digest_4_5;
7675 opti_type = OPTI_TYPE_ZERO_BYTE
7676 | OPTI_TYPE_PRECOMPUTE_INIT
7677 | OPTI_TYPE_PRECOMPUTE_MERKLE
7678 | OPTI_TYPE_EARLY_SKIP
7679 | OPTI_TYPE_NOT_ITERATED
7680 | OPTI_TYPE_PREPENDED_SALT
7681 | OPTI_TYPE_RAW_HASH;
7682 dgst_pos0 = 3;
7683 dgst_pos1 = 4;
7684 dgst_pos2 = 2;
7685 dgst_pos3 = 1;
7686 break;
7687
7688 case 141: hash_type = HASH_TYPE_SHA1;
7689 salt_type = SALT_TYPE_EMBEDDED;
7690 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7691 opts_type = OPTS_TYPE_PT_GENERATE_BE
7692 | OPTS_TYPE_PT_ADD80
7693 | OPTS_TYPE_PT_ADDBITS15
7694 | OPTS_TYPE_PT_UNICODE
7695 | OPTS_TYPE_ST_BASE64;
7696 kern_type = KERN_TYPE_SHA1_SLTPWU;
7697 dgst_size = DGST_SIZE_4_5;
7698 parse_func = episerver_parse_hash;
7699 sort_by_digest = sort_by_digest_4_5;
7700 opti_type = OPTI_TYPE_ZERO_BYTE
7701 | OPTI_TYPE_PRECOMPUTE_INIT
7702 | OPTI_TYPE_PRECOMPUTE_MERKLE
7703 | OPTI_TYPE_EARLY_SKIP
7704 | OPTI_TYPE_NOT_ITERATED
7705 | OPTI_TYPE_PREPENDED_SALT
7706 | OPTI_TYPE_RAW_HASH;
7707 dgst_pos0 = 3;
7708 dgst_pos1 = 4;
7709 dgst_pos2 = 2;
7710 dgst_pos3 = 1;
7711 break;
7712
7713 case 150: hash_type = HASH_TYPE_SHA1;
7714 salt_type = SALT_TYPE_INTERN;
7715 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7716 opts_type = OPTS_TYPE_PT_GENERATE_BE
7717 | OPTS_TYPE_ST_ADD80
7718 | OPTS_TYPE_ST_ADDBITS15;
7719 kern_type = KERN_TYPE_HMACSHA1_PW;
7720 dgst_size = DGST_SIZE_4_5;
7721 parse_func = hmacsha1_parse_hash;
7722 sort_by_digest = sort_by_digest_4_5;
7723 opti_type = OPTI_TYPE_ZERO_BYTE
7724 | OPTI_TYPE_NOT_ITERATED;
7725 dgst_pos0 = 3;
7726 dgst_pos1 = 4;
7727 dgst_pos2 = 2;
7728 dgst_pos3 = 1;
7729 break;
7730
7731 case 160: hash_type = HASH_TYPE_SHA1;
7732 salt_type = SALT_TYPE_INTERN;
7733 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7734 opts_type = OPTS_TYPE_PT_GENERATE_BE
7735 | OPTS_TYPE_PT_ADD80
7736 | OPTS_TYPE_PT_ADDBITS15;
7737 kern_type = KERN_TYPE_HMACSHA1_SLT;
7738 dgst_size = DGST_SIZE_4_5;
7739 parse_func = hmacsha1_parse_hash;
7740 sort_by_digest = sort_by_digest_4_5;
7741 opti_type = OPTI_TYPE_ZERO_BYTE
7742 | OPTI_TYPE_NOT_ITERATED;
7743 dgst_pos0 = 3;
7744 dgst_pos1 = 4;
7745 dgst_pos2 = 2;
7746 dgst_pos3 = 1;
7747 break;
7748
7749 case 190: hash_type = HASH_TYPE_SHA1;
7750 salt_type = SALT_TYPE_NONE;
7751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7752 opts_type = OPTS_TYPE_PT_GENERATE_BE
7753 | OPTS_TYPE_PT_ADD80
7754 | OPTS_TYPE_PT_ADDBITS15;
7755 kern_type = KERN_TYPE_SHA1_LINKEDIN;
7756 dgst_size = DGST_SIZE_4_5;
7757 parse_func = sha1linkedin_parse_hash;
7758 sort_by_digest = sort_by_digest_4_5;
7759 opti_type = OPTI_TYPE_ZERO_BYTE
7760 | OPTI_TYPE_PRECOMPUTE_INIT
7761 | OPTI_TYPE_EARLY_SKIP
7762 | OPTI_TYPE_NOT_ITERATED
7763 | OPTI_TYPE_NOT_SALTED;
7764 dgst_pos0 = 0;
7765 dgst_pos1 = 4;
7766 dgst_pos2 = 3;
7767 dgst_pos3 = 2;
7768 break;
7769
7770 case 200: hash_type = HASH_TYPE_MYSQL;
7771 salt_type = SALT_TYPE_NONE;
7772 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7773 opts_type = 0;
7774 kern_type = KERN_TYPE_MYSQL;
7775 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
7776 parse_func = mysql323_parse_hash;
7777 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
7778 opti_type = OPTI_TYPE_ZERO_BYTE;
7779 dgst_pos0 = 0;
7780 dgst_pos1 = 1;
7781 dgst_pos2 = 2;
7782 dgst_pos3 = 3;
7783 break;
7784
7785 case 300: hash_type = HASH_TYPE_SHA1;
7786 salt_type = SALT_TYPE_NONE;
7787 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7788 opts_type = OPTS_TYPE_PT_GENERATE_BE
7789 | OPTS_TYPE_PT_ADD80
7790 | OPTS_TYPE_PT_ADDBITS15;
7791 kern_type = KERN_TYPE_MYSQL41;
7792 dgst_size = DGST_SIZE_4_5;
7793 parse_func = sha1_parse_hash;
7794 sort_by_digest = sort_by_digest_4_5;
7795 opti_type = OPTI_TYPE_ZERO_BYTE
7796 | OPTI_TYPE_PRECOMPUTE_INIT
7797 | OPTI_TYPE_PRECOMPUTE_MERKLE
7798 | OPTI_TYPE_EARLY_SKIP
7799 | OPTI_TYPE_NOT_ITERATED
7800 | OPTI_TYPE_NOT_SALTED;
7801 dgst_pos0 = 3;
7802 dgst_pos1 = 4;
7803 dgst_pos2 = 2;
7804 dgst_pos3 = 1;
7805 break;
7806
7807 case 400: hash_type = HASH_TYPE_MD5;
7808 salt_type = SALT_TYPE_EMBEDDED;
7809 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7810 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7811 kern_type = KERN_TYPE_PHPASS;
7812 dgst_size = DGST_SIZE_4_4;
7813 parse_func = phpass_parse_hash;
7814 sort_by_digest = sort_by_digest_4_4;
7815 opti_type = OPTI_TYPE_ZERO_BYTE
7816 | OPTI_TYPE_SLOW_HASH_SIMD;
7817 dgst_pos0 = 0;
7818 dgst_pos1 = 1;
7819 dgst_pos2 = 2;
7820 dgst_pos3 = 3;
7821 break;
7822
7823 case 500: hash_type = HASH_TYPE_MD5;
7824 salt_type = SALT_TYPE_EMBEDDED;
7825 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7826 opts_type = OPTS_TYPE_PT_GENERATE_LE;
7827 kern_type = KERN_TYPE_MD5CRYPT;
7828 dgst_size = DGST_SIZE_4_4;
7829 parse_func = md5crypt_parse_hash;
7830 sort_by_digest = sort_by_digest_4_4;
7831 opti_type = OPTI_TYPE_ZERO_BYTE;
7832 dgst_pos0 = 0;
7833 dgst_pos1 = 1;
7834 dgst_pos2 = 2;
7835 dgst_pos3 = 3;
7836 break;
7837
7838 case 501: hash_type = HASH_TYPE_MD5;
7839 salt_type = SALT_TYPE_EMBEDDED;
7840 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
7841 opts_type = OPTS_TYPE_PT_GENERATE_LE
7842 | OPTS_TYPE_HASH_COPY;
7843 kern_type = KERN_TYPE_MD5CRYPT;
7844 dgst_size = DGST_SIZE_4_4;
7845 parse_func = juniper_parse_hash;
7846 sort_by_digest = sort_by_digest_4_4;
7847 opti_type = OPTI_TYPE_ZERO_BYTE;
7848 dgst_pos0 = 0;
7849 dgst_pos1 = 1;
7850 dgst_pos2 = 2;
7851 dgst_pos3 = 3;
7852 break;
7853
7854 case 900: hash_type = HASH_TYPE_MD4;
7855 salt_type = SALT_TYPE_NONE;
7856 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7857 opts_type = OPTS_TYPE_PT_GENERATE_LE
7858 | OPTS_TYPE_PT_ADD80
7859 | OPTS_TYPE_PT_ADDBITS14;
7860 kern_type = KERN_TYPE_MD4;
7861 dgst_size = DGST_SIZE_4_4;
7862 parse_func = md4_parse_hash;
7863 sort_by_digest = sort_by_digest_4_4;
7864 opti_type = OPTI_TYPE_ZERO_BYTE
7865 | OPTI_TYPE_PRECOMPUTE_INIT
7866 | OPTI_TYPE_PRECOMPUTE_MERKLE
7867 | OPTI_TYPE_MEET_IN_MIDDLE
7868 | OPTI_TYPE_EARLY_SKIP
7869 | OPTI_TYPE_NOT_ITERATED
7870 | OPTI_TYPE_NOT_SALTED
7871 | OPTI_TYPE_RAW_HASH;
7872 dgst_pos0 = 0;
7873 dgst_pos1 = 3;
7874 dgst_pos2 = 2;
7875 dgst_pos3 = 1;
7876 break;
7877
7878 case 1000: hash_type = HASH_TYPE_MD4;
7879 salt_type = SALT_TYPE_NONE;
7880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7881 opts_type = OPTS_TYPE_PT_GENERATE_LE
7882 | OPTS_TYPE_PT_ADD80
7883 | OPTS_TYPE_PT_ADDBITS14
7884 | OPTS_TYPE_PT_UNICODE;
7885 kern_type = KERN_TYPE_MD4_PWU;
7886 dgst_size = DGST_SIZE_4_4;
7887 parse_func = md4_parse_hash;
7888 sort_by_digest = sort_by_digest_4_4;
7889 opti_type = OPTI_TYPE_ZERO_BYTE
7890 | OPTI_TYPE_PRECOMPUTE_INIT
7891 | OPTI_TYPE_PRECOMPUTE_MERKLE
7892 | OPTI_TYPE_MEET_IN_MIDDLE
7893 | OPTI_TYPE_EARLY_SKIP
7894 | OPTI_TYPE_NOT_ITERATED
7895 | OPTI_TYPE_NOT_SALTED
7896 | OPTI_TYPE_RAW_HASH;
7897 dgst_pos0 = 0;
7898 dgst_pos1 = 3;
7899 dgst_pos2 = 2;
7900 dgst_pos3 = 1;
7901 break;
7902
7903 case 1100: hash_type = HASH_TYPE_MD4;
7904 salt_type = SALT_TYPE_INTERN;
7905 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7906 opts_type = OPTS_TYPE_PT_GENERATE_LE
7907 | OPTS_TYPE_PT_ADD80
7908 | OPTS_TYPE_PT_ADDBITS14
7909 | OPTS_TYPE_PT_UNICODE
7910 | OPTS_TYPE_ST_ADD80
7911 | OPTS_TYPE_ST_UNICODE
7912 | OPTS_TYPE_ST_LOWER;
7913 kern_type = KERN_TYPE_MD44_PWUSLT;
7914 dgst_size = DGST_SIZE_4_4;
7915 parse_func = dcc_parse_hash;
7916 sort_by_digest = sort_by_digest_4_4;
7917 opti_type = OPTI_TYPE_ZERO_BYTE
7918 | OPTI_TYPE_PRECOMPUTE_INIT
7919 | OPTI_TYPE_PRECOMPUTE_MERKLE
7920 | OPTI_TYPE_EARLY_SKIP
7921 | OPTI_TYPE_NOT_ITERATED;
7922 dgst_pos0 = 0;
7923 dgst_pos1 = 3;
7924 dgst_pos2 = 2;
7925 dgst_pos3 = 1;
7926 break;
7927
7928 case 1400: hash_type = HASH_TYPE_SHA256;
7929 salt_type = SALT_TYPE_NONE;
7930 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7931 opts_type = OPTS_TYPE_PT_GENERATE_BE
7932 | OPTS_TYPE_PT_ADD80
7933 | OPTS_TYPE_PT_ADDBITS15;
7934 kern_type = KERN_TYPE_SHA256;
7935 dgst_size = DGST_SIZE_4_8;
7936 parse_func = sha256_parse_hash;
7937 sort_by_digest = sort_by_digest_4_8;
7938 opti_type = OPTI_TYPE_ZERO_BYTE
7939 | OPTI_TYPE_PRECOMPUTE_INIT
7940 | OPTI_TYPE_PRECOMPUTE_MERKLE
7941 | OPTI_TYPE_EARLY_SKIP
7942 | OPTI_TYPE_NOT_ITERATED
7943 | OPTI_TYPE_NOT_SALTED
7944 | OPTI_TYPE_RAW_HASH;
7945 dgst_pos0 = 3;
7946 dgst_pos1 = 7;
7947 dgst_pos2 = 2;
7948 dgst_pos3 = 6;
7949 break;
7950
7951 case 1410: hash_type = HASH_TYPE_SHA256;
7952 salt_type = SALT_TYPE_INTERN;
7953 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7954 opts_type = OPTS_TYPE_PT_GENERATE_BE
7955 | OPTS_TYPE_ST_ADD80
7956 | OPTS_TYPE_ST_ADDBITS15;
7957 kern_type = KERN_TYPE_SHA256_PWSLT;
7958 dgst_size = DGST_SIZE_4_8;
7959 parse_func = sha256s_parse_hash;
7960 sort_by_digest = sort_by_digest_4_8;
7961 opti_type = OPTI_TYPE_ZERO_BYTE
7962 | OPTI_TYPE_PRECOMPUTE_INIT
7963 | OPTI_TYPE_PRECOMPUTE_MERKLE
7964 | OPTI_TYPE_EARLY_SKIP
7965 | OPTI_TYPE_NOT_ITERATED
7966 | OPTI_TYPE_APPENDED_SALT
7967 | OPTI_TYPE_RAW_HASH;
7968 dgst_pos0 = 3;
7969 dgst_pos1 = 7;
7970 dgst_pos2 = 2;
7971 dgst_pos3 = 6;
7972 break;
7973
7974 case 1420: hash_type = HASH_TYPE_SHA256;
7975 salt_type = SALT_TYPE_INTERN;
7976 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
7977 opts_type = OPTS_TYPE_PT_GENERATE_BE
7978 | OPTS_TYPE_PT_ADD80
7979 | OPTS_TYPE_PT_ADDBITS15;
7980 kern_type = KERN_TYPE_SHA256_SLTPW;
7981 dgst_size = DGST_SIZE_4_8;
7982 parse_func = sha256s_parse_hash;
7983 sort_by_digest = sort_by_digest_4_8;
7984 opti_type = OPTI_TYPE_ZERO_BYTE
7985 | OPTI_TYPE_PRECOMPUTE_INIT
7986 | OPTI_TYPE_PRECOMPUTE_MERKLE
7987 | OPTI_TYPE_EARLY_SKIP
7988 | OPTI_TYPE_NOT_ITERATED
7989 | OPTI_TYPE_PREPENDED_SALT
7990 | OPTI_TYPE_RAW_HASH;
7991 dgst_pos0 = 3;
7992 dgst_pos1 = 7;
7993 dgst_pos2 = 2;
7994 dgst_pos3 = 6;
7995 break;
7996
7997 case 1421: hash_type = HASH_TYPE_SHA256;
7998 salt_type = SALT_TYPE_EMBEDDED;
7999 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8000 opts_type = OPTS_TYPE_PT_GENERATE_BE
8001 | OPTS_TYPE_PT_ADD80
8002 | OPTS_TYPE_PT_ADDBITS15;
8003 kern_type = KERN_TYPE_SHA256_SLTPW;
8004 dgst_size = DGST_SIZE_4_8;
8005 parse_func = hmailserver_parse_hash;
8006 sort_by_digest = sort_by_digest_4_8;
8007 opti_type = OPTI_TYPE_ZERO_BYTE
8008 | OPTI_TYPE_PRECOMPUTE_INIT
8009 | OPTI_TYPE_PRECOMPUTE_MERKLE
8010 | OPTI_TYPE_EARLY_SKIP
8011 | OPTI_TYPE_NOT_ITERATED
8012 | OPTI_TYPE_PREPENDED_SALT
8013 | OPTI_TYPE_RAW_HASH;
8014 dgst_pos0 = 3;
8015 dgst_pos1 = 7;
8016 dgst_pos2 = 2;
8017 dgst_pos3 = 6;
8018 break;
8019
8020 case 1430: hash_type = HASH_TYPE_SHA256;
8021 salt_type = SALT_TYPE_INTERN;
8022 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8023 opts_type = OPTS_TYPE_PT_GENERATE_BE
8024 | OPTS_TYPE_PT_UNICODE
8025 | OPTS_TYPE_ST_ADD80
8026 | OPTS_TYPE_ST_ADDBITS15;
8027 kern_type = KERN_TYPE_SHA256_PWUSLT;
8028 dgst_size = DGST_SIZE_4_8;
8029 parse_func = sha256s_parse_hash;
8030 sort_by_digest = sort_by_digest_4_8;
8031 opti_type = OPTI_TYPE_ZERO_BYTE
8032 | OPTI_TYPE_PRECOMPUTE_INIT
8033 | OPTI_TYPE_PRECOMPUTE_MERKLE
8034 | OPTI_TYPE_EARLY_SKIP
8035 | OPTI_TYPE_NOT_ITERATED
8036 | OPTI_TYPE_APPENDED_SALT
8037 | OPTI_TYPE_RAW_HASH;
8038 dgst_pos0 = 3;
8039 dgst_pos1 = 7;
8040 dgst_pos2 = 2;
8041 dgst_pos3 = 6;
8042 break;
8043
8044 case 1440: hash_type = HASH_TYPE_SHA256;
8045 salt_type = SALT_TYPE_INTERN;
8046 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8047 opts_type = OPTS_TYPE_PT_GENERATE_BE
8048 | OPTS_TYPE_PT_ADD80
8049 | OPTS_TYPE_PT_ADDBITS15
8050 | OPTS_TYPE_PT_UNICODE;
8051 kern_type = KERN_TYPE_SHA256_SLTPWU;
8052 dgst_size = DGST_SIZE_4_8;
8053 parse_func = sha256s_parse_hash;
8054 sort_by_digest = sort_by_digest_4_8;
8055 opti_type = OPTI_TYPE_ZERO_BYTE
8056 | OPTI_TYPE_PRECOMPUTE_INIT
8057 | OPTI_TYPE_PRECOMPUTE_MERKLE
8058 | OPTI_TYPE_EARLY_SKIP
8059 | OPTI_TYPE_NOT_ITERATED
8060 | OPTI_TYPE_PREPENDED_SALT
8061 | OPTI_TYPE_RAW_HASH;
8062 dgst_pos0 = 3;
8063 dgst_pos1 = 7;
8064 dgst_pos2 = 2;
8065 dgst_pos3 = 6;
8066 break;
8067
8068 case 1441: hash_type = HASH_TYPE_SHA256;
8069 salt_type = SALT_TYPE_EMBEDDED;
8070 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8071 opts_type = OPTS_TYPE_PT_GENERATE_BE
8072 | OPTS_TYPE_PT_ADD80
8073 | OPTS_TYPE_PT_ADDBITS15
8074 | OPTS_TYPE_PT_UNICODE
8075 | OPTS_TYPE_ST_BASE64;
8076 kern_type = KERN_TYPE_SHA256_SLTPWU;
8077 dgst_size = DGST_SIZE_4_8;
8078 parse_func = episerver4_parse_hash;
8079 sort_by_digest = sort_by_digest_4_8;
8080 opti_type = OPTI_TYPE_ZERO_BYTE
8081 | OPTI_TYPE_PRECOMPUTE_INIT
8082 | OPTI_TYPE_PRECOMPUTE_MERKLE
8083 | OPTI_TYPE_EARLY_SKIP
8084 | OPTI_TYPE_NOT_ITERATED
8085 | OPTI_TYPE_PREPENDED_SALT
8086 | OPTI_TYPE_RAW_HASH;
8087 dgst_pos0 = 3;
8088 dgst_pos1 = 7;
8089 dgst_pos2 = 2;
8090 dgst_pos3 = 6;
8091 break;
8092
8093 case 1450: hash_type = HASH_TYPE_SHA256;
8094 salt_type = SALT_TYPE_INTERN;
8095 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8096 opts_type = OPTS_TYPE_PT_GENERATE_BE
8097 | OPTS_TYPE_ST_ADD80;
8098 kern_type = KERN_TYPE_HMACSHA256_PW;
8099 dgst_size = DGST_SIZE_4_8;
8100 parse_func = hmacsha256_parse_hash;
8101 sort_by_digest = sort_by_digest_4_8;
8102 opti_type = OPTI_TYPE_ZERO_BYTE
8103 | OPTI_TYPE_NOT_ITERATED;
8104 dgst_pos0 = 3;
8105 dgst_pos1 = 7;
8106 dgst_pos2 = 2;
8107 dgst_pos3 = 6;
8108 break;
8109
8110 case 1460: hash_type = HASH_TYPE_SHA256;
8111 salt_type = SALT_TYPE_INTERN;
8112 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8113 opts_type = OPTS_TYPE_PT_GENERATE_BE
8114 | OPTS_TYPE_PT_ADD80
8115 | OPTS_TYPE_PT_ADDBITS15;
8116 kern_type = KERN_TYPE_HMACSHA256_SLT;
8117 dgst_size = DGST_SIZE_4_8;
8118 parse_func = hmacsha256_parse_hash;
8119 sort_by_digest = sort_by_digest_4_8;
8120 opti_type = OPTI_TYPE_ZERO_BYTE
8121 | OPTI_TYPE_NOT_ITERATED;
8122 dgst_pos0 = 3;
8123 dgst_pos1 = 7;
8124 dgst_pos2 = 2;
8125 dgst_pos3 = 6;
8126 break;
8127
8128 case 1500: hash_type = HASH_TYPE_DESCRYPT;
8129 salt_type = SALT_TYPE_EMBEDDED;
8130 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8131 opts_type = OPTS_TYPE_PT_GENERATE_LE
8132 | OPTS_TYPE_PT_BITSLICE;
8133 kern_type = KERN_TYPE_DESCRYPT;
8134 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8135 parse_func = descrypt_parse_hash;
8136 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8137 opti_type = OPTI_TYPE_ZERO_BYTE
8138 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8139 dgst_pos0 = 0;
8140 dgst_pos1 = 1;
8141 dgst_pos2 = 2;
8142 dgst_pos3 = 3;
8143 break;
8144
8145 case 1600: hash_type = HASH_TYPE_MD5;
8146 salt_type = SALT_TYPE_EMBEDDED;
8147 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8148 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8149 kern_type = KERN_TYPE_APR1CRYPT;
8150 dgst_size = DGST_SIZE_4_4;
8151 parse_func = md5apr1_parse_hash;
8152 sort_by_digest = sort_by_digest_4_4;
8153 opti_type = OPTI_TYPE_ZERO_BYTE;
8154 dgst_pos0 = 0;
8155 dgst_pos1 = 1;
8156 dgst_pos2 = 2;
8157 dgst_pos3 = 3;
8158 break;
8159
8160 case 1700: hash_type = HASH_TYPE_SHA512;
8161 salt_type = SALT_TYPE_NONE;
8162 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8163 opts_type = OPTS_TYPE_PT_GENERATE_BE
8164 | OPTS_TYPE_PT_ADD80
8165 | OPTS_TYPE_PT_ADDBITS15;
8166 kern_type = KERN_TYPE_SHA512;
8167 dgst_size = DGST_SIZE_8_8;
8168 parse_func = sha512_parse_hash;
8169 sort_by_digest = sort_by_digest_8_8;
8170 opti_type = OPTI_TYPE_ZERO_BYTE
8171 | OPTI_TYPE_PRECOMPUTE_INIT
8172 | OPTI_TYPE_PRECOMPUTE_MERKLE
8173 | OPTI_TYPE_EARLY_SKIP
8174 | OPTI_TYPE_NOT_ITERATED
8175 | OPTI_TYPE_NOT_SALTED
8176 | OPTI_TYPE_USES_BITS_64
8177 | OPTI_TYPE_RAW_HASH;
8178 dgst_pos0 = 14;
8179 dgst_pos1 = 15;
8180 dgst_pos2 = 6;
8181 dgst_pos3 = 7;
8182 break;
8183
8184 case 1710: hash_type = HASH_TYPE_SHA512;
8185 salt_type = SALT_TYPE_INTERN;
8186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8187 opts_type = OPTS_TYPE_PT_GENERATE_BE
8188 | OPTS_TYPE_ST_ADD80
8189 | OPTS_TYPE_ST_ADDBITS15;
8190 kern_type = KERN_TYPE_SHA512_PWSLT;
8191 dgst_size = DGST_SIZE_8_8;
8192 parse_func = sha512s_parse_hash;
8193 sort_by_digest = sort_by_digest_8_8;
8194 opti_type = OPTI_TYPE_ZERO_BYTE
8195 | OPTI_TYPE_PRECOMPUTE_INIT
8196 | OPTI_TYPE_PRECOMPUTE_MERKLE
8197 | OPTI_TYPE_EARLY_SKIP
8198 | OPTI_TYPE_NOT_ITERATED
8199 | OPTI_TYPE_APPENDED_SALT
8200 | OPTI_TYPE_USES_BITS_64
8201 | OPTI_TYPE_RAW_HASH;
8202 dgst_pos0 = 14;
8203 dgst_pos1 = 15;
8204 dgst_pos2 = 6;
8205 dgst_pos3 = 7;
8206 break;
8207
8208 case 1711: hash_type = HASH_TYPE_SHA512;
8209 salt_type = SALT_TYPE_EMBEDDED;
8210 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8211 opts_type = OPTS_TYPE_PT_GENERATE_BE
8212 | OPTS_TYPE_ST_ADD80
8213 | OPTS_TYPE_ST_ADDBITS15;
8214 kern_type = KERN_TYPE_SHA512_PWSLT;
8215 dgst_size = DGST_SIZE_8_8;
8216 parse_func = sha512b64s_parse_hash;
8217 sort_by_digest = sort_by_digest_8_8;
8218 opti_type = OPTI_TYPE_ZERO_BYTE
8219 | OPTI_TYPE_PRECOMPUTE_INIT
8220 | OPTI_TYPE_PRECOMPUTE_MERKLE
8221 | OPTI_TYPE_EARLY_SKIP
8222 | OPTI_TYPE_NOT_ITERATED
8223 | OPTI_TYPE_APPENDED_SALT
8224 | OPTI_TYPE_USES_BITS_64
8225 | OPTI_TYPE_RAW_HASH;
8226 dgst_pos0 = 14;
8227 dgst_pos1 = 15;
8228 dgst_pos2 = 6;
8229 dgst_pos3 = 7;
8230 break;
8231
8232 case 1720: hash_type = HASH_TYPE_SHA512;
8233 salt_type = SALT_TYPE_INTERN;
8234 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8235 opts_type = OPTS_TYPE_PT_GENERATE_BE
8236 | OPTS_TYPE_PT_ADD80
8237 | OPTS_TYPE_PT_ADDBITS15;
8238 kern_type = KERN_TYPE_SHA512_SLTPW;
8239 dgst_size = DGST_SIZE_8_8;
8240 parse_func = sha512s_parse_hash;
8241 sort_by_digest = sort_by_digest_8_8;
8242 opti_type = OPTI_TYPE_ZERO_BYTE
8243 | OPTI_TYPE_PRECOMPUTE_INIT
8244 | OPTI_TYPE_PRECOMPUTE_MERKLE
8245 | OPTI_TYPE_EARLY_SKIP
8246 | OPTI_TYPE_NOT_ITERATED
8247 | OPTI_TYPE_PREPENDED_SALT
8248 | OPTI_TYPE_USES_BITS_64
8249 | OPTI_TYPE_RAW_HASH;
8250 dgst_pos0 = 14;
8251 dgst_pos1 = 15;
8252 dgst_pos2 = 6;
8253 dgst_pos3 = 7;
8254 break;
8255
8256 case 1722: hash_type = HASH_TYPE_SHA512;
8257 salt_type = SALT_TYPE_EMBEDDED;
8258 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8259 opts_type = OPTS_TYPE_PT_GENERATE_BE
8260 | OPTS_TYPE_PT_ADD80
8261 | OPTS_TYPE_PT_ADDBITS15
8262 | OPTS_TYPE_ST_HEX;
8263 kern_type = KERN_TYPE_SHA512_SLTPW;
8264 dgst_size = DGST_SIZE_8_8;
8265 parse_func = osx512_parse_hash;
8266 sort_by_digest = sort_by_digest_8_8;
8267 opti_type = OPTI_TYPE_ZERO_BYTE
8268 | OPTI_TYPE_PRECOMPUTE_INIT
8269 | OPTI_TYPE_PRECOMPUTE_MERKLE
8270 | OPTI_TYPE_EARLY_SKIP
8271 | OPTI_TYPE_NOT_ITERATED
8272 | OPTI_TYPE_PREPENDED_SALT
8273 | OPTI_TYPE_USES_BITS_64
8274 | OPTI_TYPE_RAW_HASH;
8275 dgst_pos0 = 14;
8276 dgst_pos1 = 15;
8277 dgst_pos2 = 6;
8278 dgst_pos3 = 7;
8279 break;
8280
8281 case 1730: hash_type = HASH_TYPE_SHA512;
8282 salt_type = SALT_TYPE_INTERN;
8283 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8284 opts_type = OPTS_TYPE_PT_GENERATE_BE
8285 | OPTS_TYPE_PT_UNICODE
8286 | OPTS_TYPE_ST_ADD80
8287 | OPTS_TYPE_ST_ADDBITS15;
8288 kern_type = KERN_TYPE_SHA512_PWSLTU;
8289 dgst_size = DGST_SIZE_8_8;
8290 parse_func = sha512s_parse_hash;
8291 sort_by_digest = sort_by_digest_8_8;
8292 opti_type = OPTI_TYPE_ZERO_BYTE
8293 | OPTI_TYPE_PRECOMPUTE_INIT
8294 | OPTI_TYPE_PRECOMPUTE_MERKLE
8295 | OPTI_TYPE_EARLY_SKIP
8296 | OPTI_TYPE_NOT_ITERATED
8297 | OPTI_TYPE_APPENDED_SALT
8298 | OPTI_TYPE_USES_BITS_64
8299 | OPTI_TYPE_RAW_HASH;
8300 dgst_pos0 = 14;
8301 dgst_pos1 = 15;
8302 dgst_pos2 = 6;
8303 dgst_pos3 = 7;
8304 break;
8305
8306 case 1731: hash_type = HASH_TYPE_SHA512;
8307 salt_type = SALT_TYPE_EMBEDDED;
8308 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8309 opts_type = OPTS_TYPE_PT_GENERATE_BE
8310 | OPTS_TYPE_PT_UNICODE
8311 | OPTS_TYPE_ST_ADD80
8312 | OPTS_TYPE_ST_ADDBITS15
8313 | OPTS_TYPE_ST_HEX;
8314 kern_type = KERN_TYPE_SHA512_PWSLTU;
8315 dgst_size = DGST_SIZE_8_8;
8316 parse_func = mssql2012_parse_hash;
8317 sort_by_digest = sort_by_digest_8_8;
8318 opti_type = OPTI_TYPE_ZERO_BYTE
8319 | OPTI_TYPE_PRECOMPUTE_INIT
8320 | OPTI_TYPE_PRECOMPUTE_MERKLE
8321 | OPTI_TYPE_EARLY_SKIP
8322 | OPTI_TYPE_NOT_ITERATED
8323 | OPTI_TYPE_APPENDED_SALT
8324 | OPTI_TYPE_USES_BITS_64
8325 | OPTI_TYPE_RAW_HASH;
8326 dgst_pos0 = 14;
8327 dgst_pos1 = 15;
8328 dgst_pos2 = 6;
8329 dgst_pos3 = 7;
8330 break;
8331
8332 case 1740: hash_type = HASH_TYPE_SHA512;
8333 salt_type = SALT_TYPE_INTERN;
8334 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8335 opts_type = OPTS_TYPE_PT_GENERATE_BE
8336 | OPTS_TYPE_PT_ADD80
8337 | OPTS_TYPE_PT_ADDBITS15
8338 | OPTS_TYPE_PT_UNICODE;
8339 kern_type = KERN_TYPE_SHA512_SLTPWU;
8340 dgst_size = DGST_SIZE_8_8;
8341 parse_func = sha512s_parse_hash;
8342 sort_by_digest = sort_by_digest_8_8;
8343 opti_type = OPTI_TYPE_ZERO_BYTE
8344 | OPTI_TYPE_PRECOMPUTE_INIT
8345 | OPTI_TYPE_PRECOMPUTE_MERKLE
8346 | OPTI_TYPE_EARLY_SKIP
8347 | OPTI_TYPE_NOT_ITERATED
8348 | OPTI_TYPE_PREPENDED_SALT
8349 | OPTI_TYPE_USES_BITS_64
8350 | OPTI_TYPE_RAW_HASH;
8351 dgst_pos0 = 14;
8352 dgst_pos1 = 15;
8353 dgst_pos2 = 6;
8354 dgst_pos3 = 7;
8355 break;
8356
8357 case 1750: hash_type = HASH_TYPE_SHA512;
8358 salt_type = SALT_TYPE_INTERN;
8359 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8360 opts_type = OPTS_TYPE_PT_GENERATE_BE
8361 | OPTS_TYPE_ST_ADD80;
8362 kern_type = KERN_TYPE_HMACSHA512_PW;
8363 dgst_size = DGST_SIZE_8_8;
8364 parse_func = hmacsha512_parse_hash;
8365 sort_by_digest = sort_by_digest_8_8;
8366 opti_type = OPTI_TYPE_ZERO_BYTE
8367 | OPTI_TYPE_USES_BITS_64
8368 | OPTI_TYPE_NOT_ITERATED;
8369 dgst_pos0 = 14;
8370 dgst_pos1 = 15;
8371 dgst_pos2 = 6;
8372 dgst_pos3 = 7;
8373 break;
8374
8375 case 1760: hash_type = HASH_TYPE_SHA512;
8376 salt_type = SALT_TYPE_INTERN;
8377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8378 opts_type = OPTS_TYPE_PT_GENERATE_BE
8379 | OPTS_TYPE_PT_ADD80
8380 | OPTS_TYPE_PT_ADDBITS15;
8381 kern_type = KERN_TYPE_HMACSHA512_SLT;
8382 dgst_size = DGST_SIZE_8_8;
8383 parse_func = hmacsha512_parse_hash;
8384 sort_by_digest = sort_by_digest_8_8;
8385 opti_type = OPTI_TYPE_ZERO_BYTE
8386 | OPTI_TYPE_USES_BITS_64
8387 | OPTI_TYPE_NOT_ITERATED;
8388 dgst_pos0 = 14;
8389 dgst_pos1 = 15;
8390 dgst_pos2 = 6;
8391 dgst_pos3 = 7;
8392 break;
8393
8394 case 1800: hash_type = HASH_TYPE_SHA512;
8395 salt_type = SALT_TYPE_EMBEDDED;
8396 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8397 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8398 kern_type = KERN_TYPE_SHA512CRYPT;
8399 dgst_size = DGST_SIZE_8_8;
8400 parse_func = sha512crypt_parse_hash;
8401 sort_by_digest = sort_by_digest_8_8;
8402 opti_type = OPTI_TYPE_ZERO_BYTE
8403 | OPTI_TYPE_USES_BITS_64;
8404 dgst_pos0 = 0;
8405 dgst_pos1 = 1;
8406 dgst_pos2 = 2;
8407 dgst_pos3 = 3;
8408 break;
8409
8410 case 2100: hash_type = HASH_TYPE_DCC2;
8411 salt_type = SALT_TYPE_EMBEDDED;
8412 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8413 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8414 | OPTS_TYPE_ST_LOWER
8415 | OPTS_TYPE_ST_UNICODE;
8416 kern_type = KERN_TYPE_DCC2;
8417 dgst_size = DGST_SIZE_4_4;
8418 parse_func = dcc2_parse_hash;
8419 sort_by_digest = sort_by_digest_4_4;
8420 opti_type = OPTI_TYPE_ZERO_BYTE
8421 | OPTI_TYPE_SLOW_HASH_SIMD;
8422 dgst_pos0 = 0;
8423 dgst_pos1 = 1;
8424 dgst_pos2 = 2;
8425 dgst_pos3 = 3;
8426 break;
8427
8428 case 2400: hash_type = HASH_TYPE_MD5;
8429 salt_type = SALT_TYPE_NONE;
8430 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8431 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8432 kern_type = KERN_TYPE_MD5PIX;
8433 dgst_size = DGST_SIZE_4_4;
8434 parse_func = md5pix_parse_hash;
8435 sort_by_digest = sort_by_digest_4_4;
8436 opti_type = OPTI_TYPE_ZERO_BYTE
8437 | OPTI_TYPE_PRECOMPUTE_INIT
8438 | OPTI_TYPE_PRECOMPUTE_MERKLE
8439 | OPTI_TYPE_EARLY_SKIP
8440 | OPTI_TYPE_NOT_ITERATED
8441 | OPTI_TYPE_NOT_SALTED;
8442 dgst_pos0 = 0;
8443 dgst_pos1 = 3;
8444 dgst_pos2 = 2;
8445 dgst_pos3 = 1;
8446 break;
8447
8448 case 2410: hash_type = HASH_TYPE_MD5;
8449 salt_type = SALT_TYPE_INTERN;
8450 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8451 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8452 kern_type = KERN_TYPE_MD5ASA;
8453 dgst_size = DGST_SIZE_4_4;
8454 parse_func = md5asa_parse_hash;
8455 sort_by_digest = sort_by_digest_4_4;
8456 opti_type = OPTI_TYPE_ZERO_BYTE
8457 | OPTI_TYPE_PRECOMPUTE_INIT
8458 | OPTI_TYPE_PRECOMPUTE_MERKLE
8459 | OPTI_TYPE_EARLY_SKIP
8460 | OPTI_TYPE_NOT_ITERATED;
8461 dgst_pos0 = 0;
8462 dgst_pos1 = 3;
8463 dgst_pos2 = 2;
8464 dgst_pos3 = 1;
8465 break;
8466
8467 case 2500: hash_type = HASH_TYPE_WPA;
8468 salt_type = SALT_TYPE_EMBEDDED;
8469 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8470 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8471 kern_type = KERN_TYPE_WPA;
8472 dgst_size = DGST_SIZE_4_4;
8473 parse_func = wpa_parse_hash;
8474 sort_by_digest = sort_by_digest_4_4;
8475 opti_type = OPTI_TYPE_ZERO_BYTE
8476 | OPTI_TYPE_SLOW_HASH_SIMD;
8477 dgst_pos0 = 0;
8478 dgst_pos1 = 1;
8479 dgst_pos2 = 2;
8480 dgst_pos3 = 3;
8481 break;
8482
8483 case 2600: hash_type = HASH_TYPE_MD5;
8484 salt_type = SALT_TYPE_VIRTUAL;
8485 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8486 opts_type = OPTS_TYPE_PT_GENERATE_LE
8487 | OPTS_TYPE_PT_ADD80
8488 | OPTS_TYPE_PT_ADDBITS14
8489 | OPTS_TYPE_ST_ADD80;
8490 kern_type = KERN_TYPE_MD55_PWSLT1;
8491 dgst_size = DGST_SIZE_4_4;
8492 parse_func = md5md5_parse_hash;
8493 sort_by_digest = sort_by_digest_4_4;
8494 opti_type = OPTI_TYPE_ZERO_BYTE
8495 | OPTI_TYPE_PRECOMPUTE_INIT
8496 | OPTI_TYPE_PRECOMPUTE_MERKLE
8497 | OPTI_TYPE_EARLY_SKIP;
8498 dgst_pos0 = 0;
8499 dgst_pos1 = 3;
8500 dgst_pos2 = 2;
8501 dgst_pos3 = 1;
8502 break;
8503
8504 case 2611: hash_type = HASH_TYPE_MD5;
8505 salt_type = SALT_TYPE_INTERN;
8506 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8507 opts_type = OPTS_TYPE_PT_GENERATE_LE
8508 | OPTS_TYPE_PT_ADD80
8509 | OPTS_TYPE_PT_ADDBITS14
8510 | OPTS_TYPE_ST_ADD80;
8511 kern_type = KERN_TYPE_MD55_PWSLT1;
8512 dgst_size = DGST_SIZE_4_4;
8513 parse_func = vb3_parse_hash;
8514 sort_by_digest = sort_by_digest_4_4;
8515 opti_type = OPTI_TYPE_ZERO_BYTE
8516 | OPTI_TYPE_PRECOMPUTE_INIT
8517 | OPTI_TYPE_PRECOMPUTE_MERKLE
8518 | OPTI_TYPE_EARLY_SKIP;
8519 dgst_pos0 = 0;
8520 dgst_pos1 = 3;
8521 dgst_pos2 = 2;
8522 dgst_pos3 = 1;
8523 break;
8524
8525 case 2612: hash_type = HASH_TYPE_MD5;
8526 salt_type = SALT_TYPE_EMBEDDED;
8527 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8528 opts_type = OPTS_TYPE_PT_GENERATE_LE
8529 | OPTS_TYPE_PT_ADD80
8530 | OPTS_TYPE_PT_ADDBITS14
8531 | OPTS_TYPE_ST_ADD80
8532 | OPTS_TYPE_ST_HEX;
8533 kern_type = KERN_TYPE_MD55_PWSLT1;
8534 dgst_size = DGST_SIZE_4_4;
8535 parse_func = phps_parse_hash;
8536 sort_by_digest = sort_by_digest_4_4;
8537 opti_type = OPTI_TYPE_ZERO_BYTE
8538 | OPTI_TYPE_PRECOMPUTE_INIT
8539 | OPTI_TYPE_PRECOMPUTE_MERKLE
8540 | OPTI_TYPE_EARLY_SKIP;
8541 dgst_pos0 = 0;
8542 dgst_pos1 = 3;
8543 dgst_pos2 = 2;
8544 dgst_pos3 = 1;
8545 break;
8546
8547 case 2711: hash_type = HASH_TYPE_MD5;
8548 salt_type = SALT_TYPE_INTERN;
8549 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8550 opts_type = OPTS_TYPE_PT_GENERATE_LE
8551 | OPTS_TYPE_PT_ADD80
8552 | OPTS_TYPE_PT_ADDBITS14
8553 | OPTS_TYPE_ST_ADD80;
8554 kern_type = KERN_TYPE_MD55_PWSLT2;
8555 dgst_size = DGST_SIZE_4_4;
8556 parse_func = vb30_parse_hash;
8557 sort_by_digest = sort_by_digest_4_4;
8558 opti_type = OPTI_TYPE_ZERO_BYTE
8559 | OPTI_TYPE_PRECOMPUTE_INIT
8560 | OPTI_TYPE_EARLY_SKIP;
8561 dgst_pos0 = 0;
8562 dgst_pos1 = 3;
8563 dgst_pos2 = 2;
8564 dgst_pos3 = 1;
8565 break;
8566
8567 case 2811: hash_type = HASH_TYPE_MD5;
8568 salt_type = SALT_TYPE_INTERN;
8569 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8570 opts_type = OPTS_TYPE_PT_GENERATE_LE
8571 | OPTS_TYPE_PT_ADD80
8572 | OPTS_TYPE_PT_ADDBITS14;
8573 kern_type = KERN_TYPE_MD55_SLTPW;
8574 dgst_size = DGST_SIZE_4_4;
8575 parse_func = ipb2_parse_hash;
8576 sort_by_digest = sort_by_digest_4_4;
8577 opti_type = OPTI_TYPE_ZERO_BYTE
8578 | OPTI_TYPE_PRECOMPUTE_INIT
8579 | OPTI_TYPE_EARLY_SKIP;
8580 dgst_pos0 = 0;
8581 dgst_pos1 = 3;
8582 dgst_pos2 = 2;
8583 dgst_pos3 = 1;
8584 break;
8585
8586 case 3000: hash_type = HASH_TYPE_LM;
8587 salt_type = SALT_TYPE_NONE;
8588 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8589 opts_type = OPTS_TYPE_PT_GENERATE_LE
8590 | OPTS_TYPE_PT_UPPER
8591 | OPTS_TYPE_PT_BITSLICE;
8592 kern_type = KERN_TYPE_LM;
8593 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8594 parse_func = lm_parse_hash;
8595 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8596 opti_type = OPTI_TYPE_ZERO_BYTE
8597 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8598 dgst_pos0 = 0;
8599 dgst_pos1 = 1;
8600 dgst_pos2 = 2;
8601 dgst_pos3 = 3;
8602 break;
8603
8604 case 3100: hash_type = HASH_TYPE_ORACLEH;
8605 salt_type = SALT_TYPE_INTERN;
8606 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8607 opts_type = OPTS_TYPE_PT_GENERATE_LE
8608 | OPTS_TYPE_PT_UPPER
8609 | OPTS_TYPE_ST_UPPER;
8610 kern_type = KERN_TYPE_ORACLEH;
8611 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8612 parse_func = oracleh_parse_hash;
8613 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8614 opti_type = OPTI_TYPE_ZERO_BYTE;
8615 dgst_pos0 = 0;
8616 dgst_pos1 = 1;
8617 dgst_pos2 = 2;
8618 dgst_pos3 = 3;
8619 break;
8620
8621 case 3200: hash_type = HASH_TYPE_BCRYPT;
8622 salt_type = SALT_TYPE_EMBEDDED;
8623 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8624 opts_type = OPTS_TYPE_PT_GENERATE_LE
8625 | OPTS_TYPE_ST_GENERATE_LE;
8626 kern_type = KERN_TYPE_BCRYPT;
8627 dgst_size = DGST_SIZE_4_6;
8628 parse_func = bcrypt_parse_hash;
8629 sort_by_digest = sort_by_digest_4_6;
8630 opti_type = OPTI_TYPE_ZERO_BYTE;
8631 dgst_pos0 = 0;
8632 dgst_pos1 = 1;
8633 dgst_pos2 = 2;
8634 dgst_pos3 = 3;
8635 break;
8636
8637 case 3710: hash_type = HASH_TYPE_MD5;
8638 salt_type = SALT_TYPE_INTERN;
8639 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8640 opts_type = OPTS_TYPE_PT_GENERATE_LE
8641 | OPTS_TYPE_PT_ADD80
8642 | OPTS_TYPE_PT_ADDBITS14;
8643 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8644 dgst_size = DGST_SIZE_4_4;
8645 parse_func = md5s_parse_hash;
8646 sort_by_digest = sort_by_digest_4_4;
8647 opti_type = OPTI_TYPE_ZERO_BYTE
8648 | OPTI_TYPE_PRECOMPUTE_INIT
8649 | OPTI_TYPE_PRECOMPUTE_MERKLE
8650 | OPTI_TYPE_EARLY_SKIP;
8651 dgst_pos0 = 0;
8652 dgst_pos1 = 3;
8653 dgst_pos2 = 2;
8654 dgst_pos3 = 1;
8655 break;
8656
8657 case 3711: hash_type = HASH_TYPE_MD5;
8658 salt_type = SALT_TYPE_EMBEDDED;
8659 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8660 opts_type = OPTS_TYPE_PT_GENERATE_LE
8661 | OPTS_TYPE_PT_ADD80
8662 | OPTS_TYPE_PT_ADDBITS14;
8663 kern_type = KERN_TYPE_MD5_SLT_MD5_PW;
8664 dgst_size = DGST_SIZE_4_4;
8665 parse_func = mediawiki_b_parse_hash;
8666 sort_by_digest = sort_by_digest_4_4;
8667 opti_type = OPTI_TYPE_ZERO_BYTE
8668 | OPTI_TYPE_PRECOMPUTE_INIT
8669 | OPTI_TYPE_PRECOMPUTE_MERKLE
8670 | OPTI_TYPE_EARLY_SKIP;
8671 dgst_pos0 = 0;
8672 dgst_pos1 = 3;
8673 dgst_pos2 = 2;
8674 dgst_pos3 = 1;
8675 break;
8676
8677 case 3800: hash_type = HASH_TYPE_MD5;
8678 salt_type = SALT_TYPE_INTERN;
8679 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8680 opts_type = OPTS_TYPE_PT_GENERATE_LE
8681 | OPTS_TYPE_ST_ADDBITS14;
8682 kern_type = KERN_TYPE_MD5_SLT_PW_SLT;
8683 dgst_size = DGST_SIZE_4_4;
8684 parse_func = md5s_parse_hash;
8685 sort_by_digest = sort_by_digest_4_4;
8686 opti_type = OPTI_TYPE_ZERO_BYTE
8687 | OPTI_TYPE_PRECOMPUTE_INIT
8688 | OPTI_TYPE_PRECOMPUTE_MERKLE
8689 | OPTI_TYPE_EARLY_SKIP
8690 | OPTI_TYPE_NOT_ITERATED
8691 | OPTI_TYPE_RAW_HASH;
8692 dgst_pos0 = 0;
8693 dgst_pos1 = 3;
8694 dgst_pos2 = 2;
8695 dgst_pos3 = 1;
8696 break;
8697
8698 case 4300: hash_type = HASH_TYPE_MD5;
8699 salt_type = SALT_TYPE_VIRTUAL;
8700 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8701 opts_type = OPTS_TYPE_PT_GENERATE_LE
8702 | OPTS_TYPE_PT_ADD80
8703 | OPTS_TYPE_PT_ADDBITS14
8704 | OPTS_TYPE_ST_ADD80;
8705 kern_type = KERN_TYPE_MD5U5_PWSLT1;
8706 dgst_size = DGST_SIZE_4_4;
8707 parse_func = md5md5_parse_hash;
8708 sort_by_digest = sort_by_digest_4_4;
8709 opti_type = OPTI_TYPE_ZERO_BYTE
8710 | OPTI_TYPE_PRECOMPUTE_INIT
8711 | OPTI_TYPE_PRECOMPUTE_MERKLE
8712 | OPTI_TYPE_EARLY_SKIP;
8713 dgst_pos0 = 0;
8714 dgst_pos1 = 3;
8715 dgst_pos2 = 2;
8716 dgst_pos3 = 1;
8717 break;
8718
8719
8720 case 4400: hash_type = HASH_TYPE_MD5;
8721 salt_type = SALT_TYPE_NONE;
8722 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8723 opts_type = OPTS_TYPE_PT_GENERATE_BE
8724 | OPTS_TYPE_PT_ADD80
8725 | OPTS_TYPE_PT_ADDBITS15;
8726 kern_type = KERN_TYPE_MD5_SHA1;
8727 dgst_size = DGST_SIZE_4_4;
8728 parse_func = md5_parse_hash;
8729 sort_by_digest = sort_by_digest_4_4;
8730 opti_type = OPTI_TYPE_ZERO_BYTE
8731 | OPTI_TYPE_PRECOMPUTE_INIT
8732 | OPTI_TYPE_PRECOMPUTE_MERKLE
8733 | OPTI_TYPE_EARLY_SKIP
8734 | OPTI_TYPE_NOT_ITERATED
8735 | OPTI_TYPE_NOT_SALTED
8736 | OPTI_TYPE_RAW_HASH;
8737 dgst_pos0 = 0;
8738 dgst_pos1 = 3;
8739 dgst_pos2 = 2;
8740 dgst_pos3 = 1;
8741 break;
8742
8743 case 4500: hash_type = HASH_TYPE_SHA1;
8744 salt_type = SALT_TYPE_NONE;
8745 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8746 opts_type = OPTS_TYPE_PT_GENERATE_BE
8747 | OPTS_TYPE_PT_ADD80
8748 | OPTS_TYPE_PT_ADDBITS15;
8749 kern_type = KERN_TYPE_SHA11;
8750 dgst_size = DGST_SIZE_4_5;
8751 parse_func = sha1_parse_hash;
8752 sort_by_digest = sort_by_digest_4_5;
8753 opti_type = OPTI_TYPE_ZERO_BYTE
8754 | OPTI_TYPE_PRECOMPUTE_INIT
8755 | OPTI_TYPE_PRECOMPUTE_MERKLE
8756 | OPTI_TYPE_EARLY_SKIP
8757 | OPTI_TYPE_NOT_SALTED;
8758 dgst_pos0 = 3;
8759 dgst_pos1 = 4;
8760 dgst_pos2 = 2;
8761 dgst_pos3 = 1;
8762 break;
8763
8764 case 4700: hash_type = HASH_TYPE_SHA1;
8765 salt_type = SALT_TYPE_NONE;
8766 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8767 opts_type = OPTS_TYPE_PT_GENERATE_LE
8768 | OPTS_TYPE_PT_ADD80
8769 | OPTS_TYPE_PT_ADDBITS14;
8770 kern_type = KERN_TYPE_SHA1_MD5;
8771 dgst_size = DGST_SIZE_4_5;
8772 parse_func = sha1_parse_hash;
8773 sort_by_digest = sort_by_digest_4_5;
8774 opti_type = OPTI_TYPE_ZERO_BYTE
8775 | OPTI_TYPE_PRECOMPUTE_INIT
8776 | OPTI_TYPE_PRECOMPUTE_MERKLE
8777 | OPTI_TYPE_EARLY_SKIP
8778 | OPTI_TYPE_NOT_ITERATED
8779 | OPTI_TYPE_NOT_SALTED
8780 | OPTI_TYPE_RAW_HASH;
8781 dgst_pos0 = 3;
8782 dgst_pos1 = 4;
8783 dgst_pos2 = 2;
8784 dgst_pos3 = 1;
8785 break;
8786
8787 case 4800: hash_type = HASH_TYPE_MD5;
8788 salt_type = SALT_TYPE_EMBEDDED;
8789 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8790 opts_type = OPTS_TYPE_PT_GENERATE_LE
8791 | OPTS_TYPE_PT_ADDBITS14;
8792 kern_type = KERN_TYPE_MD5_CHAP;
8793 dgst_size = DGST_SIZE_4_4;
8794 parse_func = chap_parse_hash;
8795 sort_by_digest = sort_by_digest_4_4;
8796 opti_type = OPTI_TYPE_ZERO_BYTE
8797 | OPTI_TYPE_PRECOMPUTE_INIT
8798 | OPTI_TYPE_PRECOMPUTE_MERKLE
8799 | OPTI_TYPE_MEET_IN_MIDDLE
8800 | OPTI_TYPE_EARLY_SKIP
8801 | OPTI_TYPE_NOT_ITERATED
8802 | OPTI_TYPE_RAW_HASH;
8803 dgst_pos0 = 0;
8804 dgst_pos1 = 3;
8805 dgst_pos2 = 2;
8806 dgst_pos3 = 1;
8807 break;
8808
8809 case 4900: hash_type = HASH_TYPE_SHA1;
8810 salt_type = SALT_TYPE_INTERN;
8811 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8812 opts_type = OPTS_TYPE_PT_GENERATE_LE;
8813 kern_type = KERN_TYPE_SHA1_SLT_PW_SLT;
8814 dgst_size = DGST_SIZE_4_5;
8815 parse_func = sha1s_parse_hash;
8816 sort_by_digest = sort_by_digest_4_5;
8817 opti_type = OPTI_TYPE_ZERO_BYTE
8818 | OPTI_TYPE_PRECOMPUTE_INIT
8819 | OPTI_TYPE_PRECOMPUTE_MERKLE
8820 | OPTI_TYPE_EARLY_SKIP;
8821 dgst_pos0 = 3;
8822 dgst_pos1 = 4;
8823 dgst_pos2 = 2;
8824 dgst_pos3 = 1;
8825 break;
8826
8827 case 5000: hash_type = HASH_TYPE_KECCAK;
8828 salt_type = SALT_TYPE_EMBEDDED;
8829 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8830 opts_type = OPTS_TYPE_PT_GENERATE_LE
8831 | OPTS_TYPE_PT_ADD01;
8832 kern_type = KERN_TYPE_KECCAK;
8833 dgst_size = DGST_SIZE_8_25;
8834 parse_func = keccak_parse_hash;
8835 sort_by_digest = sort_by_digest_8_25;
8836 opti_type = OPTI_TYPE_ZERO_BYTE
8837 | OPTI_TYPE_USES_BITS_64
8838 | OPTI_TYPE_RAW_HASH;
8839 dgst_pos0 = 2;
8840 dgst_pos1 = 3;
8841 dgst_pos2 = 4;
8842 dgst_pos3 = 5;
8843 break;
8844
8845 case 5100: hash_type = HASH_TYPE_MD5H;
8846 salt_type = SALT_TYPE_NONE;
8847 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8848 opts_type = OPTS_TYPE_PT_GENERATE_LE
8849 | OPTS_TYPE_PT_ADD80
8850 | OPTS_TYPE_PT_ADDBITS14;
8851 kern_type = KERN_TYPE_MD5H;
8852 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
8853 parse_func = md5half_parse_hash;
8854 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
8855 opti_type = OPTI_TYPE_ZERO_BYTE
8856 | OPTI_TYPE_RAW_HASH;
8857 dgst_pos0 = 0;
8858 dgst_pos1 = 1;
8859 dgst_pos2 = 2;
8860 dgst_pos3 = 3;
8861 break;
8862
8863 case 5200: hash_type = HASH_TYPE_SHA256;
8864 salt_type = SALT_TYPE_EMBEDDED;
8865 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8866 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
8867 kern_type = KERN_TYPE_PSAFE3;
8868 dgst_size = DGST_SIZE_4_8;
8869 parse_func = psafe3_parse_hash;
8870 sort_by_digest = sort_by_digest_4_8;
8871 opti_type = OPTI_TYPE_ZERO_BYTE;
8872 dgst_pos0 = 0;
8873 dgst_pos1 = 1;
8874 dgst_pos2 = 2;
8875 dgst_pos3 = 3;
8876 break;
8877
8878 case 5300: hash_type = HASH_TYPE_MD5;
8879 salt_type = SALT_TYPE_EMBEDDED;
8880 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8881 opts_type = OPTS_TYPE_PT_GENERATE_LE
8882 | OPTS_TYPE_ST_ADD80;
8883 kern_type = KERN_TYPE_IKEPSK_MD5;
8884 dgst_size = DGST_SIZE_4_4;
8885 parse_func = ikepsk_md5_parse_hash;
8886 sort_by_digest = sort_by_digest_4_4;
8887 opti_type = OPTI_TYPE_ZERO_BYTE;
8888 dgst_pos0 = 0;
8889 dgst_pos1 = 3;
8890 dgst_pos2 = 2;
8891 dgst_pos3 = 1;
8892 break;
8893
8894 case 5400: hash_type = HASH_TYPE_SHA1;
8895 salt_type = SALT_TYPE_EMBEDDED;
8896 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8897 opts_type = OPTS_TYPE_PT_GENERATE_BE
8898 | OPTS_TYPE_ST_ADD80;
8899 kern_type = KERN_TYPE_IKEPSK_SHA1;
8900 dgst_size = DGST_SIZE_4_5;
8901 parse_func = ikepsk_sha1_parse_hash;
8902 sort_by_digest = sort_by_digest_4_5;
8903 opti_type = OPTI_TYPE_ZERO_BYTE;
8904 dgst_pos0 = 3;
8905 dgst_pos1 = 4;
8906 dgst_pos2 = 2;
8907 dgst_pos3 = 1;
8908 break;
8909
8910 case 5500: hash_type = HASH_TYPE_NETNTLM;
8911 salt_type = SALT_TYPE_EMBEDDED;
8912 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8913 opts_type = OPTS_TYPE_PT_GENERATE_LE
8914 | OPTS_TYPE_PT_ADD80
8915 | OPTS_TYPE_PT_ADDBITS14
8916 | OPTS_TYPE_PT_UNICODE
8917 | OPTS_TYPE_ST_HEX;
8918 kern_type = KERN_TYPE_NETNTLMv1;
8919 dgst_size = DGST_SIZE_4_4;
8920 parse_func = netntlmv1_parse_hash;
8921 sort_by_digest = sort_by_digest_4_4;
8922 opti_type = OPTI_TYPE_ZERO_BYTE
8923 | OPTI_TYPE_PRECOMPUTE_PERMUT;
8924 dgst_pos0 = 0;
8925 dgst_pos1 = 1;
8926 dgst_pos2 = 2;
8927 dgst_pos3 = 3;
8928 break;
8929
8930 case 5600: hash_type = HASH_TYPE_MD5;
8931 salt_type = SALT_TYPE_EMBEDDED;
8932 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8933 opts_type = OPTS_TYPE_PT_GENERATE_LE
8934 | OPTS_TYPE_PT_ADD80
8935 | OPTS_TYPE_PT_ADDBITS14
8936 | OPTS_TYPE_PT_UNICODE;
8937 kern_type = KERN_TYPE_NETNTLMv2;
8938 dgst_size = DGST_SIZE_4_4;
8939 parse_func = netntlmv2_parse_hash;
8940 sort_by_digest = sort_by_digest_4_4;
8941 opti_type = OPTI_TYPE_ZERO_BYTE;
8942 dgst_pos0 = 0;
8943 dgst_pos1 = 3;
8944 dgst_pos2 = 2;
8945 dgst_pos3 = 1;
8946 break;
8947
8948 case 5700: hash_type = HASH_TYPE_SHA256;
8949 salt_type = SALT_TYPE_NONE;
8950 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8951 opts_type = OPTS_TYPE_PT_GENERATE_BE
8952 | OPTS_TYPE_PT_ADD80
8953 | OPTS_TYPE_PT_ADDBITS15;
8954 kern_type = KERN_TYPE_SHA256;
8955 dgst_size = DGST_SIZE_4_8;
8956 parse_func = cisco4_parse_hash;
8957 sort_by_digest = sort_by_digest_4_8;
8958 opti_type = OPTI_TYPE_ZERO_BYTE
8959 | OPTI_TYPE_PRECOMPUTE_INIT
8960 | OPTI_TYPE_PRECOMPUTE_MERKLE
8961 | OPTI_TYPE_EARLY_SKIP
8962 | OPTI_TYPE_NOT_ITERATED
8963 | OPTI_TYPE_NOT_SALTED
8964 | OPTI_TYPE_RAW_HASH;
8965 dgst_pos0 = 3;
8966 dgst_pos1 = 7;
8967 dgst_pos2 = 2;
8968 dgst_pos3 = 6;
8969 break;
8970
8971 case 5800: hash_type = HASH_TYPE_SHA1;
8972 salt_type = SALT_TYPE_INTERN;
8973 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
8974 opts_type = OPTS_TYPE_PT_GENERATE_LE // should be OPTS_TYPE_PT_GENERATE_BE
8975 | OPTS_TYPE_ST_ADD80;
8976 kern_type = KERN_TYPE_ANDROIDPIN;
8977 dgst_size = DGST_SIZE_4_5;
8978 parse_func = androidpin_parse_hash;
8979 sort_by_digest = sort_by_digest_4_5;
8980 opti_type = OPTI_TYPE_ZERO_BYTE;
8981 dgst_pos0 = 0;
8982 dgst_pos1 = 1;
8983 dgst_pos2 = 2;
8984 dgst_pos3 = 3;
8985 break;
8986
8987 case 6000: hash_type = HASH_TYPE_RIPEMD160;
8988 salt_type = SALT_TYPE_NONE;
8989 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
8990 opts_type = OPTS_TYPE_PT_GENERATE_LE
8991 | OPTS_TYPE_PT_ADD80;
8992 kern_type = KERN_TYPE_RIPEMD160;
8993 dgst_size = DGST_SIZE_4_5;
8994 parse_func = ripemd160_parse_hash;
8995 sort_by_digest = sort_by_digest_4_5;
8996 opti_type = OPTI_TYPE_ZERO_BYTE;
8997 dgst_pos0 = 0;
8998 dgst_pos1 = 1;
8999 dgst_pos2 = 2;
9000 dgst_pos3 = 3;
9001 break;
9002
9003 case 6100: hash_type = HASH_TYPE_WHIRLPOOL;
9004 salt_type = SALT_TYPE_NONE;
9005 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9006 opts_type = OPTS_TYPE_PT_GENERATE_BE
9007 | OPTS_TYPE_PT_ADD80;
9008 kern_type = KERN_TYPE_WHIRLPOOL;
9009 dgst_size = DGST_SIZE_4_16;
9010 parse_func = whirlpool_parse_hash;
9011 sort_by_digest = sort_by_digest_4_16;
9012 opti_type = OPTI_TYPE_ZERO_BYTE;
9013 dgst_pos0 = 0;
9014 dgst_pos1 = 1;
9015 dgst_pos2 = 2;
9016 dgst_pos3 = 3;
9017 break;
9018
9019 case 6211: hash_type = HASH_TYPE_RIPEMD160;
9020 salt_type = SALT_TYPE_EMBEDDED;
9021 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9022 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9023 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9024 dgst_size = DGST_SIZE_4_5;
9025 parse_func = truecrypt_parse_hash_2k;
9026 sort_by_digest = sort_by_digest_4_5;
9027 opti_type = OPTI_TYPE_ZERO_BYTE;
9028 dgst_pos0 = 0;
9029 dgst_pos1 = 1;
9030 dgst_pos2 = 2;
9031 dgst_pos3 = 3;
9032 break;
9033
9034 case 6212: hash_type = HASH_TYPE_RIPEMD160;
9035 salt_type = SALT_TYPE_EMBEDDED;
9036 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9037 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9038 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9039 dgst_size = DGST_SIZE_4_5;
9040 parse_func = truecrypt_parse_hash_2k;
9041 sort_by_digest = sort_by_digest_4_5;
9042 opti_type = OPTI_TYPE_ZERO_BYTE;
9043 dgst_pos0 = 0;
9044 dgst_pos1 = 1;
9045 dgst_pos2 = 2;
9046 dgst_pos3 = 3;
9047 break;
9048
9049 case 6213: hash_type = HASH_TYPE_RIPEMD160;
9050 salt_type = SALT_TYPE_EMBEDDED;
9051 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9052 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9053 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9054 dgst_size = DGST_SIZE_4_5;
9055 parse_func = truecrypt_parse_hash_2k;
9056 sort_by_digest = sort_by_digest_4_5;
9057 opti_type = OPTI_TYPE_ZERO_BYTE;
9058 dgst_pos0 = 0;
9059 dgst_pos1 = 1;
9060 dgst_pos2 = 2;
9061 dgst_pos3 = 3;
9062 break;
9063
9064 case 6221: hash_type = HASH_TYPE_SHA512;
9065 salt_type = SALT_TYPE_EMBEDDED;
9066 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9067 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9068 kern_type = KERN_TYPE_TCSHA512_XTS512;
9069 dgst_size = DGST_SIZE_8_8;
9070 parse_func = truecrypt_parse_hash_1k;
9071 sort_by_digest = sort_by_digest_8_8;
9072 opti_type = OPTI_TYPE_ZERO_BYTE
9073 | OPTI_TYPE_USES_BITS_64;
9074 dgst_pos0 = 0;
9075 dgst_pos1 = 1;
9076 dgst_pos2 = 2;
9077 dgst_pos3 = 3;
9078 break;
9079
9080 case 6222: hash_type = HASH_TYPE_SHA512;
9081 salt_type = SALT_TYPE_EMBEDDED;
9082 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9083 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9084 kern_type = KERN_TYPE_TCSHA512_XTS1024;
9085 dgst_size = DGST_SIZE_8_8;
9086 parse_func = truecrypt_parse_hash_1k;
9087 sort_by_digest = sort_by_digest_8_8;
9088 opti_type = OPTI_TYPE_ZERO_BYTE
9089 | OPTI_TYPE_USES_BITS_64;
9090 dgst_pos0 = 0;
9091 dgst_pos1 = 1;
9092 dgst_pos2 = 2;
9093 dgst_pos3 = 3;
9094 break;
9095
9096 case 6223: hash_type = HASH_TYPE_SHA512;
9097 salt_type = SALT_TYPE_EMBEDDED;
9098 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9099 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9100 kern_type = KERN_TYPE_TCSHA512_XTS1536;
9101 dgst_size = DGST_SIZE_8_8;
9102 parse_func = truecrypt_parse_hash_1k;
9103 sort_by_digest = sort_by_digest_8_8;
9104 opti_type = OPTI_TYPE_ZERO_BYTE
9105 | OPTI_TYPE_USES_BITS_64;
9106 dgst_pos0 = 0;
9107 dgst_pos1 = 1;
9108 dgst_pos2 = 2;
9109 dgst_pos3 = 3;
9110 break;
9111
9112 case 6231: hash_type = HASH_TYPE_WHIRLPOOL;
9113 salt_type = SALT_TYPE_EMBEDDED;
9114 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9115 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9116 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
9117 dgst_size = DGST_SIZE_4_8;
9118 parse_func = truecrypt_parse_hash_1k;
9119 sort_by_digest = sort_by_digest_4_8;
9120 opti_type = OPTI_TYPE_ZERO_BYTE;
9121 dgst_pos0 = 0;
9122 dgst_pos1 = 1;
9123 dgst_pos2 = 2;
9124 dgst_pos3 = 3;
9125 break;
9126
9127 case 6232: hash_type = HASH_TYPE_WHIRLPOOL;
9128 salt_type = SALT_TYPE_EMBEDDED;
9129 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9130 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9131 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
9132 dgst_size = DGST_SIZE_4_8;
9133 parse_func = truecrypt_parse_hash_1k;
9134 sort_by_digest = sort_by_digest_4_8;
9135 opti_type = OPTI_TYPE_ZERO_BYTE;
9136 dgst_pos0 = 0;
9137 dgst_pos1 = 1;
9138 dgst_pos2 = 2;
9139 dgst_pos3 = 3;
9140 break;
9141
9142 case 6233: hash_type = HASH_TYPE_WHIRLPOOL;
9143 salt_type = SALT_TYPE_EMBEDDED;
9144 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9145 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9146 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
9147 dgst_size = DGST_SIZE_4_8;
9148 parse_func = truecrypt_parse_hash_1k;
9149 sort_by_digest = sort_by_digest_4_8;
9150 opti_type = OPTI_TYPE_ZERO_BYTE;
9151 dgst_pos0 = 0;
9152 dgst_pos1 = 1;
9153 dgst_pos2 = 2;
9154 dgst_pos3 = 3;
9155 break;
9156
9157 case 6241: hash_type = HASH_TYPE_RIPEMD160;
9158 salt_type = SALT_TYPE_EMBEDDED;
9159 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9160 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9161 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
9162 dgst_size = DGST_SIZE_4_5;
9163 parse_func = truecrypt_parse_hash_1k;
9164 sort_by_digest = sort_by_digest_4_5;
9165 opti_type = OPTI_TYPE_ZERO_BYTE;
9166 dgst_pos0 = 0;
9167 dgst_pos1 = 1;
9168 dgst_pos2 = 2;
9169 dgst_pos3 = 3;
9170 break;
9171
9172 case 6242: hash_type = HASH_TYPE_RIPEMD160;
9173 salt_type = SALT_TYPE_EMBEDDED;
9174 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9175 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9176 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
9177 dgst_size = DGST_SIZE_4_5;
9178 parse_func = truecrypt_parse_hash_1k;
9179 sort_by_digest = sort_by_digest_4_5;
9180 opti_type = OPTI_TYPE_ZERO_BYTE;
9181 dgst_pos0 = 0;
9182 dgst_pos1 = 1;
9183 dgst_pos2 = 2;
9184 dgst_pos3 = 3;
9185 break;
9186
9187 case 6243: hash_type = HASH_TYPE_RIPEMD160;
9188 salt_type = SALT_TYPE_EMBEDDED;
9189 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9190 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9191 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
9192 dgst_size = DGST_SIZE_4_5;
9193 parse_func = truecrypt_parse_hash_1k;
9194 sort_by_digest = sort_by_digest_4_5;
9195 opti_type = OPTI_TYPE_ZERO_BYTE;
9196 dgst_pos0 = 0;
9197 dgst_pos1 = 1;
9198 dgst_pos2 = 2;
9199 dgst_pos3 = 3;
9200 break;
9201
9202 case 6300: hash_type = HASH_TYPE_MD5;
9203 salt_type = SALT_TYPE_EMBEDDED;
9204 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9205 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9206 kern_type = KERN_TYPE_MD5AIX;
9207 dgst_size = DGST_SIZE_4_4;
9208 parse_func = md5aix_parse_hash;
9209 sort_by_digest = sort_by_digest_4_4;
9210 opti_type = OPTI_TYPE_ZERO_BYTE;
9211 dgst_pos0 = 0;
9212 dgst_pos1 = 1;
9213 dgst_pos2 = 2;
9214 dgst_pos3 = 3;
9215 break;
9216
9217 case 6400: hash_type = HASH_TYPE_SHA256;
9218 salt_type = SALT_TYPE_EMBEDDED;
9219 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9220 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9221 kern_type = KERN_TYPE_SHA256AIX;
9222 dgst_size = DGST_SIZE_4_8;
9223 parse_func = sha256aix_parse_hash;
9224 sort_by_digest = sort_by_digest_4_8;
9225 opti_type = OPTI_TYPE_ZERO_BYTE;
9226 dgst_pos0 = 0;
9227 dgst_pos1 = 1;
9228 dgst_pos2 = 2;
9229 dgst_pos3 = 3;
9230 break;
9231
9232 case 6500: hash_type = HASH_TYPE_SHA512;
9233 salt_type = SALT_TYPE_EMBEDDED;
9234 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9235 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9236 kern_type = KERN_TYPE_SHA512AIX;
9237 dgst_size = DGST_SIZE_8_8;
9238 parse_func = sha512aix_parse_hash;
9239 sort_by_digest = sort_by_digest_8_8;
9240 opti_type = OPTI_TYPE_ZERO_BYTE
9241 | OPTI_TYPE_USES_BITS_64;
9242 dgst_pos0 = 0;
9243 dgst_pos1 = 1;
9244 dgst_pos2 = 2;
9245 dgst_pos3 = 3;
9246 break;
9247
9248 case 6600: hash_type = HASH_TYPE_AES;
9249 salt_type = SALT_TYPE_EMBEDDED;
9250 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9251 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9252 kern_type = KERN_TYPE_AGILEKEY;
9253 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
9254 parse_func = agilekey_parse_hash;
9255 sort_by_digest = sort_by_digest_4_5;
9256 opti_type = OPTI_TYPE_ZERO_BYTE;
9257 dgst_pos0 = 0;
9258 dgst_pos1 = 1;
9259 dgst_pos2 = 2;
9260 dgst_pos3 = 3;
9261 break;
9262
9263 case 6700: hash_type = HASH_TYPE_SHA1;
9264 salt_type = SALT_TYPE_EMBEDDED;
9265 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9266 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9267 kern_type = KERN_TYPE_SHA1AIX;
9268 dgst_size = DGST_SIZE_4_5;
9269 parse_func = sha1aix_parse_hash;
9270 sort_by_digest = sort_by_digest_4_5;
9271 opti_type = OPTI_TYPE_ZERO_BYTE;
9272 dgst_pos0 = 0;
9273 dgst_pos1 = 1;
9274 dgst_pos2 = 2;
9275 dgst_pos3 = 3;
9276 break;
9277
9278 case 6800: hash_type = HASH_TYPE_AES;
9279 salt_type = SALT_TYPE_EMBEDDED;
9280 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9281 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9282 kern_type = KERN_TYPE_LASTPASS;
9283 dgst_size = DGST_SIZE_4_8; // because kernel uses _SHA256_
9284 parse_func = lastpass_parse_hash;
9285 sort_by_digest = sort_by_digest_4_8;
9286 opti_type = OPTI_TYPE_ZERO_BYTE;
9287 dgst_pos0 = 0;
9288 dgst_pos1 = 1;
9289 dgst_pos2 = 2;
9290 dgst_pos3 = 3;
9291 break;
9292
9293 case 6900: hash_type = HASH_TYPE_GOST;
9294 salt_type = SALT_TYPE_NONE;
9295 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9296 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9297 kern_type = KERN_TYPE_GOST;
9298 dgst_size = DGST_SIZE_4_8;
9299 parse_func = gost_parse_hash;
9300 sort_by_digest = sort_by_digest_4_8;
9301 opti_type = OPTI_TYPE_ZERO_BYTE;
9302 dgst_pos0 = 0;
9303 dgst_pos1 = 1;
9304 dgst_pos2 = 2;
9305 dgst_pos3 = 3;
9306 break;
9307
9308 case 7100: hash_type = HASH_TYPE_SHA512;
9309 salt_type = SALT_TYPE_EMBEDDED;
9310 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9311 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9312 kern_type = KERN_TYPE_PBKDF2_SHA512;
9313 dgst_size = DGST_SIZE_8_16;
9314 parse_func = sha512osx_parse_hash;
9315 sort_by_digest = sort_by_digest_8_16;
9316 opti_type = OPTI_TYPE_ZERO_BYTE
9317 | OPTI_TYPE_USES_BITS_64
9318 | OPTI_TYPE_SLOW_HASH_SIMD;
9319 dgst_pos0 = 0;
9320 dgst_pos1 = 1;
9321 dgst_pos2 = 2;
9322 dgst_pos3 = 3;
9323 break;
9324
9325 case 7200: hash_type = HASH_TYPE_SHA512;
9326 salt_type = SALT_TYPE_EMBEDDED;
9327 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9328 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9329 kern_type = KERN_TYPE_PBKDF2_SHA512;
9330 dgst_size = DGST_SIZE_8_16;
9331 parse_func = sha512grub_parse_hash;
9332 sort_by_digest = sort_by_digest_8_16;
9333 opti_type = OPTI_TYPE_ZERO_BYTE
9334 | OPTI_TYPE_USES_BITS_64
9335 | OPTI_TYPE_SLOW_HASH_SIMD;
9336 dgst_pos0 = 0;
9337 dgst_pos1 = 1;
9338 dgst_pos2 = 2;
9339 dgst_pos3 = 3;
9340 break;
9341
9342 case 7300: hash_type = HASH_TYPE_SHA1;
9343 salt_type = SALT_TYPE_EMBEDDED;
9344 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9345 opts_type = OPTS_TYPE_PT_GENERATE_BE
9346 | OPTS_TYPE_ST_ADD80
9347 | OPTS_TYPE_ST_ADDBITS15;
9348 kern_type = KERN_TYPE_RAKP;
9349 dgst_size = DGST_SIZE_4_5;
9350 parse_func = rakp_parse_hash;
9351 sort_by_digest = sort_by_digest_4_5;
9352 opti_type = OPTI_TYPE_ZERO_BYTE
9353 | OPTI_TYPE_NOT_ITERATED;
9354 dgst_pos0 = 3;
9355 dgst_pos1 = 4;
9356 dgst_pos2 = 2;
9357 dgst_pos3 = 1;
9358 break;
9359
9360 case 7400: hash_type = HASH_TYPE_SHA256;
9361 salt_type = SALT_TYPE_EMBEDDED;
9362 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9363 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9364 kern_type = KERN_TYPE_SHA256CRYPT;
9365 dgst_size = DGST_SIZE_4_8;
9366 parse_func = sha256crypt_parse_hash;
9367 sort_by_digest = sort_by_digest_4_8;
9368 opti_type = OPTI_TYPE_ZERO_BYTE;
9369 dgst_pos0 = 0;
9370 dgst_pos1 = 1;
9371 dgst_pos2 = 2;
9372 dgst_pos3 = 3;
9373 break;
9374
9375 case 7500: hash_type = HASH_TYPE_KRB5PA;
9376 salt_type = SALT_TYPE_EMBEDDED;
9377 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9378 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9379 kern_type = KERN_TYPE_KRB5PA;
9380 dgst_size = DGST_SIZE_4_4;
9381 parse_func = krb5pa_parse_hash;
9382 sort_by_digest = sort_by_digest_4_4;
9383 opti_type = OPTI_TYPE_ZERO_BYTE
9384 | OPTI_TYPE_NOT_ITERATED;
9385 dgst_pos0 = 0;
9386 dgst_pos1 = 1;
9387 dgst_pos2 = 2;
9388 dgst_pos3 = 3;
9389 break;
9390
9391 case 7600: hash_type = HASH_TYPE_SHA1;
9392 salt_type = SALT_TYPE_INTERN;
9393 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9394 opts_type = OPTS_TYPE_PT_GENERATE_BE
9395 | OPTS_TYPE_PT_ADD80
9396 | OPTS_TYPE_PT_ADDBITS15;
9397 kern_type = KERN_TYPE_SHA1_SLT_SHA1_PW;
9398 dgst_size = DGST_SIZE_4_5;
9399 parse_func = redmine_parse_hash;
9400 sort_by_digest = sort_by_digest_4_5;
9401 opti_type = OPTI_TYPE_ZERO_BYTE
9402 | OPTI_TYPE_PRECOMPUTE_INIT
9403 | OPTI_TYPE_EARLY_SKIP
9404 | OPTI_TYPE_NOT_ITERATED
9405 | OPTI_TYPE_PREPENDED_SALT;
9406 dgst_pos0 = 3;
9407 dgst_pos1 = 4;
9408 dgst_pos2 = 2;
9409 dgst_pos3 = 1;
9410 break;
9411
9412 case 7700: hash_type = HASH_TYPE_SAPB;
9413 salt_type = SALT_TYPE_EMBEDDED;
9414 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9415 opts_type = OPTS_TYPE_PT_GENERATE_LE
9416 | OPTS_TYPE_PT_UPPER
9417 | OPTS_TYPE_ST_UPPER;
9418 kern_type = KERN_TYPE_SAPB;
9419 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9420 parse_func = sapb_parse_hash;
9421 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9422 opti_type = OPTI_TYPE_ZERO_BYTE
9423 | OPTI_TYPE_PRECOMPUTE_INIT
9424 | OPTI_TYPE_NOT_ITERATED;
9425 dgst_pos0 = 0;
9426 dgst_pos1 = 1;
9427 dgst_pos2 = 2;
9428 dgst_pos3 = 3;
9429 break;
9430
9431 case 7800: hash_type = HASH_TYPE_SAPG;
9432 salt_type = SALT_TYPE_EMBEDDED;
9433 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9434 opts_type = OPTS_TYPE_PT_GENERATE_BE
9435 | OPTS_TYPE_ST_ADD80
9436 | OPTS_TYPE_ST_UPPER;
9437 kern_type = KERN_TYPE_SAPG;
9438 dgst_size = DGST_SIZE_4_5;
9439 parse_func = sapg_parse_hash;
9440 sort_by_digest = sort_by_digest_4_5;
9441 opti_type = OPTI_TYPE_ZERO_BYTE
9442 | OPTI_TYPE_PRECOMPUTE_INIT
9443 | OPTI_TYPE_NOT_ITERATED;
9444 dgst_pos0 = 3;
9445 dgst_pos1 = 4;
9446 dgst_pos2 = 2;
9447 dgst_pos3 = 1;
9448 break;
9449
9450 case 7900: hash_type = HASH_TYPE_SHA512;
9451 salt_type = SALT_TYPE_EMBEDDED;
9452 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9453 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9454 kern_type = KERN_TYPE_DRUPAL7;
9455 dgst_size = DGST_SIZE_8_8;
9456 parse_func = drupal7_parse_hash;
9457 sort_by_digest = sort_by_digest_8_8;
9458 opti_type = OPTI_TYPE_ZERO_BYTE
9459 | OPTI_TYPE_USES_BITS_64;
9460 dgst_pos0 = 0;
9461 dgst_pos1 = 1;
9462 dgst_pos2 = 2;
9463 dgst_pos3 = 3;
9464 break;
9465
9466 case 8000: hash_type = HASH_TYPE_SHA256;
9467 salt_type = SALT_TYPE_EMBEDDED;
9468 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9469 opts_type = OPTS_TYPE_PT_GENERATE_BE
9470 | OPTS_TYPE_PT_UNICODE
9471 | OPTS_TYPE_ST_ADD80
9472 | OPTS_TYPE_ST_HEX;
9473 kern_type = KERN_TYPE_SYBASEASE;
9474 dgst_size = DGST_SIZE_4_8;
9475 parse_func = sybasease_parse_hash;
9476 sort_by_digest = sort_by_digest_4_8;
9477 opti_type = OPTI_TYPE_ZERO_BYTE
9478 | OPTI_TYPE_PRECOMPUTE_INIT
9479 | OPTI_TYPE_EARLY_SKIP
9480 | OPTI_TYPE_NOT_ITERATED
9481 | OPTI_TYPE_RAW_HASH;
9482 dgst_pos0 = 3;
9483 dgst_pos1 = 7;
9484 dgst_pos2 = 2;
9485 dgst_pos3 = 6;
9486 break;
9487
9488 case 8100: hash_type = HASH_TYPE_SHA1;
9489 salt_type = SALT_TYPE_EMBEDDED;
9490 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9491 opts_type = OPTS_TYPE_PT_GENERATE_BE;
9492 kern_type = KERN_TYPE_NETSCALER;
9493 dgst_size = DGST_SIZE_4_5;
9494 parse_func = netscaler_parse_hash;
9495 sort_by_digest = sort_by_digest_4_5;
9496 opti_type = OPTI_TYPE_ZERO_BYTE
9497 | OPTI_TYPE_PRECOMPUTE_INIT
9498 | OPTI_TYPE_PRECOMPUTE_MERKLE
9499 | OPTI_TYPE_EARLY_SKIP
9500 | OPTI_TYPE_NOT_ITERATED
9501 | OPTI_TYPE_PREPENDED_SALT
9502 | OPTI_TYPE_RAW_HASH;
9503 dgst_pos0 = 3;
9504 dgst_pos1 = 4;
9505 dgst_pos2 = 2;
9506 dgst_pos3 = 1;
9507 break;
9508
9509 case 8200: hash_type = HASH_TYPE_SHA256;
9510 salt_type = SALT_TYPE_EMBEDDED;
9511 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9512 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9513 kern_type = KERN_TYPE_CLOUDKEY;
9514 dgst_size = DGST_SIZE_4_8;
9515 parse_func = cloudkey_parse_hash;
9516 sort_by_digest = sort_by_digest_4_8;
9517 opti_type = OPTI_TYPE_ZERO_BYTE;
9518 dgst_pos0 = 0;
9519 dgst_pos1 = 1;
9520 dgst_pos2 = 2;
9521 dgst_pos3 = 3;
9522 break;
9523
9524 case 8300: hash_type = HASH_TYPE_SHA1;
9525 salt_type = SALT_TYPE_EMBEDDED;
9526 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9527 opts_type = OPTS_TYPE_PT_GENERATE_BE
9528 | OPTS_TYPE_ST_HEX
9529 | OPTS_TYPE_ST_ADD80;
9530 kern_type = KERN_TYPE_NSEC3;
9531 dgst_size = DGST_SIZE_4_5;
9532 parse_func = nsec3_parse_hash;
9533 sort_by_digest = sort_by_digest_4_5;
9534 opti_type = OPTI_TYPE_ZERO_BYTE;
9535 dgst_pos0 = 3;
9536 dgst_pos1 = 4;
9537 dgst_pos2 = 2;
9538 dgst_pos3 = 1;
9539 break;
9540
9541 case 8400: hash_type = HASH_TYPE_SHA1;
9542 salt_type = SALT_TYPE_INTERN;
9543 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9544 opts_type = OPTS_TYPE_PT_GENERATE_BE
9545 | OPTS_TYPE_PT_ADD80
9546 | OPTS_TYPE_PT_ADDBITS15;
9547 kern_type = KERN_TYPE_WBB3;
9548 dgst_size = DGST_SIZE_4_5;
9549 parse_func = wbb3_parse_hash;
9550 sort_by_digest = sort_by_digest_4_5;
9551 opti_type = OPTI_TYPE_ZERO_BYTE
9552 | OPTI_TYPE_PRECOMPUTE_INIT
9553 | OPTI_TYPE_NOT_ITERATED;
9554 dgst_pos0 = 3;
9555 dgst_pos1 = 4;
9556 dgst_pos2 = 2;
9557 dgst_pos3 = 1;
9558 break;
9559
9560 case 8500: hash_type = HASH_TYPE_DESRACF;
9561 salt_type = SALT_TYPE_EMBEDDED;
9562 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9563 opts_type = OPTS_TYPE_PT_GENERATE_LE
9564 | OPTS_TYPE_ST_UPPER;
9565 kern_type = KERN_TYPE_RACF;
9566 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9567 parse_func = racf_parse_hash;
9568 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9569 opti_type = OPTI_TYPE_ZERO_BYTE
9570 | OPTI_TYPE_PRECOMPUTE_PERMUT;
9571 dgst_pos0 = 0;
9572 dgst_pos1 = 1;
9573 dgst_pos2 = 2;
9574 dgst_pos3 = 3;
9575 break;
9576
9577 case 8600: hash_type = HASH_TYPE_LOTUS5;
9578 salt_type = SALT_TYPE_NONE;
9579 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9580 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9581 kern_type = KERN_TYPE_LOTUS5;
9582 dgst_size = DGST_SIZE_4_4;
9583 parse_func = lotus5_parse_hash;
9584 sort_by_digest = sort_by_digest_4_4;
9585 opti_type = OPTI_TYPE_EARLY_SKIP
9586 | OPTI_TYPE_NOT_ITERATED
9587 | OPTI_TYPE_NOT_SALTED
9588 | OPTI_TYPE_RAW_HASH;
9589 dgst_pos0 = 0;
9590 dgst_pos1 = 1;
9591 dgst_pos2 = 2;
9592 dgst_pos3 = 3;
9593 break;
9594
9595 case 8700: hash_type = HASH_TYPE_LOTUS6;
9596 salt_type = SALT_TYPE_EMBEDDED;
9597 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9598 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9599 kern_type = KERN_TYPE_LOTUS6;
9600 dgst_size = DGST_SIZE_4_4;
9601 parse_func = lotus6_parse_hash;
9602 sort_by_digest = sort_by_digest_4_4;
9603 opti_type = OPTI_TYPE_EARLY_SKIP
9604 | OPTI_TYPE_NOT_ITERATED
9605 | OPTI_TYPE_RAW_HASH;
9606 dgst_pos0 = 0;
9607 dgst_pos1 = 1;
9608 dgst_pos2 = 2;
9609 dgst_pos3 = 3;
9610 break;
9611
9612 case 8800: hash_type = HASH_TYPE_ANDROIDFDE;
9613 salt_type = SALT_TYPE_EMBEDDED;
9614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9615 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9616 kern_type = KERN_TYPE_ANDROIDFDE;
9617 dgst_size = DGST_SIZE_4_4;
9618 parse_func = androidfde_parse_hash;
9619 sort_by_digest = sort_by_digest_4_4;
9620 opti_type = OPTI_TYPE_ZERO_BYTE;
9621 dgst_pos0 = 0;
9622 dgst_pos1 = 1;
9623 dgst_pos2 = 2;
9624 dgst_pos3 = 3;
9625 break;
9626
9627 case 8900: hash_type = HASH_TYPE_SCRYPT;
9628 salt_type = SALT_TYPE_EMBEDDED;
9629 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9630 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9631 kern_type = KERN_TYPE_SCRYPT;
9632 dgst_size = DGST_SIZE_4_8;
9633 parse_func = scrypt_parse_hash;
9634 sort_by_digest = sort_by_digest_4_8;
9635 opti_type = OPTI_TYPE_ZERO_BYTE;
9636 dgst_pos0 = 0;
9637 dgst_pos1 = 1;
9638 dgst_pos2 = 2;
9639 dgst_pos3 = 3;
9640 break;
9641
9642 case 9000: hash_type = HASH_TYPE_SHA1;
9643 salt_type = SALT_TYPE_EMBEDDED;
9644 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9645 opts_type = OPTS_TYPE_PT_GENERATE_LE
9646 | OPTS_TYPE_ST_GENERATE_LE;
9647 kern_type = KERN_TYPE_PSAFE2;
9648 dgst_size = DGST_SIZE_4_5;
9649 parse_func = psafe2_parse_hash;
9650 sort_by_digest = sort_by_digest_4_5;
9651 opti_type = OPTI_TYPE_ZERO_BYTE;
9652 dgst_pos0 = 0;
9653 dgst_pos1 = 1;
9654 dgst_pos2 = 2;
9655 dgst_pos3 = 3;
9656 break;
9657
9658 case 9100: hash_type = HASH_TYPE_LOTUS8;
9659 salt_type = SALT_TYPE_EMBEDDED;
9660 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9661 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9662 kern_type = KERN_TYPE_LOTUS8;
9663 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9664 parse_func = lotus8_parse_hash;
9665 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9666 opti_type = OPTI_TYPE_ZERO_BYTE;
9667 dgst_pos0 = 0;
9668 dgst_pos1 = 1;
9669 dgst_pos2 = 2;
9670 dgst_pos3 = 3;
9671 break;
9672
9673 case 9200: hash_type = HASH_TYPE_SHA256;
9674 salt_type = SALT_TYPE_EMBEDDED;
9675 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9676 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9677 kern_type = KERN_TYPE_PBKDF2_SHA256;
9678 dgst_size = DGST_SIZE_4_32;
9679 parse_func = cisco8_parse_hash;
9680 sort_by_digest = sort_by_digest_4_32;
9681 opti_type = OPTI_TYPE_ZERO_BYTE
9682 | OPTI_TYPE_SLOW_HASH_SIMD;
9683 dgst_pos0 = 0;
9684 dgst_pos1 = 1;
9685 dgst_pos2 = 2;
9686 dgst_pos3 = 3;
9687 break;
9688
9689 case 9300: hash_type = HASH_TYPE_SCRYPT;
9690 salt_type = SALT_TYPE_EMBEDDED;
9691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9693 kern_type = KERN_TYPE_SCRYPT;
9694 dgst_size = DGST_SIZE_4_8;
9695 parse_func = cisco9_parse_hash;
9696 sort_by_digest = sort_by_digest_4_8;
9697 opti_type = OPTI_TYPE_ZERO_BYTE;
9698 dgst_pos0 = 0;
9699 dgst_pos1 = 1;
9700 dgst_pos2 = 2;
9701 dgst_pos3 = 3;
9702 break;
9703
9704 case 9400: hash_type = HASH_TYPE_OFFICE2007;
9705 salt_type = SALT_TYPE_EMBEDDED;
9706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9708 kern_type = KERN_TYPE_OFFICE2007;
9709 dgst_size = DGST_SIZE_4_4;
9710 parse_func = office2007_parse_hash;
9711 sort_by_digest = sort_by_digest_4_4;
9712 opti_type = OPTI_TYPE_ZERO_BYTE;
9713 dgst_pos0 = 0;
9714 dgst_pos1 = 1;
9715 dgst_pos2 = 2;
9716 dgst_pos3 = 3;
9717 break;
9718
9719 case 9500: hash_type = HASH_TYPE_OFFICE2010;
9720 salt_type = SALT_TYPE_EMBEDDED;
9721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9723 kern_type = KERN_TYPE_OFFICE2010;
9724 dgst_size = DGST_SIZE_4_4;
9725 parse_func = office2010_parse_hash;
9726 sort_by_digest = sort_by_digest_4_4;
9727 opti_type = OPTI_TYPE_ZERO_BYTE;
9728 dgst_pos0 = 0;
9729 dgst_pos1 = 1;
9730 dgst_pos2 = 2;
9731 dgst_pos3 = 3;
9732 break;
9733
9734 case 9600: hash_type = HASH_TYPE_OFFICE2013;
9735 salt_type = SALT_TYPE_EMBEDDED;
9736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9737 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9738 kern_type = KERN_TYPE_OFFICE2013;
9739 dgst_size = DGST_SIZE_4_4;
9740 parse_func = office2013_parse_hash;
9741 sort_by_digest = sort_by_digest_4_4;
9742 opti_type = OPTI_TYPE_ZERO_BYTE;
9743 dgst_pos0 = 0;
9744 dgst_pos1 = 1;
9745 dgst_pos2 = 2;
9746 dgst_pos3 = 3;
9747 break;
9748
9749 case 9700: hash_type = HASH_TYPE_OLDOFFICE01;
9750 salt_type = SALT_TYPE_EMBEDDED;
9751 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9752 opts_type = OPTS_TYPE_PT_GENERATE_LE
9753 | OPTS_TYPE_PT_ADD80
9754 | OPTS_TYPE_PT_UNICODE;
9755 kern_type = KERN_TYPE_OLDOFFICE01;
9756 dgst_size = DGST_SIZE_4_4;
9757 parse_func = oldoffice01_parse_hash;
9758 sort_by_digest = sort_by_digest_4_4;
9759 opti_type = OPTI_TYPE_ZERO_BYTE
9760 | OPTI_TYPE_PRECOMPUTE_INIT
9761 | OPTI_TYPE_NOT_ITERATED;
9762 dgst_pos0 = 0;
9763 dgst_pos1 = 1;
9764 dgst_pos2 = 2;
9765 dgst_pos3 = 3;
9766 break;
9767
9768 case 9710: hash_type = HASH_TYPE_OLDOFFICE01;
9769 salt_type = SALT_TYPE_EMBEDDED;
9770 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9771 opts_type = OPTS_TYPE_PT_GENERATE_LE
9772 | OPTS_TYPE_PT_ADD80;
9773 kern_type = KERN_TYPE_OLDOFFICE01CM1;
9774 dgst_size = DGST_SIZE_4_4;
9775 parse_func = oldoffice01cm1_parse_hash;
9776 sort_by_digest = sort_by_digest_4_4;
9777 opti_type = OPTI_TYPE_ZERO_BYTE
9778 | OPTI_TYPE_PRECOMPUTE_INIT
9779 | OPTI_TYPE_NOT_ITERATED;
9780 dgst_pos0 = 0;
9781 dgst_pos1 = 1;
9782 dgst_pos2 = 2;
9783 dgst_pos3 = 3;
9784 break;
9785
9786 case 9720: hash_type = HASH_TYPE_OLDOFFICE01;
9787 salt_type = SALT_TYPE_EMBEDDED;
9788 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9789 opts_type = OPTS_TYPE_PT_GENERATE_LE
9790 | OPTS_TYPE_PT_ADD80
9791 | OPTS_TYPE_PT_UNICODE
9792 | OPTS_TYPE_PT_NEVERCRACK;
9793 kern_type = KERN_TYPE_OLDOFFICE01CM2;
9794 dgst_size = DGST_SIZE_4_4;
9795 parse_func = oldoffice01cm2_parse_hash;
9796 sort_by_digest = sort_by_digest_4_4;
9797 opti_type = OPTI_TYPE_ZERO_BYTE
9798 | OPTI_TYPE_PRECOMPUTE_INIT
9799 | OPTI_TYPE_NOT_ITERATED;
9800 dgst_pos0 = 0;
9801 dgst_pos1 = 1;
9802 dgst_pos2 = 2;
9803 dgst_pos3 = 3;
9804 break;
9805
9806 case 9800: hash_type = HASH_TYPE_OLDOFFICE34;
9807 salt_type = SALT_TYPE_EMBEDDED;
9808 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9809 opts_type = OPTS_TYPE_PT_GENERATE_BE
9810 | OPTS_TYPE_PT_ADD80
9811 | OPTS_TYPE_PT_UNICODE;
9812 kern_type = KERN_TYPE_OLDOFFICE34;
9813 dgst_size = DGST_SIZE_4_4;
9814 parse_func = oldoffice34_parse_hash;
9815 sort_by_digest = sort_by_digest_4_4;
9816 opti_type = OPTI_TYPE_ZERO_BYTE
9817 | OPTI_TYPE_PRECOMPUTE_INIT
9818 | OPTI_TYPE_NOT_ITERATED;
9819 dgst_pos0 = 0;
9820 dgst_pos1 = 1;
9821 dgst_pos2 = 2;
9822 dgst_pos3 = 3;
9823 break;
9824
9825 case 9810: hash_type = HASH_TYPE_OLDOFFICE34;
9826 salt_type = SALT_TYPE_EMBEDDED;
9827 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9828 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9829 kern_type = KERN_TYPE_OLDOFFICE34CM1;
9830 dgst_size = DGST_SIZE_4_4;
9831 parse_func = oldoffice34cm1_parse_hash;
9832 sort_by_digest = sort_by_digest_4_4;
9833 opti_type = OPTI_TYPE_ZERO_BYTE
9834 | OPTI_TYPE_PRECOMPUTE_INIT
9835 | OPTI_TYPE_NOT_ITERATED;
9836 dgst_pos0 = 0;
9837 dgst_pos1 = 1;
9838 dgst_pos2 = 2;
9839 dgst_pos3 = 3;
9840 break;
9841
9842 case 9820: hash_type = HASH_TYPE_OLDOFFICE34;
9843 salt_type = SALT_TYPE_EMBEDDED;
9844 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9845 opts_type = OPTS_TYPE_PT_GENERATE_BE
9846 | OPTS_TYPE_PT_ADD80
9847 | OPTS_TYPE_PT_UNICODE
9848 | OPTS_TYPE_PT_NEVERCRACK;
9849 kern_type = KERN_TYPE_OLDOFFICE34CM2;
9850 dgst_size = DGST_SIZE_4_4;
9851 parse_func = oldoffice34cm2_parse_hash;
9852 sort_by_digest = sort_by_digest_4_4;
9853 opti_type = OPTI_TYPE_ZERO_BYTE
9854 | OPTI_TYPE_PRECOMPUTE_INIT
9855 | OPTI_TYPE_NOT_ITERATED;
9856 dgst_pos0 = 0;
9857 dgst_pos1 = 1;
9858 dgst_pos2 = 2;
9859 dgst_pos3 = 3;
9860 break;
9861
9862 case 9900: hash_type = HASH_TYPE_MD5;
9863 salt_type = SALT_TYPE_NONE;
9864 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9865 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9866 kern_type = KERN_TYPE_RADMIN2;
9867 dgst_size = DGST_SIZE_4_4;
9868 parse_func = radmin2_parse_hash;
9869 sort_by_digest = sort_by_digest_4_4;
9870 opti_type = OPTI_TYPE_ZERO_BYTE
9871 | OPTI_TYPE_PRECOMPUTE_INIT
9872 | OPTI_TYPE_EARLY_SKIP
9873 | OPTI_TYPE_NOT_ITERATED
9874 | OPTI_TYPE_NOT_SALTED;
9875 dgst_pos0 = 0;
9876 dgst_pos1 = 3;
9877 dgst_pos2 = 2;
9878 dgst_pos3 = 1;
9879 break;
9880
9881 case 10000: hash_type = HASH_TYPE_SHA256;
9882 salt_type = SALT_TYPE_EMBEDDED;
9883 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9884 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9885 kern_type = KERN_TYPE_PBKDF2_SHA256;
9886 dgst_size = DGST_SIZE_4_32;
9887 parse_func = djangopbkdf2_parse_hash;
9888 sort_by_digest = sort_by_digest_4_32;
9889 opti_type = OPTI_TYPE_ZERO_BYTE
9890 | OPTI_TYPE_SLOW_HASH_SIMD;
9891 dgst_pos0 = 0;
9892 dgst_pos1 = 1;
9893 dgst_pos2 = 2;
9894 dgst_pos3 = 3;
9895 break;
9896
9897 case 10100: hash_type = HASH_TYPE_SIPHASH;
9898 salt_type = SALT_TYPE_EMBEDDED;
9899 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9900 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9901 kern_type = KERN_TYPE_SIPHASH;
9902 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
9903 parse_func = siphash_parse_hash;
9904 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
9905 opti_type = OPTI_TYPE_ZERO_BYTE
9906 | OPTI_TYPE_NOT_ITERATED
9907 | OPTI_TYPE_RAW_HASH;
9908 dgst_pos0 = 0;
9909 dgst_pos1 = 1;
9910 dgst_pos2 = 2;
9911 dgst_pos3 = 3;
9912 break;
9913
9914 case 10200: hash_type = HASH_TYPE_MD5;
9915 salt_type = SALT_TYPE_EMBEDDED;
9916 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9917 opts_type = OPTS_TYPE_PT_GENERATE_LE
9918 | OPTS_TYPE_ST_ADD80
9919 | OPTS_TYPE_ST_ADDBITS14;
9920 kern_type = KERN_TYPE_HMACMD5_PW;
9921 dgst_size = DGST_SIZE_4_4;
9922 parse_func = crammd5_parse_hash;
9923 sort_by_digest = sort_by_digest_4_4;
9924 opti_type = OPTI_TYPE_ZERO_BYTE
9925 | OPTI_TYPE_NOT_ITERATED;
9926 dgst_pos0 = 0;
9927 dgst_pos1 = 3;
9928 dgst_pos2 = 2;
9929 dgst_pos3 = 1;
9930 break;
9931
9932 case 10300: hash_type = HASH_TYPE_SHA1;
9933 salt_type = SALT_TYPE_EMBEDDED;
9934 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9935 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
9936 kern_type = KERN_TYPE_SAPH_SHA1;
9937 dgst_size = DGST_SIZE_4_5;
9938 parse_func = saph_sha1_parse_hash;
9939 sort_by_digest = sort_by_digest_4_5;
9940 opti_type = OPTI_TYPE_ZERO_BYTE;
9941 dgst_pos0 = 0;
9942 dgst_pos1 = 1;
9943 dgst_pos2 = 2;
9944 dgst_pos3 = 3;
9945 break;
9946
9947 case 10400: hash_type = HASH_TYPE_PDFU16;
9948 salt_type = SALT_TYPE_EMBEDDED;
9949 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9950 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9951 kern_type = KERN_TYPE_PDF11;
9952 dgst_size = DGST_SIZE_4_4;
9953 parse_func = pdf11_parse_hash;
9954 sort_by_digest = sort_by_digest_4_4;
9955 opti_type = OPTI_TYPE_ZERO_BYTE
9956 | OPTI_TYPE_NOT_ITERATED;
9957 dgst_pos0 = 0;
9958 dgst_pos1 = 1;
9959 dgst_pos2 = 2;
9960 dgst_pos3 = 3;
9961 break;
9962
9963 case 10410: hash_type = HASH_TYPE_PDFU16;
9964 salt_type = SALT_TYPE_EMBEDDED;
9965 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9966 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9967 kern_type = KERN_TYPE_PDF11CM1;
9968 dgst_size = DGST_SIZE_4_4;
9969 parse_func = pdf11cm1_parse_hash;
9970 sort_by_digest = sort_by_digest_4_4;
9971 opti_type = OPTI_TYPE_ZERO_BYTE
9972 | OPTI_TYPE_NOT_ITERATED;
9973 dgst_pos0 = 0;
9974 dgst_pos1 = 1;
9975 dgst_pos2 = 2;
9976 dgst_pos3 = 3;
9977 break;
9978
9979 case 10420: hash_type = HASH_TYPE_PDFU16;
9980 salt_type = SALT_TYPE_EMBEDDED;
9981 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
9982 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9983 kern_type = KERN_TYPE_PDF11CM2;
9984 dgst_size = DGST_SIZE_4_4;
9985 parse_func = pdf11cm2_parse_hash;
9986 sort_by_digest = sort_by_digest_4_4;
9987 opti_type = OPTI_TYPE_ZERO_BYTE
9988 | OPTI_TYPE_NOT_ITERATED;
9989 dgst_pos0 = 0;
9990 dgst_pos1 = 1;
9991 dgst_pos2 = 2;
9992 dgst_pos3 = 3;
9993 break;
9994
9995 case 10500: hash_type = HASH_TYPE_PDFU16;
9996 salt_type = SALT_TYPE_EMBEDDED;
9997 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
9998 opts_type = OPTS_TYPE_PT_GENERATE_LE;
9999 kern_type = KERN_TYPE_PDF14;
10000 dgst_size = DGST_SIZE_4_4;
10001 parse_func = pdf14_parse_hash;
10002 sort_by_digest = sort_by_digest_4_4;
10003 opti_type = OPTI_TYPE_ZERO_BYTE
10004 | OPTI_TYPE_NOT_ITERATED;
10005 dgst_pos0 = 0;
10006 dgst_pos1 = 1;
10007 dgst_pos2 = 2;
10008 dgst_pos3 = 3;
10009 break;
10010
10011 case 10600: hash_type = HASH_TYPE_SHA256;
10012 salt_type = SALT_TYPE_EMBEDDED;
10013 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10014 opts_type = OPTS_TYPE_PT_GENERATE_BE
10015 | OPTS_TYPE_ST_ADD80
10016 | OPTS_TYPE_ST_ADDBITS15
10017 | OPTS_TYPE_HASH_COPY;
10018 kern_type = KERN_TYPE_SHA256_PWSLT;
10019 dgst_size = DGST_SIZE_4_8;
10020 parse_func = pdf17l3_parse_hash;
10021 sort_by_digest = sort_by_digest_4_8;
10022 opti_type = OPTI_TYPE_ZERO_BYTE
10023 | OPTI_TYPE_PRECOMPUTE_INIT
10024 | OPTI_TYPE_PRECOMPUTE_MERKLE
10025 | OPTI_TYPE_EARLY_SKIP
10026 | OPTI_TYPE_NOT_ITERATED
10027 | OPTI_TYPE_APPENDED_SALT
10028 | OPTI_TYPE_RAW_HASH;
10029 dgst_pos0 = 3;
10030 dgst_pos1 = 7;
10031 dgst_pos2 = 2;
10032 dgst_pos3 = 6;
10033 break;
10034
10035 case 10700: hash_type = HASH_TYPE_PDFU32;
10036 salt_type = SALT_TYPE_EMBEDDED;
10037 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10038 opts_type = OPTS_TYPE_PT_GENERATE_LE
10039 | OPTS_TYPE_HASH_COPY;
10040 kern_type = KERN_TYPE_PDF17L8;
10041 dgst_size = DGST_SIZE_4_8;
10042 parse_func = pdf17l8_parse_hash;
10043 sort_by_digest = sort_by_digest_4_8;
10044 opti_type = OPTI_TYPE_ZERO_BYTE
10045 | OPTI_TYPE_NOT_ITERATED;
10046 dgst_pos0 = 0;
10047 dgst_pos1 = 1;
10048 dgst_pos2 = 2;
10049 dgst_pos3 = 3;
10050 break;
10051
10052 case 10800: hash_type = HASH_TYPE_SHA384;
10053 salt_type = SALT_TYPE_NONE;
10054 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10055 opts_type = OPTS_TYPE_PT_GENERATE_BE
10056 | OPTS_TYPE_PT_ADD80
10057 | OPTS_TYPE_PT_ADDBITS15;
10058 kern_type = KERN_TYPE_SHA384;
10059 dgst_size = DGST_SIZE_8_8;
10060 parse_func = sha384_parse_hash;
10061 sort_by_digest = sort_by_digest_8_8;
10062 opti_type = OPTI_TYPE_ZERO_BYTE
10063 | OPTI_TYPE_PRECOMPUTE_INIT
10064 | OPTI_TYPE_PRECOMPUTE_MERKLE
10065 | OPTI_TYPE_EARLY_SKIP
10066 | OPTI_TYPE_NOT_ITERATED
10067 | OPTI_TYPE_NOT_SALTED
10068 | OPTI_TYPE_USES_BITS_64
10069 | OPTI_TYPE_RAW_HASH;
10070 dgst_pos0 = 6;
10071 dgst_pos1 = 7;
10072 dgst_pos2 = 4;
10073 dgst_pos3 = 5;
10074 break;
10075
10076 case 10900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10077 salt_type = SALT_TYPE_EMBEDDED;
10078 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10079 opts_type = OPTS_TYPE_PT_GENERATE_LE
10080 | OPTS_TYPE_ST_BASE64
10081 | OPTS_TYPE_HASH_COPY;
10082 kern_type = KERN_TYPE_PBKDF2_SHA256;
10083 dgst_size = DGST_SIZE_4_32;
10084 parse_func = pbkdf2_sha256_parse_hash;
10085 sort_by_digest = sort_by_digest_4_32;
10086 opti_type = OPTI_TYPE_ZERO_BYTE
10087 | OPTI_TYPE_SLOW_HASH_SIMD;
10088 dgst_pos0 = 0;
10089 dgst_pos1 = 1;
10090 dgst_pos2 = 2;
10091 dgst_pos3 = 3;
10092 break;
10093
10094 case 11000: hash_type = HASH_TYPE_MD5;
10095 salt_type = SALT_TYPE_INTERN;
10096 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10097 opts_type = OPTS_TYPE_PT_GENERATE_LE
10098 | OPTS_TYPE_PT_ADD80;
10099 kern_type = KERN_TYPE_PRESTASHOP;
10100 dgst_size = DGST_SIZE_4_4;
10101 parse_func = prestashop_parse_hash;
10102 sort_by_digest = sort_by_digest_4_4;
10103 opti_type = OPTI_TYPE_ZERO_BYTE
10104 | OPTI_TYPE_PRECOMPUTE_INIT
10105 | OPTI_TYPE_NOT_ITERATED
10106 | OPTI_TYPE_PREPENDED_SALT;
10107 dgst_pos0 = 0;
10108 dgst_pos1 = 3;
10109 dgst_pos2 = 2;
10110 dgst_pos3 = 1;
10111 break;
10112
10113 case 11100: hash_type = HASH_TYPE_MD5;
10114 salt_type = SALT_TYPE_EMBEDDED;
10115 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10116 opts_type = OPTS_TYPE_PT_GENERATE_LE
10117 | OPTS_TYPE_ST_ADD80;
10118 kern_type = KERN_TYPE_POSTGRESQL_AUTH;
10119 dgst_size = DGST_SIZE_4_4;
10120 parse_func = postgresql_auth_parse_hash;
10121 sort_by_digest = sort_by_digest_4_4;
10122 opti_type = OPTI_TYPE_ZERO_BYTE
10123 | OPTI_TYPE_PRECOMPUTE_INIT
10124 | OPTI_TYPE_PRECOMPUTE_MERKLE
10125 | OPTI_TYPE_EARLY_SKIP;
10126 dgst_pos0 = 0;
10127 dgst_pos1 = 3;
10128 dgst_pos2 = 2;
10129 dgst_pos3 = 1;
10130 break;
10131
10132 case 11200: hash_type = HASH_TYPE_SHA1;
10133 salt_type = SALT_TYPE_EMBEDDED;
10134 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10135 opts_type = OPTS_TYPE_PT_GENERATE_BE
10136 | OPTS_TYPE_PT_ADD80
10137 | OPTS_TYPE_ST_HEX;
10138 kern_type = KERN_TYPE_MYSQL_AUTH;
10139 dgst_size = DGST_SIZE_4_5;
10140 parse_func = mysql_auth_parse_hash;
10141 sort_by_digest = sort_by_digest_4_5;
10142 opti_type = OPTI_TYPE_ZERO_BYTE
10143 | OPTI_TYPE_EARLY_SKIP;
10144 dgst_pos0 = 3;
10145 dgst_pos1 = 4;
10146 dgst_pos2 = 2;
10147 dgst_pos3 = 1;
10148 break;
10149
10150 case 11300: hash_type = HASH_TYPE_BITCOIN_WALLET;
10151 salt_type = SALT_TYPE_EMBEDDED;
10152 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10153 opts_type = OPTS_TYPE_PT_GENERATE_LE
10154 | OPTS_TYPE_ST_HEX
10155 | OPTS_TYPE_ST_ADD80;
10156 kern_type = KERN_TYPE_BITCOIN_WALLET;
10157 dgst_size = DGST_SIZE_4_4;
10158 parse_func = bitcoin_wallet_parse_hash;
10159 sort_by_digest = sort_by_digest_4_4;
10160 opti_type = OPTI_TYPE_ZERO_BYTE;
10161 dgst_pos0 = 0;
10162 dgst_pos1 = 1;
10163 dgst_pos2 = 2;
10164 dgst_pos3 = 3;
10165 break;
10166
10167 case 11400: hash_type = HASH_TYPE_MD5;
10168 salt_type = SALT_TYPE_EMBEDDED;
10169 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10170 opts_type = OPTS_TYPE_PT_GENERATE_LE
10171 | OPTS_TYPE_PT_ADD80
10172 | OPTS_TYPE_HASH_COPY;
10173 kern_type = KERN_TYPE_SIP_AUTH;
10174 dgst_size = DGST_SIZE_4_4;
10175 parse_func = sip_auth_parse_hash;
10176 sort_by_digest = sort_by_digest_4_4;
10177 opti_type = OPTI_TYPE_ZERO_BYTE;
10178 dgst_pos0 = 0;
10179 dgst_pos1 = 3;
10180 dgst_pos2 = 2;
10181 dgst_pos3 = 1;
10182 break;
10183
10184 case 11500: hash_type = HASH_TYPE_CRC32;
10185 salt_type = SALT_TYPE_INTERN;
10186 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10187 opts_type = OPTS_TYPE_PT_GENERATE_LE
10188 | OPTS_TYPE_ST_GENERATE_LE
10189 | OPTS_TYPE_ST_HEX;
10190 kern_type = KERN_TYPE_CRC32;
10191 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10192 parse_func = crc32_parse_hash;
10193 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10194 opti_type = OPTI_TYPE_ZERO_BYTE;
10195 dgst_pos0 = 0;
10196 dgst_pos1 = 1;
10197 dgst_pos2 = 2;
10198 dgst_pos3 = 3;
10199 break;
10200
10201 case 11600: hash_type = HASH_TYPE_AES;
10202 salt_type = SALT_TYPE_EMBEDDED;
10203 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10204 opts_type = OPTS_TYPE_PT_GENERATE_LE
10205 | OPTS_TYPE_PT_NEVERCRACK;
10206 kern_type = KERN_TYPE_SEVEN_ZIP;
10207 dgst_size = DGST_SIZE_4_4; // originally DGST_SIZE_4_2
10208 parse_func = seven_zip_parse_hash;
10209 sort_by_digest = sort_by_digest_4_4; // originally sort_by_digest_4_2
10210 opti_type = OPTI_TYPE_ZERO_BYTE;
10211 dgst_pos0 = 0;
10212 dgst_pos1 = 1;
10213 dgst_pos2 = 2;
10214 dgst_pos3 = 3;
10215 break;
10216
10217 case 11700: hash_type = HASH_TYPE_GOST_2012SBOG_256;
10218 salt_type = SALT_TYPE_NONE;
10219 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10220 opts_type = OPTS_TYPE_PT_GENERATE_LE
10221 | OPTS_TYPE_PT_ADD01;
10222 kern_type = KERN_TYPE_GOST_2012SBOG_256;
10223 dgst_size = DGST_SIZE_4_8;
10224 parse_func = gost2012sbog_256_parse_hash;
10225 sort_by_digest = sort_by_digest_4_8;
10226 opti_type = OPTI_TYPE_ZERO_BYTE;
10227 dgst_pos0 = 0;
10228 dgst_pos1 = 1;
10229 dgst_pos2 = 2;
10230 dgst_pos3 = 3;
10231 break;
10232
10233 case 11800: hash_type = HASH_TYPE_GOST_2012SBOG_512;
10234 salt_type = SALT_TYPE_NONE;
10235 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10236 opts_type = OPTS_TYPE_PT_GENERATE_LE
10237 | OPTS_TYPE_PT_ADD01;
10238 kern_type = KERN_TYPE_GOST_2012SBOG_512;
10239 dgst_size = DGST_SIZE_4_16;
10240 parse_func = gost2012sbog_512_parse_hash;
10241 sort_by_digest = sort_by_digest_4_16;
10242 opti_type = OPTI_TYPE_ZERO_BYTE;
10243 dgst_pos0 = 0;
10244 dgst_pos1 = 1;
10245 dgst_pos2 = 2;
10246 dgst_pos3 = 3;
10247 break;
10248
10249 case 11900: hash_type = HASH_TYPE_PBKDF2_MD5;
10250 salt_type = SALT_TYPE_EMBEDDED;
10251 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10252 opts_type = OPTS_TYPE_PT_GENERATE_LE
10253 | OPTS_TYPE_ST_BASE64
10254 | OPTS_TYPE_HASH_COPY;
10255 kern_type = KERN_TYPE_PBKDF2_MD5;
10256 dgst_size = DGST_SIZE_4_32;
10257 parse_func = pbkdf2_md5_parse_hash;
10258 sort_by_digest = sort_by_digest_4_32;
10259 opti_type = OPTI_TYPE_ZERO_BYTE
10260 | OPTI_TYPE_SLOW_HASH_SIMD;
10261 dgst_pos0 = 0;
10262 dgst_pos1 = 1;
10263 dgst_pos2 = 2;
10264 dgst_pos3 = 3;
10265 break;
10266
10267 case 12000: hash_type = HASH_TYPE_PBKDF2_SHA1;
10268 salt_type = SALT_TYPE_EMBEDDED;
10269 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10270 opts_type = OPTS_TYPE_PT_GENERATE_LE
10271 | OPTS_TYPE_ST_BASE64
10272 | OPTS_TYPE_HASH_COPY;
10273 kern_type = KERN_TYPE_PBKDF2_SHA1;
10274 dgst_size = DGST_SIZE_4_32;
10275 parse_func = pbkdf2_sha1_parse_hash;
10276 sort_by_digest = sort_by_digest_4_32;
10277 opti_type = OPTI_TYPE_ZERO_BYTE
10278 | OPTI_TYPE_SLOW_HASH_SIMD;
10279 dgst_pos0 = 0;
10280 dgst_pos1 = 1;
10281 dgst_pos2 = 2;
10282 dgst_pos3 = 3;
10283 break;
10284
10285 case 12100: hash_type = HASH_TYPE_PBKDF2_SHA512;
10286 salt_type = SALT_TYPE_EMBEDDED;
10287 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10288 opts_type = OPTS_TYPE_PT_GENERATE_LE
10289 | OPTS_TYPE_ST_BASE64
10290 | OPTS_TYPE_HASH_COPY;
10291 kern_type = KERN_TYPE_PBKDF2_SHA512;
10292 dgst_size = DGST_SIZE_8_16;
10293 parse_func = pbkdf2_sha512_parse_hash;
10294 sort_by_digest = sort_by_digest_8_16;
10295 opti_type = OPTI_TYPE_ZERO_BYTE
10296 | OPTI_TYPE_USES_BITS_64
10297 | OPTI_TYPE_SLOW_HASH_SIMD;
10298 dgst_pos0 = 0;
10299 dgst_pos1 = 1;
10300 dgst_pos2 = 2;
10301 dgst_pos3 = 3;
10302 break;
10303
10304 case 12200: hash_type = HASH_TYPE_ECRYPTFS;
10305 salt_type = SALT_TYPE_EMBEDDED;
10306 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10307 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10308 kern_type = KERN_TYPE_ECRYPTFS;
10309 dgst_size = DGST_SIZE_8_8;
10310 parse_func = ecryptfs_parse_hash;
10311 sort_by_digest = sort_by_digest_8_8;
10312 opti_type = OPTI_TYPE_ZERO_BYTE
10313 | OPTI_TYPE_USES_BITS_64;
10314 dgst_pos0 = 0;
10315 dgst_pos1 = 1;
10316 dgst_pos2 = 2;
10317 dgst_pos3 = 3;
10318 break;
10319
10320 case 12300: hash_type = HASH_TYPE_ORACLET;
10321 salt_type = SALT_TYPE_EMBEDDED;
10322 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10323 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10324 kern_type = KERN_TYPE_ORACLET;
10325 dgst_size = DGST_SIZE_8_16;
10326 parse_func = oraclet_parse_hash;
10327 sort_by_digest = sort_by_digest_8_16;
10328 opti_type = OPTI_TYPE_ZERO_BYTE
10329 | OPTI_TYPE_USES_BITS_64;
10330 dgst_pos0 = 0;
10331 dgst_pos1 = 1;
10332 dgst_pos2 = 2;
10333 dgst_pos3 = 3;
10334 break;
10335
10336 case 12400: hash_type = HASH_TYPE_BSDICRYPT;
10337 salt_type = SALT_TYPE_EMBEDDED;
10338 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10339 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10340 kern_type = KERN_TYPE_BSDICRYPT;
10341 dgst_size = DGST_SIZE_4_4;
10342 parse_func = bsdicrypt_parse_hash;
10343 sort_by_digest = sort_by_digest_4_4;
10344 opti_type = OPTI_TYPE_ZERO_BYTE
10345 | OPTI_TYPE_PRECOMPUTE_PERMUT;
10346 dgst_pos0 = 0;
10347 dgst_pos1 = 1;
10348 dgst_pos2 = 2;
10349 dgst_pos3 = 3;
10350 break;
10351
10352 case 12500: hash_type = HASH_TYPE_RAR3HP;
10353 salt_type = SALT_TYPE_EMBEDDED;
10354 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10355 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10356 kern_type = KERN_TYPE_RAR3;
10357 dgst_size = DGST_SIZE_4_4;
10358 parse_func = rar3hp_parse_hash;
10359 sort_by_digest = sort_by_digest_4_4;
10360 opti_type = OPTI_TYPE_ZERO_BYTE;
10361 dgst_pos0 = 0;
10362 dgst_pos1 = 1;
10363 dgst_pos2 = 2;
10364 dgst_pos3 = 3;
10365 break;
10366
10367 case 12600: hash_type = HASH_TYPE_SHA256;
10368 salt_type = SALT_TYPE_INTERN;
10369 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10370 opts_type = OPTS_TYPE_PT_GENERATE_BE
10371 | OPTS_TYPE_PT_ADD80;
10372 kern_type = KERN_TYPE_CF10;
10373 dgst_size = DGST_SIZE_4_8;
10374 parse_func = cf10_parse_hash;
10375 sort_by_digest = sort_by_digest_4_8;
10376 opti_type = OPTI_TYPE_ZERO_BYTE
10377 | OPTI_TYPE_PRECOMPUTE_INIT
10378 | OPTI_TYPE_EARLY_SKIP
10379 | OPTI_TYPE_NOT_ITERATED;
10380 dgst_pos0 = 3;
10381 dgst_pos1 = 7;
10382 dgst_pos2 = 2;
10383 dgst_pos3 = 6;
10384 break;
10385
10386 case 12700: hash_type = HASH_TYPE_AES;
10387 salt_type = SALT_TYPE_EMBEDDED;
10388 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10389 opts_type = OPTS_TYPE_PT_GENERATE_LE
10390 | OPTS_TYPE_HASH_COPY;
10391 kern_type = KERN_TYPE_MYWALLET;
10392 dgst_size = DGST_SIZE_4_5; // because kernel uses _SHA1_
10393 parse_func = mywallet_parse_hash;
10394 sort_by_digest = sort_by_digest_4_5;
10395 opti_type = OPTI_TYPE_ZERO_BYTE;
10396 dgst_pos0 = 0;
10397 dgst_pos1 = 1;
10398 dgst_pos2 = 2;
10399 dgst_pos3 = 3;
10400 break;
10401
10402 case 12800: hash_type = HASH_TYPE_PBKDF2_SHA256;
10403 salt_type = SALT_TYPE_EMBEDDED;
10404 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10405 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10406 kern_type = KERN_TYPE_MS_DRSR;
10407 dgst_size = DGST_SIZE_4_8;
10408 parse_func = ms_drsr_parse_hash;
10409 sort_by_digest = sort_by_digest_4_8;
10410 opti_type = OPTI_TYPE_ZERO_BYTE;
10411 dgst_pos0 = 0;
10412 dgst_pos1 = 1;
10413 dgst_pos2 = 2;
10414 dgst_pos3 = 3;
10415 break;
10416
10417 case 12900: hash_type = HASH_TYPE_PBKDF2_SHA256;
10418 salt_type = SALT_TYPE_EMBEDDED;
10419 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10420 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10421 kern_type = KERN_TYPE_ANDROIDFDE_SAMSUNG;
10422 dgst_size = DGST_SIZE_4_8;
10423 parse_func = androidfde_samsung_parse_hash;
10424 sort_by_digest = sort_by_digest_4_8;
10425 opti_type = OPTI_TYPE_ZERO_BYTE;
10426 dgst_pos0 = 0;
10427 dgst_pos1 = 1;
10428 dgst_pos2 = 2;
10429 dgst_pos3 = 3;
10430 break;
10431
10432 case 13000: hash_type = HASH_TYPE_PBKDF2_SHA256;
10433 salt_type = SALT_TYPE_EMBEDDED;
10434 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10435 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10436 kern_type = KERN_TYPE_RAR5;
10437 dgst_size = DGST_SIZE_4_4;
10438 parse_func = rar5_parse_hash;
10439 sort_by_digest = sort_by_digest_4_4;
10440 opti_type = OPTI_TYPE_ZERO_BYTE;
10441 dgst_pos0 = 0;
10442 dgst_pos1 = 1;
10443 dgst_pos2 = 2;
10444 dgst_pos3 = 3;
10445 break;
10446
10447 case 13100: hash_type = HASH_TYPE_KRB5TGS;
10448 salt_type = SALT_TYPE_EMBEDDED;
10449 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10450 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10451 kern_type = KERN_TYPE_KRB5TGS;
10452 dgst_size = DGST_SIZE_4_4;
10453 parse_func = krb5tgs_parse_hash;
10454 sort_by_digest = sort_by_digest_4_4;
10455 opti_type = OPTI_TYPE_ZERO_BYTE
10456 | OPTI_TYPE_NOT_ITERATED;
10457 dgst_pos0 = 0;
10458 dgst_pos1 = 1;
10459 dgst_pos2 = 2;
10460 dgst_pos3 = 3;
10461 break;
10462
10463 case 13200: hash_type = HASH_TYPE_AES;
10464 salt_type = SALT_TYPE_EMBEDDED;
10465 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10466 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10467 kern_type = KERN_TYPE_AXCRYPT;
10468 dgst_size = DGST_SIZE_4_4;
10469 parse_func = axcrypt_parse_hash;
10470 sort_by_digest = sort_by_digest_4_4;
10471 opti_type = OPTI_TYPE_ZERO_BYTE;
10472 dgst_pos0 = 0;
10473 dgst_pos1 = 1;
10474 dgst_pos2 = 2;
10475 dgst_pos3 = 3;
10476 break;
10477
10478 case 13300: hash_type = HASH_TYPE_SHA1;
10479 salt_type = SALT_TYPE_NONE;
10480 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10481 opts_type = OPTS_TYPE_PT_GENERATE_BE
10482 | OPTS_TYPE_PT_ADD80
10483 | OPTS_TYPE_PT_ADDBITS15;
10484 kern_type = KERN_TYPE_SHA1_AXCRYPT;
10485 dgst_size = DGST_SIZE_4_5;
10486 parse_func = sha1axcrypt_parse_hash;
10487 sort_by_digest = sort_by_digest_4_5;
10488 opti_type = OPTI_TYPE_ZERO_BYTE
10489 | OPTI_TYPE_PRECOMPUTE_INIT
10490 | OPTI_TYPE_EARLY_SKIP
10491 | OPTI_TYPE_NOT_ITERATED
10492 | OPTI_TYPE_NOT_SALTED;
10493 dgst_pos0 = 0;
10494 dgst_pos1 = 4;
10495 dgst_pos2 = 3;
10496 dgst_pos3 = 2;
10497 break;
10498
10499 case 13400: hash_type = HASH_TYPE_AES;
10500 salt_type = SALT_TYPE_EMBEDDED;
10501 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10502 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10503 kern_type = KERN_TYPE_KEEPASS;
10504 dgst_size = DGST_SIZE_4_4;
10505 parse_func = keepass_parse_hash;
10506 sort_by_digest = sort_by_digest_4_4;
10507 opti_type = OPTI_TYPE_ZERO_BYTE;
10508 dgst_pos0 = 0;
10509 dgst_pos1 = 1;
10510 dgst_pos2 = 2;
10511 dgst_pos3 = 3;
10512 break;
10513
10514 case 13500: hash_type = HASH_TYPE_SHA1;
10515 salt_type = SALT_TYPE_EMBEDDED;
10516 attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
10517 opts_type = OPTS_TYPE_PT_GENERATE_BE
10518 | OPTS_TYPE_PT_UNICODE
10519 | OPTS_TYPE_PT_ADD80;
10520 kern_type = KERN_TYPE_PSTOKEN;
10521 dgst_size = DGST_SIZE_4_5;
10522 parse_func = pstoken_parse_hash;
10523 sort_by_digest = sort_by_digest_4_5;
10524 opti_type = OPTI_TYPE_ZERO_BYTE
10525 | OPTI_TYPE_PRECOMPUTE_INIT
10526 | OPTI_TYPE_EARLY_SKIP
10527 | OPTI_TYPE_NOT_ITERATED
10528 | OPTI_TYPE_PREPENDED_SALT
10529 | OPTI_TYPE_RAW_HASH;
10530 dgst_pos0 = 3;
10531 dgst_pos1 = 4;
10532 dgst_pos2 = 2;
10533 dgst_pos3 = 1;
10534 break;
10535
10536 case 13600: hash_type = HASH_TYPE_PBKDF2_SHA1;
10537 salt_type = SALT_TYPE_EMBEDDED;
10538 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10539 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10540 kern_type = KERN_TYPE_ZIP2;
10541 dgst_size = DGST_SIZE_4_4;
10542 parse_func = zip2_parse_hash;
10543 sort_by_digest = sort_by_digest_4_4;
10544 opti_type = OPTI_TYPE_ZERO_BYTE;
10545 dgst_pos0 = 0;
10546 dgst_pos1 = 1;
10547 dgst_pos2 = 2;
10548 dgst_pos3 = 3;
10549 break;
10550
10551 case 13711: hash_type = HASH_TYPE_RIPEMD160;
10552 salt_type = SALT_TYPE_EMBEDDED;
10553 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10554 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10555 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10556 dgst_size = DGST_SIZE_4_5;
10557 parse_func = veracrypt_parse_hash_655331;
10558 sort_by_digest = sort_by_digest_4_5;
10559 opti_type = OPTI_TYPE_ZERO_BYTE;
10560 dgst_pos0 = 0;
10561 dgst_pos1 = 1;
10562 dgst_pos2 = 2;
10563 dgst_pos3 = 3;
10564 break;
10565
10566 case 13712: hash_type = HASH_TYPE_RIPEMD160;
10567 salt_type = SALT_TYPE_EMBEDDED;
10568 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10569 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10570 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10571 dgst_size = DGST_SIZE_4_5;
10572 parse_func = veracrypt_parse_hash_655331;
10573 sort_by_digest = sort_by_digest_4_5;
10574 opti_type = OPTI_TYPE_ZERO_BYTE;
10575 dgst_pos0 = 0;
10576 dgst_pos1 = 1;
10577 dgst_pos2 = 2;
10578 dgst_pos3 = 3;
10579 break;
10580
10581 case 13713: hash_type = HASH_TYPE_RIPEMD160;
10582 salt_type = SALT_TYPE_EMBEDDED;
10583 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10584 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10585 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10586 dgst_size = DGST_SIZE_4_5;
10587 parse_func = veracrypt_parse_hash_655331;
10588 sort_by_digest = sort_by_digest_4_5;
10589 opti_type = OPTI_TYPE_ZERO_BYTE;
10590 dgst_pos0 = 0;
10591 dgst_pos1 = 1;
10592 dgst_pos2 = 2;
10593 dgst_pos3 = 3;
10594 break;
10595
10596 case 13721: hash_type = HASH_TYPE_SHA512;
10597 salt_type = SALT_TYPE_EMBEDDED;
10598 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10599 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10600 kern_type = KERN_TYPE_TCSHA512_XTS512;
10601 dgst_size = DGST_SIZE_8_8;
10602 parse_func = veracrypt_parse_hash_500000;
10603 sort_by_digest = sort_by_digest_8_8;
10604 opti_type = OPTI_TYPE_ZERO_BYTE
10605 | OPTI_TYPE_USES_BITS_64;
10606 dgst_pos0 = 0;
10607 dgst_pos1 = 1;
10608 dgst_pos2 = 2;
10609 dgst_pos3 = 3;
10610 break;
10611
10612 case 13722: hash_type = HASH_TYPE_SHA512;
10613 salt_type = SALT_TYPE_EMBEDDED;
10614 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10615 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10616 kern_type = KERN_TYPE_TCSHA512_XTS1024;
10617 dgst_size = DGST_SIZE_8_8;
10618 parse_func = veracrypt_parse_hash_500000;
10619 sort_by_digest = sort_by_digest_8_8;
10620 opti_type = OPTI_TYPE_ZERO_BYTE
10621 | OPTI_TYPE_USES_BITS_64;
10622 dgst_pos0 = 0;
10623 dgst_pos1 = 1;
10624 dgst_pos2 = 2;
10625 dgst_pos3 = 3;
10626 break;
10627
10628 case 13723: hash_type = HASH_TYPE_SHA512;
10629 salt_type = SALT_TYPE_EMBEDDED;
10630 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10631 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10632 kern_type = KERN_TYPE_TCSHA512_XTS1536;
10633 dgst_size = DGST_SIZE_8_8;
10634 parse_func = veracrypt_parse_hash_500000;
10635 sort_by_digest = sort_by_digest_8_8;
10636 opti_type = OPTI_TYPE_ZERO_BYTE
10637 | OPTI_TYPE_USES_BITS_64;
10638 dgst_pos0 = 0;
10639 dgst_pos1 = 1;
10640 dgst_pos2 = 2;
10641 dgst_pos3 = 3;
10642 break;
10643
10644 case 13731: hash_type = HASH_TYPE_WHIRLPOOL;
10645 salt_type = SALT_TYPE_EMBEDDED;
10646 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10647 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10648 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512;
10649 dgst_size = DGST_SIZE_4_8;
10650 parse_func = veracrypt_parse_hash_500000;
10651 sort_by_digest = sort_by_digest_4_8;
10652 opti_type = OPTI_TYPE_ZERO_BYTE;
10653 dgst_pos0 = 0;
10654 dgst_pos1 = 1;
10655 dgst_pos2 = 2;
10656 dgst_pos3 = 3;
10657 break;
10658
10659 case 13732: hash_type = HASH_TYPE_WHIRLPOOL;
10660 salt_type = SALT_TYPE_EMBEDDED;
10661 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10662 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10663 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024;
10664 dgst_size = DGST_SIZE_4_8;
10665 parse_func = veracrypt_parse_hash_500000;
10666 sort_by_digest = sort_by_digest_4_8;
10667 opti_type = OPTI_TYPE_ZERO_BYTE;
10668 dgst_pos0 = 0;
10669 dgst_pos1 = 1;
10670 dgst_pos2 = 2;
10671 dgst_pos3 = 3;
10672 break;
10673
10674 case 13733: hash_type = HASH_TYPE_WHIRLPOOL;
10675 salt_type = SALT_TYPE_EMBEDDED;
10676 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10677 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10678 kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536;
10679 dgst_size = DGST_SIZE_4_8;
10680 parse_func = veracrypt_parse_hash_500000;
10681 sort_by_digest = sort_by_digest_4_8;
10682 opti_type = OPTI_TYPE_ZERO_BYTE;
10683 dgst_pos0 = 0;
10684 dgst_pos1 = 1;
10685 dgst_pos2 = 2;
10686 dgst_pos3 = 3;
10687 break;
10688
10689 case 13741: hash_type = HASH_TYPE_RIPEMD160;
10690 salt_type = SALT_TYPE_EMBEDDED;
10691 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10692 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10693 kern_type = KERN_TYPE_TCRIPEMD160_XTS512;
10694 dgst_size = DGST_SIZE_4_5;
10695 parse_func = veracrypt_parse_hash_327661;
10696 sort_by_digest = sort_by_digest_4_5;
10697 opti_type = OPTI_TYPE_ZERO_BYTE;
10698 dgst_pos0 = 0;
10699 dgst_pos1 = 1;
10700 dgst_pos2 = 2;
10701 dgst_pos3 = 3;
10702 break;
10703
10704 case 13742: hash_type = HASH_TYPE_RIPEMD160;
10705 salt_type = SALT_TYPE_EMBEDDED;
10706 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10707 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10708 kern_type = KERN_TYPE_TCRIPEMD160_XTS1024;
10709 dgst_size = DGST_SIZE_4_5;
10710 parse_func = veracrypt_parse_hash_327661;
10711 sort_by_digest = sort_by_digest_4_5;
10712 opti_type = OPTI_TYPE_ZERO_BYTE;
10713 dgst_pos0 = 0;
10714 dgst_pos1 = 1;
10715 dgst_pos2 = 2;
10716 dgst_pos3 = 3;
10717 break;
10718
10719 case 13743: hash_type = HASH_TYPE_RIPEMD160;
10720 salt_type = SALT_TYPE_EMBEDDED;
10721 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10722 opts_type = OPTS_TYPE_PT_GENERATE_LE;
10723 kern_type = KERN_TYPE_TCRIPEMD160_XTS1536;
10724 dgst_size = DGST_SIZE_4_5;
10725 parse_func = veracrypt_parse_hash_327661;
10726 sort_by_digest = sort_by_digest_4_5;
10727 opti_type = OPTI_TYPE_ZERO_BYTE;
10728 dgst_pos0 = 0;
10729 dgst_pos1 = 1;
10730 dgst_pos2 = 2;
10731 dgst_pos3 = 3;
10732 break;
10733
10734 case 13751: hash_type = HASH_TYPE_SHA256;
10735 salt_type = SALT_TYPE_EMBEDDED;
10736 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10737 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10738 kern_type = KERN_TYPE_VCSHA256_XTS512;
10739 dgst_size = DGST_SIZE_4_8;
10740 parse_func = veracrypt_parse_hash_500000;
10741 sort_by_digest = sort_by_digest_4_8;
10742 opti_type = OPTI_TYPE_ZERO_BYTE;
10743 dgst_pos0 = 0;
10744 dgst_pos1 = 1;
10745 dgst_pos2 = 2;
10746 dgst_pos3 = 3;
10747 break;
10748
10749 case 13752: hash_type = HASH_TYPE_SHA256;
10750 salt_type = SALT_TYPE_EMBEDDED;
10751 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10752 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10753 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10754 dgst_size = DGST_SIZE_4_8;
10755 parse_func = veracrypt_parse_hash_500000;
10756 sort_by_digest = sort_by_digest_4_8;
10757 opti_type = OPTI_TYPE_ZERO_BYTE;
10758 dgst_pos0 = 0;
10759 dgst_pos1 = 1;
10760 dgst_pos2 = 2;
10761 dgst_pos3 = 3;
10762 break;
10763
10764 case 13753: hash_type = HASH_TYPE_SHA256;
10765 salt_type = SALT_TYPE_EMBEDDED;
10766 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10767 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10768 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10769 dgst_size = DGST_SIZE_4_8;
10770 parse_func = veracrypt_parse_hash_500000;
10771 sort_by_digest = sort_by_digest_4_8;
10772 opti_type = OPTI_TYPE_ZERO_BYTE;
10773 dgst_pos0 = 0;
10774 dgst_pos1 = 1;
10775 dgst_pos2 = 2;
10776 dgst_pos3 = 3;
10777 break;
10778
10779 case 13761: hash_type = HASH_TYPE_SHA256;
10780 salt_type = SALT_TYPE_EMBEDDED;
10781 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10782 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10783 kern_type = KERN_TYPE_VCSHA256_XTS512;
10784 dgst_size = DGST_SIZE_4_8;
10785 parse_func = veracrypt_parse_hash_200000;
10786 sort_by_digest = sort_by_digest_4_8;
10787 opti_type = OPTI_TYPE_ZERO_BYTE;
10788 dgst_pos0 = 0;
10789 dgst_pos1 = 1;
10790 dgst_pos2 = 2;
10791 dgst_pos3 = 3;
10792 break;
10793
10794 case 13762: hash_type = HASH_TYPE_SHA256;
10795 salt_type = SALT_TYPE_EMBEDDED;
10796 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10797 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10798 kern_type = KERN_TYPE_VCSHA256_XTS1024;
10799 dgst_size = DGST_SIZE_4_8;
10800 parse_func = veracrypt_parse_hash_200000;
10801 sort_by_digest = sort_by_digest_4_8;
10802 opti_type = OPTI_TYPE_ZERO_BYTE;
10803 dgst_pos0 = 0;
10804 dgst_pos1 = 1;
10805 dgst_pos2 = 2;
10806 dgst_pos3 = 3;
10807 break;
10808
10809 case 13763: hash_type = HASH_TYPE_SHA256;
10810 salt_type = SALT_TYPE_EMBEDDED;
10811 attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL;
10812 opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE
10813 kern_type = KERN_TYPE_VCSHA256_XTS1536;
10814 dgst_size = DGST_SIZE_4_8;
10815 parse_func = veracrypt_parse_hash_200000;
10816 sort_by_digest = sort_by_digest_4_8;
10817 opti_type = OPTI_TYPE_ZERO_BYTE;
10818 dgst_pos0 = 0;
10819 dgst_pos1 = 1;
10820 dgst_pos2 = 2;
10821 dgst_pos3 = 3;
10822 break;
10823
10824
10825 default: usage_mini_print (PROGNAME); return (-1);
10826 }
10827
10828 /**
10829 * parser
10830 */
10831
10832 data.parse_func = parse_func;
10833
10834 /**
10835 * misc stuff
10836 */
10837
10838 if (hex_salt)
10839 {
10840 if (salt_type == SALT_TYPE_INTERN)
10841 {
10842 opts_type |= OPTS_TYPE_ST_HEX;
10843 }
10844 else
10845 {
10846 log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode);
10847
10848 return (-1);
10849 }
10850 }
10851
10852 uint isSalted = ((salt_type == SALT_TYPE_INTERN)
10853 | (salt_type == SALT_TYPE_EXTERN)
10854 | (salt_type == SALT_TYPE_EMBEDDED)
10855 | (salt_type == SALT_TYPE_VIRTUAL));
10856
10857 sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest
10858
10859 data.hash_type = hash_type;
10860 data.attack_mode = attack_mode;
10861 data.attack_kern = attack_kern;
10862 data.attack_exec = attack_exec;
10863 data.kern_type = kern_type;
10864 data.opts_type = opts_type;
10865 data.dgst_size = dgst_size;
10866 data.salt_type = salt_type;
10867 data.isSalted = isSalted;
10868 data.sort_by_digest = sort_by_digest;
10869 data.dgst_pos0 = dgst_pos0;
10870 data.dgst_pos1 = dgst_pos1;
10871 data.dgst_pos2 = dgst_pos2;
10872 data.dgst_pos3 = dgst_pos3;
10873
10874 esalt_size = 0;
10875
10876 switch (hash_mode)
10877 {
10878 case 2500: esalt_size = sizeof (wpa_t); break;
10879 case 5300: esalt_size = sizeof (ikepsk_t); break;
10880 case 5400: esalt_size = sizeof (ikepsk_t); break;
10881 case 5500: esalt_size = sizeof (netntlm_t); break;
10882 case 5600: esalt_size = sizeof (netntlm_t); break;
10883 case 6211: esalt_size = sizeof (tc_t); break;
10884 case 6212: esalt_size = sizeof (tc_t); break;
10885 case 6213: esalt_size = sizeof (tc_t); break;
10886 case 6221: esalt_size = sizeof (tc_t); break;
10887 case 6222: esalt_size = sizeof (tc_t); break;
10888 case 6223: esalt_size = sizeof (tc_t); break;
10889 case 6231: esalt_size = sizeof (tc_t); break;
10890 case 6232: esalt_size = sizeof (tc_t); break;
10891 case 6233: esalt_size = sizeof (tc_t); break;
10892 case 6241: esalt_size = sizeof (tc_t); break;
10893 case 6242: esalt_size = sizeof (tc_t); break;
10894 case 6243: esalt_size = sizeof (tc_t); break;
10895 case 6600: esalt_size = sizeof (agilekey_t); break;
10896 case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10897 case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break;
10898 case 7300: esalt_size = sizeof (rakp_t); break;
10899 case 7500: esalt_size = sizeof (krb5pa_t); break;
10900 case 8200: esalt_size = sizeof (cloudkey_t); break;
10901 case 8800: esalt_size = sizeof (androidfde_t); break;
10902 case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break;
10903 case 9400: esalt_size = sizeof (office2007_t); break;
10904 case 9500: esalt_size = sizeof (office2010_t); break;
10905 case 9600: esalt_size = sizeof (office2013_t); break;
10906 case 9700: esalt_size = sizeof (oldoffice01_t); break;
10907 case 9710: esalt_size = sizeof (oldoffice01_t); break;
10908 case 9720: esalt_size = sizeof (oldoffice01_t); break;
10909 case 9800: esalt_size = sizeof (oldoffice34_t); break;
10910 case 9810: esalt_size = sizeof (oldoffice34_t); break;
10911 case 9820: esalt_size = sizeof (oldoffice34_t); break;
10912 case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break;
10913 case 10200: esalt_size = sizeof (cram_md5_t); break;
10914 case 10400: esalt_size = sizeof (pdf_t); break;
10915 case 10410: esalt_size = sizeof (pdf_t); break;
10916 case 10420: esalt_size = sizeof (pdf_t); break;
10917 case 10500: esalt_size = sizeof (pdf_t); break;
10918 case 10600: esalt_size = sizeof (pdf_t); break;
10919 case 10700: esalt_size = sizeof (pdf_t); break;
10920 case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break;
10921 case 11300: esalt_size = sizeof (bitcoin_wallet_t); break;
10922 case 11400: esalt_size = sizeof (sip_t); break;
10923 case 11600: esalt_size = sizeof (seven_zip_t); break;
10924 case 11900: esalt_size = sizeof (pbkdf2_md5_t); break;
10925 case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break;
10926 case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break;
10927 case 13000: esalt_size = sizeof (rar5_t); break;
10928 case 13100: esalt_size = sizeof (krb5tgs_t); break;
10929 case 13400: esalt_size = sizeof (keepass_t); break;
10930 case 13500: esalt_size = sizeof (pstoken_t); break;
10931 case 13600: esalt_size = sizeof (zip2_t); break;
10932 case 13711: esalt_size = sizeof (tc_t); break;
10933 case 13712: esalt_size = sizeof (tc_t); break;
10934 case 13713: esalt_size = sizeof (tc_t); break;
10935 case 13721: esalt_size = sizeof (tc_t); break;
10936 case 13722: esalt_size = sizeof (tc_t); break;
10937 case 13723: esalt_size = sizeof (tc_t); break;
10938 case 13731: esalt_size = sizeof (tc_t); break;
10939 case 13732: esalt_size = sizeof (tc_t); break;
10940 case 13733: esalt_size = sizeof (tc_t); break;
10941 case 13741: esalt_size = sizeof (tc_t); break;
10942 case 13742: esalt_size = sizeof (tc_t); break;
10943 case 13743: esalt_size = sizeof (tc_t); break;
10944 case 13751: esalt_size = sizeof (tc_t); break;
10945 case 13752: esalt_size = sizeof (tc_t); break;
10946 case 13753: esalt_size = sizeof (tc_t); break;
10947 case 13761: esalt_size = sizeof (tc_t); break;
10948 case 13762: esalt_size = sizeof (tc_t); break;
10949 case 13763: esalt_size = sizeof (tc_t); break;
10950 }
10951
10952 data.esalt_size = esalt_size;
10953
10954 /**
10955 * choose dictionary parser
10956 */
10957
10958 if (hash_type == HASH_TYPE_LM)
10959 {
10960 get_next_word_func = get_next_word_lm;
10961 }
10962 else if (opts_type & OPTS_TYPE_PT_UPPER)
10963 {
10964 get_next_word_func = get_next_word_uc;
10965 }
10966 else
10967 {
10968 get_next_word_func = get_next_word_std;
10969 }
10970
10971 /**
10972 * dictstat
10973 */
10974
10975 dictstat_t *dictstat_base = (dictstat_t *) mycalloc (MAX_DICTSTAT, sizeof (dictstat_t));
10976
10977 #ifdef _POSIX
10978 size_t dictstat_nmemb = 0;
10979 #endif
10980
10981 #ifdef _WIN
10982 uint dictstat_nmemb = 0;
10983 #endif
10984
10985 char dictstat[256] = { 0 };
10986
10987 FILE *dictstat_fp = NULL;
10988
10989 if (keyspace == 0)
10990 {
10991 snprintf (dictstat, sizeof (dictstat) - 1, "%s/%s", profile_dir, DICTSTAT_FILENAME);
10992
10993 dictstat_fp = fopen (dictstat, "rb");
10994
10995 if (dictstat_fp)
10996 {
10997 #ifdef _POSIX
10998 struct stat tmpstat;
10999
11000 fstat (fileno (dictstat_fp), &tmpstat);
11001 #endif
11002
11003 #ifdef _WIN
11004 struct stat64 tmpstat;
11005
11006 _fstat64 (fileno (dictstat_fp), &tmpstat);
11007 #endif
11008
11009 if (tmpstat.st_mtime < COMPTIME)
11010 {
11011 /* with v0.15 the format changed so we have to ensure user is using a good version
11012 since there is no version-header in the dictstat file */
11013
11014 fclose (dictstat_fp);
11015
11016 unlink (dictstat);
11017 }
11018 else
11019 {
11020 while (!feof (dictstat_fp))
11021 {
11022 dictstat_t d;
11023
11024 if (fread (&d, sizeof (dictstat_t), 1, dictstat_fp) == 0) continue;
11025
11026 lsearch (&d, dictstat_base, &dictstat_nmemb, sizeof (dictstat_t), sort_by_dictstat);
11027
11028 if (dictstat_nmemb == (MAX_DICTSTAT - 1000))
11029 {
11030 log_error ("ERROR: There are too many entries in the %s database. You have to remove/rename it.", dictstat);
11031
11032 return -1;
11033 }
11034 }
11035
11036 fclose (dictstat_fp);
11037 }
11038 }
11039 }
11040
11041 /**
11042 * potfile
11043 */
11044
11045 char potfile[256] = { 0 };
11046
11047 if (potfile_path == NULL)
11048 {
11049 snprintf (potfile, sizeof (potfile) - 1, "%s/%s", profile_dir, POTFILE_FILENAME);
11050 }
11051 else
11052 {
11053 strncpy (potfile, potfile_path, sizeof (potfile) - 1);
11054 }
11055
11056 data.pot_fp = NULL;
11057
11058 FILE *out_fp = NULL;
11059 FILE *pot_fp = NULL;
11060
11061 if (show == 1 || left == 1)
11062 {
11063 pot_fp = fopen (potfile, "rb");
11064
11065 if (pot_fp == NULL)
11066 {
11067 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11068
11069 return (-1);
11070 }
11071
11072 if (outfile != NULL)
11073 {
11074 if ((out_fp = fopen (outfile, "ab")) == NULL)
11075 {
11076 log_error ("ERROR: %s: %s", outfile, strerror (errno));
11077
11078 fclose (pot_fp);
11079
11080 return (-1);
11081 }
11082 }
11083 else
11084 {
11085 out_fp = stdout;
11086 }
11087 }
11088 else
11089 {
11090 if (potfile_disable == 0)
11091 {
11092 pot_fp = fopen (potfile, "ab");
11093
11094 if (pot_fp == NULL)
11095 {
11096 log_error ("ERROR: %s: %s", potfile, strerror (errno));
11097
11098 return (-1);
11099 }
11100
11101 data.pot_fp = pot_fp;
11102 }
11103 }
11104
11105 pot_t *pot = NULL;
11106
11107 uint pot_cnt = 0;
11108 uint pot_avail = 0;
11109
11110 if (show == 1 || left == 1)
11111 {
11112 SUPPRESS_OUTPUT = 1;
11113
11114 pot_avail = count_lines (pot_fp);
11115
11116 rewind (pot_fp);
11117
11118 pot = (pot_t *) mycalloc (pot_avail, sizeof (pot_t));
11119
11120 uint pot_hashes_avail = 0;
11121
11122 uint line_num = 0;
11123
11124 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11125
11126 while (!feof (pot_fp))
11127 {
11128 line_num++;
11129
11130 int line_len = fgetl (pot_fp, line_buf);
11131
11132 if (line_len == 0) continue;
11133
11134 char *plain_buf = line_buf + line_len;
11135
11136 pot_t *pot_ptr = &pot[pot_cnt];
11137
11138 hash_t *hashes_buf = &pot_ptr->hash;
11139
11140 // we do not initialize all hashes_buf->digest etc at the beginning, since many lines may not be
11141 // valid lines of this specific hash type (otherwise it would be more waste of memory than gain)
11142
11143 if (pot_cnt == pot_hashes_avail)
11144 {
11145 uint pos = 0;
11146
11147 for (pos = 0; pos < INCR_POT; pos++)
11148 {
11149 if ((pot_cnt + pos) >= pot_avail) break;
11150
11151 pot_t *tmp_pot = &pot[pot_cnt + pos];
11152
11153 hash_t *tmp_hash = &tmp_pot->hash;
11154
11155 tmp_hash->digest = mymalloc (dgst_size);
11156
11157 if (isSalted)
11158 {
11159 tmp_hash->salt = (salt_t *) mymalloc (sizeof (salt_t));
11160 }
11161
11162 if (esalt_size)
11163 {
11164 tmp_hash->esalt = mymalloc (esalt_size);
11165 }
11166
11167 pot_hashes_avail++;
11168 }
11169 }
11170
11171 int plain_len = 0;
11172
11173 int parser_status;
11174
11175 int iter = MAX_CUT_TRIES;
11176
11177 do
11178 {
11179 for (int i = line_len - 1; i; i--, plain_len++, plain_buf--, line_len--)
11180 {
11181 if (line_buf[i] == ':')
11182 {
11183 line_len--;
11184
11185 break;
11186 }
11187 }
11188
11189 if (data.hash_mode != 2500)
11190 {
11191 parser_status = parse_func (line_buf, line_len, hashes_buf);
11192 }
11193 else
11194 {
11195 int max_salt_size = sizeof (hashes_buf->salt->salt_buf);
11196
11197 if (line_len > max_salt_size)
11198 {
11199 parser_status = PARSER_GLOBAL_LENGTH;
11200 }
11201 else
11202 {
11203 memset (&hashes_buf->salt->salt_buf, 0, max_salt_size);
11204
11205 memcpy (&hashes_buf->salt->salt_buf, line_buf, line_len);
11206
11207 hashes_buf->salt->salt_len = line_len;
11208
11209 parser_status = PARSER_OK;
11210 }
11211 }
11212
11213 // if NOT parsed without error, we add the ":" to the plain
11214
11215 if (parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH)
11216 {
11217 plain_len++;
11218 plain_buf--;
11219 }
11220
11221 } while ((parser_status == PARSER_GLOBAL_LENGTH || parser_status == PARSER_HASH_LENGTH || parser_status == PARSER_SALT_LENGTH) && --iter);
11222
11223 if (parser_status < PARSER_GLOBAL_ZERO)
11224 {
11225 // log_info ("WARNING: Potfile '%s' in line %u (%s): %s", potfile, line_num, line_buf, strparser (parser_status));
11226
11227 continue;
11228 }
11229
11230 if (plain_len >= 255) continue;
11231
11232 memcpy (pot_ptr->plain_buf, plain_buf, plain_len);
11233
11234 pot_ptr->plain_len = plain_len;
11235
11236 pot_cnt++;
11237 }
11238
11239 myfree (line_buf);
11240
11241 fclose (pot_fp);
11242
11243 SUPPRESS_OUTPUT = 0;
11244
11245 qsort (pot, pot_cnt, sizeof (pot_t), sort_by_pot);
11246 }
11247
11248 /**
11249 * word len
11250 */
11251
11252 uint pw_min = PW_MIN;
11253 uint pw_max = PW_MAX;
11254
11255 switch (hash_mode)
11256 {
11257 case 125: if (pw_max > 32) pw_max = 32;
11258 break;
11259 case 400: if (pw_max > 40) pw_max = 40;
11260 break;
11261 case 500: if (pw_max > 16) pw_max = 16;
11262 break;
11263 case 1500: if (pw_max > 8) pw_max = 8;
11264 break;
11265 case 1600: if (pw_max > 16) pw_max = 16;
11266 break;
11267 case 1800: if (pw_max > 16) pw_max = 16;
11268 break;
11269 case 2100: if (pw_max > 16) pw_max = 16;
11270 break;
11271 case 2500: if (pw_min < 8) pw_min = 8;
11272 break;
11273 case 3000: if (pw_max > 7) pw_max = 7;
11274 break;
11275 case 5200: if (pw_max > 24) pw_max = 24;
11276 break;
11277 case 5800: if (pw_max > 16) pw_max = 16;
11278 break;
11279 case 6300: if (pw_max > 16) pw_max = 16;
11280 break;
11281 case 7400: if (pw_max > 16) pw_max = 16;
11282 break;
11283 case 7500: if (pw_max > 8) pw_max = 8;
11284 break;
11285 case 7900: if (pw_max > 48) pw_max = 48;
11286 break;
11287 case 8500: if (pw_max > 8) pw_max = 8;
11288 break;
11289 case 8600: if (pw_max > 16) pw_max = 16;
11290 break;
11291 case 9710: pw_min = 5;
11292 pw_max = 5;
11293 break;
11294 case 9810: pw_min = 5;
11295 pw_max = 5;
11296 break;
11297 case 10410: pw_min = 5;
11298 pw_max = 5;
11299 break;
11300 case 10300: if (pw_max < 3) pw_min = 3;
11301 if (pw_max > 40) pw_max = 40;
11302 break;
11303 case 10500: if (pw_max < 3) pw_min = 3;
11304 if (pw_max > 40) pw_max = 40;
11305 break;
11306 case 10700: if (pw_max > 16) pw_max = 16;
11307 break;
11308 case 11300: if (pw_max > 40) pw_max = 40;
11309 break;
11310 case 11600: if (pw_max > 32) pw_max = 32;
11311 break;
11312 case 12500: if (pw_max > 20) pw_max = 20;
11313 break;
11314 case 12800: if (pw_max > 24) pw_max = 24;
11315 break;
11316 }
11317
11318 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
11319 {
11320 switch (attack_kern)
11321 {
11322 case ATTACK_KERN_STRAIGHT: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11323 break;
11324 case ATTACK_KERN_COMBI: if (pw_max > PW_DICTMAX) pw_max = PW_DICTMAX1;
11325 break;
11326 }
11327 }
11328
11329 /**
11330 * charsets : keep them together for more easy maintainnce
11331 */
11332
11333 cs_t mp_sys[6] = { { { 0 }, 0 } };
11334 cs_t mp_usr[4] = { { { 0 }, 0 } };
11335
11336 mp_setup_sys (mp_sys);
11337
11338 if (custom_charset_1) mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
11339 if (custom_charset_2) mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
11340 if (custom_charset_3) mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
11341 if (custom_charset_4) mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
11342
11343 /**
11344 * load hashes, part I: find input mode, count hashes
11345 */
11346
11347 uint hashlist_mode = 0;
11348 uint hashlist_format = HLFMT_HASHCAT;
11349
11350 uint hashes_avail = 0;
11351
11352 if (benchmark == 0)
11353 {
11354 struct stat f;
11355
11356 hashlist_mode = (stat (myargv[optind], &f) == 0) ? HL_MODE_FILE : HL_MODE_ARG;
11357
11358 if ((hash_mode == 2500) ||
11359 (hash_mode == 5200) ||
11360 ((hash_mode >= 6200) && (hash_mode <= 6299)) ||
11361 ((hash_mode >= 13700) && (hash_mode <= 13799)) ||
11362 (hash_mode == 9000))
11363 {
11364 hashlist_mode = HL_MODE_ARG;
11365
11366 char *hashfile = myargv[optind];
11367
11368 data.hashfile = hashfile;
11369
11370 logfile_top_var_string ("target", hashfile);
11371 }
11372
11373 if (hashlist_mode == HL_MODE_ARG)
11374 {
11375 if (hash_mode == 2500)
11376 {
11377 struct stat st;
11378
11379 if (stat (data.hashfile, &st) == -1)
11380 {
11381 log_error ("ERROR: %s: %s", data.hashfile, strerror (errno));
11382
11383 return (-1);
11384 }
11385
11386 hashes_avail = st.st_size / sizeof (hccap_t);
11387 }
11388 else
11389 {
11390 hashes_avail = 1;
11391 }
11392 }
11393 else if (hashlist_mode == HL_MODE_FILE)
11394 {
11395 char *hashfile = myargv[optind];
11396
11397 data.hashfile = hashfile;
11398
11399 logfile_top_var_string ("target", hashfile);
11400
11401 FILE *fp = NULL;
11402
11403 if ((fp = fopen (hashfile, "rb")) == NULL)
11404 {
11405 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11406
11407 return (-1);
11408 }
11409
11410 if (data.quiet == 0) log_info_nn ("Counting lines in %s", hashfile);
11411
11412 hashes_avail = count_lines (fp);
11413
11414 rewind (fp);
11415
11416 if (hashes_avail == 0)
11417 {
11418 log_error ("ERROR: hashfile is empty or corrupt");
11419
11420 fclose (fp);
11421
11422 return (-1);
11423 }
11424
11425 hashlist_format = hlfmt_detect (fp, 100); // 100 = max numbers to "scan". could be hashes_avail, too
11426
11427 if ((remove == 1) && (hashlist_format != HLFMT_HASHCAT))
11428 {
11429 log_error ("ERROR: remove not supported in native hashfile-format mode");
11430
11431 fclose (fp);
11432
11433 return (-1);
11434 }
11435
11436 fclose (fp);
11437 }
11438 }
11439 else
11440 {
11441 hashlist_mode = HL_MODE_ARG;
11442
11443 hashes_avail = 1;
11444 }
11445
11446 if (hash_mode == 3000) hashes_avail *= 2;
11447
11448 data.hashlist_mode = hashlist_mode;
11449 data.hashlist_format = hashlist_format;
11450
11451 logfile_top_uint (hashlist_mode);
11452 logfile_top_uint (hashlist_format);
11453
11454 /**
11455 * load hashes, part II: allocate required memory, set pointers
11456 */
11457
11458 hash_t *hashes_buf = NULL;
11459 void *digests_buf = NULL;
11460 salt_t *salts_buf = NULL;
11461 void *esalts_buf = NULL;
11462
11463 hashes_buf = (hash_t *) mycalloc (hashes_avail, sizeof (hash_t));
11464
11465 digests_buf = (void *) mycalloc (hashes_avail, dgst_size);
11466
11467 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
11468 {
11469 u32 hash_pos;
11470
11471 for (hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11472 {
11473 hashinfo_t *hash_info = (hashinfo_t *) mymalloc (sizeof (hashinfo_t));
11474
11475 hashes_buf[hash_pos].hash_info = hash_info;
11476
11477 if (username && (remove || show || left))
11478 {
11479 hash_info->user = (user_t*) mymalloc (sizeof (user_t));
11480 }
11481
11482 if (benchmark)
11483 {
11484 hash_info->orighash = (char *) mymalloc (256);
11485 }
11486 }
11487 }
11488
11489 if (isSalted)
11490 {
11491 salts_buf = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
11492
11493 if (esalt_size)
11494 {
11495 esalts_buf = (void *) mycalloc (hashes_avail, esalt_size);
11496 }
11497 }
11498 else
11499 {
11500 salts_buf = (salt_t *) mycalloc (1, sizeof (salt_t));
11501 }
11502
11503 for (uint hash_pos = 0; hash_pos < hashes_avail; hash_pos++)
11504 {
11505 hashes_buf[hash_pos].digest = ((char *) digests_buf) + (hash_pos * dgst_size);
11506
11507 if (isSalted)
11508 {
11509 hashes_buf[hash_pos].salt = &salts_buf[hash_pos];
11510
11511 if (esalt_size)
11512 {
11513 hashes_buf[hash_pos].esalt = ((char *) esalts_buf) + (hash_pos * esalt_size);
11514 }
11515 }
11516 else
11517 {
11518 hashes_buf[hash_pos].salt = &salts_buf[0];
11519 }
11520 }
11521
11522 /**
11523 * load hashes, part III: parse hashes or generate them if benchmark
11524 */
11525
11526 uint hashes_cnt = 0;
11527
11528 if (benchmark == 0)
11529 {
11530 if (keyspace == 1)
11531 {
11532 // useless to read hash file for keyspace, cheat a little bit w/ optind
11533 }
11534 else if (hashes_avail == 0)
11535 {
11536 }
11537 else if (hashlist_mode == HL_MODE_ARG)
11538 {
11539 char *input_buf = myargv[optind];
11540
11541 uint input_len = strlen (input_buf);
11542
11543 logfile_top_var_string ("target", input_buf);
11544
11545 char *hash_buf = NULL;
11546 int hash_len = 0;
11547
11548 hlfmt_hash (hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
11549
11550 bool hash_fmt_error = 0;
11551
11552 if (hash_len < 1) hash_fmt_error = 1;
11553 if (hash_buf == NULL) hash_fmt_error = 1;
11554
11555 if (hash_fmt_error)
11556 {
11557 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11558 }
11559 else
11560 {
11561 if (opts_type & OPTS_TYPE_HASH_COPY)
11562 {
11563 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11564
11565 hash_info_tmp->orighash = mystrdup (hash_buf);
11566 }
11567
11568 if (isSalted)
11569 {
11570 memset (hashes_buf[0].salt, 0, sizeof (salt_t));
11571 }
11572
11573 int parser_status = PARSER_OK;
11574
11575 if (hash_mode == 2500)
11576 {
11577 if (hash_len == 0)
11578 {
11579 log_error ("ERROR: hccap file not specified");
11580
11581 return (-1);
11582 }
11583
11584 hashlist_mode = HL_MODE_FILE;
11585
11586 data.hashlist_mode = hashlist_mode;
11587
11588 FILE *fp = fopen (hash_buf, "rb");
11589
11590 if (fp == NULL)
11591 {
11592 log_error ("ERROR: %s: %s", hash_buf, strerror (errno));
11593
11594 return (-1);
11595 }
11596
11597 if (hashes_avail < 1)
11598 {
11599 log_error ("ERROR: hccap file is empty or corrupt");
11600
11601 fclose (fp);
11602
11603 return (-1);
11604 }
11605
11606 uint hccap_size = sizeof (hccap_t);
11607
11608 char *in = (char *) mymalloc (hccap_size);
11609
11610 while (!feof (fp))
11611 {
11612 int n = fread (in, hccap_size, 1, fp);
11613
11614 if (n != 1)
11615 {
11616 if (hashes_cnt < 1) parser_status = PARSER_HCCAP_FILE_SIZE;
11617
11618 break;
11619 }
11620
11621 parser_status = parse_func (in, hccap_size, &hashes_buf[hashes_cnt]);
11622
11623 if (parser_status != PARSER_OK)
11624 {
11625 log_info ("WARNING: Hash '%s': %s", hash_buf, strparser (parser_status));
11626
11627 continue;
11628 }
11629
11630 // hack: append MAC1 and MAC2 s.t. in --show and --left the line matches with the .pot file format (i.e. ESSID:MAC1:MAC2)
11631
11632 if ((show == 1) || (left == 1))
11633 {
11634 salt_t *tmp_salt = hashes_buf[hashes_cnt].salt;
11635
11636 char *salt_ptr = (char *) tmp_salt->salt_buf;
11637
11638 int cur_pos = tmp_salt->salt_len;
11639 int rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11640
11641 wpa_t *wpa = (wpa_t *) hashes_buf[hashes_cnt].esalt;
11642
11643 // do the appending task
11644
11645 snprintf (salt_ptr + cur_pos,
11646 rem_len,
11647 ":%02x%02x%02x%02x%02x%02x:%02x%02x%02x%02x%02x%02x",
11648 wpa->orig_mac1[0],
11649 wpa->orig_mac1[1],
11650 wpa->orig_mac1[2],
11651 wpa->orig_mac1[3],
11652 wpa->orig_mac1[4],
11653 wpa->orig_mac1[5],
11654 wpa->orig_mac2[0],
11655 wpa->orig_mac2[1],
11656 wpa->orig_mac2[2],
11657 wpa->orig_mac2[3],
11658 wpa->orig_mac2[4],
11659 wpa->orig_mac2[5]);
11660
11661 // memset () the remaining part of the salt
11662
11663 cur_pos = tmp_salt->salt_len + 1 + 12 + 1 + 12;
11664 rem_len = sizeof (hashes_buf[hashes_cnt].salt->salt_buf) - cur_pos;
11665
11666 if (rem_len > 0) memset (salt_ptr + cur_pos, 0, rem_len);
11667
11668 tmp_salt->salt_len += 1 + 12 + 1 + 12;
11669 }
11670
11671 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);
11672 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);
11673
11674 hashes_cnt++;
11675 }
11676
11677 fclose (fp);
11678
11679 myfree (in);
11680 }
11681 else if (hash_mode == 3000)
11682 {
11683 if (hash_len == 32)
11684 {
11685 parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11686
11687 hash_t *lm_hash_left = NULL;
11688
11689 if (parser_status == PARSER_OK)
11690 {
11691 lm_hash_left = &hashes_buf[hashes_cnt];
11692
11693 hashes_cnt++;
11694 }
11695 else
11696 {
11697 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11698 }
11699
11700 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11701
11702 hash_t *lm_hash_right = NULL;
11703
11704 if (parser_status == PARSER_OK)
11705 {
11706 lm_hash_right = &hashes_buf[hashes_cnt];
11707
11708 hashes_cnt++;
11709 }
11710 else
11711 {
11712 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11713 }
11714
11715 // show / left
11716
11717 if ((lm_hash_left != NULL) && (lm_hash_right != NULL))
11718 {
11719 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);
11720 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);
11721 }
11722 }
11723 else
11724 {
11725 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11726
11727 if (parser_status == PARSER_OK)
11728 {
11729 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11730 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11731 }
11732
11733 if (parser_status == PARSER_OK)
11734 {
11735 hashes_cnt++;
11736 }
11737 else
11738 {
11739 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11740 }
11741 }
11742 }
11743 else
11744 {
11745 parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11746
11747 if (parser_status == PARSER_OK)
11748 {
11749 if (show == 1) handle_show_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11750 if (left == 1) handle_left_request (pot, pot_cnt, input_buf, input_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11751 }
11752
11753 if (parser_status == PARSER_OK)
11754 {
11755 hashes_cnt++;
11756 }
11757 else
11758 {
11759 log_info ("WARNING: Hash '%s': %s", input_buf, strparser (parser_status));
11760 }
11761 }
11762 }
11763 }
11764 else if (hashlist_mode == HL_MODE_FILE)
11765 {
11766 char *hashfile = data.hashfile;
11767
11768 FILE *fp;
11769
11770 if ((fp = fopen (hashfile, "rb")) == NULL)
11771 {
11772 log_error ("ERROR: %s: %s", hashfile, strerror (errno));
11773
11774 return (-1);
11775 }
11776
11777 uint line_num = 0;
11778
11779 char *line_buf = (char *) mymalloc (HCBUFSIZ);
11780
11781 while (!feof (fp))
11782 {
11783 line_num++;
11784
11785 int line_len = fgetl (fp, line_buf);
11786
11787 if (line_len == 0) continue;
11788
11789 char *hash_buf = NULL;
11790 int hash_len = 0;
11791
11792 hlfmt_hash (hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
11793
11794 bool hash_fmt_error = 0;
11795
11796 if (hash_len < 1) hash_fmt_error = 1;
11797 if (hash_buf == NULL) hash_fmt_error = 1;
11798
11799 if (hash_fmt_error)
11800 {
11801 log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
11802
11803 continue;
11804 }
11805
11806 if (username)
11807 {
11808 char *user_buf = NULL;
11809 int user_len = 0;
11810
11811 hlfmt_user (hashlist_format, line_buf, line_len, &user_buf, &user_len);
11812
11813 if (remove || show)
11814 {
11815 user_t **user = &hashes_buf[hashes_cnt].hash_info->user;
11816
11817 *user = (user_t *) mymalloc (sizeof (user_t));
11818
11819 user_t *user_ptr = *user;
11820
11821 if (user_buf != NULL)
11822 {
11823 user_ptr->user_name = mystrdup (user_buf);
11824 }
11825 else
11826 {
11827 user_ptr->user_name = mystrdup ("");
11828 }
11829
11830 user_ptr->user_len = user_len;
11831 }
11832 }
11833
11834 if (opts_type & OPTS_TYPE_HASH_COPY)
11835 {
11836 hashinfo_t *hash_info_tmp = hashes_buf[hashes_cnt].hash_info;
11837
11838 hash_info_tmp->orighash = mystrdup (hash_buf);
11839 }
11840
11841 if (isSalted)
11842 {
11843 memset (hashes_buf[hashes_cnt].salt, 0, sizeof (salt_t));
11844 }
11845
11846 if (hash_mode == 3000)
11847 {
11848 if (hash_len == 32)
11849 {
11850 int parser_status = parse_func (hash_buf, 16, &hashes_buf[hashes_cnt]);
11851
11852 if (parser_status < PARSER_GLOBAL_ZERO)
11853 {
11854 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11855
11856 continue;
11857 }
11858
11859 hash_t *lm_hash_left = &hashes_buf[hashes_cnt];
11860
11861 hashes_cnt++;
11862
11863 parser_status = parse_func (hash_buf + 16, 16, &hashes_buf[hashes_cnt]);
11864
11865 if (parser_status < PARSER_GLOBAL_ZERO)
11866 {
11867 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11868
11869 continue;
11870 }
11871
11872 hash_t *lm_hash_right = &hashes_buf[hashes_cnt];
11873
11874 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);
11875
11876 hashes_cnt++;
11877
11878 // show / left
11879
11880 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);
11881 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);
11882 }
11883 else
11884 {
11885 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11886
11887 if (parser_status < PARSER_GLOBAL_ZERO)
11888 {
11889 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11890
11891 continue;
11892 }
11893
11894 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);
11895
11896 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11897 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11898
11899 hashes_cnt++;
11900 }
11901 }
11902 else
11903 {
11904 int parser_status = parse_func (hash_buf, hash_len, &hashes_buf[hashes_cnt]);
11905
11906 if (parser_status < PARSER_GLOBAL_ZERO)
11907 {
11908 log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
11909
11910 continue;
11911 }
11912
11913 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);
11914
11915 if (show == 1) handle_show_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11916 if (left == 1) handle_left_request (pot, pot_cnt, line_buf, line_len, &hashes_buf[hashes_cnt], sort_by_pot, out_fp);
11917
11918 hashes_cnt++;
11919 }
11920 }
11921
11922 myfree (line_buf);
11923
11924 fclose (fp);
11925
11926 if (data.quiet == 0) log_info_nn ("Parsed Hashes: %u/%u (%0.2f%%)", hashes_avail, hashes_avail, 100.00);
11927
11928 if ((out_fp != NULL) && (out_fp != stdout)) fclose (out_fp);
11929 }
11930 }
11931 else
11932 {
11933 if (isSalted)
11934 {
11935 hashes_buf[0].salt->salt_len = 8;
11936
11937 // special salt handling
11938
11939 switch (hash_mode)
11940 {
11941 case 1500: hashes_buf[0].salt->salt_len = 2;
11942 hashes_buf[0].salt->salt_buf[0] = 388; // pure magic
11943 break;
11944 case 1731: hashes_buf[0].salt->salt_len = 4;
11945 break;
11946 case 2410: hashes_buf[0].salt->salt_len = 4;
11947 break;
11948 case 2500: memcpy (hashes_buf[0].salt->salt_buf, "hashcat.net", 11);
11949 break;
11950 case 3100: hashes_buf[0].salt->salt_len = 1;
11951 break;
11952 case 5000: hashes_buf[0].salt->keccak_mdlen = 32;
11953 break;
11954 case 5800: hashes_buf[0].salt->salt_len = 16;
11955 break;
11956 case 6800: hashes_buf[0].salt->salt_len = 32;
11957 break;
11958 case 8400: hashes_buf[0].salt->salt_len = 40;
11959 break;
11960 case 8800: hashes_buf[0].salt->salt_len = 16;
11961 break;
11962 case 8900: hashes_buf[0].salt->salt_len = 16;
11963 hashes_buf[0].salt->scrypt_N = 1024;
11964 hashes_buf[0].salt->scrypt_r = 1;
11965 hashes_buf[0].salt->scrypt_p = 1;
11966 break;
11967 case 9100: hashes_buf[0].salt->salt_len = 16;
11968 break;
11969 case 9300: hashes_buf[0].salt->salt_len = 14;
11970 hashes_buf[0].salt->scrypt_N = 16384;
11971 hashes_buf[0].salt->scrypt_r = 1;
11972 hashes_buf[0].salt->scrypt_p = 1;
11973 break;
11974 case 9400: hashes_buf[0].salt->salt_len = 16;
11975 break;
11976 case 9500: hashes_buf[0].salt->salt_len = 16;
11977 break;
11978 case 9600: hashes_buf[0].salt->salt_len = 16;
11979 break;
11980 case 9700: hashes_buf[0].salt->salt_len = 16;
11981 break;
11982 case 9710: hashes_buf[0].salt->salt_len = 16;
11983 break;
11984 case 9720: hashes_buf[0].salt->salt_len = 16;
11985 break;
11986 case 9800: hashes_buf[0].salt->salt_len = 16;
11987 break;
11988 case 9810: hashes_buf[0].salt->salt_len = 16;
11989 break;
11990 case 9820: hashes_buf[0].salt->salt_len = 16;
11991 break;
11992 case 10300: hashes_buf[0].salt->salt_len = 12;
11993 break;
11994 case 11500: hashes_buf[0].salt->salt_len = 4;
11995 break;
11996 case 11600: hashes_buf[0].salt->salt_len = 4;
11997 break;
11998 case 12400: hashes_buf[0].salt->salt_len = 4;
11999 break;
12000 case 12500: hashes_buf[0].salt->salt_len = 8;
12001 break;
12002 case 12600: hashes_buf[0].salt->salt_len = 64;
12003 break;
12004 }
12005
12006 // special esalt handling
12007
12008 switch (hash_mode)
12009 {
12010 case 2500: ((wpa_t *) hashes_buf[0].esalt)->eapol_size = 128;
12011 break;
12012 case 5300: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12013 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12014 break;
12015 case 5400: ((ikepsk_t *) hashes_buf[0].esalt)->nr_len = 1;
12016 ((ikepsk_t *) hashes_buf[0].esalt)->msg_len = 1;
12017 break;
12018 case 5500: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12019 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12020 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12021 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12022 break;
12023 case 5600: ((netntlm_t *) hashes_buf[0].esalt)->user_len = 1;
12024 ((netntlm_t *) hashes_buf[0].esalt)->domain_len = 1;
12025 ((netntlm_t *) hashes_buf[0].esalt)->srvchall_len = 1;
12026 ((netntlm_t *) hashes_buf[0].esalt)->clichall_len = 1;
12027 break;
12028 case 7300: ((rakp_t *) hashes_buf[0].esalt)->salt_len = 32;
12029 break;
12030 case 10400: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12031 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12032 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12033 break;
12034 case 10410: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12035 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12036 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12037 break;
12038 case 10420: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12039 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12040 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12041 break;
12042 case 10500: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12043 ((pdf_t *) hashes_buf[0].esalt)->o_len = 32;
12044 ((pdf_t *) hashes_buf[0].esalt)->u_len = 32;
12045 break;
12046 case 10600: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12047 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12048 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12049 break;
12050 case 10700: ((pdf_t *) hashes_buf[0].esalt)->id_len = 16;
12051 ((pdf_t *) hashes_buf[0].esalt)->o_len = 127;
12052 ((pdf_t *) hashes_buf[0].esalt)->u_len = 127;
12053 break;
12054 case 11600: ((seven_zip_t *) hashes_buf[0].esalt)->iv_len = 16;
12055 ((seven_zip_t *) hashes_buf[0].esalt)->data_len = 112;
12056 ((seven_zip_t *) hashes_buf[0].esalt)->unpack_size = 112;
12057 break;
12058 case 13400: ((keepass_t *) hashes_buf[0].esalt)->version = 2;
12059 break;
12060 case 13500: ((pstoken_t *) hashes_buf[0].esalt)->salt_len = 113;
12061 break;
12062 case 13600: ((zip2_t *) hashes_buf[0].esalt)->salt_len = 16;
12063 ((zip2_t *) hashes_buf[0].esalt)->data_len = 32;
12064 ((zip2_t *) hashes_buf[0].esalt)->mode = 3;
12065 break;
12066 }
12067 }
12068
12069 // set hashfile
12070
12071 switch (hash_mode)
12072 {
12073 case 5200: data.hashfile = mystrdup ("hashcat.psafe3");
12074 break;
12075 case 5300: data.hashfile = mystrdup ("hashcat.ikemd5");
12076 break;
12077 case 5400: data.hashfile = mystrdup ("hashcat.ikesha1");
12078 break;
12079 case 6211: data.hashfile = mystrdup ("hashcat.tc");
12080 break;
12081 case 6212: data.hashfile = mystrdup ("hashcat.tc");
12082 break;
12083 case 6213: data.hashfile = mystrdup ("hashcat.tc");
12084 break;
12085 case 6221: data.hashfile = mystrdup ("hashcat.tc");
12086 break;
12087 case 6222: data.hashfile = mystrdup ("hashcat.tc");
12088 break;
12089 case 6223: data.hashfile = mystrdup ("hashcat.tc");
12090 break;
12091 case 6231: data.hashfile = mystrdup ("hashcat.tc");
12092 break;
12093 case 6232: data.hashfile = mystrdup ("hashcat.tc");
12094 break;
12095 case 6233: data.hashfile = mystrdup ("hashcat.tc");
12096 break;
12097 case 6241: data.hashfile = mystrdup ("hashcat.tc");
12098 break;
12099 case 6242: data.hashfile = mystrdup ("hashcat.tc");
12100 break;
12101 case 6243: data.hashfile = mystrdup ("hashcat.tc");
12102 break;
12103 case 6600: data.hashfile = mystrdup ("hashcat.agilekey");
12104 break;
12105 case 8200: data.hashfile = mystrdup ("hashcat.cloudkey");
12106 break;
12107 case 9000: data.hashfile = mystrdup ("hashcat.psafe2");
12108 break;
12109 case 13711: data.hashfile = mystrdup ("hashcat.vc");
12110 break;
12111 case 13712: data.hashfile = mystrdup ("hashcat.vc");
12112 break;
12113 case 13713: data.hashfile = mystrdup ("hashcat.vc");
12114 break;
12115 case 13721: data.hashfile = mystrdup ("hashcat.vc");
12116 break;
12117 case 13722: data.hashfile = mystrdup ("hashcat.vc");
12118 break;
12119 case 13723: data.hashfile = mystrdup ("hashcat.vc");
12120 break;
12121 case 13731: data.hashfile = mystrdup ("hashcat.vc");
12122 break;
12123 case 13732: data.hashfile = mystrdup ("hashcat.vc");
12124 break;
12125 case 13733: data.hashfile = mystrdup ("hashcat.vc");
12126 break;
12127 case 13741: data.hashfile = mystrdup ("hashcat.vc");
12128 break;
12129 case 13742: data.hashfile = mystrdup ("hashcat.vc");
12130 break;
12131 case 13743: data.hashfile = mystrdup ("hashcat.vc");
12132 break;
12133 case 13751: data.hashfile = mystrdup ("hashcat.vc");
12134 break;
12135 case 13752: data.hashfile = mystrdup ("hashcat.vc");
12136 break;
12137 case 13753: data.hashfile = mystrdup ("hashcat.vc");
12138 break;
12139 case 13761: data.hashfile = mystrdup ("hashcat.vc");
12140 break;
12141 case 13762: data.hashfile = mystrdup ("hashcat.vc");
12142 break;
12143 case 13763: data.hashfile = mystrdup ("hashcat.vc");
12144 break;
12145 }
12146
12147 // set default iterations
12148
12149 switch (hash_mode)
12150 {
12151 case 400: hashes_buf[0].salt->salt_iter = ROUNDS_PHPASS;
12152 break;
12153 case 500: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12154 break;
12155 case 501: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12156 break;
12157 case 1600: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12158 break;
12159 case 1800: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512CRYPT;
12160 break;
12161 case 2100: hashes_buf[0].salt->salt_iter = ROUNDS_DCC2;
12162 break;
12163 case 2500: hashes_buf[0].salt->salt_iter = ROUNDS_WPA2;
12164 break;
12165 case 3200: hashes_buf[0].salt->salt_iter = ROUNDS_BCRYPT;
12166 break;
12167 case 5200: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE3;
12168 break;
12169 case 5800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDPIN - 1;
12170 break;
12171 case 6211: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12172 break;
12173 case 6212: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12174 break;
12175 case 6213: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_2K;
12176 break;
12177 case 6221: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12178 break;
12179 case 6222: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12180 break;
12181 case 6223: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12182 break;
12183 case 6231: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12184 break;
12185 case 6232: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12186 break;
12187 case 6233: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12188 break;
12189 case 6241: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12190 break;
12191 case 6242: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12192 break;
12193 case 6243: hashes_buf[0].salt->salt_iter = ROUNDS_TRUECRYPT_1K;
12194 break;
12195 case 6300: hashes_buf[0].salt->salt_iter = ROUNDS_MD5CRYPT;
12196 break;
12197 case 6400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256AIX;
12198 break;
12199 case 6500: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512AIX;
12200 break;
12201 case 6700: hashes_buf[0].salt->salt_iter = ROUNDS_SHA1AIX;
12202 break;
12203 case 6600: hashes_buf[0].salt->salt_iter = ROUNDS_AGILEKEY;
12204 break;
12205 case 6800: hashes_buf[0].salt->salt_iter = ROUNDS_LASTPASS;
12206 break;
12207 case 7100: hashes_buf[0].salt->salt_iter = ROUNDS_SHA512OSX;
12208 break;
12209 case 7200: hashes_buf[0].salt->salt_iter = ROUNDS_GRUB;
12210 break;
12211 case 7400: hashes_buf[0].salt->salt_iter = ROUNDS_SHA256CRYPT;
12212 break;
12213 case 7900: hashes_buf[0].salt->salt_iter = ROUNDS_DRUPAL7;
12214 break;
12215 case 8200: hashes_buf[0].salt->salt_iter = ROUNDS_CLOUDKEY;
12216 break;
12217 case 8300: hashes_buf[0].salt->salt_iter = ROUNDS_NSEC3;
12218 break;
12219 case 8800: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE;
12220 break;
12221 case 8900: hashes_buf[0].salt->salt_iter = 1;
12222 break;
12223 case 9000: hashes_buf[0].salt->salt_iter = ROUNDS_PSAFE2;
12224 break;
12225 case 9100: hashes_buf[0].salt->salt_iter = ROUNDS_LOTUS8;
12226 break;
12227 case 9200: hashes_buf[0].salt->salt_iter = ROUNDS_CISCO8;
12228 break;
12229 case 9300: hashes_buf[0].salt->salt_iter = 1;
12230 break;
12231 case 9400: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2007;
12232 break;
12233 case 9500: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2010;
12234 break;
12235 case 9600: hashes_buf[0].salt->salt_iter = ROUNDS_OFFICE2013;
12236 break;
12237 case 10000: hashes_buf[0].salt->salt_iter = ROUNDS_DJANGOPBKDF2;
12238 break;
12239 case 10300: hashes_buf[0].salt->salt_iter = ROUNDS_SAPH_SHA1 - 1;
12240 break;
12241 case 10500: hashes_buf[0].salt->salt_iter = ROUNDS_PDF14;
12242 break;
12243 case 10700: hashes_buf[0].salt->salt_iter = ROUNDS_PDF17L8;
12244 break;
12245 case 10900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA256 - 1;
12246 break;
12247 case 11300: hashes_buf[0].salt->salt_iter = ROUNDS_BITCOIN_WALLET - 1;
12248 break;
12249 case 11600: hashes_buf[0].salt->salt_iter = ROUNDS_SEVEN_ZIP;
12250 break;
12251 case 11900: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_MD5 - 1;
12252 break;
12253 case 12000: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA1 - 1;
12254 break;
12255 case 12100: hashes_buf[0].salt->salt_iter = ROUNDS_PBKDF2_SHA512 - 1;
12256 break;
12257 case 12200: hashes_buf[0].salt->salt_iter = ROUNDS_ECRYPTFS - 1;
12258 break;
12259 case 12300: hashes_buf[0].salt->salt_iter = ROUNDS_ORACLET - 1;
12260 break;
12261 case 12400: hashes_buf[0].salt->salt_iter = ROUNDS_BSDICRYPT - 1;
12262 break;
12263 case 12500: hashes_buf[0].salt->salt_iter = ROUNDS_RAR3;
12264 break;
12265 case 12700: hashes_buf[0].salt->salt_iter = ROUNDS_MYWALLET;
12266 break;
12267 case 12800: hashes_buf[0].salt->salt_iter = ROUNDS_MS_DRSR - 1;
12268 break;
12269 case 12900: hashes_buf[0].salt->salt_iter = ROUNDS_ANDROIDFDE_SAMSUNG - 1;
12270 break;
12271 case 13000: hashes_buf[0].salt->salt_iter = ROUNDS_RAR5 - 1;
12272 break;
12273 case 13200: hashes_buf[0].salt->salt_iter = ROUNDS_AXCRYPT;
12274 break;
12275 case 13400: hashes_buf[0].salt->salt_iter = ROUNDS_KEEPASS;
12276 break;
12277 case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2;
12278 break;
12279 case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12280 break;
12281 case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12282 break;
12283 case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331;
12284 break;
12285 case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12286 break;
12287 case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12288 break;
12289 case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12290 break;
12291 case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12292 break;
12293 case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12294 break;
12295 case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12296 break;
12297 case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12298 break;
12299 case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12300 break;
12301 case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661;
12302 break;
12303 case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12304 break;
12305 case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12306 break;
12307 case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000;
12308 break;
12309 case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12310 break;
12311 case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12312 break;
12313 case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000;
12314 break;
12315 }
12316
12317 hashes_cnt = 1;
12318 }
12319
12320 if (show == 1 || left == 1)
12321 {
12322 for (uint i = 0; i < pot_cnt; i++)
12323 {
12324 pot_t *pot_ptr = &pot[i];
12325
12326 hash_t *hashes_buf = &pot_ptr->hash;
12327
12328 local_free (hashes_buf->digest);
12329
12330 if (isSalted)
12331 {
12332 local_free (hashes_buf->salt);
12333 }
12334 }
12335
12336 local_free (pot);
12337
12338 if (data.quiet == 0) log_info_nn ("");
12339
12340 return (0);
12341 }
12342
12343 if (keyspace == 0)
12344 {
12345 if (hashes_cnt == 0)
12346 {
12347 log_error ("ERROR: No hashes loaded");
12348
12349 return (-1);
12350 }
12351 }
12352
12353 /**
12354 * Sanity check for hashfile vs outfile (should not point to the same physical file)
12355 */
12356
12357 if (data.outfile != NULL)
12358 {
12359 if (data.hashfile != NULL)
12360 {
12361 #ifdef _POSIX
12362 struct stat tmpstat_outfile;
12363 struct stat tmpstat_hashfile;
12364 #endif
12365
12366 #ifdef _WIN
12367 struct stat64 tmpstat_outfile;
12368 struct stat64 tmpstat_hashfile;
12369 #endif
12370
12371 FILE *tmp_outfile_fp = fopen (data.outfile, "r");
12372
12373 if (tmp_outfile_fp)
12374 {
12375 #ifdef _POSIX
12376 fstat (fileno (tmp_outfile_fp), &tmpstat_outfile);
12377 #endif
12378
12379 #ifdef _WIN
12380 _fstat64 (fileno (tmp_outfile_fp), &tmpstat_outfile);
12381 #endif
12382
12383 fclose (tmp_outfile_fp);
12384 }
12385
12386 FILE *tmp_hashfile_fp = fopen (data.hashfile, "r");
12387
12388 if (tmp_hashfile_fp)
12389 {
12390 #ifdef _POSIX
12391 fstat (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12392 #endif
12393
12394 #ifdef _WIN
12395 _fstat64 (fileno (tmp_hashfile_fp), &tmpstat_hashfile);
12396 #endif
12397
12398 fclose (tmp_hashfile_fp);
12399 }
12400
12401 if (tmp_outfile_fp && tmp_outfile_fp)
12402 {
12403 tmpstat_outfile.st_mode = 0;
12404 tmpstat_outfile.st_nlink = 0;
12405 tmpstat_outfile.st_uid = 0;
12406 tmpstat_outfile.st_gid = 0;
12407 tmpstat_outfile.st_rdev = 0;
12408 tmpstat_outfile.st_atime = 0;
12409
12410 tmpstat_hashfile.st_mode = 0;
12411 tmpstat_hashfile.st_nlink = 0;
12412 tmpstat_hashfile.st_uid = 0;
12413 tmpstat_hashfile.st_gid = 0;
12414 tmpstat_hashfile.st_rdev = 0;
12415 tmpstat_hashfile.st_atime = 0;
12416
12417 #ifdef _POSIX
12418 tmpstat_outfile.st_blksize = 0;
12419 tmpstat_outfile.st_blocks = 0;
12420
12421 tmpstat_hashfile.st_blksize = 0;
12422 tmpstat_hashfile.st_blocks = 0;
12423 #endif
12424
12425 #ifdef _POSIX
12426 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat)) == 0)
12427 {
12428 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12429
12430 return (-1);
12431 }
12432 #endif
12433
12434 #ifdef _WIN
12435 if (memcmp (&tmpstat_outfile, &tmpstat_hashfile, sizeof (struct stat64)) == 0)
12436 {
12437 log_error ("ERROR: Hashfile and Outfile are not allowed to point to the same file");
12438
12439 return (-1);
12440 }
12441 #endif
12442 }
12443 }
12444 }
12445
12446 /**
12447 * Remove duplicates
12448 */
12449
12450 if (data.quiet == 0) log_info_nn ("Removing duplicate hashes...");
12451
12452 if (isSalted)
12453 {
12454 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12455 }
12456 else
12457 {
12458 qsort (hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12459 }
12460
12461 uint hashes_cnt_orig = hashes_cnt;
12462
12463 hashes_cnt = 1;
12464
12465 for (uint hashes_pos = 1; hashes_pos < hashes_cnt_orig; hashes_pos++)
12466 {
12467 if (isSalted)
12468 {
12469 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) == 0)
12470 {
12471 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12472 }
12473 }
12474 else
12475 {
12476 if (sort_by_digest (hashes_buf[hashes_pos].digest, hashes_buf[hashes_pos - 1].digest) == 0) continue;
12477 }
12478
12479 if (hashes_pos > hashes_cnt)
12480 {
12481 memcpy (&hashes_buf[hashes_cnt], &hashes_buf[hashes_pos], sizeof (hash_t));
12482 }
12483
12484 hashes_cnt++;
12485 }
12486
12487 /**
12488 * Potfile removes
12489 */
12490
12491 uint potfile_remove_cracks = 0;
12492
12493 if (potfile_disable == 0)
12494 {
12495 hash_t hash_buf;
12496
12497 hash_buf.digest = mymalloc (dgst_size);
12498 hash_buf.salt = NULL;
12499 hash_buf.esalt = NULL;
12500 hash_buf.hash_info = NULL;
12501 hash_buf.cracked = 0;
12502
12503 if (isSalted)
12504 {
12505 hash_buf.salt = (salt_t *) mymalloc (sizeof (salt_t));
12506 }
12507
12508 if (esalt_size)
12509 {
12510 hash_buf.esalt = mymalloc (esalt_size);
12511 }
12512
12513 if (quiet == 0) log_info_nn ("Comparing hashes with potfile entries...");
12514
12515 // no solution for these special hash types (for instane because they use hashfile in output etc)
12516 if ((hash_mode != 5200) &&
12517 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
12518 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
12519 (hash_mode != 9000))
12520 {
12521 FILE *fp = fopen (potfile, "rb");
12522
12523 if (fp != NULL)
12524 {
12525 char *line_buf = (char *) mymalloc (HCBUFSIZ);
12526
12527 // to be safe work with a copy (because of line_len loop, i etc)
12528 // moved up here because it's easier to handle continue case
12529 // it's just 64kb
12530
12531 char *line_buf_cpy = (char *) mymalloc (HCBUFSIZ);
12532
12533 while (!feof (fp))
12534 {
12535 char *ptr = fgets (line_buf, HCBUFSIZ - 1, fp);
12536
12537 if (ptr == NULL) break;
12538
12539 int line_len = strlen (line_buf);
12540
12541 if (line_len == 0) continue;
12542
12543 int iter = MAX_CUT_TRIES;
12544
12545 for (int i = line_len - 1; i && iter; i--, line_len--)
12546 {
12547 if (line_buf[i] != ':') continue;
12548
12549 if (isSalted)
12550 {
12551 memset (hash_buf.salt, 0, sizeof (salt_t));
12552 }
12553
12554 hash_t *found = NULL;
12555
12556 if (hash_mode == 6800)
12557 {
12558 if (i < 64) // 64 = 16 * uint in salt_buf[]
12559 {
12560 // manipulate salt_buf
12561 memcpy (hash_buf.salt->salt_buf, line_buf, i);
12562
12563 hash_buf.salt->salt_len = i;
12564
12565 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
12566 }
12567 }
12568 else if (hash_mode == 2500)
12569 {
12570 if (i < 64) // 64 = 16 * uint in salt_buf[]
12571 {
12572 // here we have in line_buf: ESSID:MAC1:MAC2 (without the plain)
12573 // manipulate salt_buf
12574
12575 memcpy (line_buf_cpy, line_buf, i);
12576
12577 char *mac2_pos = strrchr (line_buf_cpy, ':');
12578
12579 if (mac2_pos == NULL) continue;
12580
12581 mac2_pos[0] = 0;
12582 mac2_pos++;
12583
12584 if (strlen (mac2_pos) != 12) continue;
12585
12586 char *mac1_pos = strrchr (line_buf_cpy, ':');
12587
12588 if (mac1_pos == NULL) continue;
12589
12590 mac1_pos[0] = 0;
12591 mac1_pos++;
12592
12593 if (strlen (mac1_pos) != 12) continue;
12594
12595 uint essid_length = mac1_pos - line_buf_cpy - 1;
12596
12597 // here we need the ESSID
12598 memcpy (hash_buf.salt->salt_buf, line_buf_cpy, essid_length);
12599
12600 hash_buf.salt->salt_len = essid_length;
12601
12602 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt_hccap);
12603
12604 if (found)
12605 {
12606 wpa_t *wpa = (wpa_t *) found->esalt;
12607
12608 // compare hex string(s) vs binary MAC address(es)
12609
12610 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12611 {
12612 if (wpa->orig_mac1[i] != hex_to_u8 ((const u8 *) &mac1_pos[j]))
12613 {
12614 found = NULL;
12615
12616 break;
12617 }
12618 }
12619
12620 // early skip ;)
12621 if (!found) continue;
12622
12623 for (uint i = 0, j = 0; i < 6; i++, j += 2)
12624 {
12625 if (wpa->orig_mac2[i] != hex_to_u8 ((const u8 *) &mac2_pos[j]))
12626 {
12627 found = NULL;
12628
12629 break;
12630 }
12631 }
12632 }
12633 }
12634 }
12635 else
12636 {
12637 int parser_status = parse_func (line_buf, line_len - 1, &hash_buf);
12638
12639 if (parser_status == PARSER_OK)
12640 {
12641 if (isSalted)
12642 {
12643 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash);
12644 }
12645 else
12646 {
12647 found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt);
12648 }
12649 }
12650 }
12651
12652 if (found == NULL) continue;
12653
12654 if (!found->cracked) potfile_remove_cracks++;
12655
12656 found->cracked = 1;
12657
12658 if (found) break;
12659
12660 iter--;
12661 }
12662 }
12663
12664 myfree (line_buf_cpy);
12665
12666 myfree (line_buf);
12667
12668 fclose (fp);
12669 }
12670 }
12671
12672 if (esalt_size)
12673 {
12674 local_free (hash_buf.esalt);
12675 }
12676
12677 if (isSalted)
12678 {
12679 local_free (hash_buf.salt);
12680 }
12681
12682 local_free (hash_buf.digest);
12683 }
12684
12685 /**
12686 * Now generate all the buffers required for later
12687 */
12688
12689 void *digests_buf_new = (void *) mycalloc (hashes_avail, dgst_size);
12690
12691 salt_t *salts_buf_new = NULL;
12692 void *esalts_buf_new = NULL;
12693
12694 if (isSalted)
12695 {
12696 salts_buf_new = (salt_t *) mycalloc (hashes_avail, sizeof (salt_t));
12697
12698 if (esalt_size)
12699 {
12700 esalts_buf_new = (void *) mycalloc (hashes_avail, esalt_size);
12701 }
12702 }
12703 else
12704 {
12705 salts_buf_new = (salt_t *) mycalloc (1, sizeof (salt_t));
12706 }
12707
12708 if (data.quiet == 0) log_info_nn ("Structuring salts for cracking task...");
12709
12710 uint digests_cnt = hashes_cnt;
12711 uint digests_done = 0;
12712
12713 size_t size_digests = digests_cnt * dgst_size;
12714 size_t size_shown = digests_cnt * sizeof (uint);
12715
12716 uint *digests_shown = (uint *) mymalloc (size_shown);
12717 uint *digests_shown_tmp = (uint *) mymalloc (size_shown);
12718
12719 uint salts_cnt = 0;
12720 uint salts_done = 0;
12721
12722 hashinfo_t **hash_info = NULL;
12723
12724 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12725 {
12726 hash_info = (hashinfo_t**) mymalloc (hashes_cnt * sizeof (hashinfo_t *));
12727
12728 if (username && (remove || show))
12729 {
12730 uint user_pos;
12731
12732 for (user_pos = 0; user_pos < hashes_cnt; user_pos++)
12733 {
12734 hash_info[user_pos] = (hashinfo_t*) mycalloc (hashes_cnt, sizeof (hashinfo_t));
12735
12736 hash_info[user_pos]->user = (user_t*) mymalloc (sizeof (user_t));
12737 }
12738 }
12739 }
12740
12741 uint *salts_shown = (uint *) mymalloc (size_shown);
12742
12743 salt_t *salt_buf;
12744
12745 {
12746 // copied from inner loop
12747
12748 salt_buf = &salts_buf_new[salts_cnt];
12749
12750 memcpy (salt_buf, hashes_buf[0].salt, sizeof (salt_t));
12751
12752 if (esalt_size)
12753 {
12754 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[0].esalt, esalt_size);
12755 }
12756
12757 salt_buf->digests_cnt = 0;
12758 salt_buf->digests_done = 0;
12759 salt_buf->digests_offset = 0;
12760
12761 salts_cnt++;
12762 }
12763
12764 if (hashes_buf[0].cracked == 1)
12765 {
12766 digests_shown[0] = 1;
12767
12768 digests_done++;
12769
12770 salt_buf->digests_done++;
12771 }
12772
12773 salt_buf->digests_cnt++;
12774
12775 memcpy (((char *) digests_buf_new) + (0 * dgst_size), hashes_buf[0].digest, dgst_size);
12776
12777 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12778 {
12779 hash_info[0] = hashes_buf[0].hash_info;
12780 }
12781
12782 // copy from inner loop
12783
12784 for (uint hashes_pos = 1; hashes_pos < hashes_cnt; hashes_pos++)
12785 {
12786 if (isSalted)
12787 {
12788 if (sort_by_salt (hashes_buf[hashes_pos].salt, hashes_buf[hashes_pos - 1].salt) != 0)
12789 {
12790 salt_buf = &salts_buf_new[salts_cnt];
12791
12792 memcpy (salt_buf, hashes_buf[hashes_pos].salt, sizeof (salt_t));
12793
12794 if (esalt_size)
12795 {
12796 memcpy (((char *) esalts_buf_new) + (salts_cnt * esalt_size), hashes_buf[hashes_pos].esalt, esalt_size);
12797 }
12798
12799 salt_buf->digests_cnt = 0;
12800 salt_buf->digests_done = 0;
12801 salt_buf->digests_offset = hashes_pos;
12802
12803 salts_cnt++;
12804 }
12805 }
12806
12807 if (hashes_buf[hashes_pos].cracked == 1)
12808 {
12809 digests_shown[hashes_pos] = 1;
12810
12811 digests_done++;
12812
12813 salt_buf->digests_done++;
12814 }
12815
12816 salt_buf->digests_cnt++;
12817
12818 memcpy (((char *) digests_buf_new) + (hashes_pos * dgst_size), hashes_buf[hashes_pos].digest, dgst_size);
12819
12820 if ((username && (remove || show)) || (opts_type & OPTS_TYPE_HASH_COPY))
12821 {
12822 hash_info[hashes_pos] = hashes_buf[hashes_pos].hash_info;
12823 }
12824 }
12825
12826 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
12827 {
12828 salt_t *salt_buf = &salts_buf_new[salt_pos];
12829
12830 if (salt_buf->digests_done == salt_buf->digests_cnt)
12831 {
12832 salts_shown[salt_pos] = 1;
12833
12834 salts_done++;
12835 }
12836
12837 if (salts_done == salts_cnt) data.devices_status = STATUS_CRACKED;
12838 }
12839
12840 local_free (digests_buf);
12841 local_free (salts_buf);
12842 local_free (esalts_buf);
12843
12844 digests_buf = digests_buf_new;
12845 salts_buf = salts_buf_new;
12846 esalts_buf = esalts_buf_new;
12847
12848 local_free (hashes_buf);
12849
12850 /**
12851 * special modification not set from parser
12852 */
12853
12854 switch (hash_mode)
12855 {
12856 case 6211: salts_buf->truecrypt_mdlen = 1 * 512; break;
12857 case 6212: salts_buf->truecrypt_mdlen = 2 * 512; break;
12858 case 6213: salts_buf->truecrypt_mdlen = 3 * 512; break;
12859 case 6221: salts_buf->truecrypt_mdlen = 1 * 512; break;
12860 case 6222: salts_buf->truecrypt_mdlen = 2 * 512; break;
12861 case 6223: salts_buf->truecrypt_mdlen = 3 * 512; break;
12862 case 6231: salts_buf->truecrypt_mdlen = 1 * 512; break;
12863 case 6232: salts_buf->truecrypt_mdlen = 2 * 512; break;
12864 case 6233: salts_buf->truecrypt_mdlen = 3 * 512; break;
12865 case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break;
12866 case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break;
12867 case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break;
12868 case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break;
12869 case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break;
12870 case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break;
12871 case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break;
12872 case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break;
12873 case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break;
12874 case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break;
12875 case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break;
12876 case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break;
12877 case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break;
12878 case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break;
12879 case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break;
12880 case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break;
12881 case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break;
12882 case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break;
12883 case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break;
12884 case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break;
12885 case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break;
12886 }
12887
12888 if (truecrypt_keyfiles)
12889 {
12890 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12891
12892 char *keyfiles = strdup (truecrypt_keyfiles);
12893
12894 char *keyfile = strtok (keyfiles, ",");
12895
12896 do
12897 {
12898 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12899
12900 } while ((keyfile = strtok (NULL, ",")) != NULL);
12901
12902 free (keyfiles);
12903 }
12904
12905 if (veracrypt_keyfiles)
12906 {
12907 uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf;
12908
12909 char *keyfiles = strdup (veracrypt_keyfiles);
12910
12911 char *keyfile = strtok (keyfiles, ",");
12912
12913 do
12914 {
12915 truecrypt_crc32 (keyfile, (u8 *) keyfile_buf);
12916
12917 } while ((keyfile = strtok (NULL, ",")) != NULL);
12918
12919 free (keyfiles);
12920 }
12921
12922 data.digests_cnt = digests_cnt;
12923 data.digests_done = digests_done;
12924 data.digests_buf = digests_buf;
12925 data.digests_shown = digests_shown;
12926 data.digests_shown_tmp = digests_shown_tmp;
12927
12928 data.salts_cnt = salts_cnt;
12929 data.salts_done = salts_done;
12930 data.salts_buf = salts_buf;
12931 data.salts_shown = salts_shown;
12932
12933 data.esalts_buf = esalts_buf;
12934 data.hash_info = hash_info;
12935
12936 /**
12937 * Automatic Optimizers
12938 */
12939
12940 if (salts_cnt == 1)
12941 opti_type |= OPTI_TYPE_SINGLE_SALT;
12942
12943 if (digests_cnt == 1)
12944 opti_type |= OPTI_TYPE_SINGLE_HASH;
12945
12946 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
12947 opti_type |= OPTI_TYPE_NOT_ITERATED;
12948
12949 if (attack_mode == ATTACK_MODE_BF)
12950 opti_type |= OPTI_TYPE_BRUTE_FORCE;
12951
12952 data.opti_type = opti_type;
12953
12954 if (opti_type & OPTI_TYPE_BRUTE_FORCE)
12955 {
12956 if (opti_type & OPTI_TYPE_SINGLE_HASH)
12957 {
12958 if (opti_type & OPTI_TYPE_APPENDED_SALT)
12959 {
12960 if (opts_type & OPTS_TYPE_ST_ADD80)
12961 {
12962 opts_type &= ~OPTS_TYPE_ST_ADD80;
12963 opts_type |= OPTS_TYPE_PT_ADD80;
12964 }
12965
12966 if (opts_type & OPTS_TYPE_ST_ADDBITS14)
12967 {
12968 opts_type &= ~OPTS_TYPE_ST_ADDBITS14;
12969 opts_type |= OPTS_TYPE_PT_ADDBITS14;
12970 }
12971
12972 if (opts_type & OPTS_TYPE_ST_ADDBITS15)
12973 {
12974 opts_type &= ~OPTS_TYPE_ST_ADDBITS15;
12975 opts_type |= OPTS_TYPE_PT_ADDBITS15;
12976 }
12977 }
12978 }
12979 }
12980
12981 /**
12982 * Some algorithm, like descrypt, can benefit from JIT compilation
12983 */
12984
12985 int force_jit_compilation = -1;
12986
12987 if (hash_mode == 8900)
12988 {
12989 force_jit_compilation = 8900;
12990 }
12991 else if (hash_mode == 9300)
12992 {
12993 force_jit_compilation = 8900;
12994 }
12995 else if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF && data.salts_cnt == 1)
12996 {
12997 force_jit_compilation = 1500;
12998 }
12999
13000 /**
13001 * generate bitmap tables
13002 */
13003
13004 const uint bitmap_shift1 = 5;
13005 const uint bitmap_shift2 = 13;
13006
13007 if (bitmap_max < bitmap_min) bitmap_max = bitmap_min;
13008
13009 uint *bitmap_s1_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13010 uint *bitmap_s1_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13011 uint *bitmap_s1_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13012 uint *bitmap_s1_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13013 uint *bitmap_s2_a = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13014 uint *bitmap_s2_b = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13015 uint *bitmap_s2_c = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13016 uint *bitmap_s2_d = (uint *) mymalloc ((1 << bitmap_max) * sizeof (uint));
13017
13018 uint bitmap_bits;
13019 uint bitmap_nums;
13020 uint bitmap_mask;
13021 uint bitmap_size;
13022
13023 for (bitmap_bits = bitmap_min; bitmap_bits < bitmap_max; bitmap_bits++)
13024 {
13025 if (data.quiet == 0) log_info_nn ("Generating bitmap tables with %u bits...", bitmap_bits);
13026
13027 bitmap_nums = 1 << bitmap_bits;
13028
13029 bitmap_mask = bitmap_nums - 1;
13030
13031 bitmap_size = bitmap_nums * sizeof (uint);
13032
13033 if ((hashes_cnt & bitmap_mask) == hashes_cnt) break;
13034
13035 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;
13036 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;
13037
13038 break;
13039 }
13040
13041 bitmap_nums = 1 << bitmap_bits;
13042
13043 bitmap_mask = bitmap_nums - 1;
13044
13045 bitmap_size = bitmap_nums * sizeof (uint);
13046
13047 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);
13048 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);
13049
13050 /**
13051 * prepare quick rule
13052 */
13053
13054 data.rule_buf_l = rule_buf_l;
13055 data.rule_buf_r = rule_buf_r;
13056
13057 int rule_len_l = (int) strlen (rule_buf_l);
13058 int rule_len_r = (int) strlen (rule_buf_r);
13059
13060 data.rule_len_l = rule_len_l;
13061 data.rule_len_r = rule_len_r;
13062
13063 /**
13064 * load rules
13065 */
13066
13067 uint *all_kernel_rules_cnt = NULL;
13068
13069 kernel_rule_t **all_kernel_rules_buf = NULL;
13070
13071 if (rp_files_cnt)
13072 {
13073 all_kernel_rules_cnt = (uint *) mycalloc (rp_files_cnt, sizeof (uint));
13074
13075 all_kernel_rules_buf = (kernel_rule_t **) mycalloc (rp_files_cnt, sizeof (kernel_rule_t *));
13076 }
13077
13078 char *rule_buf = (char *) mymalloc (HCBUFSIZ);
13079
13080 int rule_len = 0;
13081
13082 for (uint i = 0; i < rp_files_cnt; i++)
13083 {
13084 uint kernel_rules_avail = 0;
13085
13086 uint kernel_rules_cnt = 0;
13087
13088 kernel_rule_t *kernel_rules_buf = NULL;
13089
13090 char *rp_file = rp_files[i];
13091
13092 char in[BLOCK_SIZE] = { 0 };
13093 char out[BLOCK_SIZE] = { 0 };
13094
13095 FILE *fp = NULL;
13096
13097 uint rule_line = 0;
13098
13099 if ((fp = fopen (rp_file, "rb")) == NULL)
13100 {
13101 log_error ("ERROR: %s: %s", rp_file, strerror (errno));
13102
13103 return (-1);
13104 }
13105
13106 while (!feof (fp))
13107 {
13108 memset (rule_buf, 0, HCBUFSIZ);
13109
13110 rule_len = fgetl (fp, rule_buf);
13111
13112 rule_line++;
13113
13114 if (rule_len == 0) continue;
13115
13116 if (rule_buf[0] == '#') continue;
13117
13118 if (kernel_rules_avail == kernel_rules_cnt)
13119 {
13120 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13121
13122 kernel_rules_avail += INCR_RULES;
13123 }
13124
13125 memset (in, 0, BLOCK_SIZE);
13126 memset (out, 0, BLOCK_SIZE);
13127
13128 int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
13129
13130 if (result == -1)
13131 {
13132 log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13133
13134 continue;
13135 }
13136
13137 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
13138 {
13139 log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13140
13141 memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
13142
13143 continue;
13144 }
13145
13146 /* its so slow
13147 if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule))
13148 {
13149 log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
13150
13151 continue;
13152 }
13153 */
13154
13155 kernel_rules_cnt++;
13156 }
13157
13158 fclose (fp);
13159
13160 all_kernel_rules_cnt[i] = kernel_rules_cnt;
13161
13162 all_kernel_rules_buf[i] = kernel_rules_buf;
13163 }
13164
13165 /**
13166 * merge rules or automatic rule generator
13167 */
13168
13169 uint kernel_rules_cnt = 0;
13170
13171 kernel_rule_t *kernel_rules_buf = NULL;
13172
13173 if (attack_mode == ATTACK_MODE_STRAIGHT)
13174 {
13175 if (rp_files_cnt)
13176 {
13177 kernel_rules_cnt = 1;
13178
13179 uint *repeats = (uint *) mycalloc (rp_files_cnt + 1, sizeof (uint));
13180
13181 repeats[0] = kernel_rules_cnt;
13182
13183 for (uint i = 0; i < rp_files_cnt; i++)
13184 {
13185 kernel_rules_cnt *= all_kernel_rules_cnt[i];
13186
13187 repeats[i + 1] = kernel_rules_cnt;
13188 }
13189
13190 kernel_rules_buf = (kernel_rule_t *) mycalloc (kernel_rules_cnt, sizeof (kernel_rule_t));
13191
13192 memset (kernel_rules_buf, 0, kernel_rules_cnt * sizeof (kernel_rule_t));
13193
13194 for (uint i = 0; i < kernel_rules_cnt; i++)
13195 {
13196 uint out_pos = 0;
13197
13198 kernel_rule_t *out = &kernel_rules_buf[i];
13199
13200 for (uint j = 0; j < rp_files_cnt; j++)
13201 {
13202 uint in_off = (i / repeats[j]) % all_kernel_rules_cnt[j];
13203 uint in_pos;
13204
13205 kernel_rule_t *in = &all_kernel_rules_buf[j][in_off];
13206
13207 for (in_pos = 0; in->cmds[in_pos]; in_pos++, out_pos++)
13208 {
13209 if (out_pos == RULES_MAX - 1)
13210 {
13211 // log_info ("WARNING: Truncating chaining of rule %d and rule %d as maximum number of function calls per rule exceeded", i, in_off);
13212
13213 break;
13214 }
13215
13216 out->cmds[out_pos] = in->cmds[in_pos];
13217 }
13218 }
13219 }
13220
13221 local_free (repeats);
13222 }
13223 else if (rp_gen)
13224 {
13225 uint kernel_rules_avail = 0;
13226
13227 while (kernel_rules_cnt < rp_gen)
13228 {
13229 if (kernel_rules_avail == kernel_rules_cnt)
13230 {
13231 kernel_rules_buf = (kernel_rule_t *) myrealloc (kernel_rules_buf, kernel_rules_avail * sizeof (kernel_rule_t), INCR_RULES * sizeof (kernel_rule_t));
13232
13233 kernel_rules_avail += INCR_RULES;
13234 }
13235
13236 memset (rule_buf, 0, HCBUFSIZ);
13237
13238 rule_len = (int) generate_random_rule (rule_buf, rp_gen_func_min, rp_gen_func_max);
13239
13240 if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1) continue;
13241
13242 kernel_rules_cnt++;
13243 }
13244 }
13245 }
13246
13247 myfree (rule_buf);
13248
13249 /**
13250 * generate NOP rules
13251 */
13252
13253 if (kernel_rules_cnt == 0)
13254 {
13255 kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t));
13256
13257 kernel_rules_buf[kernel_rules_cnt].cmds[0] = RULE_OP_MANGLE_NOOP;
13258
13259 kernel_rules_cnt++;
13260 }
13261
13262 data.kernel_rules_cnt = kernel_rules_cnt;
13263 data.kernel_rules_buf = kernel_rules_buf;
13264
13265 /**
13266 * OpenCL platforms: detect
13267 */
13268
13269 cl_platform_id platforms[CL_PLATFORMS_MAX] = { 0 };
13270 cl_device_id platform_devices[DEVICES_MAX] = { 0 };
13271
13272 cl_uint platforms_cnt = 0;
13273 cl_uint platform_devices_cnt = 0;
13274
13275 if (keyspace == 0)
13276 {
13277 hc_clGetPlatformIDs (data.ocl, CL_PLATFORMS_MAX, platforms, &platforms_cnt);
13278
13279 if (platforms_cnt == 0)
13280 {
13281 log_info ("");
13282 log_info ("ATTENTION! No OpenCL compatible platform found");
13283 log_info ("");
13284 log_info ("You're probably missing the OpenCL runtime installation");
13285 log_info (" AMD users require AMD drivers 14.9 or later (recommended 15.12 or later)");
13286 log_info (" Intel users require Intel OpenCL Runtime 14.2 or later (recommended 15.1 or later)");
13287 log_info (" NVidia users require NVidia drivers 346.59 or later (recommended 361.x or later)");
13288 log_info ("");
13289
13290 return (-1);
13291 }
13292
13293 if (opencl_platforms_filter != (uint) -1)
13294 {
13295 uint platform_cnt_mask = ~(((uint) -1 >> platforms_cnt) << platforms_cnt);
13296
13297 if (opencl_platforms_filter > platform_cnt_mask)
13298 {
13299 log_error ("ERROR: The platform selected by the --opencl-platforms parameter is larger than the number of available platforms (%d)", platforms_cnt);
13300
13301 return (-1);
13302 }
13303 }
13304 }
13305
13306 /**
13307 * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain
13308 */
13309
13310 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13311 {
13312 cl_platform_id platform = platforms[platform_id];
13313
13314 char platform_vendor[INFOSZ] = { 0 };
13315
13316 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13317
13318 #ifdef HAVE_HWMON
13319 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
13320 if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13321 {
13322 // make sure that we do not directly control the fan for NVidia
13323
13324 gpu_temp_retain = 0;
13325
13326 data.gpu_temp_retain = gpu_temp_retain;
13327 }
13328 #endif // HAVE_NVML || HAVE_NVAPI
13329 #endif
13330 }
13331
13332 /**
13333 * OpenCL device types:
13334 * 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.
13335 * In such a case, automatically enable CPU device type support, since it's disabled by default.
13336 */
13337
13338 if (opencl_device_types == NULL)
13339 {
13340 cl_device_type device_types_all = 0;
13341
13342 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13343 {
13344 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13345
13346 cl_platform_id platform = platforms[platform_id];
13347
13348 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13349
13350 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13351 {
13352 cl_device_id device = platform_devices[platform_devices_id];
13353
13354 cl_device_type device_type;
13355
13356 hc_clGetDeviceInfo (data.ocl, device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13357
13358 device_types_all |= device_type;
13359 }
13360 }
13361
13362 if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
13363 {
13364 device_types_filter |= CL_DEVICE_TYPE_CPU;
13365 }
13366 }
13367
13368 /**
13369 * OpenCL devices: simply push all devices from all platforms into the same device array
13370 */
13371
13372 hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t));
13373
13374 data.devices_param = devices_param;
13375
13376 uint devices_cnt = 0;
13377
13378 uint devices_active = 0;
13379
13380 for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
13381 {
13382 if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
13383
13384 cl_platform_id platform = platforms[platform_id];
13385
13386 hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
13387
13388 char platform_vendor[INFOSZ] = { 0 };
13389
13390 hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL);
13391
13392 // find our own platform vendor because pocl and mesa are pushing original vendor_id through opencl
13393 // this causes trouble with vendor id based macros
13394 // we'll assign generic to those without special optimization available
13395
13396 cl_uint platform_vendor_id = 0;
13397
13398 if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0)
13399 {
13400 platform_vendor_id = VENDOR_ID_AMD;
13401 }
13402 else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13403 {
13404 platform_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13405 }
13406 else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0)
13407 {
13408 platform_vendor_id = VENDOR_ID_APPLE;
13409 }
13410 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13411 {
13412 platform_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13413 }
13414 else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0)
13415 {
13416 platform_vendor_id = VENDOR_ID_INTEL_SDK;
13417 }
13418 else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0)
13419 {
13420 platform_vendor_id = VENDOR_ID_MESA;
13421 }
13422 else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0)
13423 {
13424 platform_vendor_id = VENDOR_ID_NV;
13425 }
13426 else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0)
13427 {
13428 platform_vendor_id = VENDOR_ID_POCL;
13429 }
13430 else
13431 {
13432 platform_vendor_id = VENDOR_ID_GENERIC;
13433 }
13434
13435 for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
13436 {
13437 size_t param_value_size = 0;
13438
13439 const uint device_id = devices_cnt;
13440
13441 hc_device_param_t *device_param = &data.devices_param[device_id];
13442
13443 device_param->platform_vendor_id = platform_vendor_id;
13444
13445 device_param->device = platform_devices[platform_devices_id];
13446
13447 device_param->device_id = device_id;
13448
13449 device_param->platform_devices_id = platform_devices_id;
13450
13451 // device_type
13452
13453 cl_device_type device_type;
13454
13455 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_TYPE, sizeof (device_type), &device_type, NULL);
13456
13457 device_type &= ~CL_DEVICE_TYPE_DEFAULT;
13458
13459 device_param->device_type = device_type;
13460
13461 // device_name
13462
13463 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, 0, NULL, &param_value_size);
13464
13465 char *device_name = (char *) mymalloc (param_value_size);
13466
13467 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NAME, param_value_size, device_name, NULL);
13468
13469 device_param->device_name = device_name;
13470
13471 // device_vendor
13472
13473 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, &param_value_size);
13474
13475 char *device_vendor = (char *) mymalloc (param_value_size);
13476
13477 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL);
13478
13479 device_param->device_vendor = device_vendor;
13480
13481 cl_uint device_vendor_id = 0;
13482
13483 if (strcmp (device_vendor, CL_VENDOR_AMD) == 0)
13484 {
13485 device_vendor_id = VENDOR_ID_AMD;
13486 }
13487 else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0)
13488 {
13489 device_vendor_id = VENDOR_ID_AMD_USE_INTEL;
13490 }
13491 else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0)
13492 {
13493 device_vendor_id = VENDOR_ID_APPLE;
13494 }
13495 else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0)
13496 {
13497 device_vendor_id = VENDOR_ID_INTEL_BEIGNET;
13498 }
13499 else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0)
13500 {
13501 device_vendor_id = VENDOR_ID_INTEL_SDK;
13502 }
13503 else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0)
13504 {
13505 device_vendor_id = VENDOR_ID_MESA;
13506 }
13507 else if (strcmp (device_vendor, CL_VENDOR_NV) == 0)
13508 {
13509 device_vendor_id = VENDOR_ID_NV;
13510 }
13511 else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0)
13512 {
13513 device_vendor_id = VENDOR_ID_POCL;
13514 }
13515 else
13516 {
13517 device_vendor_id = VENDOR_ID_GENERIC;
13518 }
13519
13520 device_param->device_vendor_id = device_vendor_id;
13521
13522 // tuning db
13523
13524 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13525
13526 // device_version
13527
13528 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, 0, NULL, &param_value_size);
13529
13530 char *device_version = (char *) mymalloc (param_value_size);
13531
13532 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VERSION, param_value_size, device_version, NULL);
13533
13534 device_param->device_version = device_version;
13535
13536 // device_opencl_version
13537
13538 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, 0, NULL, &param_value_size);
13539
13540 char *device_opencl_version = (char *) mymalloc (param_value_size);
13541
13542 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_OPENCL_C_VERSION, param_value_size, device_opencl_version, NULL);
13543
13544 device_param->opencl_v12 = device_opencl_version[9] > '1' || device_opencl_version[11] >= '2';
13545
13546 myfree (device_opencl_version);
13547
13548 // vector_width
13549
13550 cl_uint vector_width;
13551
13552 if (opencl_vector_width_chgd == 0)
13553 {
13554 if (tuningdb_entry == NULL || tuningdb_entry->vector_width == -1)
13555 {
13556 if (opti_type & OPTI_TYPE_USES_BITS_64)
13557 {
13558 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, sizeof (vector_width), &vector_width, NULL);
13559 }
13560 else
13561 {
13562 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, sizeof (vector_width), &vector_width, NULL);
13563 }
13564 }
13565 else
13566 {
13567 vector_width = (cl_uint) tuningdb_entry->vector_width;
13568 }
13569 }
13570 else
13571 {
13572 vector_width = opencl_vector_width;
13573 }
13574
13575 if (vector_width > 16) vector_width = 16;
13576
13577 device_param->vector_width = vector_width;
13578
13579 // max_compute_units
13580
13581 cl_uint device_processors;
13582
13583 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof (device_processors), &device_processors, NULL);
13584
13585 device_param->device_processors = device_processors;
13586
13587 // device_maxmem_alloc
13588 // note we'll limit to 2gb, otherwise this causes all kinds of weird errors because of possible integer overflows in opencl runtimes
13589
13590 cl_ulong device_maxmem_alloc;
13591
13592 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof (device_maxmem_alloc), &device_maxmem_alloc, NULL);
13593
13594 device_param->device_maxmem_alloc = MIN (device_maxmem_alloc, 0x7fffffff);
13595
13596 // device_global_mem
13597
13598 cl_ulong device_global_mem;
13599
13600 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (device_global_mem), &device_global_mem, NULL);
13601
13602 device_param->device_global_mem = device_global_mem;
13603
13604 // max_work_group_size
13605
13606 size_t device_maxworkgroup_size;
13607
13608 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof (device_maxworkgroup_size), &device_maxworkgroup_size, NULL);
13609
13610 device_param->device_maxworkgroup_size = device_maxworkgroup_size;
13611
13612 // max_clock_frequency
13613
13614 cl_uint device_maxclock_frequency;
13615
13616 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof (device_maxclock_frequency), &device_maxclock_frequency, NULL);
13617
13618 device_param->device_maxclock_frequency = device_maxclock_frequency;
13619
13620 // device_endian_little
13621
13622 cl_bool device_endian_little;
13623
13624 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_ENDIAN_LITTLE, sizeof (device_endian_little), &device_endian_little, NULL);
13625
13626 if (device_endian_little == CL_FALSE)
13627 {
13628 if (data.quiet == 0) log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
13629
13630 device_param->skipped = 1;
13631 }
13632
13633 // device_available
13634
13635 cl_bool device_available;
13636
13637 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_AVAILABLE, sizeof (device_available), &device_available, NULL);
13638
13639 if (device_available == CL_FALSE)
13640 {
13641 if (data.quiet == 0) log_info ("Device #%u: WARNING: device not available", device_id + 1);
13642
13643 device_param->skipped = 1;
13644 }
13645
13646 // device_compiler_available
13647
13648 cl_bool device_compiler_available;
13649
13650 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPILER_AVAILABLE, sizeof (device_compiler_available), &device_compiler_available, NULL);
13651
13652 if (device_compiler_available == CL_FALSE)
13653 {
13654 if (data.quiet == 0) log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
13655
13656 device_param->skipped = 1;
13657 }
13658
13659 // device_execution_capabilities
13660
13661 cl_device_exec_capabilities device_execution_capabilities;
13662
13663 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXECUTION_CAPABILITIES, sizeof (device_execution_capabilities), &device_execution_capabilities, NULL);
13664
13665 if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
13666 {
13667 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
13668
13669 device_param->skipped = 1;
13670 }
13671
13672 // device_extensions
13673
13674 size_t device_extensions_size;
13675
13676 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, 0, NULL, &device_extensions_size);
13677
13678 char *device_extensions = mymalloc (device_extensions_size + 1);
13679
13680 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_EXTENSIONS, device_extensions_size, device_extensions, NULL);
13681
13682 if (strstr (device_extensions, "base_atomics") == 0)
13683 {
13684 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
13685
13686 device_param->skipped = 1;
13687 }
13688
13689 if (strstr (device_extensions, "byte_addressable_store") == 0)
13690 {
13691 if (data.quiet == 0) log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
13692
13693 device_param->skipped = 1;
13694 }
13695
13696 myfree (device_extensions);
13697
13698 // device_local_mem_size
13699
13700 cl_ulong device_local_mem_size;
13701
13702 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (device_local_mem_size), &device_local_mem_size, NULL);
13703
13704 if (device_local_mem_size < 32768)
13705 {
13706 if (data.quiet == 0) log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
13707
13708 device_param->skipped = 1;
13709 }
13710
13711 // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
13712 // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources
13713 // This results in both utilizing it for 50%
13714 // However, Intel has much better SIMD control over their own hardware
13715 // It makes sense to give them full control over their own hardware
13716
13717 if (device_type & CL_DEVICE_TYPE_CPU)
13718 {
13719 if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL)
13720 {
13721 if (data.quiet == 0) log_info ("Device #%u: WARNING: not native intel opencl platform", device_id + 1);
13722
13723 device_param->skipped = 1;
13724 }
13725 }
13726
13727 // skipped
13728
13729 device_param->skipped |= ((devices_filter & (1 << device_id)) == 0);
13730 device_param->skipped |= ((device_types_filter & (device_type)) == 0);
13731
13732 // driver_version
13733
13734 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, 0, NULL, &param_value_size);
13735
13736 char *driver_version = (char *) mymalloc (param_value_size);
13737
13738 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DRIVER_VERSION, param_value_size, driver_version, NULL);
13739
13740 device_param->driver_version = driver_version;
13741
13742 // device_name_chksum
13743
13744 char *device_name_chksum = (char *) mymalloc (INFOSZ);
13745
13746 #if __x86_64__
13747 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13748 #else
13749 snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME);
13750 #endif
13751
13752 uint device_name_digest[4] = { 0 };
13753
13754 md5_64 ((uint *) device_name_chksum, device_name_digest);
13755
13756 snprintf (device_name_chksum, INFOSZ - 1, "%08x", device_name_digest[0]);
13757
13758 device_param->device_name_chksum = device_name_chksum;
13759
13760 // device_processor_cores
13761
13762 if (device_type & CL_DEVICE_TYPE_CPU)
13763 {
13764 cl_uint device_processor_cores = 1;
13765
13766 device_param->device_processor_cores = device_processor_cores;
13767 }
13768
13769 if (device_type & CL_DEVICE_TYPE_GPU)
13770 {
13771 if (device_vendor_id == VENDOR_ID_AMD)
13772 {
13773 cl_uint device_processor_cores = 0;
13774
13775 #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043
13776
13777 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL);
13778
13779 device_param->device_processor_cores = device_processor_cores;
13780 }
13781 else if (device_vendor_id == VENDOR_ID_NV)
13782 {
13783 cl_uint kernel_exec_timeout = 0;
13784
13785 #define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005
13786
13787 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, sizeof (kernel_exec_timeout), &kernel_exec_timeout, NULL);
13788
13789 device_param->kernel_exec_timeout = kernel_exec_timeout;
13790
13791 cl_uint device_processor_cores = 0;
13792
13793 #define CL_DEVICE_WARP_SIZE_NV 0x4003
13794
13795 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL);
13796
13797 device_param->device_processor_cores = device_processor_cores;
13798
13799 cl_uint sm_minor = 0;
13800 cl_uint sm_major = 0;
13801
13802 #define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000
13803 #define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001
13804
13805 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV, sizeof (sm_minor), &sm_minor, NULL);
13806 hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, sizeof (sm_major), &sm_major, NULL);
13807
13808 device_param->sm_minor = sm_minor;
13809 device_param->sm_major = sm_major;
13810 }
13811 else
13812 {
13813 cl_uint device_processor_cores = 1;
13814
13815 device_param->device_processor_cores = device_processor_cores;
13816 }
13817 }
13818
13819 // display results
13820
13821 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
13822 {
13823 if (machine_readable == 0)
13824 {
13825 if (device_param->skipped == 0)
13826 {
13827 log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
13828 device_id + 1,
13829 device_name,
13830 (unsigned int) (device_maxmem_alloc / 1024 / 1024),
13831 (unsigned int) (device_global_mem / 1024 / 1024),
13832 (unsigned int) device_processors);
13833 }
13834 else
13835 {
13836 log_info ("Device #%u: %s, skipped",
13837 device_id + 1,
13838 device_name);
13839 }
13840 }
13841 }
13842
13843 // common driver check
13844
13845 if (device_param->skipped == 0)
13846 {
13847 if (device_type & CL_DEVICE_TYPE_GPU)
13848 {
13849 if (platform_vendor_id == VENDOR_ID_AMD)
13850 {
13851 int catalyst_check = (force == 1) ? 0 : 1;
13852
13853 int catalyst_warn = 0;
13854
13855 int catalyst_broken = 0;
13856
13857 if (catalyst_check == 1)
13858 {
13859 catalyst_warn = 1;
13860
13861 // v14.9 and higher
13862 if (atoi (device_param->driver_version) >= 1573)
13863 {
13864 catalyst_warn = 0;
13865 }
13866
13867 catalyst_check = 0;
13868 }
13869
13870 if (catalyst_broken == 1)
13871 {
13872 log_info ("");
13873 log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
13874 log_info ("It will pass over cracked hashes and does not report them as cracked");
13875 log_info ("You are STRONGLY encouraged not to use it");
13876 log_info ("You can use --force to override this but do not post error reports if you do so");
13877 log_info ("");
13878
13879 return (-1);
13880 }
13881
13882 if (catalyst_warn == 1)
13883 {
13884 log_info ("");
13885 log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
13886 log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
13887 log_info ("See hashcat's homepage for official supported catalyst drivers");
13888 #ifdef _WIN
13889 log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
13890 #endif
13891 log_info ("You can use --force to override this but do not post error reports if you do so");
13892 log_info ("");
13893
13894 return (-1);
13895 }
13896 }
13897 else if (platform_vendor_id == VENDOR_ID_NV)
13898 {
13899 if (device_param->kernel_exec_timeout != 0)
13900 {
13901 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);
13902 if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
13903 }
13904 }
13905 }
13906
13907 /* turns out pocl still creates segfaults (because of llvm)
13908 if (device_type & CL_DEVICE_TYPE_CPU)
13909 {
13910 if (platform_vendor_id == VENDOR_ID_AMD)
13911 {
13912 if (force == 0)
13913 {
13914 log_info ("");
13915 log_info ("ATTENTION! OpenCL support for CPU of catalyst driver is not reliable.");
13916 log_info ("You are STRONGLY encouraged not to use it");
13917 log_info ("You can use --force to override this but do not post error reports if you do so");
13918 log_info ("A good alternative is the free pocl >= v0.13, but make sure to use a LLVM >= v3.8");
13919 log_info ("");
13920
13921 return (-1);
13922 }
13923 }
13924 }
13925 */
13926
13927 /**
13928 * kernel accel and loops tuning db adjustment
13929 */
13930
13931 device_param->kernel_accel_min = 1;
13932 device_param->kernel_accel_max = 1024;
13933
13934 device_param->kernel_loops_min = 1;
13935 device_param->kernel_loops_max = 1024;
13936
13937 tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode);
13938
13939 if (tuningdb_entry)
13940 {
13941 u32 _kernel_accel = tuningdb_entry->kernel_accel;
13942 u32 _kernel_loops = tuningdb_entry->kernel_loops;
13943
13944 if (_kernel_accel)
13945 {
13946 device_param->kernel_accel_min = _kernel_accel;
13947 device_param->kernel_accel_max = _kernel_accel;
13948 }
13949
13950 if (_kernel_loops)
13951 {
13952 if (workload_profile == 1)
13953 {
13954 _kernel_loops = (_kernel_loops > 8) ? _kernel_loops / 8 : 1;
13955 }
13956 else if (workload_profile == 2)
13957 {
13958 _kernel_loops = (_kernel_loops > 4) ? _kernel_loops / 4 : 1;
13959 }
13960
13961 device_param->kernel_loops_min = _kernel_loops;
13962 device_param->kernel_loops_max = _kernel_loops;
13963 }
13964 }
13965
13966 // commandline parameters overwrite tuningdb entries
13967
13968 if (kernel_accel)
13969 {
13970 device_param->kernel_accel_min = kernel_accel;
13971 device_param->kernel_accel_max = kernel_accel;
13972 }
13973
13974 if (kernel_loops)
13975 {
13976 device_param->kernel_loops_min = kernel_loops;
13977 device_param->kernel_loops_max = kernel_loops;
13978 }
13979
13980 /**
13981 * activate device
13982 */
13983
13984 devices_active++;
13985 }
13986
13987 // next please
13988
13989 devices_cnt++;
13990 }
13991 }
13992
13993 if (keyspace == 0 && devices_active == 0)
13994 {
13995 log_error ("ERROR: No devices found/left");
13996
13997 return (-1);
13998 }
13999
14000 // 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)
14001
14002 if (devices_filter != (uint) -1)
14003 {
14004 uint devices_cnt_mask = ~(((uint) -1 >> devices_cnt) << devices_cnt);
14005
14006 if (devices_filter > devices_cnt_mask)
14007 {
14008 log_error ("ERROR: The device specified by the --opencl-devices parameter is larger than the number of available devices (%d)", devices_cnt);
14009
14010 return (-1);
14011 }
14012 }
14013
14014 data.devices_cnt = devices_cnt;
14015
14016 data.devices_active = devices_active;
14017
14018 if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
14019 {
14020 if (machine_readable == 0)
14021 {
14022 log_info ("");
14023 }
14024 }
14025
14026 /**
14027 * HM devices: init
14028 */
14029
14030 #ifdef HAVE_HWMON
14031 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14032 hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
14033 #endif
14034
14035 #ifdef HAVE_ADL
14036 hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0, 0, 0 } };
14037 #endif
14038
14039 if (gpu_temp_disable == 0)
14040 {
14041 #if defined(WIN) && defined(HAVE_NVAPI)
14042 NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR));
14043
14044 if (nvapi_init (nvapi) == 0)
14045 data.hm_nv = nvapi;
14046
14047 if (data.hm_nv)
14048 {
14049 if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK)
14050 {
14051 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14052
14053 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14054
14055 int tmp_out = 0;
14056
14057 for (int i = 0; i < tmp_in; i++)
14058 {
14059 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14060 }
14061
14062 for (int i = 0; i < tmp_out; i++)
14063 {
14064 NV_GPU_COOLER_SETTINGS pCoolerSettings;
14065
14066 pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS);
14067
14068 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;
14069 }
14070 }
14071 }
14072 #endif // WIN && HAVE_NVAPI
14073
14074 #if defined(LINUX) && defined(HAVE_NVML)
14075 NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR));
14076
14077 if (nvml_init (nvml) == 0)
14078 data.hm_nv = nvml;
14079
14080 if (data.hm_nv)
14081 {
14082 if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS)
14083 {
14084 HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 };
14085
14086 int tmp_in = hm_get_adapter_index_nv (nvGPUHandle);
14087
14088 int tmp_out = 0;
14089
14090 for (int i = 0; i < tmp_in; i++)
14091 {
14092 hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i];
14093 }
14094
14095 for (int i = 0; i < tmp_out; i++)
14096 {
14097 unsigned int speed;
14098
14099 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;
14100 }
14101 }
14102 }
14103 #endif // LINUX && HAVE_NVML
14104
14105 data.hm_amd = NULL;
14106
14107 #ifdef HAVE_ADL
14108 ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR));
14109
14110 if (adl_init (adl) == 0)
14111 data.hm_amd = adl;
14112
14113 if (data.hm_amd)
14114 {
14115 if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK)
14116 {
14117 // total number of adapters
14118
14119 int hm_adapters_num;
14120
14121 if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1);
14122
14123 // adapter info
14124
14125 LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num);
14126
14127 if (lpAdapterInfo == NULL) return (-1);
14128
14129 // get a list (of ids of) valid/usable adapters
14130
14131 int num_adl_adapters = 0;
14132
14133 u32 *valid_adl_device_list = hm_get_list_valid_adl_adapters (hm_adapters_num, &num_adl_adapters, lpAdapterInfo);
14134
14135 if (num_adl_adapters > 0)
14136 {
14137 hc_thread_mutex_lock (mux_adl);
14138
14139 // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all);
14140
14141 hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14142
14143 hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14144 hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo);
14145
14146 hc_thread_mutex_unlock (mux_adl);
14147 }
14148
14149 myfree (valid_adl_device_list);
14150 myfree (lpAdapterInfo);
14151 }
14152 }
14153 #endif // HAVE_ADL
14154
14155 if (data.hm_amd == NULL && data.hm_nv == NULL)
14156 {
14157 gpu_temp_disable = 1;
14158 }
14159 }
14160
14161 /**
14162 * OpenCL devices: allocate buffer for device specific information
14163 */
14164
14165 #ifdef HAVE_HWMON
14166 int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int));
14167
14168 #ifdef HAVE_ADL
14169 ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState));
14170
14171 int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int));
14172 #endif // ADL
14173 #endif
14174
14175 /**
14176 * enable custom signal handler(s)
14177 */
14178
14179 if (benchmark == 0)
14180 {
14181 hc_signal (sigHandler_default);
14182 }
14183 else
14184 {
14185 hc_signal (sigHandler_benchmark);
14186 }
14187
14188 /**
14189 * User-defined GPU temp handling
14190 */
14191
14192 #ifdef HAVE_HWMON
14193 if (gpu_temp_disable == 1)
14194 {
14195 gpu_temp_abort = 0;
14196 gpu_temp_retain = 0;
14197 }
14198
14199 if ((gpu_temp_abort != 0) && (gpu_temp_retain != 0))
14200 {
14201 if (gpu_temp_abort < gpu_temp_retain)
14202 {
14203 log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
14204
14205 return (-1);
14206 }
14207 }
14208
14209 data.gpu_temp_disable = gpu_temp_disable;
14210 data.gpu_temp_abort = gpu_temp_abort;
14211 data.gpu_temp_retain = gpu_temp_retain;
14212 #endif
14213
14214 /**
14215 * inform the user
14216 */
14217
14218 if (data.quiet == 0)
14219 {
14220 log_info ("Hashes: %u hashes; %u unique digests, %u unique salts", hashes_cnt_orig, digests_cnt, salts_cnt);
14221
14222 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);
14223
14224 if (attack_mode == ATTACK_MODE_STRAIGHT)
14225 {
14226 log_info ("Rules: %u", kernel_rules_cnt);
14227 }
14228
14229 if (opti_type)
14230 {
14231 log_info ("Applicable Optimizers:");
14232
14233 for (uint i = 0; i < 32; i++)
14234 {
14235 const uint opti_bit = 1u << i;
14236
14237 if (opti_type & opti_bit) log_info ("* %s", stroptitype (opti_bit));
14238 }
14239 }
14240
14241 /**
14242 * Watchdog and Temperature balance
14243 */
14244
14245 #ifdef HAVE_HWMON
14246 if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL)
14247 {
14248 log_info ("Watchdog: Hardware Monitoring Interface not found on your system");
14249 }
14250
14251 if (gpu_temp_abort == 0)
14252 {
14253 log_info ("Watchdog: Temperature abort trigger disabled");
14254 }
14255 else
14256 {
14257 log_info ("Watchdog: Temperature abort trigger set to %uc", gpu_temp_abort);
14258 }
14259
14260 if (gpu_temp_retain == 0)
14261 {
14262 log_info ("Watchdog: Temperature retain trigger disabled");
14263 }
14264 else
14265 {
14266 log_info ("Watchdog: Temperature retain trigger set to %uc", gpu_temp_retain);
14267 }
14268
14269 if (data.quiet == 0) log_info ("");
14270 #endif
14271 }
14272
14273 /**
14274 * HM devices: copy
14275 */
14276
14277 if (gpu_temp_disable == 0)
14278 {
14279 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14280 {
14281 hc_device_param_t *device_param = &data.devices_param[device_id];
14282
14283 if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue;
14284
14285 if (device_param->skipped) continue;
14286
14287 const uint platform_devices_id = device_param->platform_devices_id;
14288
14289 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
14290 if (device_param->device_vendor_id == VENDOR_ID_NV)
14291 {
14292 memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t));
14293 }
14294 #endif
14295
14296 #ifdef HAVE_ADL
14297 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14298 {
14299 memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t));
14300 }
14301 #endif
14302 }
14303 }
14304
14305 /**
14306 * Temporary fix:
14307 * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff
14308 * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately
14309 * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem)
14310 * Driver / ADL bug?
14311 */
14312
14313 #ifdef HAVE_ADL
14314 if (powertune_enable == 1)
14315 {
14316 hc_thread_mutex_lock (mux_adl);
14317
14318 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14319 {
14320 hc_device_param_t *device_param = &data.devices_param[device_id];
14321
14322 if (device_param->skipped) continue;
14323
14324 if (data.hm_device[device_id].od_version == 6)
14325 {
14326 // set powertune value only
14327
14328 int powertune_supported = 0;
14329
14330 int ADL_rc = 0;
14331
14332 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
14333 {
14334 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
14335
14336 return (-1);
14337 }
14338
14339 if (powertune_supported != 0)
14340 {
14341 // powertune set
14342 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
14343
14344 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK)
14345 {
14346 log_error ("ERROR: Failed to get current ADL PowerControl settings");
14347
14348 return (-1);
14349 }
14350
14351 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
14352 {
14353 log_error ("ERROR: Failed to set new ADL PowerControl values");
14354
14355 return (-1);
14356 }
14357 }
14358 }
14359 }
14360
14361 hc_thread_mutex_unlock (mux_adl);
14362 }
14363 #endif // HAVE_ADK
14364 #endif // HAVE_HWMON
14365
14366 #ifdef DEBUG
14367 if (benchmark == 1) log_info ("Hashmode: %d", data.hash_mode);
14368 #endif
14369
14370 if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory...");
14371
14372 uint kernel_power_all = 0;
14373
14374 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
14375 {
14376 /**
14377 * host buffer
14378 */
14379
14380 hc_device_param_t *device_param = &data.devices_param[device_id];
14381
14382 if (device_param->skipped) continue;
14383
14384 /**
14385 * device properties
14386 */
14387
14388 const char *device_name_chksum = device_param->device_name_chksum;
14389 const u32 device_processors = device_param->device_processors;
14390 const u32 device_processor_cores = device_param->device_processor_cores;
14391
14392 /**
14393 * create context for each device
14394 */
14395
14396 device_param->context = hc_clCreateContext (data.ocl, NULL, 1, &device_param->device, NULL, NULL);
14397
14398 /**
14399 * create command-queue
14400 */
14401
14402 // not supported with NV
14403 // device_param->command_queue = hc_clCreateCommandQueueWithProperties (device_param->context, device_param->device, NULL);
14404
14405 device_param->command_queue = hc_clCreateCommandQueue (data.ocl, device_param->context, device_param->device, CL_QUEUE_PROFILING_ENABLE);
14406
14407 /**
14408 * kernel threads: some algorithms need a fixed kernel-threads count
14409 * because of shared memory usage or bitslice
14410 * there needs to be some upper limit, otherwise there's too much overhead
14411 */
14412
14413 uint kernel_threads = MIN (KERNEL_THREADS_MAX, device_param->device_maxworkgroup_size);
14414
14415 if (device_param->device_type & CL_DEVICE_TYPE_CPU)
14416 {
14417 kernel_threads = KERNEL_THREADS_MAX_CPU;
14418 }
14419
14420 if (hash_mode == 1500) kernel_threads = 64; // DES
14421 if (hash_mode == 3000) kernel_threads = 64; // DES
14422 if (hash_mode == 3200) kernel_threads = 8; // Blowfish
14423 if (hash_mode == 7500) kernel_threads = 64; // RC4
14424 if (hash_mode == 9000) kernel_threads = 8; // Blowfish
14425 if (hash_mode == 9700) kernel_threads = 64; // RC4
14426 if (hash_mode == 9710) kernel_threads = 64; // RC4
14427 if (hash_mode == 9800) kernel_threads = 64; // RC4
14428 if (hash_mode == 9810) kernel_threads = 64; // RC4
14429 if (hash_mode == 10400) kernel_threads = 64; // RC4
14430 if (hash_mode == 10410) kernel_threads = 64; // RC4
14431 if (hash_mode == 10500) kernel_threads = 64; // RC4
14432 if (hash_mode == 13100) kernel_threads = 64; // RC4
14433
14434 /**
14435 * create input buffers on device : calculate size of fixed memory buffers
14436 */
14437
14438 size_t size_root_css = SP_PW_MAX * sizeof (cs_t);
14439 size_t size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
14440
14441 device_param->size_root_css = size_root_css;
14442 device_param->size_markov_css = size_markov_css;
14443
14444 size_t size_results = sizeof (uint);
14445
14446 device_param->size_results = size_results;
14447
14448 size_t size_rules = kernel_rules_cnt * sizeof (kernel_rule_t);
14449 size_t size_rules_c = KERNEL_RULES * sizeof (kernel_rule_t);
14450
14451 size_t size_plains = digests_cnt * sizeof (plain_t);
14452 size_t size_salts = salts_cnt * sizeof (salt_t);
14453 size_t size_esalts = salts_cnt * esalt_size;
14454
14455 device_param->size_plains = size_plains;
14456 device_param->size_digests = size_digests;
14457 device_param->size_shown = size_shown;
14458 device_param->size_salts = size_salts;
14459
14460 size_t size_combs = KERNEL_COMBS * sizeof (comb_t);
14461 size_t size_bfs = KERNEL_BFS * sizeof (bf_t);
14462 size_t size_tm = 32 * sizeof (bs_word_t);
14463
14464 // scryptV stuff
14465
14466 size_t size_scryptV = 1;
14467
14468 if ((hash_mode == 8900) || (hash_mode == 9300))
14469 {
14470 uint tmto_start = 0;
14471 uint tmto_stop = 10;
14472
14473 if (scrypt_tmto)
14474 {
14475 tmto_start = scrypt_tmto;
14476 }
14477 else
14478 {
14479 // in case the user did not specify the tmto manually
14480 // use some values known to run best (tested on 290x for AMD and 980ti for NV)
14481 // but set the lower end only in case the user has a device with too less memory
14482
14483 if (hash_mode == 8900)
14484 {
14485 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14486 {
14487 tmto_start = 1;
14488 }
14489 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14490 {
14491 tmto_start = 2;
14492 }
14493 }
14494 else if (hash_mode == 9300)
14495 {
14496 if (device_param->device_vendor_id == VENDOR_ID_AMD)
14497 {
14498 tmto_start = 2;
14499 }
14500 else if (device_param->device_vendor_id == VENDOR_ID_NV)
14501 {
14502 tmto_start = 2;
14503 }
14504 }
14505 }
14506
14507 for (uint tmto = tmto_start; tmto < tmto_stop; tmto++)
14508 {
14509 // TODO: in theory the following calculation needs to be done per salt, not global
14510 // we assume all hashes have the same scrypt settings
14511
14512 size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N;
14513
14514 size_scryptV /= 1 << tmto;
14515
14516 size_scryptV *= device_processors * device_processor_cores;
14517
14518 if (size_scryptV > device_param->device_maxmem_alloc)
14519 {
14520 if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
14521
14522 continue;
14523 }
14524
14525 for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++)
14526 {
14527 data.salts_buf[salts_pos].scrypt_tmto = tmto;
14528 data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores;
14529 }
14530
14531 break;
14532 }
14533
14534 if (data.salts_buf[0].scrypt_phy == 0)
14535 {
14536 log_error ("ERROR: can't allocate enough device memory");
14537
14538 return -1;
14539 }
14540
14541 if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV);
14542 }
14543
14544 /**
14545 * some algorithms need a fixed kernel-loops count
14546 */
14547
14548 if (hash_mode == 1500)
14549 {
14550 const u32 kernel_loops_fixed = 1024;
14551
14552 device_param->kernel_loops_min = kernel_loops_fixed;
14553 device_param->kernel_loops_max = kernel_loops_fixed;
14554 }
14555
14556 if (hash_mode == 3000)
14557 {
14558 const u32 kernel_loops_fixed = 1024;
14559
14560 device_param->kernel_loops_min = kernel_loops_fixed;
14561 device_param->kernel_loops_max = kernel_loops_fixed;
14562 }
14563
14564 if (hash_mode == 8900)
14565 {
14566 const u32 kernel_loops_fixed = 1;
14567
14568 device_param->kernel_loops_min = kernel_loops_fixed;
14569 device_param->kernel_loops_max = kernel_loops_fixed;
14570 }
14571
14572 if (hash_mode == 9300)
14573 {
14574 const u32 kernel_loops_fixed = 1;
14575
14576 device_param->kernel_loops_min = kernel_loops_fixed;
14577 device_param->kernel_loops_max = kernel_loops_fixed;
14578 }
14579
14580 if (hash_mode == 12500)
14581 {
14582 const u32 kernel_loops_fixed = ROUNDS_RAR3 / 16;
14583
14584 device_param->kernel_loops_min = kernel_loops_fixed;
14585 device_param->kernel_loops_max = kernel_loops_fixed;
14586 }
14587
14588 /**
14589 * some algorithms have a maximum kernel-loops count
14590 */
14591
14592 if (device_param->kernel_loops_min < device_param->kernel_loops_max)
14593 {
14594 u32 innerloop_cnt = 0;
14595
14596 if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
14597 {
14598 if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt;
14599 else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt;
14600 else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt;
14601 }
14602 else
14603 {
14604 innerloop_cnt = data.salts_buf[0].salt_iter;
14605 }
14606
14607 if ((innerloop_cnt >= device_param->kernel_loops_min) &&
14608 (innerloop_cnt <= device_param->kernel_loops_max))
14609 {
14610 device_param->kernel_loops_max = innerloop_cnt;
14611 }
14612 }
14613
14614 u32 kernel_accel_min = device_param->kernel_accel_min;
14615 u32 kernel_accel_max = device_param->kernel_accel_max;
14616
14617 // find out if we would request too much memory on memory blocks which are based on kernel_accel
14618
14619 size_t size_pws = 4;
14620 size_t size_tmps = 4;
14621 size_t size_hooks = 4;
14622
14623 while (kernel_accel_max >= kernel_accel_min)
14624 {
14625 const u32 kernel_power_max = device_processors * kernel_threads * kernel_accel_max;
14626
14627 // size_pws
14628
14629 size_pws = kernel_power_max * sizeof (pw_t);
14630
14631 // size_tmps
14632
14633 switch (hash_mode)
14634 {
14635 case 400: size_tmps = kernel_power_max * sizeof (phpass_tmp_t); break;
14636 case 500: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14637 case 501: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14638 case 1600: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14639 case 1800: size_tmps = kernel_power_max * sizeof (sha512crypt_tmp_t); break;
14640 case 2100: size_tmps = kernel_power_max * sizeof (dcc2_tmp_t); break;
14641 case 2500: size_tmps = kernel_power_max * sizeof (wpa_tmp_t); break;
14642 case 3200: size_tmps = kernel_power_max * sizeof (bcrypt_tmp_t); break;
14643 case 5200: size_tmps = kernel_power_max * sizeof (pwsafe3_tmp_t); break;
14644 case 5800: size_tmps = kernel_power_max * sizeof (androidpin_tmp_t); break;
14645 case 6211: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14646 case 6212: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14647 case 6213: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14648 case 6221: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14649 case 6222: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14650 case 6223: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14651 case 6231: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14652 case 6232: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14653 case 6233: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14654 case 6241: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14655 case 6242: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14656 case 6243: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14657 case 6300: size_tmps = kernel_power_max * sizeof (md5crypt_tmp_t); break;
14658 case 6400: size_tmps = kernel_power_max * sizeof (sha256aix_tmp_t); break;
14659 case 6500: size_tmps = kernel_power_max * sizeof (sha512aix_tmp_t); break;
14660 case 6600: size_tmps = kernel_power_max * sizeof (agilekey_tmp_t); break;
14661 case 6700: size_tmps = kernel_power_max * sizeof (sha1aix_tmp_t); break;
14662 case 6800: size_tmps = kernel_power_max * sizeof (lastpass_tmp_t); break;
14663 case 7100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14664 case 7200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14665 case 7400: size_tmps = kernel_power_max * sizeof (sha256crypt_tmp_t); break;
14666 case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break;
14667 case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14668 case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break;
14669 case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14670 case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break;
14671 case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break;
14672 case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14673 case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break;
14674 case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break;
14675 case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break;
14676 case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break;
14677 case 10000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14678 case 10200: size_tmps = kernel_power_max * sizeof (cram_md5_t); break;
14679 case 10300: size_tmps = kernel_power_max * sizeof (saph_sha1_tmp_t); break;
14680 case 10500: size_tmps = kernel_power_max * sizeof (pdf14_tmp_t); break;
14681 case 10700: size_tmps = kernel_power_max * sizeof (pdf17l8_tmp_t); break;
14682 case 10900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14683 case 11300: size_tmps = kernel_power_max * sizeof (bitcoin_wallet_tmp_t); break;
14684 case 11600: size_tmps = kernel_power_max * sizeof (seven_zip_tmp_t); break;
14685 case 11900: size_tmps = kernel_power_max * sizeof (pbkdf2_md5_tmp_t); break;
14686 case 12000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14687 case 12100: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break;
14688 case 12200: size_tmps = kernel_power_max * sizeof (ecryptfs_tmp_t); break;
14689 case 12300: size_tmps = kernel_power_max * sizeof (oraclet_tmp_t); break;
14690 case 12400: size_tmps = kernel_power_max * sizeof (bsdicrypt_tmp_t); break;
14691 case 12500: size_tmps = kernel_power_max * sizeof (rar3_tmp_t); break;
14692 case 12700: size_tmps = kernel_power_max * sizeof (mywallet_tmp_t); break;
14693 case 12800: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14694 case 12900: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14695 case 13000: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break;
14696 case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break;
14697 case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break;
14698 case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break;
14699 case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14700 case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14701 case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14702 case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14703 case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14704 case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break;
14705 case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14706 case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14707 case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14708 case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14709 case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14710 case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14711 case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14712 case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14713 case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14714 case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14715 case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14716 case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break;
14717 };
14718
14719 // size_hooks
14720
14721 if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
14722 {
14723 // none yet
14724 }
14725
14726 // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries
14727 // if not, decrease amplifier and try again
14728
14729 int skip = 0;
14730
14731 const u64 size_total
14732 = bitmap_size
14733 + bitmap_size
14734 + bitmap_size
14735 + bitmap_size
14736 + bitmap_size
14737 + bitmap_size
14738 + bitmap_size
14739 + bitmap_size
14740 + size_bfs
14741 + size_combs
14742 + size_digests
14743 + size_esalts
14744 + size_hooks
14745 + size_markov_css
14746 + size_plains
14747 + size_pws
14748 + size_pws // not a bug
14749 + size_results
14750 + size_root_css
14751 + size_rules
14752 + size_rules_c
14753 + size_salts
14754 + size_scryptV
14755 + size_shown
14756 + size_tm
14757 + size_tmps;
14758
14759 // Don't ask me, ask AMD!
14760
14761 if (size_total > device_param->device_maxmem_alloc) skip = 1;
14762 if (size_total > device_param->device_global_mem) skip = 1;
14763
14764 if (skip == 1)
14765 {
14766 kernel_accel_max--;
14767
14768 continue;
14769 }
14770
14771 break;
14772 }
14773
14774 /*
14775 if (kernel_accel_max == 0)
14776 {
14777 log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
14778
14779 return -1;
14780 }
14781 */
14782
14783 device_param->kernel_accel_min = kernel_accel_min;
14784 device_param->kernel_accel_max = kernel_accel_max;
14785
14786 /*
14787 if (kernel_accel_max < kernel_accel)
14788 {
14789 if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
14790
14791 device_param->kernel_accel = kernel_accel_max;
14792 }
14793 */
14794
14795 device_param->size_bfs = size_bfs;
14796 device_param->size_combs = size_combs;
14797 device_param->size_rules = size_rules;
14798 device_param->size_rules_c = size_rules_c;
14799 device_param->size_pws = size_pws;
14800 device_param->size_tmps = size_tmps;
14801 device_param->size_hooks = size_hooks;
14802
14803 // do not confuse kernel_accel_max with kernel_accel here
14804
14805 const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max;
14806
14807 device_param->kernel_threads = kernel_threads;
14808 device_param->kernel_power_user = kernel_power;
14809
14810 kernel_power_all += kernel_power;
14811
14812 /**
14813 * default building options
14814 */
14815
14816 char build_opts[1024] = { 0 };
14817
14818 // we don't have sm_* on vendors not NV but it doesn't matter
14819
14820 #if _WIN
14821 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\\OpenCL\\\" -I '%s\\OpenCL\\' -I %s\\OpenCL\\ -I\"%s\\OpenCL\\\" -I'%s\\OpenCL\\' -I%s\\OpenCL\\", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14822 #else
14823 snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s/OpenCL/\" -I '%s/OpenCL/' -I %s/OpenCL/ -I\"%s/OpenCL/\" -I'%s/OpenCL/' -I%s/OpenCL/", shared_dir, shared_dir, shared_dir, shared_dir, shared_dir, shared_dir);
14824 #endif
14825
14826 char build_opts_new[1024] = { 0 };
14827
14828 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type);
14829
14830 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14831
14832 /*
14833 if (device_param->device_vendor_id == VENDOR_ID_INTEL_SDK)
14834 {
14835 // we do vectorizing much better than the auto-vectorizer
14836
14837 snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts);
14838
14839 strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1);
14840 }
14841 */
14842
14843 #ifdef DEBUG
14844 log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
14845 #endif
14846
14847 /**
14848 * main kernel
14849 */
14850
14851 {
14852 /**
14853 * kernel source filename
14854 */
14855
14856 char source_file[256] = { 0 };
14857
14858 generate_source_kernel_filename (attack_exec, attack_kern, kern_type, shared_dir, source_file);
14859
14860 struct stat sst;
14861
14862 if (stat (source_file, &sst) == -1)
14863 {
14864 log_error ("ERROR: %s: %s", source_file, strerror (errno));
14865
14866 return -1;
14867 }
14868
14869 /**
14870 * kernel cached filename
14871 */
14872
14873 char cached_file[256] = { 0 };
14874
14875 generate_cached_kernel_filename (attack_exec, attack_kern, kern_type, profile_dir, device_name_chksum, cached_file);
14876
14877 int cached = 1;
14878
14879 struct stat cst;
14880
14881 if ((stat (cached_file, &cst) == -1) || cst.st_size == 0)
14882 {
14883 cached = 0;
14884 }
14885
14886 /**
14887 * kernel compile or load
14888 */
14889
14890 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
14891
14892 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
14893
14894 if (force_jit_compilation == -1)
14895 {
14896 if (cached == 0)
14897 {
14898 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
14899
14900 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14901
14902 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14903
14904 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, false);
14905
14906 #ifdef DEBUG
14907 size_t build_log_size = 0;
14908
14909 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14910
14911 if (build_log_size > 1)
14912 {
14913 char *build_log = (char *) malloc (build_log_size + 1);
14914
14915 memset (build_log, 0, build_log_size + 1);
14916
14917 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14918
14919 puts (build_log);
14920
14921 free (build_log);
14922 }
14923 #endif
14924
14925 if (rc != 0)
14926 {
14927 device_param->skipped = true;
14928
14929 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
14930
14931 continue;
14932 }
14933
14934 size_t binary_size;
14935
14936 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
14937
14938 u8 *binary = (u8 *) mymalloc (binary_size);
14939
14940 hc_clGetProgramInfo (data.ocl, device_param->program, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
14941
14942 writeProgramBin (cached_file, binary, binary_size);
14943
14944 local_free (binary);
14945 }
14946 else
14947 {
14948 #ifdef DEBUG
14949 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
14950 #endif
14951
14952 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
14953
14954 device_param->program = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
14955
14956 hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts, NULL, NULL, true);
14957 }
14958 }
14959 else
14960 {
14961 #ifdef DEBUG
14962 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
14963 #endif
14964
14965 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
14966
14967 device_param->program = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
14968
14969 char build_opts_update[1024] = { 0 };
14970
14971 if (force_jit_compilation == 1500)
14972 {
14973 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]);
14974 }
14975 else if (force_jit_compilation == 8900)
14976 {
14977 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);
14978 }
14979 else
14980 {
14981 snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s", build_opts);
14982 }
14983
14984 int rc = hc_clBuildProgram (data.ocl, device_param->program, 1, &device_param->device, build_opts_update, NULL, NULL, false);
14985
14986 #ifdef DEBUG
14987 size_t build_log_size = 0;
14988
14989 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, 0, NULL, &build_log_size);
14990
14991 if (build_log_size > 1)
14992 {
14993 char *build_log = (char *) malloc (build_log_size + 1);
14994
14995 memset (build_log, 0, build_log_size + 1);
14996
14997 hc_clGetProgramBuildInfo (data.ocl, device_param->program, device_param->device, CL_PROGRAM_BUILD_LOG, build_log_size, build_log, NULL);
14998
14999 puts (build_log);
15000
15001 free (build_log);
15002 }
15003 #endif
15004
15005 if (rc != 0)
15006 {
15007 device_param->skipped = true;
15008
15009 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15010 }
15011 }
15012
15013 local_free (kernel_lengths);
15014 local_free (kernel_sources[0]);
15015 local_free (kernel_sources);
15016 }
15017
15018 /**
15019 * word generator kernel
15020 */
15021
15022 if (attack_mode != ATTACK_MODE_STRAIGHT)
15023 {
15024 /**
15025 * kernel mp source filename
15026 */
15027
15028 char source_file[256] = { 0 };
15029
15030 generate_source_kernel_mp_filename (opti_type, opts_type, shared_dir, source_file);
15031
15032 struct stat sst;
15033
15034 if (stat (source_file, &sst) == -1)
15035 {
15036 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15037
15038 return -1;
15039 }
15040
15041 /**
15042 * kernel mp cached filename
15043 */
15044
15045 char cached_file[256] = { 0 };
15046
15047 generate_cached_kernel_mp_filename (opti_type, opts_type, profile_dir, device_name_chksum, cached_file);
15048
15049 int cached = 1;
15050
15051 struct stat cst;
15052
15053 if (stat (cached_file, &cst) == -1)
15054 {
15055 cached = 0;
15056 }
15057
15058 /**
15059 * kernel compile or load
15060 */
15061
15062 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15063
15064 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15065
15066 if (cached == 0)
15067 {
15068 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15069 if (quiet == 0) log_info ("");
15070
15071 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15072
15073 device_param->program_mp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15074
15075 int rc = hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, false);
15076
15077 if (rc != 0)
15078 {
15079 device_param->skipped = true;
15080
15081 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15082
15083 continue;
15084 }
15085
15086 size_t binary_size;
15087
15088 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15089
15090 u8 *binary = (u8 *) mymalloc (binary_size);
15091
15092 hc_clGetProgramInfo (data.ocl, device_param->program_mp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15093
15094 writeProgramBin (cached_file, binary, binary_size);
15095
15096 local_free (binary);
15097 }
15098 else
15099 {
15100 #ifdef DEBUG
15101 log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15102 #endif
15103
15104 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15105
15106 device_param->program_mp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15107
15108 hc_clBuildProgram (data.ocl, device_param->program_mp, 1, &device_param->device, build_opts, NULL, NULL, true);
15109 }
15110
15111 local_free (kernel_lengths);
15112 local_free (kernel_sources[0]);
15113 local_free (kernel_sources);
15114 }
15115
15116 /**
15117 * amplifier kernel
15118 */
15119
15120 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15121 {
15122
15123 }
15124 else
15125 {
15126 /**
15127 * kernel amp source filename
15128 */
15129
15130 char source_file[256] = { 0 };
15131
15132 generate_source_kernel_amp_filename (attack_kern, shared_dir, source_file);
15133
15134 struct stat sst;
15135
15136 if (stat (source_file, &sst) == -1)
15137 {
15138 log_error ("ERROR: %s: %s", source_file, strerror (errno));
15139
15140 return -1;
15141 }
15142
15143 /**
15144 * kernel amp cached filename
15145 */
15146
15147 char cached_file[256] = { 0 };
15148
15149 generate_cached_kernel_amp_filename (attack_kern, profile_dir, device_name_chksum, cached_file);
15150
15151 int cached = 1;
15152
15153 struct stat cst;
15154
15155 if (stat (cached_file, &cst) == -1)
15156 {
15157 cached = 0;
15158 }
15159
15160 /**
15161 * kernel compile or load
15162 */
15163
15164 size_t *kernel_lengths = (size_t *) mymalloc (sizeof (size_t));
15165
15166 const u8 **kernel_sources = (const u8 **) mymalloc (sizeof (u8 *));
15167
15168 if (cached == 0)
15169 {
15170 if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
15171 if (quiet == 0) log_info ("");
15172
15173 load_kernel (source_file, 1, kernel_lengths, kernel_sources);
15174
15175 device_param->program_amp = hc_clCreateProgramWithSource (data.ocl, device_param->context, 1, (const char **) kernel_sources, NULL);
15176
15177 int rc = hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, false);
15178
15179 if (rc != 0)
15180 {
15181 device_param->skipped = true;
15182
15183 log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
15184
15185 continue;
15186 }
15187
15188 size_t binary_size;
15189
15190 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARY_SIZES, sizeof (size_t), &binary_size, NULL);
15191
15192 u8 *binary = (u8 *) mymalloc (binary_size);
15193
15194 hc_clGetProgramInfo (data.ocl, device_param->program_amp, CL_PROGRAM_BINARIES, sizeof (binary), &binary, NULL);
15195
15196 writeProgramBin (cached_file, binary, binary_size);
15197
15198 local_free (binary);
15199 }
15200 else
15201 {
15202 #ifdef DEBUG
15203 if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
15204 #endif
15205
15206 load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
15207
15208 device_param->program_amp = hc_clCreateProgramWithBinary (data.ocl, device_param->context, 1, &device_param->device, kernel_lengths, (const u8 **) kernel_sources, NULL);
15209
15210 hc_clBuildProgram (data.ocl, device_param->program_amp, 1, &device_param->device, build_opts, NULL, NULL, true);
15211 }
15212
15213 local_free (kernel_lengths);
15214 local_free (kernel_sources[0]);
15215 local_free (kernel_sources);
15216 }
15217
15218 // some algorithm collide too fast, make that impossible
15219
15220 if (benchmark == 1)
15221 {
15222 ((uint *) digests_buf)[0] = -1;
15223 ((uint *) digests_buf)[1] = -1;
15224 ((uint *) digests_buf)[2] = -1;
15225 ((uint *) digests_buf)[3] = -1;
15226 }
15227
15228 /**
15229 * global buffers
15230 */
15231
15232 device_param->d_pws_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15233 device_param->d_pws_amp_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_pws, NULL);
15234 device_param->d_tmps = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_tmps, NULL);
15235 device_param->d_hooks = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_hooks, NULL);
15236 device_param->d_bitmap_s1_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15237 device_param->d_bitmap_s1_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15238 device_param->d_bitmap_s1_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15239 device_param->d_bitmap_s1_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15240 device_param->d_bitmap_s2_a = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15241 device_param->d_bitmap_s2_b = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15242 device_param->d_bitmap_s2_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15243 device_param->d_bitmap_s2_d = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, bitmap_size, NULL);
15244 device_param->d_plain_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_plains, NULL);
15245 device_param->d_digests_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_digests, NULL);
15246 device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL);
15247 device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL);
15248 device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL);
15249 device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL);
15250
15251 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);
15252 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);
15253 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);
15254 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);
15255 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);
15256 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);
15257 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);
15258 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);
15259 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_buf, CL_TRUE, 0, size_digests, data.digests_buf, 0, NULL, NULL);
15260 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL);
15261 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL);
15262
15263 /**
15264 * special buffers
15265 */
15266
15267 if (attack_kern == ATTACK_KERN_STRAIGHT)
15268 {
15269 device_param->d_rules = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules, NULL);
15270 device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL);
15271
15272 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL);
15273 }
15274 else if (attack_kern == ATTACK_KERN_COMBI)
15275 {
15276 device_param->d_combs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15277 device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL);
15278 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15279 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15280 }
15281 else if (attack_kern == ATTACK_KERN_BF)
15282 {
15283 device_param->d_bfs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15284 device_param->d_bfs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_bfs, NULL);
15285 device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL);
15286 device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL);
15287 device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL);
15288 }
15289
15290 if (size_esalts)
15291 {
15292 device_param->d_esalt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_esalts, NULL);
15293
15294 hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_esalt_bufs, CL_TRUE, 0, size_esalts, data.esalts_buf, 0, NULL, NULL);
15295 }
15296
15297 /**
15298 * main host data
15299 */
15300
15301 pw_t *pws_buf = (pw_t *) mymalloc (size_pws);
15302
15303 device_param->pws_buf = pws_buf;
15304
15305 comb_t *combs_buf = (comb_t *) mycalloc (KERNEL_COMBS, sizeof (comb_t));
15306
15307 device_param->combs_buf = combs_buf;
15308
15309 void *hooks_buf = mymalloc (size_hooks);
15310
15311 device_param->hooks_buf = hooks_buf;
15312
15313 /**
15314 * kernel args
15315 */
15316
15317 device_param->kernel_params_buf32[21] = bitmap_mask;
15318 device_param->kernel_params_buf32[22] = bitmap_shift1;
15319 device_param->kernel_params_buf32[23] = bitmap_shift2;
15320 device_param->kernel_params_buf32[24] = 0; // salt_pos
15321 device_param->kernel_params_buf32[25] = 0; // loop_pos
15322 device_param->kernel_params_buf32[26] = 0; // loop_cnt
15323 device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt
15324 device_param->kernel_params_buf32[28] = 0; // digests_cnt
15325 device_param->kernel_params_buf32[29] = 0; // digests_offset
15326 device_param->kernel_params_buf32[30] = 0; // combs_mode
15327 device_param->kernel_params_buf32[31] = 0; // gid_max
15328
15329 device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15330 ? &device_param->d_pws_buf
15331 : &device_param->d_pws_amp_buf;
15332 device_param->kernel_params[ 1] = &device_param->d_rules_c;
15333 device_param->kernel_params[ 2] = &device_param->d_combs_c;
15334 device_param->kernel_params[ 3] = &device_param->d_bfs_c;
15335 device_param->kernel_params[ 4] = &device_param->d_tmps;
15336 device_param->kernel_params[ 5] = &device_param->d_hooks;
15337 device_param->kernel_params[ 6] = &device_param->d_bitmap_s1_a;
15338 device_param->kernel_params[ 7] = &device_param->d_bitmap_s1_b;
15339 device_param->kernel_params[ 8] = &device_param->d_bitmap_s1_c;
15340 device_param->kernel_params[ 9] = &device_param->d_bitmap_s1_d;
15341 device_param->kernel_params[10] = &device_param->d_bitmap_s2_a;
15342 device_param->kernel_params[11] = &device_param->d_bitmap_s2_b;
15343 device_param->kernel_params[12] = &device_param->d_bitmap_s2_c;
15344 device_param->kernel_params[13] = &device_param->d_bitmap_s2_d;
15345 device_param->kernel_params[14] = &device_param->d_plain_bufs;
15346 device_param->kernel_params[15] = &device_param->d_digests_buf;
15347 device_param->kernel_params[16] = &device_param->d_digests_shown;
15348 device_param->kernel_params[17] = &device_param->d_salt_bufs;
15349 device_param->kernel_params[18] = &device_param->d_esalt_bufs;
15350 device_param->kernel_params[19] = &device_param->d_result;
15351 device_param->kernel_params[20] = &device_param->d_scryptV_buf;
15352 device_param->kernel_params[21] = &device_param->kernel_params_buf32[21];
15353 device_param->kernel_params[22] = &device_param->kernel_params_buf32[22];
15354 device_param->kernel_params[23] = &device_param->kernel_params_buf32[23];
15355 device_param->kernel_params[24] = &device_param->kernel_params_buf32[24];
15356 device_param->kernel_params[25] = &device_param->kernel_params_buf32[25];
15357 device_param->kernel_params[26] = &device_param->kernel_params_buf32[26];
15358 device_param->kernel_params[27] = &device_param->kernel_params_buf32[27];
15359 device_param->kernel_params[28] = &device_param->kernel_params_buf32[28];
15360 device_param->kernel_params[29] = &device_param->kernel_params_buf32[29];
15361 device_param->kernel_params[30] = &device_param->kernel_params_buf32[30];
15362 device_param->kernel_params[31] = &device_param->kernel_params_buf32[31];
15363
15364 device_param->kernel_params_mp_buf64[3] = 0;
15365 device_param->kernel_params_mp_buf32[4] = 0;
15366 device_param->kernel_params_mp_buf32[5] = 0;
15367 device_param->kernel_params_mp_buf32[6] = 0;
15368 device_param->kernel_params_mp_buf32[7] = 0;
15369 device_param->kernel_params_mp_buf32[8] = 0;
15370
15371 device_param->kernel_params_mp[0] = NULL;
15372 device_param->kernel_params_mp[1] = NULL;
15373 device_param->kernel_params_mp[2] = NULL;
15374 device_param->kernel_params_mp[3] = &device_param->kernel_params_mp_buf64[3];
15375 device_param->kernel_params_mp[4] = &device_param->kernel_params_mp_buf32[4];
15376 device_param->kernel_params_mp[5] = &device_param->kernel_params_mp_buf32[5];
15377 device_param->kernel_params_mp[6] = &device_param->kernel_params_mp_buf32[6];
15378 device_param->kernel_params_mp[7] = &device_param->kernel_params_mp_buf32[7];
15379 device_param->kernel_params_mp[8] = &device_param->kernel_params_mp_buf32[8];
15380
15381 device_param->kernel_params_mp_l_buf64[3] = 0;
15382 device_param->kernel_params_mp_l_buf32[4] = 0;
15383 device_param->kernel_params_mp_l_buf32[5] = 0;
15384 device_param->kernel_params_mp_l_buf32[6] = 0;
15385 device_param->kernel_params_mp_l_buf32[7] = 0;
15386 device_param->kernel_params_mp_l_buf32[8] = 0;
15387 device_param->kernel_params_mp_l_buf32[9] = 0;
15388
15389 device_param->kernel_params_mp_l[0] = NULL;
15390 device_param->kernel_params_mp_l[1] = NULL;
15391 device_param->kernel_params_mp_l[2] = NULL;
15392 device_param->kernel_params_mp_l[3] = &device_param->kernel_params_mp_l_buf64[3];
15393 device_param->kernel_params_mp_l[4] = &device_param->kernel_params_mp_l_buf32[4];
15394 device_param->kernel_params_mp_l[5] = &device_param->kernel_params_mp_l_buf32[5];
15395 device_param->kernel_params_mp_l[6] = &device_param->kernel_params_mp_l_buf32[6];
15396 device_param->kernel_params_mp_l[7] = &device_param->kernel_params_mp_l_buf32[7];
15397 device_param->kernel_params_mp_l[8] = &device_param->kernel_params_mp_l_buf32[8];
15398 device_param->kernel_params_mp_l[9] = &device_param->kernel_params_mp_l_buf32[9];
15399
15400 device_param->kernel_params_mp_r_buf64[3] = 0;
15401 device_param->kernel_params_mp_r_buf32[4] = 0;
15402 device_param->kernel_params_mp_r_buf32[5] = 0;
15403 device_param->kernel_params_mp_r_buf32[6] = 0;
15404 device_param->kernel_params_mp_r_buf32[7] = 0;
15405 device_param->kernel_params_mp_r_buf32[8] = 0;
15406
15407 device_param->kernel_params_mp_r[0] = NULL;
15408 device_param->kernel_params_mp_r[1] = NULL;
15409 device_param->kernel_params_mp_r[2] = NULL;
15410 device_param->kernel_params_mp_r[3] = &device_param->kernel_params_mp_r_buf64[3];
15411 device_param->kernel_params_mp_r[4] = &device_param->kernel_params_mp_r_buf32[4];
15412 device_param->kernel_params_mp_r[5] = &device_param->kernel_params_mp_r_buf32[5];
15413 device_param->kernel_params_mp_r[6] = &device_param->kernel_params_mp_r_buf32[6];
15414 device_param->kernel_params_mp_r[7] = &device_param->kernel_params_mp_r_buf32[7];
15415 device_param->kernel_params_mp_r[8] = &device_param->kernel_params_mp_r_buf32[8];
15416
15417 device_param->kernel_params_amp_buf32[5] = 0; // combs_mode
15418 device_param->kernel_params_amp_buf32[6] = 0; // gid_max
15419
15420 device_param->kernel_params_amp[0] = &device_param->d_pws_buf;
15421 device_param->kernel_params_amp[1] = &device_param->d_pws_amp_buf;
15422 device_param->kernel_params_amp[2] = &device_param->d_rules_c;
15423 device_param->kernel_params_amp[3] = &device_param->d_combs_c;
15424 device_param->kernel_params_amp[4] = &device_param->d_bfs_c;
15425 device_param->kernel_params_amp[5] = &device_param->kernel_params_amp_buf32[5];
15426 device_param->kernel_params_amp[6] = &device_param->kernel_params_amp_buf32[6];
15427
15428 device_param->kernel_params_tm[0] = &device_param->d_bfs_c;
15429 device_param->kernel_params_tm[1] = &device_param->d_tm_c;
15430
15431 device_param->kernel_params_memset_buf32[1] = 0; // value
15432 device_param->kernel_params_memset_buf32[2] = 0; // gid_max
15433
15434 device_param->kernel_params_memset[0] = NULL;
15435 device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1];
15436 device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2];
15437
15438 /**
15439 * kernel name
15440 */
15441
15442 size_t kernel_wgs_tmp;
15443
15444 char kernel_name[64] = { 0 };
15445
15446 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15447 {
15448 if (opti_type & OPTI_TYPE_SINGLE_HASH)
15449 {
15450 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 4);
15451
15452 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15453
15454 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 8);
15455
15456 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15457
15458 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_s%02d", kern_type, 16);
15459
15460 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15461 }
15462 else
15463 {
15464 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 4);
15465
15466 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15467
15468 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 8);
15469
15470 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15471
15472 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_m%02d", kern_type, 16);
15473
15474 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15475 }
15476
15477 if (data.attack_mode == ATTACK_MODE_BF)
15478 {
15479 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15480 {
15481 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_tm", kern_type);
15482
15483 device_param->kernel_tm = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15484
15485 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);
15486 }
15487 }
15488 }
15489 else
15490 {
15491 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_init", kern_type);
15492
15493 device_param->kernel1 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15494
15495 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_loop", kern_type);
15496
15497 device_param->kernel2 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15498
15499 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_comp", kern_type);
15500
15501 device_param->kernel3 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15502
15503 if (opts_type & OPTS_TYPE_HOOK12)
15504 {
15505 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook12", kern_type);
15506
15507 device_param->kernel12 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15508
15509 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);
15510 }
15511
15512 if (opts_type & OPTS_TYPE_HOOK23)
15513 {
15514 snprintf (kernel_name, sizeof (kernel_name) - 1, "m%05d_hook23", kern_type);
15515
15516 device_param->kernel23 = hc_clCreateKernel (data.ocl, device_param->program, kernel_name);
15517
15518 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);
15519 }
15520 }
15521
15522 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);
15523 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);
15524 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);
15525
15526 for (uint i = 0; i <= 20; i++)
15527 {
15528 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]);
15529 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]);
15530 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_mem), device_param->kernel_params[i]);
15531
15532 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_mem), device_param->kernel_params[i]);
15533 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]);
15534 }
15535
15536 for (uint i = 21; i <= 31; i++)
15537 {
15538 hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]);
15539 hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]);
15540 hc_clSetKernelArg (data.ocl, device_param->kernel3, i, sizeof (cl_uint), device_param->kernel_params[i]);
15541
15542 if (opts_type & OPTS_TYPE_HOOK12) hc_clSetKernelArg (data.ocl, device_param->kernel12, i, sizeof (cl_uint), device_param->kernel_params[i]);
15543 if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]);
15544 }
15545
15546 // GPU memset
15547
15548 device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset");
15549
15550 hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp);
15551
15552 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]);
15553 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]);
15554 hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]);
15555
15556 // MP start
15557
15558 if (attack_mode == ATTACK_MODE_BF)
15559 {
15560 device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov");
15561 device_param->kernel_mp_r = hc_clCreateKernel (data.ocl, device_param->program_mp, "r_markov");
15562
15563 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);
15564 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);
15565
15566 if (opts_type & OPTS_TYPE_PT_BITSLICE)
15567 {
15568 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 0, sizeof (cl_mem), device_param->kernel_params_tm[0]);
15569 hc_clSetKernelArg (data.ocl, device_param->kernel_tm, 1, sizeof (cl_mem), device_param->kernel_params_tm[1]);
15570 }
15571 }
15572 else if (attack_mode == ATTACK_MODE_HYBRID1)
15573 {
15574 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15575
15576 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);
15577 }
15578 else if (attack_mode == ATTACK_MODE_HYBRID2)
15579 {
15580 device_param->kernel_mp = hc_clCreateKernel (data.ocl, device_param->program_mp, "C_markov");
15581
15582 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);
15583 }
15584
15585 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15586 {
15587 // nothing to do
15588 }
15589 else
15590 {
15591 device_param->kernel_amp = hc_clCreateKernel (data.ocl, device_param->program_amp, "amp");
15592
15593 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);
15594 }
15595
15596 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
15597 {
15598 // nothing to do
15599 }
15600 else
15601 {
15602 for (uint i = 0; i < 5; i++)
15603 {
15604 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_mem), device_param->kernel_params_amp[i]);
15605 }
15606
15607 for (uint i = 5; i < 7; i++)
15608 {
15609 hc_clSetKernelArg (data.ocl, device_param->kernel_amp, i, sizeof (cl_uint), device_param->kernel_params_amp[i]);
15610 }
15611 }
15612
15613 // maybe this has been updated by clGetKernelWorkGroupInfo()
15614 // value can only be decreased, so we don't need to reallocate buffers
15615
15616 device_param->kernel_threads = kernel_threads;
15617
15618 // zero some data buffers
15619
15620 run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws);
15621 run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws);
15622 run_kernel_bzero (device_param, device_param->d_tmps, size_tmps);
15623 run_kernel_bzero (device_param, device_param->d_hooks, size_hooks);
15624 run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains);
15625 run_kernel_bzero (device_param, device_param->d_result, size_results);
15626
15627 /**
15628 * special buffers
15629 */
15630
15631 if (attack_kern == ATTACK_KERN_STRAIGHT)
15632 {
15633 run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c);
15634 }
15635 else if (attack_kern == ATTACK_KERN_COMBI)
15636 {
15637 run_kernel_bzero (device_param, device_param->d_combs, size_combs);
15638 run_kernel_bzero (device_param, device_param->d_combs_c, size_combs);
15639 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15640 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15641 }
15642 else if (attack_kern == ATTACK_KERN_BF)
15643 {
15644 run_kernel_bzero (device_param, device_param->d_bfs, size_bfs);
15645 run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs);
15646 run_kernel_bzero (device_param, device_param->d_tm_c, size_tm);
15647 run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css);
15648 run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css);
15649 }
15650
15651 /**
15652 * Store thermal target temperature so we can send a notice to user
15653 */
15654
15655 #if defined(HAVE_HWMON)
15656 if (gpu_temp_disable == 0)
15657 {
15658 const int gpu_temp_threshold_slowdown = hm_get_threshold_slowdown_with_device_id (device_id);
15659
15660 data.hm_device[device_id].gpu_temp_threshold_slowdown = (gpu_temp_threshold_slowdown == -1) ? 100000 : gpu_temp_threshold_slowdown;
15661 }
15662 #endif
15663
15664 /**
15665 * Store initial fanspeed if gpu_temp_retain is enabled
15666 */
15667
15668 #if defined(HAVE_HWMON) && defined(HAVE_ADL)
15669 int gpu_temp_retain_set = 0;
15670
15671 if (gpu_temp_disable == 0)
15672 {
15673 if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied
15674 {
15675 hc_thread_mutex_lock (mux_adl);
15676
15677 if (data.hm_device[device_id].fan_supported == 1)
15678 {
15679 if (gpu_temp_retain_chgd == 0)
15680 {
15681 uint cur_temp = 0;
15682 uint default_temp = 0;
15683
15684 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);
15685
15686 if (ADL_rc == ADL_OK)
15687 {
15688 #define GPU_TEMP_RETAIN_ABORT_DIFF 15
15689
15690 const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF;
15691
15692 // special case with multi gpu setups: always use minimum retain
15693
15694 if (gpu_temp_retain_set == 0)
15695 {
15696 gpu_temp_retain = gpu_temp_retain_target;
15697 gpu_temp_retain_set = 1;
15698 }
15699 else
15700 {
15701 gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target);
15702 }
15703
15704 if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF;
15705 }
15706 }
15707
15708 const int fan_speed = hm_get_fanspeed_with_device_id (device_id);
15709
15710 temp_retain_fanspeed_value[device_id] = fan_speed;
15711
15712 if (fan_speed == -1)
15713 {
15714 log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1);
15715
15716 temp_retain_fanspeed_value[device_id] = 0;
15717 }
15718 }
15719
15720 hc_thread_mutex_unlock (mux_adl);
15721 }
15722 }
15723
15724 /**
15725 * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings
15726 */
15727
15728 if (powertune_enable == 1) // VENDOR_ID_AMD implied
15729 {
15730 hc_thread_mutex_lock (mux_adl);
15731
15732 if (data.hm_device[device_id].od_version == 6)
15733 {
15734 int ADL_rc;
15735
15736 // check powertune capabilities first, if not available then skip device
15737
15738 int powertune_supported = 0;
15739
15740 if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
15741 {
15742 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
15743
15744 return (-1);
15745 }
15746
15747 if (powertune_supported != 0)
15748 {
15749 // powercontrol settings
15750
15751 ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0};
15752
15753 if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK)
15754 {
15755 ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]);
15756 }
15757
15758 if (ADL_rc != ADL_OK)
15759 {
15760 log_error ("ERROR: Failed to get current ADL PowerControl settings");
15761
15762 return (-1);
15763 }
15764
15765 if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK)
15766 {
15767 log_error ("ERROR: Failed to set new ADL PowerControl values");
15768
15769 return (-1);
15770 }
15771
15772 // clocks
15773
15774 memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState));
15775
15776 od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2;
15777
15778 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)
15779 {
15780 log_error ("ERROR: Failed to get ADL memory and engine clock frequency");
15781
15782 return (-1);
15783 }
15784
15785 // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings
15786
15787 ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0};
15788
15789 if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK)
15790 {
15791 log_error ("ERROR: Failed to get ADL device capabilities");
15792
15793 return (-1);
15794 }
15795
15796 int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666;
15797 int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250;
15798
15799 int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max);
15800 int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max);
15801
15802 int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
15803 int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
15804
15805 // warning if profile has too low max values
15806
15807 if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
15808 {
15809 log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
15810 }
15811
15812 if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
15813 {
15814 log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
15815 }
15816
15817 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
15818
15819 performance_state->iNumberOfPerformanceLevels = 2;
15820
15821 performance_state->aLevels[0].iEngineClock = engine_clock_profile_max;
15822 performance_state->aLevels[1].iEngineClock = engine_clock_profile_max;
15823 performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max;
15824 performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max;
15825
15826 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)
15827 {
15828 log_info ("ERROR: Failed to set ADL performance state");
15829
15830 return (-1);
15831 }
15832
15833 local_free (performance_state);
15834 }
15835 }
15836
15837 hc_thread_mutex_unlock (mux_adl);
15838 }
15839 #endif // HAVE_HWMON && HAVE_ADL
15840 }
15841
15842 data.kernel_power_all = kernel_power_all;
15843
15844 if (data.quiet == 0) log_info_nn ("");
15845
15846 /**
15847 * In benchmark-mode, inform user which algorithm is checked
15848 */
15849
15850 if (benchmark == 1)
15851 {
15852 if (machine_readable == 0)
15853 {
15854 quiet = 0;
15855
15856 data.quiet = quiet;
15857
15858 char *hash_type = strhashtype (data.hash_mode); // not a bug
15859
15860 log_info ("Hashtype: %s", hash_type);
15861 log_info ("");
15862 }
15863 }
15864
15865 /**
15866 * keep track of the progress
15867 */
15868
15869 data.words_progress_done = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15870 data.words_progress_rejected = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15871 data.words_progress_restored = (u64 *) mycalloc (data.salts_cnt, sizeof (u64));
15872
15873 /**
15874 * open filehandles
15875 */
15876
15877 #if _WIN
15878 if (_setmode (_fileno (stdin), _O_BINARY) == -1)
15879 {
15880 log_error ("ERROR: %s: %s", "stdin", strerror (errno));
15881
15882 return (-1);
15883 }
15884
15885 if (_setmode (_fileno (stdout), _O_BINARY) == -1)
15886 {
15887 log_error ("ERROR: %s: %s", "stdout", strerror (errno));
15888
15889 return (-1);
15890 }
15891
15892 if (_setmode (_fileno (stderr), _O_BINARY) == -1)
15893 {
15894 log_error ("ERROR: %s: %s", "stderr", strerror (errno));
15895
15896 return (-1);
15897 }
15898 #endif
15899
15900 /**
15901 * dictionary pad
15902 */
15903
15904 segment_size *= (1024 * 1024);
15905
15906 data.segment_size = segment_size;
15907
15908 wl_data_t *wl_data = (wl_data_t *) mymalloc (sizeof (wl_data_t));
15909
15910 wl_data->buf = (char *) mymalloc (segment_size);
15911 wl_data->avail = segment_size;
15912 wl_data->incr = segment_size;
15913 wl_data->cnt = 0;
15914 wl_data->pos = 0;
15915
15916 uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN;
15917
15918 data.wordlist_mode = wordlist_mode;
15919
15920 cs_t *css_buf = NULL;
15921 uint css_cnt = 0;
15922 uint dictcnt = 0;
15923 uint maskcnt = 1;
15924 char **masks = NULL;
15925 char **dictfiles = NULL;
15926
15927 uint mask_from_file = 0;
15928
15929 if (attack_mode == ATTACK_MODE_STRAIGHT)
15930 {
15931 if (wordlist_mode == WL_MODE_FILE)
15932 {
15933 int wls_left = myargc - (optind + 1);
15934
15935 for (int i = 0; i < wls_left; i++)
15936 {
15937 char *l0_filename = myargv[optind + 1 + i];
15938
15939 struct stat l0_stat;
15940
15941 if (stat (l0_filename, &l0_stat) == -1)
15942 {
15943 log_error ("ERROR: %s: %s", l0_filename, strerror (errno));
15944
15945 return (-1);
15946 }
15947
15948 uint is_dir = S_ISDIR (l0_stat.st_mode);
15949
15950 if (is_dir == 0)
15951 {
15952 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15953
15954 dictcnt++;
15955
15956 dictfiles[dictcnt - 1] = l0_filename;
15957 }
15958 else
15959 {
15960 // do not allow --keyspace w/ a directory
15961
15962 if (keyspace == 1)
15963 {
15964 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
15965
15966 return (-1);
15967 }
15968
15969 char **dictionary_files = NULL;
15970
15971 dictionary_files = scan_directory (l0_filename);
15972
15973 if (dictionary_files != NULL)
15974 {
15975 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
15976
15977 for (int d = 0; dictionary_files[d] != NULL; d++)
15978 {
15979 char *l1_filename = dictionary_files[d];
15980
15981 struct stat l1_stat;
15982
15983 if (stat (l1_filename, &l1_stat) == -1)
15984 {
15985 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
15986
15987 return (-1);
15988 }
15989
15990 if (S_ISREG (l1_stat.st_mode))
15991 {
15992 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
15993
15994 dictcnt++;
15995
15996 dictfiles[dictcnt - 1] = strdup (l1_filename);
15997 }
15998 }
15999 }
16000
16001 local_free (dictionary_files);
16002 }
16003 }
16004
16005 if (dictcnt < 1)
16006 {
16007 log_error ("ERROR: No usable dictionary file found.");
16008
16009 return (-1);
16010 }
16011 }
16012 else if (wordlist_mode == WL_MODE_STDIN)
16013 {
16014 dictcnt = 1;
16015 }
16016 }
16017 else if (attack_mode == ATTACK_MODE_COMBI)
16018 {
16019 // display
16020
16021 char *dictfile1 = myargv[optind + 1 + 0];
16022 char *dictfile2 = myargv[optind + 1 + 1];
16023
16024 // find the bigger dictionary and use as base
16025
16026 FILE *fp1 = NULL;
16027 FILE *fp2 = NULL;
16028
16029 struct stat tmp_stat;
16030
16031 if ((fp1 = fopen (dictfile1, "rb")) == NULL)
16032 {
16033 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16034
16035 return (-1);
16036 }
16037
16038 if (stat (dictfile1, &tmp_stat) == -1)
16039 {
16040 log_error ("ERROR: %s: %s", dictfile1, strerror (errno));
16041
16042 fclose (fp1);
16043
16044 return (-1);
16045 }
16046
16047 if (S_ISDIR (tmp_stat.st_mode))
16048 {
16049 log_error ("ERROR: %s must be a regular file", dictfile1, strerror (errno));
16050
16051 fclose (fp1);
16052
16053 return (-1);
16054 }
16055
16056 if ((fp2 = fopen (dictfile2, "rb")) == NULL)
16057 {
16058 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16059
16060 fclose (fp1);
16061
16062 return (-1);
16063 }
16064
16065 if (stat (dictfile2, &tmp_stat) == -1)
16066 {
16067 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
16068
16069 fclose (fp1);
16070 fclose (fp2);
16071
16072 return (-1);
16073 }
16074
16075 if (S_ISDIR (tmp_stat.st_mode))
16076 {
16077 log_error ("ERROR: %s must be a regular file", dictfile2, strerror (errno));
16078
16079 fclose (fp1);
16080 fclose (fp2);
16081
16082 return (-1);
16083 }
16084
16085 data.combs_cnt = 1;
16086
16087 data.quiet = 1;
16088
16089 const u64 words1_cnt = count_words (wl_data, fp1, dictfile1, dictstat_base, &dictstat_nmemb);
16090
16091 data.quiet = quiet;
16092
16093 if (words1_cnt == 0)
16094 {
16095 log_error ("ERROR: %s: empty file", dictfile1);
16096
16097 fclose (fp1);
16098 fclose (fp2);
16099
16100 return (-1);
16101 }
16102
16103 data.combs_cnt = 1;
16104
16105 data.quiet = 1;
16106
16107 const u64 words2_cnt = count_words (wl_data, fp2, dictfile2, dictstat_base, &dictstat_nmemb);
16108
16109 data.quiet = quiet;
16110
16111 if (words2_cnt == 0)
16112 {
16113 log_error ("ERROR: %s: empty file", dictfile2);
16114
16115 fclose (fp1);
16116 fclose (fp2);
16117
16118 return (-1);
16119 }
16120
16121 fclose (fp1);
16122 fclose (fp2);
16123
16124 data.dictfile = dictfile1;
16125 data.dictfile2 = dictfile2;
16126
16127 if (words1_cnt >= words2_cnt)
16128 {
16129 data.combs_cnt = words2_cnt;
16130 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16131
16132 dictfiles = &data.dictfile;
16133
16134 dictcnt = 1;
16135 }
16136 else
16137 {
16138 data.combs_cnt = words1_cnt;
16139 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16140
16141 dictfiles = &data.dictfile2;
16142
16143 dictcnt = 1;
16144
16145 // we also have to switch wordlist related rules!
16146
16147 char *tmpc = data.rule_buf_l;
16148
16149 data.rule_buf_l = data.rule_buf_r;
16150 data.rule_buf_r = tmpc;
16151
16152 int tmpi = data.rule_len_l;
16153
16154 data.rule_len_l = data.rule_len_r;
16155 data.rule_len_r = tmpi;
16156 }
16157 }
16158 else if (attack_mode == ATTACK_MODE_BF)
16159 {
16160 char *mask = NULL;
16161
16162 maskcnt = 0;
16163
16164 if (benchmark == 0)
16165 {
16166 mask = myargv[optind + 1];
16167
16168 masks = (char **) mymalloc (INCR_MASKS * sizeof (char *));
16169
16170 if ((optind + 2) <= myargc)
16171 {
16172 struct stat file_stat;
16173
16174 if (stat (mask, &file_stat) == -1)
16175 {
16176 maskcnt = 1;
16177
16178 masks[maskcnt - 1] = mystrdup (mask);
16179 }
16180 else
16181 {
16182 int wls_left = myargc - (optind + 1);
16183
16184 uint masks_avail = INCR_MASKS;
16185
16186 for (int i = 0; i < wls_left; i++)
16187 {
16188 if (i != 0)
16189 {
16190 mask = myargv[optind + 1 + i];
16191
16192 if (stat (mask, &file_stat) == -1)
16193 {
16194 log_error ("ERROR: %s: %s", mask, strerror (errno));
16195
16196 return (-1);
16197 }
16198 }
16199
16200 uint is_file = S_ISREG (file_stat.st_mode);
16201
16202 if (is_file == 1)
16203 {
16204 FILE *mask_fp;
16205
16206 if ((mask_fp = fopen (mask, "r")) == NULL)
16207 {
16208 log_error ("ERROR: %s: %s", mask, strerror (errno));
16209
16210 return (-1);
16211 }
16212
16213 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16214
16215 while (!feof (mask_fp))
16216 {
16217 memset (line_buf, 0, HCBUFSIZ);
16218
16219 int line_len = fgetl (mask_fp, line_buf);
16220
16221 if (line_len == 0) continue;
16222
16223 if (line_buf[0] == '#') continue;
16224
16225 if (masks_avail == maskcnt)
16226 {
16227 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16228
16229 masks_avail += INCR_MASKS;
16230 }
16231
16232 masks[maskcnt] = mystrdup (line_buf);
16233
16234 maskcnt++;
16235 }
16236
16237 myfree (line_buf);
16238
16239 fclose (mask_fp);
16240 }
16241 else
16242 {
16243 log_error ("ERROR: %s: unsupported file-type", mask);
16244
16245 return (-1);
16246 }
16247 }
16248
16249 mask_from_file = 1;
16250 }
16251 }
16252 else
16253 {
16254 custom_charset_1 = (char *) "?l?d?u";
16255 custom_charset_2 = (char *) "?l?d";
16256 custom_charset_3 = (char *) "?l?d*!$@_";
16257
16258 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16259 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16260 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16261
16262 masks[maskcnt] = mystrdup ("?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d");
16263
16264 wordlist_mode = WL_MODE_MASK;
16265
16266 data.wordlist_mode = wordlist_mode;
16267
16268 increment = 1;
16269
16270 maskcnt = 1;
16271 }
16272 }
16273 else
16274 {
16275 /**
16276 * generate full masks and charsets
16277 */
16278
16279 masks = (char **) mymalloc (sizeof (char *));
16280
16281 switch (hash_mode)
16282 {
16283 case 1731: pw_min = 5;
16284 pw_max = 5;
16285 mask = mystrdup ("?b?b?b?b?b");
16286 break;
16287 case 12500: pw_min = 5;
16288 pw_max = 5;
16289 mask = mystrdup ("?b?b?b?b?b");
16290 break;
16291 default: pw_min = 7;
16292 pw_max = 7;
16293 mask = mystrdup ("?b?b?b?b?b?b?b");
16294 break;
16295 }
16296
16297 maskcnt = 1;
16298
16299 masks[maskcnt - 1] = mystrdup (mask);
16300
16301 wordlist_mode = WL_MODE_MASK;
16302
16303 data.wordlist_mode = wordlist_mode;
16304
16305 increment = 1;
16306 }
16307
16308 dictfiles = (char **) mycalloc (pw_max, sizeof (char *));
16309
16310 if (increment)
16311 {
16312 if (increment_min > pw_min) pw_min = increment_min;
16313
16314 if (increment_max < pw_max) pw_max = increment_max;
16315 }
16316 }
16317 else if (attack_mode == ATTACK_MODE_HYBRID1)
16318 {
16319 data.combs_mode = COMBINATOR_MODE_BASE_LEFT;
16320
16321 // display
16322
16323 char *mask = myargv[myargc - 1];
16324
16325 maskcnt = 0;
16326
16327 masks = (char **) mymalloc (1 * sizeof (char *));
16328
16329 // mod
16330
16331 struct stat file_stat;
16332
16333 if (stat (mask, &file_stat) == -1)
16334 {
16335 maskcnt = 1;
16336
16337 masks[maskcnt - 1] = mystrdup (mask);
16338 }
16339 else
16340 {
16341 uint is_file = S_ISREG (file_stat.st_mode);
16342
16343 if (is_file == 1)
16344 {
16345 FILE *mask_fp;
16346
16347 if ((mask_fp = fopen (mask, "r")) == NULL)
16348 {
16349 log_error ("ERROR: %s: %s", mask, strerror (errno));
16350
16351 return (-1);
16352 }
16353
16354 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16355
16356 uint masks_avail = 1;
16357
16358 while (!feof (mask_fp))
16359 {
16360 memset (line_buf, 0, HCBUFSIZ);
16361
16362 int line_len = fgetl (mask_fp, line_buf);
16363
16364 if (line_len == 0) continue;
16365
16366 if (line_buf[0] == '#') continue;
16367
16368 if (masks_avail == maskcnt)
16369 {
16370 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16371
16372 masks_avail += INCR_MASKS;
16373 }
16374
16375 masks[maskcnt] = mystrdup (line_buf);
16376
16377 maskcnt++;
16378 }
16379
16380 myfree (line_buf);
16381
16382 fclose (mask_fp);
16383
16384 mask_from_file = 1;
16385 }
16386 else
16387 {
16388 maskcnt = 1;
16389
16390 masks[maskcnt - 1] = mystrdup (mask);
16391 }
16392 }
16393
16394 // base
16395
16396 int wls_left = myargc - (optind + 2);
16397
16398 for (int i = 0; i < wls_left; i++)
16399 {
16400 char *filename = myargv[optind + 1 + i];
16401
16402 struct stat file_stat;
16403
16404 if (stat (filename, &file_stat) == -1)
16405 {
16406 log_error ("ERROR: %s: %s", filename, strerror (errno));
16407
16408 return (-1);
16409 }
16410
16411 uint is_dir = S_ISDIR (file_stat.st_mode);
16412
16413 if (is_dir == 0)
16414 {
16415 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16416
16417 dictcnt++;
16418
16419 dictfiles[dictcnt - 1] = filename;
16420 }
16421 else
16422 {
16423 // do not allow --keyspace w/ a directory
16424
16425 if (keyspace == 1)
16426 {
16427 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16428
16429 return (-1);
16430 }
16431
16432 char **dictionary_files = NULL;
16433
16434 dictionary_files = scan_directory (filename);
16435
16436 if (dictionary_files != NULL)
16437 {
16438 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16439
16440 for (int d = 0; dictionary_files[d] != NULL; d++)
16441 {
16442 char *l1_filename = dictionary_files[d];
16443
16444 struct stat l1_stat;
16445
16446 if (stat (l1_filename, &l1_stat) == -1)
16447 {
16448 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16449
16450 return (-1);
16451 }
16452
16453 if (S_ISREG (l1_stat.st_mode))
16454 {
16455 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16456
16457 dictcnt++;
16458
16459 dictfiles[dictcnt - 1] = strdup (l1_filename);
16460 }
16461 }
16462 }
16463
16464 local_free (dictionary_files);
16465 }
16466 }
16467
16468 if (dictcnt < 1)
16469 {
16470 log_error ("ERROR: No usable dictionary file found.");
16471
16472 return (-1);
16473 }
16474
16475 if (increment)
16476 {
16477 maskcnt = 0;
16478
16479 uint mask_min = increment_min; // we can't reject smaller masks here
16480 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16481
16482 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16483 {
16484 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16485
16486 if (cur_mask == NULL) break;
16487
16488 masks[maskcnt] = cur_mask;
16489
16490 maskcnt++;
16491
16492 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16493 }
16494 }
16495 }
16496 else if (attack_mode == ATTACK_MODE_HYBRID2)
16497 {
16498 data.combs_mode = COMBINATOR_MODE_BASE_RIGHT;
16499
16500 // display
16501
16502 char *mask = myargv[optind + 1 + 0];
16503
16504 maskcnt = 0;
16505
16506 masks = (char **) mymalloc (1 * sizeof (char *));
16507
16508 // mod
16509
16510 struct stat file_stat;
16511
16512 if (stat (mask, &file_stat) == -1)
16513 {
16514 maskcnt = 1;
16515
16516 masks[maskcnt - 1] = mystrdup (mask);
16517 }
16518 else
16519 {
16520 uint is_file = S_ISREG (file_stat.st_mode);
16521
16522 if (is_file == 1)
16523 {
16524 FILE *mask_fp;
16525
16526 if ((mask_fp = fopen (mask, "r")) == NULL)
16527 {
16528 log_error ("ERROR: %s: %s", mask, strerror (errno));
16529
16530 return (-1);
16531 }
16532
16533 char *line_buf = (char *) mymalloc (HCBUFSIZ);
16534
16535 uint masks_avail = 1;
16536
16537 while (!feof (mask_fp))
16538 {
16539 memset (line_buf, 0, HCBUFSIZ);
16540
16541 int line_len = fgetl (mask_fp, line_buf);
16542
16543 if (line_len == 0) continue;
16544
16545 if (line_buf[0] == '#') continue;
16546
16547 if (masks_avail == maskcnt)
16548 {
16549 masks = (char **) myrealloc (masks, masks_avail * sizeof (char *), INCR_MASKS * sizeof (char *));
16550
16551 masks_avail += INCR_MASKS;
16552 }
16553
16554 masks[maskcnt] = mystrdup (line_buf);
16555
16556 maskcnt++;
16557 }
16558
16559 myfree (line_buf);
16560
16561 fclose (mask_fp);
16562
16563 mask_from_file = 1;
16564 }
16565 else
16566 {
16567 maskcnt = 1;
16568
16569 masks[maskcnt - 1] = mystrdup (mask);
16570 }
16571 }
16572
16573 // base
16574
16575 int wls_left = myargc - (optind + 2);
16576
16577 for (int i = 0; i < wls_left; i++)
16578 {
16579 char *filename = myargv[optind + 2 + i];
16580
16581 struct stat file_stat;
16582
16583 if (stat (filename, &file_stat) == -1)
16584 {
16585 log_error ("ERROR: %s: %s", filename, strerror (errno));
16586
16587 return (-1);
16588 }
16589
16590 uint is_dir = S_ISDIR (file_stat.st_mode);
16591
16592 if (is_dir == 0)
16593 {
16594 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16595
16596 dictcnt++;
16597
16598 dictfiles[dictcnt - 1] = filename;
16599 }
16600 else
16601 {
16602 // do not allow --keyspace w/ a directory
16603
16604 if (keyspace == 1)
16605 {
16606 log_error ("ERROR: keyspace parameter is not allowed together with a directory");
16607
16608 return (-1);
16609 }
16610
16611 char **dictionary_files = NULL;
16612
16613 dictionary_files = scan_directory (filename);
16614
16615 if (dictionary_files != NULL)
16616 {
16617 qsort (dictionary_files, count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr);
16618
16619 for (int d = 0; dictionary_files[d] != NULL; d++)
16620 {
16621 char *l1_filename = dictionary_files[d];
16622
16623 struct stat l1_stat;
16624
16625 if (stat (l1_filename, &l1_stat) == -1)
16626 {
16627 log_error ("ERROR: %s: %s", l1_filename, strerror (errno));
16628
16629 return (-1);
16630 }
16631
16632 if (S_ISREG (l1_stat.st_mode))
16633 {
16634 dictfiles = (char **) myrealloc (dictfiles, dictcnt * sizeof (char *), sizeof (char *));
16635
16636 dictcnt++;
16637
16638 dictfiles[dictcnt - 1] = strdup (l1_filename);
16639 }
16640 }
16641 }
16642
16643 local_free (dictionary_files);
16644 }
16645 }
16646
16647 if (dictcnt < 1)
16648 {
16649 log_error ("ERROR: No usable dictionary file found.");
16650
16651 return (-1);
16652 }
16653
16654 if (increment)
16655 {
16656 maskcnt = 0;
16657
16658 uint mask_min = increment_min; // we can't reject smaller masks here
16659 uint mask_max = (increment_max < pw_max) ? increment_max : pw_max;
16660
16661 for (uint mask_cur = mask_min; mask_cur <= mask_max; mask_cur++)
16662 {
16663 char *cur_mask = mp_get_truncated_mask (mask, strlen (mask), mask_cur);
16664
16665 if (cur_mask == NULL) break;
16666
16667 masks[maskcnt] = cur_mask;
16668
16669 maskcnt++;
16670
16671 masks = (char **) myrealloc (masks, maskcnt * sizeof (char *), sizeof (char *));
16672 }
16673 }
16674 }
16675
16676 data.pw_min = pw_min;
16677 data.pw_max = pw_max;
16678
16679 /**
16680 * weak hash check
16681 */
16682
16683 if (weak_hash_threshold >= salts_cnt)
16684 {
16685 hc_device_param_t *device_param = NULL;
16686
16687 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16688 {
16689 device_param = &data.devices_param[device_id];
16690
16691 if (device_param->skipped) continue;
16692
16693 break;
16694 }
16695
16696 if (data.quiet == 0) log_info_nn ("Checking for weak hashes...");
16697
16698 for (uint salt_pos = 0; salt_pos < salts_cnt; salt_pos++)
16699 {
16700 weak_hash_check (device_param, salt_pos);
16701 }
16702
16703 // Display hack, guarantee that there is at least one \r before real start
16704
16705 //if (data.quiet == 0) log_info ("");
16706 }
16707
16708 /**
16709 * status and monitor threads
16710 */
16711
16712 if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING;
16713
16714 hc_thread_t i_thread = 0;
16715
16716 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
16717 {
16718 hc_thread_create (i_thread, thread_keypress, &benchmark);
16719 }
16720
16721 if (wordlist_mode == WL_MODE_STDIN) data.status = 1;
16722
16723 uint ni_threads_cnt = 0;
16724
16725 hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t));
16726
16727 hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL);
16728
16729 ni_threads_cnt++;
16730
16731 /**
16732 * Outfile remove
16733 */
16734
16735 if (keyspace == 0)
16736 {
16737 if (outfile_check_timer != 0)
16738 {
16739 if (data.outfile_check_directory != NULL)
16740 {
16741 if ((hash_mode != 5200) &&
16742 !((hash_mode >= 6200) && (hash_mode <= 6299)) &&
16743 !((hash_mode >= 13700) && (hash_mode <= 13799)) &&
16744 (hash_mode != 9000))
16745 {
16746 hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL);
16747
16748 ni_threads_cnt++;
16749 }
16750 else
16751 {
16752 outfile_check_timer = 0;
16753 }
16754 }
16755 else
16756 {
16757 outfile_check_timer = 0;
16758 }
16759 }
16760 }
16761
16762 /**
16763 * Inform the user if we got some hashes remove because of the pot file remove feature
16764 */
16765
16766 if (data.quiet == 0)
16767 {
16768 if (potfile_remove_cracks > 0)
16769 {
16770 if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
16771 else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
16772 }
16773 }
16774
16775 data.outfile_check_timer = outfile_check_timer;
16776
16777 /**
16778 * main loop
16779 */
16780
16781 char **induction_dictionaries = NULL;
16782
16783 int induction_dictionaries_cnt = 0;
16784
16785 hcstat_table_t *root_table_buf = NULL;
16786 hcstat_table_t *markov_table_buf = NULL;
16787
16788 uint initial_restore_done = 0;
16789
16790 data.maskcnt = maskcnt;
16791
16792 for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++)
16793 {
16794 if (data.devices_status == STATUS_CRACKED) break;
16795
16796 data.devices_status = STATUS_INIT;
16797
16798 if (maskpos > rd->maskpos)
16799 {
16800 rd->dictpos = 0;
16801 }
16802
16803 rd->maskpos = maskpos;
16804 data.maskpos = maskpos;
16805
16806 if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2 || attack_mode == ATTACK_MODE_BF)
16807 {
16808 char *mask = masks[maskpos];
16809
16810 if (mask_from_file == 1)
16811 {
16812 if (mask[0] == '\\' && mask[1] == '#') mask++; // escaped comment sign (sharp) "\#"
16813
16814 char *str_ptr;
16815 uint str_pos;
16816
16817 uint mask_offset = 0;
16818
16819 uint separator_cnt;
16820
16821 for (separator_cnt = 0; separator_cnt < 4; separator_cnt++)
16822 {
16823 str_ptr = strstr (mask + mask_offset, ",");
16824
16825 if (str_ptr == NULL) break;
16826
16827 str_pos = str_ptr - mask;
16828
16829 // escaped separator, i.e. "\,"
16830
16831 if (str_pos > 0)
16832 {
16833 if (mask[str_pos - 1] == '\\')
16834 {
16835 separator_cnt --;
16836
16837 mask_offset = str_pos + 1;
16838
16839 continue;
16840 }
16841 }
16842
16843 // reset the offset
16844
16845 mask_offset = 0;
16846
16847 mask[str_pos] = '\0';
16848
16849 switch (separator_cnt)
16850 {
16851 case 0:
16852 mp_reset_usr (mp_usr, 0);
16853
16854 custom_charset_1 = mask;
16855 mp_setup_usr (mp_sys, mp_usr, custom_charset_1, 0);
16856 break;
16857
16858 case 1:
16859 mp_reset_usr (mp_usr, 1);
16860
16861 custom_charset_2 = mask;
16862 mp_setup_usr (mp_sys, mp_usr, custom_charset_2, 1);
16863 break;
16864
16865 case 2:
16866 mp_reset_usr (mp_usr, 2);
16867
16868 custom_charset_3 = mask;
16869 mp_setup_usr (mp_sys, mp_usr, custom_charset_3, 2);
16870 break;
16871
16872 case 3:
16873 mp_reset_usr (mp_usr, 3);
16874
16875 custom_charset_4 = mask;
16876 mp_setup_usr (mp_sys, mp_usr, custom_charset_4, 3);
16877 break;
16878 }
16879
16880 mask = mask + str_pos + 1;
16881 }
16882 }
16883
16884 if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
16885 {
16886 if (maskpos > 0)
16887 {
16888 local_free (css_buf);
16889 local_free (data.root_css_buf);
16890 local_free (data.markov_css_buf);
16891
16892 local_free (masks[maskpos - 1]);
16893 }
16894
16895 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
16896
16897 data.mask = mask;
16898 data.css_cnt = css_cnt;
16899 data.css_buf = css_buf;
16900
16901 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
16902
16903 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
16904
16905 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
16906 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
16907
16908 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
16909
16910 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
16911
16912 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
16913 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
16914
16915 data.root_css_buf = root_css_buf;
16916 data.markov_css_buf = markov_css_buf;
16917
16918 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
16919
16920 data.combs_cnt = sp_get_sum (0, css_cnt, root_css_buf);
16921
16922 local_free (root_table_buf);
16923 local_free (markov_table_buf);
16924
16925 // args
16926
16927 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
16928 {
16929 hc_device_param_t *device_param = &data.devices_param[device_id];
16930
16931 if (device_param->skipped) continue;
16932
16933 device_param->kernel_params_mp[0] = &device_param->d_combs;
16934 device_param->kernel_params_mp[1] = &device_param->d_root_css_buf;
16935 device_param->kernel_params_mp[2] = &device_param->d_markov_css_buf;
16936
16937 device_param->kernel_params_mp_buf64[3] = 0;
16938 device_param->kernel_params_mp_buf32[4] = css_cnt;
16939 device_param->kernel_params_mp_buf32[5] = 0;
16940 device_param->kernel_params_mp_buf32[6] = 0;
16941 device_param->kernel_params_mp_buf32[7] = 0;
16942
16943 if (attack_mode == ATTACK_MODE_HYBRID1)
16944 {
16945 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_buf32[5] = full01;
16946 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_buf32[5] = full80;
16947 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_buf32[6] = 1;
16948 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_buf32[7] = 1;
16949 }
16950 else if (attack_mode == ATTACK_MODE_HYBRID2)
16951 {
16952 device_param->kernel_params_mp_buf32[5] = 0;
16953 device_param->kernel_params_mp_buf32[6] = 0;
16954 device_param->kernel_params_mp_buf32[7] = 0;
16955 }
16956
16957 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]);
16958 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]);
16959 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]);
16960
16961 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);
16962 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);
16963 }
16964 }
16965 else if (attack_mode == ATTACK_MODE_BF)
16966 {
16967 dictcnt = 0; // number of "sub-masks", i.e. when using incremental mode
16968
16969 if (increment)
16970 {
16971 for (uint i = 0; i < dictcnt; i++)
16972 {
16973 local_free (dictfiles[i]);
16974 }
16975
16976 for (uint pw_len = MAX (1, pw_min); pw_len <= pw_max; pw_len++)
16977 {
16978 char *l1_filename = mp_get_truncated_mask (mask, strlen (mask), pw_len);
16979
16980 if (l1_filename == NULL) break;
16981
16982 dictcnt++;
16983
16984 dictfiles[dictcnt - 1] = l1_filename;
16985 }
16986 }
16987 else
16988 {
16989 dictcnt++;
16990
16991 dictfiles[dictcnt - 1] = mask;
16992 }
16993
16994 if (dictcnt == 0)
16995 {
16996 log_error ("ERROR: Mask is too small");
16997
16998 return (-1);
16999 }
17000 }
17001 }
17002
17003 free (induction_dictionaries);
17004
17005 // induction_dictionaries_cnt = 0; // implied
17006
17007 if (attack_mode != ATTACK_MODE_BF)
17008 {
17009 if (keyspace == 0)
17010 {
17011 induction_dictionaries = scan_directory (induction_directory);
17012
17013 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17014 }
17015 }
17016
17017 if (induction_dictionaries_cnt)
17018 {
17019 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17020 }
17021
17022 /**
17023 * prevent the user from using --keyspace together w/ maskfile and or dictfile
17024 */
17025 if (keyspace == 1)
17026 {
17027 if ((maskcnt > 1) || (dictcnt > 1))
17028 {
17029 log_error ("ERROR: --keyspace is not supported with --increment or mask files");
17030
17031 return (-1);
17032 }
17033 }
17034
17035 for (uint dictpos = rd->dictpos; dictpos < dictcnt; )
17036 {
17037 char *subid = logfile_generate_subid ();
17038
17039 data.subid = subid;
17040
17041 logfile_sub_msg ("START");
17042
17043 data.devices_status = STATUS_INIT;
17044
17045 memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64));
17046 memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64));
17047 memset (data.words_progress_restored, 0, data.salts_cnt * sizeof (u64));
17048
17049 memset (data.cpt_buf, 0, CPT_BUF * sizeof (cpt_t));
17050
17051 data.cpt_pos = 0;
17052
17053 data.cpt_start = time (NULL);
17054
17055 data.cpt_total = 0;
17056
17057 if (data.restore == 0)
17058 {
17059 rd->words_cur = skip;
17060
17061 skip = 0;
17062
17063 data.skip = 0;
17064 }
17065
17066 data.ms_paused = 0;
17067
17068 data.words_cur = rd->words_cur;
17069
17070 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17071 {
17072 hc_device_param_t *device_param = &data.devices_param[device_id];
17073
17074 if (device_param->skipped) continue;
17075
17076 device_param->speed_pos = 0;
17077
17078 memset (device_param->speed_cnt, 0, SPEED_CACHE * sizeof (u64));
17079 memset (device_param->speed_ms, 0, SPEED_CACHE * sizeof (double));
17080
17081 device_param->exec_pos = 0;
17082
17083 memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double));
17084
17085 device_param->kernel_power = device_param->kernel_power_user;
17086
17087 device_param->outerloop_pos = 0;
17088 device_param->outerloop_left = 0;
17089 device_param->innerloop_pos = 0;
17090 device_param->innerloop_left = 0;
17091
17092 // some more resets:
17093
17094 if (device_param->pws_buf) memset (device_param->pws_buf, 0, device_param->size_pws);
17095
17096 device_param->pws_cnt = 0;
17097
17098 device_param->words_off = 0;
17099 device_param->words_done = 0;
17100 }
17101
17102 data.kernel_power_div = 0;
17103
17104 // figure out some workload
17105
17106 if (attack_mode == ATTACK_MODE_STRAIGHT)
17107 {
17108 if (data.wordlist_mode == WL_MODE_FILE)
17109 {
17110 char *dictfile = NULL;
17111
17112 if (induction_dictionaries_cnt)
17113 {
17114 dictfile = induction_dictionaries[0];
17115 }
17116 else
17117 {
17118 dictfile = dictfiles[dictpos];
17119 }
17120
17121 data.dictfile = dictfile;
17122
17123 logfile_sub_string (dictfile);
17124
17125 for (uint i = 0; i < rp_files_cnt; i++)
17126 {
17127 logfile_sub_var_string ("rulefile", rp_files[i]);
17128 }
17129
17130 FILE *fd2 = fopen (dictfile, "rb");
17131
17132 if (fd2 == NULL)
17133 {
17134 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17135
17136 return (-1);
17137 }
17138
17139 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17140
17141 fclose (fd2);
17142
17143 if (data.words_cnt == 0)
17144 {
17145 if (data.devices_status == STATUS_CRACKED) break;
17146 if (data.devices_status == STATUS_ABORTED) break;
17147
17148 dictpos++;
17149
17150 continue;
17151 }
17152 }
17153 }
17154 else if (attack_mode == ATTACK_MODE_COMBI)
17155 {
17156 char *dictfile = data.dictfile;
17157 char *dictfile2 = data.dictfile2;
17158
17159 logfile_sub_string (dictfile);
17160 logfile_sub_string (dictfile2);
17161
17162 if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT)
17163 {
17164 FILE *fd2 = fopen (dictfile, "rb");
17165
17166 if (fd2 == NULL)
17167 {
17168 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17169
17170 return (-1);
17171 }
17172
17173 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17174
17175 fclose (fd2);
17176 }
17177 else if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT)
17178 {
17179 FILE *fd2 = fopen (dictfile2, "rb");
17180
17181 if (fd2 == NULL)
17182 {
17183 log_error ("ERROR: %s: %s", dictfile2, strerror (errno));
17184
17185 return (-1);
17186 }
17187
17188 data.words_cnt = count_words (wl_data, fd2, dictfile2, dictstat_base, &dictstat_nmemb);
17189
17190 fclose (fd2);
17191 }
17192
17193 if (data.words_cnt == 0)
17194 {
17195 if (data.devices_status == STATUS_CRACKED) break;
17196 if (data.devices_status == STATUS_ABORTED) break;
17197
17198 dictpos++;
17199
17200 continue;
17201 }
17202 }
17203 else if ((attack_mode == ATTACK_MODE_HYBRID1) || (attack_mode == ATTACK_MODE_HYBRID2))
17204 {
17205 char *dictfile = NULL;
17206
17207 if (induction_dictionaries_cnt)
17208 {
17209 dictfile = induction_dictionaries[0];
17210 }
17211 else
17212 {
17213 dictfile = dictfiles[dictpos];
17214 }
17215
17216 data.dictfile = dictfile;
17217
17218 char *mask = data.mask;
17219
17220 logfile_sub_string (dictfile);
17221 logfile_sub_string (mask);
17222
17223 FILE *fd2 = fopen (dictfile, "rb");
17224
17225 if (fd2 == NULL)
17226 {
17227 log_error ("ERROR: %s: %s", dictfile, strerror (errno));
17228
17229 return (-1);
17230 }
17231
17232 data.words_cnt = count_words (wl_data, fd2, dictfile, dictstat_base, &dictstat_nmemb);
17233
17234 fclose (fd2);
17235
17236 if (data.words_cnt == 0)
17237 {
17238 if (data.devices_status == STATUS_CRACKED) break;
17239 if (data.devices_status == STATUS_ABORTED) break;
17240
17241 dictpos++;
17242
17243 continue;
17244 }
17245 }
17246 else if (attack_mode == ATTACK_MODE_BF)
17247 {
17248 local_free (css_buf);
17249 local_free (data.root_css_buf);
17250 local_free (data.markov_css_buf);
17251
17252 char *mask = dictfiles[dictpos];
17253
17254 logfile_sub_string (mask);
17255
17256 // base
17257
17258 css_buf = mp_gen_css (mask, strlen (mask), mp_sys, mp_usr, &css_cnt);
17259
17260 if (opts_type & OPTS_TYPE_PT_UNICODE)
17261 {
17262 uint css_cnt_unicode = css_cnt * 2;
17263
17264 cs_t *css_buf_unicode = (cs_t *) mycalloc (css_cnt_unicode, sizeof (cs_t));
17265
17266 for (uint i = 0, j = 0; i < css_cnt; i += 1, j += 2)
17267 {
17268 memcpy (&css_buf_unicode[j + 0], &css_buf[i], sizeof (cs_t));
17269
17270 css_buf_unicode[j + 1].cs_buf[0] = 0;
17271 css_buf_unicode[j + 1].cs_len = 1;
17272 }
17273
17274 free (css_buf);
17275
17276 css_buf = css_buf_unicode;
17277 css_cnt = css_cnt_unicode;
17278 }
17279
17280 // check if mask is not too large or too small for pw_min/pw_max (*2 if unicode)
17281
17282 uint mask_min = pw_min;
17283 uint mask_max = pw_max;
17284
17285 if (opts_type & OPTS_TYPE_PT_UNICODE)
17286 {
17287 mask_min *= 2;
17288 mask_max *= 2;
17289 }
17290
17291 if ((css_cnt < mask_min) || (css_cnt > mask_max))
17292 {
17293 if (css_cnt < mask_min)
17294 {
17295 log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
17296 }
17297
17298 if (css_cnt > mask_max)
17299 {
17300 log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
17301 }
17302
17303 // skip to next mask
17304
17305 dictpos++;
17306
17307 rd->dictpos = dictpos;
17308
17309 logfile_sub_msg ("STOP");
17310
17311 continue;
17312 }
17313
17314 uint save_css_cnt = css_cnt;
17315
17316 if (opti_type & OPTI_TYPE_SINGLE_HASH)
17317 {
17318 if (opti_type & OPTI_TYPE_APPENDED_SALT)
17319 {
17320 uint salt_len = (uint) data.salts_buf[0].salt_len;
17321 char *salt_buf = (char *) data.salts_buf[0].salt_buf;
17322
17323 uint css_cnt_salt = css_cnt + salt_len;
17324
17325 cs_t *css_buf_salt = (cs_t *) mycalloc (css_cnt_salt, sizeof (cs_t));
17326
17327 memcpy (css_buf_salt, css_buf, css_cnt * sizeof (cs_t));
17328
17329 for (uint i = 0, j = css_cnt; i < salt_len; i++, j++)
17330 {
17331 css_buf_salt[j].cs_buf[0] = salt_buf[i];
17332 css_buf_salt[j].cs_len = 1;
17333 }
17334
17335 free (css_buf);
17336
17337 css_buf = css_buf_salt;
17338 css_cnt = css_cnt_salt;
17339 }
17340 }
17341
17342 data.mask = mask;
17343 data.css_cnt = css_cnt;
17344 data.css_buf = css_buf;
17345
17346 if (maskpos > 0 && dictpos == 0) free (masks[maskpos - 1]);
17347
17348 uint uniq_tbls[SP_PW_MAX][CHARSIZ] = { { 0 } };
17349
17350 mp_css_to_uniq_tbl (css_cnt, css_buf, uniq_tbls);
17351
17352 if (root_table_buf == NULL) root_table_buf = (hcstat_table_t *) mycalloc (SP_ROOT_CNT, sizeof (hcstat_table_t));
17353 if (markov_table_buf == NULL) markov_table_buf = (hcstat_table_t *) mycalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t));
17354
17355 sp_setup_tbl (shared_dir, markov_hcstat, markov_disable, markov_classic, root_table_buf, markov_table_buf);
17356
17357 markov_threshold = (markov_threshold != 0) ? markov_threshold : CHARSIZ;
17358
17359 cs_t *root_css_buf = (cs_t *) mycalloc (SP_PW_MAX, sizeof (cs_t));
17360 cs_t *markov_css_buf = (cs_t *) mycalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t));
17361
17362 data.root_css_buf = root_css_buf;
17363 data.markov_css_buf = markov_css_buf;
17364
17365 sp_tbl_to_css (root_table_buf, markov_table_buf, root_css_buf, markov_css_buf, markov_threshold, uniq_tbls);
17366
17367 data.words_cnt = sp_get_sum (0, css_cnt, root_css_buf);
17368
17369 local_free (root_table_buf);
17370 local_free (markov_table_buf);
17371
17372 // copy + args
17373
17374 uint css_cnt_l = css_cnt;
17375 uint css_cnt_r;
17376
17377 if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
17378 {
17379 if (save_css_cnt < 6)
17380 {
17381 css_cnt_r = 1;
17382 }
17383 else if (save_css_cnt == 6)
17384 {
17385 css_cnt_r = 2;
17386 }
17387 else
17388 {
17389 if (opts_type & OPTS_TYPE_PT_UNICODE)
17390 {
17391 if (save_css_cnt == 8 || save_css_cnt == 10)
17392 {
17393 css_cnt_r = 2;
17394 }
17395 else
17396 {
17397 css_cnt_r = 4;
17398 }
17399 }
17400 else
17401 {
17402 if ((css_buf[0].cs_len * css_buf[1].cs_len * css_buf[2].cs_len) > 256)
17403 {
17404 css_cnt_r = 3;
17405 }
17406 else
17407 {
17408 css_cnt_r = 4;
17409 }
17410 }
17411 }
17412 }
17413 else
17414 {
17415 css_cnt_r = 1;
17416
17417 /* unfinished code?
17418 int sum = css_buf[css_cnt_r - 1].cs_len;
17419
17420 for (uint i = 1; i < 4 && i < css_cnt; i++)
17421 {
17422 if (sum > 1) break; // we really don't need alot of amplifier them for slow hashes
17423
17424 css_cnt_r++;
17425
17426 sum *= css_buf[css_cnt_r - 1].cs_len;
17427 }
17428 */
17429 }
17430
17431 css_cnt_l -= css_cnt_r;
17432
17433 data.bfs_cnt = sp_get_sum (0, css_cnt_r, root_css_buf);
17434
17435 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17436 {
17437 hc_device_param_t *device_param = &data.devices_param[device_id];
17438
17439 if (device_param->skipped) continue;
17440
17441 device_param->kernel_params_mp_l[0] = &device_param->d_pws_buf;
17442 device_param->kernel_params_mp_l[1] = &device_param->d_root_css_buf;
17443 device_param->kernel_params_mp_l[2] = &device_param->d_markov_css_buf;
17444
17445 device_param->kernel_params_mp_l_buf64[3] = 0;
17446 device_param->kernel_params_mp_l_buf32[4] = css_cnt_l;
17447 device_param->kernel_params_mp_l_buf32[5] = css_cnt_r;
17448 device_param->kernel_params_mp_l_buf32[6] = 0;
17449 device_param->kernel_params_mp_l_buf32[7] = 0;
17450 device_param->kernel_params_mp_l_buf32[8] = 0;
17451
17452 if (opts_type & OPTS_TYPE_PT_ADD01) device_param->kernel_params_mp_l_buf32[6] = full01;
17453 if (opts_type & OPTS_TYPE_PT_ADD80) device_param->kernel_params_mp_l_buf32[6] = full80;
17454 if (opts_type & OPTS_TYPE_PT_ADDBITS14) device_param->kernel_params_mp_l_buf32[7] = 1;
17455 if (opts_type & OPTS_TYPE_PT_ADDBITS15) device_param->kernel_params_mp_l_buf32[8] = 1;
17456
17457 device_param->kernel_params_mp_r[0] = &device_param->d_bfs;
17458 device_param->kernel_params_mp_r[1] = &device_param->d_root_css_buf;
17459 device_param->kernel_params_mp_r[2] = &device_param->d_markov_css_buf;
17460
17461 device_param->kernel_params_mp_r_buf64[3] = 0;
17462 device_param->kernel_params_mp_r_buf32[4] = css_cnt_r;
17463 device_param->kernel_params_mp_r_buf32[5] = 0;
17464 device_param->kernel_params_mp_r_buf32[6] = 0;
17465 device_param->kernel_params_mp_r_buf32[7] = 0;
17466
17467 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]);
17468 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]);
17469 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]);
17470
17471 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]);
17472 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]);
17473 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]);
17474
17475 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);
17476 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);
17477 }
17478 }
17479
17480 u64 words_base = data.words_cnt;
17481
17482 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17483 {
17484 if (data.kernel_rules_cnt)
17485 {
17486 words_base /= data.kernel_rules_cnt;
17487 }
17488 }
17489 else if (data.attack_kern == ATTACK_KERN_COMBI)
17490 {
17491 if (data.combs_cnt)
17492 {
17493 words_base /= data.combs_cnt;
17494 }
17495 }
17496 else if (data.attack_kern == ATTACK_KERN_BF)
17497 {
17498 if (data.bfs_cnt)
17499 {
17500 words_base /= data.bfs_cnt;
17501 }
17502 }
17503
17504 data.words_base = words_base;
17505
17506 if (keyspace == 1)
17507 {
17508 log_info ("%llu", (unsigned long long int) words_base);
17509
17510 return (0);
17511 }
17512
17513 if (data.words_cur > data.words_base)
17514 {
17515 log_error ("ERROR: restore value greater keyspace");
17516
17517 return (-1);
17518 }
17519
17520 if (data.words_cur)
17521 {
17522 if (data.attack_kern == ATTACK_KERN_STRAIGHT)
17523 {
17524 for (uint i = 0; i < data.salts_cnt; i++)
17525 {
17526 data.words_progress_restored[i] = data.words_cur * data.kernel_rules_cnt;
17527 }
17528 }
17529 else if (data.attack_kern == ATTACK_KERN_COMBI)
17530 {
17531 for (uint i = 0; i < data.salts_cnt; i++)
17532 {
17533 data.words_progress_restored[i] = data.words_cur * data.combs_cnt;
17534 }
17535 }
17536 else if (data.attack_kern == ATTACK_KERN_BF)
17537 {
17538 for (uint i = 0; i < data.salts_cnt; i++)
17539 {
17540 data.words_progress_restored[i] = data.words_cur * data.bfs_cnt;
17541 }
17542 }
17543 }
17544
17545 /*
17546 * Inform user about possible slow speeds
17547 */
17548
17549 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17550 {
17551 if (data.words_base < kernel_power_all)
17552 {
17553 if (quiet == 0)
17554 {
17555 log_info ("ATTENTION!");
17556 log_info (" The wordlist or mask you are using is too small.");
17557 log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s).");
17558 log_info (" The cracking speed will drop.");
17559 log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed");
17560 log_info ("");
17561 }
17562 }
17563 }
17564
17565 /*
17566 * Update loopback file
17567 */
17568
17569 if (loopback == 1)
17570 {
17571 time_t now;
17572
17573 time (&now);
17574
17575 uint random_num = get_random_num (0, 9999);
17576
17577 snprintf (loopback_file, loopback_size - 1, "%s/%s.%d_%i", induction_directory, LOOPBACK_FILE, (int) now, random_num);
17578
17579 data.loopback_file = loopback_file;
17580 }
17581
17582 /*
17583 * Update dictionary statistic
17584 */
17585
17586 if (keyspace == 0)
17587 {
17588 dictstat_fp = fopen (dictstat, "wb");
17589
17590 if (dictstat_fp)
17591 {
17592 lock_file (dictstat_fp);
17593
17594 fwrite (dictstat_base, sizeof (dictstat_t), dictstat_nmemb, dictstat_fp);
17595
17596 fclose (dictstat_fp);
17597 }
17598 }
17599
17600 data.devices_status = STATUS_RUNNING;
17601
17602 if (initial_restore_done == 0)
17603 {
17604 if (data.restore_disable == 0) cycle_restore ();
17605
17606 initial_restore_done = 1;
17607 }
17608
17609 hc_timer_set (&data.timer_running);
17610
17611 if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK))
17612 {
17613 if ((quiet == 0) && (status == 0) && (benchmark == 0))
17614 {
17615 if (quiet == 0) fprintf (stdout, "%s", PROMPT);
17616 if (quiet == 0) fflush (stdout);
17617 }
17618 }
17619 else if (wordlist_mode == WL_MODE_STDIN)
17620 {
17621 if (data.quiet == 0) log_info ("Starting attack in stdin mode...");
17622 if (data.quiet == 0) log_info ("");
17623 }
17624
17625 time_t runtime_start;
17626
17627 time (&runtime_start);
17628
17629 data.runtime_start = runtime_start;
17630
17631 /**
17632 * create cracker threads
17633 */
17634
17635 hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t));
17636
17637 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17638 {
17639 hc_device_param_t *device_param = &devices_param[device_id];
17640
17641 if (wordlist_mode == WL_MODE_STDIN)
17642 {
17643 hc_thread_create (c_threads[device_id], thread_calc_stdin, device_param);
17644 }
17645 else
17646 {
17647 hc_thread_create (c_threads[device_id], thread_calc, device_param);
17648 }
17649 }
17650
17651 // wait for crack threads to exit
17652
17653 hc_thread_wait (data.devices_cnt, c_threads);
17654
17655 local_free (c_threads);
17656
17657 data.restore = 0;
17658
17659 // finalize task
17660
17661 logfile_sub_var_uint ("status-after-work", data.devices_status);
17662
17663 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17664
17665 if (data.devices_status == STATUS_CRACKED) break;
17666 if (data.devices_status == STATUS_ABORTED) break;
17667
17668 if (data.devices_status == STATUS_BYPASS)
17669 {
17670 data.devices_status = STATUS_RUNNING;
17671 }
17672
17673 if (induction_dictionaries_cnt)
17674 {
17675 unlink (induction_dictionaries[0]);
17676 }
17677
17678 free (induction_dictionaries);
17679
17680 if (attack_mode != ATTACK_MODE_BF)
17681 {
17682 induction_dictionaries = scan_directory (induction_directory);
17683
17684 induction_dictionaries_cnt = count_dictionaries (induction_dictionaries);
17685 }
17686
17687 if (benchmark == 0)
17688 {
17689 if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt)
17690 {
17691 if (quiet == 0) clear_prompt ();
17692
17693 if (quiet == 0) log_info ("");
17694
17695 if (status == 1)
17696 {
17697 status_display ();
17698 }
17699 else
17700 {
17701 if (quiet == 0) status_display ();
17702 }
17703
17704 if (quiet == 0) log_info ("");
17705 }
17706 }
17707
17708 if (attack_mode == ATTACK_MODE_BF)
17709 {
17710 dictpos++;
17711
17712 rd->dictpos = dictpos;
17713 }
17714 else
17715 {
17716 if (induction_dictionaries_cnt)
17717 {
17718 qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime);
17719 }
17720 else
17721 {
17722 dictpos++;
17723
17724 rd->dictpos = dictpos;
17725 }
17726 }
17727
17728 time_t runtime_stop;
17729
17730 time (&runtime_stop);
17731
17732 data.runtime_stop = runtime_stop;
17733
17734 logfile_sub_uint (runtime_start);
17735 logfile_sub_uint (runtime_stop);
17736
17737 logfile_sub_msg ("STOP");
17738
17739 global_free (subid);
17740 }
17741
17742 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint ();
17743
17744 if (data.devices_status == STATUS_CRACKED) break;
17745 if (data.devices_status == STATUS_ABORTED) break;
17746 if (data.devices_status == STATUS_QUIT) break;
17747
17748 if (data.devices_status == STATUS_BYPASS)
17749 {
17750 data.devices_status = STATUS_RUNNING;
17751 }
17752 }
17753
17754 // 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
17755
17756 if (attack_mode == ATTACK_MODE_STRAIGHT)
17757 {
17758 if (data.wordlist_mode == WL_MODE_FILE)
17759 {
17760 if (data.dictfile == NULL)
17761 {
17762 if (dictfiles != NULL)
17763 {
17764 data.dictfile = dictfiles[0];
17765
17766 hc_timer_set (&data.timer_running);
17767 }
17768 }
17769 }
17770 }
17771 // NOTE: combi is okay because it is already set beforehand
17772 else if (attack_mode == ATTACK_MODE_HYBRID1 || attack_mode == ATTACK_MODE_HYBRID2)
17773 {
17774 if (data.dictfile == NULL)
17775 {
17776 if (dictfiles != NULL)
17777 {
17778 hc_timer_set (&data.timer_running);
17779
17780 data.dictfile = dictfiles[0];
17781 }
17782 }
17783 }
17784 else if (attack_mode == ATTACK_MODE_BF)
17785 {
17786 if (data.mask == NULL)
17787 {
17788 hc_timer_set (&data.timer_running);
17789
17790 data.mask = masks[0];
17791 }
17792 }
17793
17794 if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
17795 {
17796 data.devices_status = STATUS_EXHAUSTED;
17797 }
17798
17799 // if cracked / aborted remove last induction dictionary
17800
17801 for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++)
17802 {
17803 struct stat induct_stat;
17804
17805 if (stat (induction_dictionaries[file_pos], &induct_stat) == 0)
17806 {
17807 unlink (induction_dictionaries[file_pos]);
17808 }
17809 }
17810
17811 // wait for non-interactive threads
17812
17813 for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++)
17814 {
17815 hc_thread_wait (1, &ni_threads[thread_idx]);
17816 }
17817
17818 local_free (ni_threads);
17819
17820 // wait for interactive threads
17821
17822 if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK))
17823 {
17824 hc_thread_wait (1, &i_thread);
17825 }
17826
17827 // we dont need restore file anymore
17828 if (data.restore_disable == 0)
17829 {
17830 if ((data.devices_status == STATUS_EXHAUSTED) || (data.devices_status == STATUS_CRACKED))
17831 {
17832 unlink (eff_restore_file);
17833 unlink (new_restore_file);
17834 }
17835 else
17836 {
17837 cycle_restore ();
17838 }
17839 }
17840
17841 // finally save left hashes
17842
17843 if ((hashlist_mode == HL_MODE_FILE) && (remove == 1) && (data.digests_saved != data.digests_done))
17844 {
17845 save_hash ();
17846 }
17847
17848 /**
17849 * Clean up
17850 */
17851
17852 if (benchmark == 1)
17853 {
17854 status_benchmark ();
17855
17856 if (machine_readable == 0)
17857 {
17858 log_info ("");
17859 }
17860 }
17861 else
17862 {
17863 if (quiet == 0) clear_prompt ();
17864
17865 if (quiet == 0) log_info ("");
17866
17867 if (status == 1)
17868 {
17869 status_display ();
17870 }
17871 else
17872 {
17873 if (quiet == 0) status_display ();
17874 }
17875
17876 if (quiet == 0) log_info ("");
17877 }
17878
17879 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17880 {
17881 hc_device_param_t *device_param = &data.devices_param[device_id];
17882
17883 if (device_param->skipped) continue;
17884
17885 local_free (device_param->combs_buf);
17886
17887 local_free (device_param->hooks_buf);
17888
17889 local_free (device_param->device_name);
17890
17891 local_free (device_param->device_name_chksum);
17892
17893 local_free (device_param->device_version);
17894
17895 local_free (device_param->driver_version);
17896
17897 if (device_param->pws_buf) myfree (device_param->pws_buf);
17898 if (device_param->d_pws_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_buf);
17899 if (device_param->d_pws_amp_buf) hc_clReleaseMemObject (data.ocl, device_param->d_pws_amp_buf);
17900 if (device_param->d_rules) hc_clReleaseMemObject (data.ocl, device_param->d_rules);
17901 if (device_param->d_rules_c) hc_clReleaseMemObject (data.ocl, device_param->d_rules_c);
17902 if (device_param->d_combs) hc_clReleaseMemObject (data.ocl, device_param->d_combs);
17903 if (device_param->d_combs_c) hc_clReleaseMemObject (data.ocl, device_param->d_combs_c);
17904 if (device_param->d_bfs) hc_clReleaseMemObject (data.ocl, device_param->d_bfs);
17905 if (device_param->d_bfs_c) hc_clReleaseMemObject (data.ocl, device_param->d_bfs_c);
17906 if (device_param->d_bitmap_s1_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_a);
17907 if (device_param->d_bitmap_s1_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_b);
17908 if (device_param->d_bitmap_s1_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_c);
17909 if (device_param->d_bitmap_s1_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s1_d);
17910 if (device_param->d_bitmap_s2_a) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_a);
17911 if (device_param->d_bitmap_s2_b) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_b);
17912 if (device_param->d_bitmap_s2_c) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_c);
17913 if (device_param->d_bitmap_s2_d) hc_clReleaseMemObject (data.ocl, device_param->d_bitmap_s2_d);
17914 if (device_param->d_plain_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_plain_bufs);
17915 if (device_param->d_digests_buf) hc_clReleaseMemObject (data.ocl, device_param->d_digests_buf);
17916 if (device_param->d_digests_shown) hc_clReleaseMemObject (data.ocl, device_param->d_digests_shown);
17917 if (device_param->d_salt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_salt_bufs);
17918 if (device_param->d_esalt_bufs) hc_clReleaseMemObject (data.ocl, device_param->d_esalt_bufs);
17919 if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps);
17920 if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks);
17921 if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result);
17922 if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf);
17923 if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf);
17924 if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf);
17925 if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c);
17926
17927 if (device_param->kernel1) hc_clReleaseKernel (data.ocl, device_param->kernel1);
17928 if (device_param->kernel12) hc_clReleaseKernel (data.ocl, device_param->kernel12);
17929 if (device_param->kernel2) hc_clReleaseKernel (data.ocl, device_param->kernel2);
17930 if (device_param->kernel23) hc_clReleaseKernel (data.ocl, device_param->kernel23);
17931 if (device_param->kernel3) hc_clReleaseKernel (data.ocl, device_param->kernel3);
17932 if (device_param->kernel_mp) hc_clReleaseKernel (data.ocl, device_param->kernel_mp);
17933 if (device_param->kernel_mp_l) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_l);
17934 if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r);
17935 if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm);
17936 if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp);
17937 if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset);
17938
17939 if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program);
17940 if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp);
17941 if (device_param->program_amp) hc_clReleaseProgram (data.ocl, device_param->program_amp);
17942
17943 if (device_param->command_queue) hc_clReleaseCommandQueue (data.ocl, device_param->command_queue);
17944 if (device_param->context) hc_clReleaseContext (data.ocl, device_param->context);
17945 }
17946
17947 // reset default fan speed
17948
17949 #ifdef HAVE_HWMON
17950 if (gpu_temp_disable == 0)
17951 {
17952 #ifdef HAVE_ADL
17953 if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here
17954 {
17955 hc_thread_mutex_lock (mux_adl);
17956
17957 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17958 {
17959 hc_device_param_t *device_param = &data.devices_param[device_id];
17960
17961 if (device_param->skipped) continue;
17962
17963 if (data.hm_device[device_id].fan_supported == 1)
17964 {
17965 int fanspeed = temp_retain_fanspeed_value[device_id];
17966
17967 if (fanspeed == -1) continue;
17968
17969 int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed);
17970
17971 if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id);
17972 }
17973 }
17974
17975 hc_thread_mutex_unlock (mux_adl);
17976 }
17977 #endif // HAVE_ADL
17978 }
17979
17980 #ifdef HAVE_ADL
17981 // reset power tuning
17982
17983 if (powertune_enable == 1) // VENDOR_ID_AMD is implied here
17984 {
17985 hc_thread_mutex_lock (mux_adl);
17986
17987 for (uint device_id = 0; device_id < data.devices_cnt; device_id++)
17988 {
17989 hc_device_param_t *device_param = &data.devices_param[device_id];
17990
17991 if (device_param->skipped) continue;
17992
17993 if (data.hm_device[device_id].od_version == 6)
17994 {
17995 // check powertune capabilities first, if not available then skip device
17996
17997 int powertune_supported = 0;
17998
17999 if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK)
18000 {
18001 log_error ("ERROR: Failed to get ADL PowerControl Capabilities");
18002
18003 return (-1);
18004 }
18005
18006 if (powertune_supported != 0)
18007 {
18008 // powercontrol settings
18009
18010 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)
18011 {
18012 log_info ("ERROR: Failed to restore the ADL PowerControl values");
18013
18014 return (-1);
18015 }
18016
18017 // clocks
18018
18019 ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
18020
18021 performance_state->iNumberOfPerformanceLevels = 2;
18022
18023 performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock;
18024 performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock;
18025 performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock;
18026 performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock;
18027
18028 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)
18029 {
18030 log_info ("ERROR: Failed to restore ADL performance state");
18031
18032 return (-1);
18033 }
18034
18035 local_free (performance_state);
18036 }
18037 }
18038 }
18039
18040 hc_thread_mutex_unlock (mux_adl);
18041 }
18042 #endif // HAVE_ADL
18043
18044 if (gpu_temp_disable == 0)
18045 {
18046 #if defined(HAVE_NVML) || defined(HAVE_NVAPI)
18047 if (data.hm_nv)
18048 {
18049 #if defined(LINUX) && defined(HAVE_NVML)
18050
18051 hm_NVML_nvmlShutdown (data.hm_nv);
18052
18053 nvml_close (data.hm_nv);
18054
18055 #elif defined(WIN) && (HAVE_NVAPI)
18056
18057 hm_NvAPI_Unload (data.hm_nv);
18058
18059 nvapi_close (data.hm_nv);
18060
18061 #endif
18062
18063 data.hm_nv = NULL;
18064 }
18065 #endif
18066
18067 #ifdef HAVE_ADL
18068 if (data.hm_amd)
18069 {
18070 hm_ADL_Main_Control_Destroy (data.hm_amd);
18071
18072 adl_close (data.hm_amd);
18073 data.hm_amd = NULL;
18074 }
18075 #endif
18076 }
18077 #endif // HAVE_HWMON
18078
18079 // free memory
18080
18081 local_free (masks);
18082
18083 local_free (dictstat_base);
18084
18085 for (uint pot_pos = 0; pot_pos < pot_cnt; pot_pos++)
18086 {
18087 pot_t *pot_ptr = &pot[pot_pos];
18088
18089 hash_t *hash = &pot_ptr->hash;
18090
18091 local_free (hash->digest);
18092
18093 if (isSalted)
18094 {
18095 local_free (hash->salt);
18096 }
18097 }
18098
18099 local_free (pot);
18100
18101 local_free (all_kernel_rules_cnt);
18102 local_free (all_kernel_rules_buf);
18103
18104 local_free (wl_data->buf);
18105 local_free (wl_data);
18106
18107 local_free (bitmap_s1_a);
18108 local_free (bitmap_s1_b);
18109 local_free (bitmap_s1_c);
18110 local_free (bitmap_s1_d);
18111 local_free (bitmap_s2_a);
18112 local_free (bitmap_s2_b);
18113 local_free (bitmap_s2_c);
18114 local_free (bitmap_s2_d);
18115
18116 #ifdef HAVE_HWMON
18117 local_free (temp_retain_fanspeed_value);
18118 #ifdef HAVE_ADL
18119 local_free (od_clock_mem_status);
18120 local_free (od_power_control_status);
18121 #endif // ADL
18122 #endif
18123
18124 global_free (devices_param);
18125
18126 global_free (kernel_rules_buf);
18127
18128 global_free (root_css_buf);
18129 global_free (markov_css_buf);
18130
18131 global_free (digests_buf);
18132 global_free (digests_shown);
18133 global_free (digests_shown_tmp);
18134
18135 global_free (salts_buf);
18136 global_free (salts_shown);
18137
18138 global_free (esalts_buf);
18139
18140 global_free (words_progress_done);
18141 global_free (words_progress_rejected);
18142 global_free (words_progress_restored);
18143
18144 if (pot_fp) fclose (pot_fp);
18145
18146 if (data.devices_status == STATUS_QUIT) break;
18147 }
18148
18149 // destroy others mutex
18150
18151 hc_thread_mutex_delete (mux_dispatcher);
18152 hc_thread_mutex_delete (mux_counter);
18153 hc_thread_mutex_delete (mux_display);
18154 hc_thread_mutex_delete (mux_adl);
18155
18156 // free memory
18157
18158 local_free (eff_restore_file);
18159 local_free (new_restore_file);
18160
18161 local_free (rd);
18162
18163 // tuning db
18164
18165 tuning_db_destroy (tuning_db);
18166
18167 // loopback
18168
18169 local_free (loopback_file);
18170
18171 if (loopback == 1) unlink (loopback_file);
18172
18173 // induction directory
18174
18175 if (induction_dir == NULL)
18176 {
18177 if (attack_mode != ATTACK_MODE_BF)
18178 {
18179 if (rmdir (induction_directory) == -1)
18180 {
18181 if (errno == ENOENT)
18182 {
18183 // good, we can ignore
18184 }
18185 else if (errno == ENOTEMPTY)
18186 {
18187 // good, we can ignore
18188 }
18189 else
18190 {
18191 log_error ("ERROR: %s: %s", induction_directory, strerror (errno));
18192
18193 return (-1);
18194 }
18195 }
18196
18197 local_free (induction_directory);
18198 }
18199 }
18200
18201 // outfile-check directory
18202
18203 if (outfile_check_dir == NULL)
18204 {
18205 if (rmdir (outfile_check_directory) == -1)
18206 {
18207 if (errno == ENOENT)
18208 {
18209 // good, we can ignore
18210 }
18211 else if (errno == ENOTEMPTY)
18212 {
18213 // good, we can ignore
18214 }
18215 else
18216 {
18217 log_error ("ERROR: %s: %s", outfile_check_directory, strerror (errno));
18218
18219 return (-1);
18220 }
18221 }
18222
18223 local_free (outfile_check_directory);
18224 }
18225
18226 time_t proc_stop;
18227
18228 time (&proc_stop);
18229
18230 logfile_top_uint (proc_start);
18231 logfile_top_uint (proc_stop);
18232
18233 logfile_top_msg ("STOP");
18234
18235 if (quiet == 0) log_info_nn ("Started: %s", ctime (&proc_start));
18236 if (quiet == 0) log_info_nn ("Stopped: %s", ctime (&proc_stop));
18237
18238 if (data.ocl) ocl_close (data.ocl);
18239
18240 if (data.devices_status == STATUS_ABORTED) return 2;
18241 if (data.devices_status == STATUS_QUIT) return 2;
18242 if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) return 2;
18243 if (data.devices_status == STATUS_EXHAUSTED) return 1;
18244 if (data.devices_status == STATUS_CRACKED) return 0;
18245
18246 return -1;
18247 }
Hashcat additions to support pwdhash